Conteinerização da sua aplicação

Welcome to containerization! Imagine your application needing specific tools and settings to run perfectly. On different computers, these settings might vary, leading to the dreaded "It works on my machine!" problem.

Docker solves this by packaging your application and all its dependencies into a standardized unit called a container. This ensures your app runs consistently everywhere, from your laptop to the cloud.

At the heart of Docker are two key concepts:

• Docker Image: Think of an image as a read-only blueprint or a template. It contains your application's code, runtime, libraries, environment variables, and configuration files. It's everything your app needs to run.
• Docker Container: A container is a runnable instance of an image. When you run an image, Docker creates a container, which is an isolated, executable package. You can have multiple containers running from the same image.

To create a Docker Image, you write a Dockerfile. This is a simple text file that contains a series of instructions. Each instruction builds a layer on top of the previous one, eventually forming your complete image.

It's like writing a recipe for building your application's environment. Docker reads this recipe step-by-step to assemble your image.

Let's look at some fundamental Dockerfile instructions:

• FROM: Specifies the base image your application will build upon (e.g., an official Python or Node.js image).
• WORKDIR: Sets the working directory inside the container for subsequent instructions.
• COPY: Copies files or directories from your host machine into the container's filesystem.

Here's a start to a Dockerfile:

Continuing our Dockerfile, we need to install dependencies and tell Docker which port our app uses:

• RUN: Executes any command in a new layer on top of the current image. This is where you'd install dependencies or run build steps.
• EXPOSE: Informs Docker that the container listens on the specified network ports at runtime. It's documentation, not a firewall rule.
• CMD: Provides defaults for an executing container. This is typically your application's startup command.

Once your Dockerfile is ready, you use the docker build command to create an image. The -t flag allows you to tag your image with a name and optional version (e.g., my-saas-app:1.0).

The . at the end tells Docker to look for the Dockerfile in the current directory.

After building, you can run your application inside a Docker container using the docker run command. The -p flag is crucial for port mapping.

It maps a port on your host machine (e.g., 8080) to a port inside the container (e.g., 8000). This lets you access your app from your browser.

Once your container is running, you'll want to check its status or view its output. Here are some useful commands:

• docker ps: Lists all currently running containers.
• docker ps -a: Lists all containers, including stopped ones.
• docker logs [container_id_or_name]: Shows the logs (standard output/error) from a container.

When you're done with a container, it's good practice to stop and remove it to free up resources. Docker containers, even when stopped, still consume disk space.

• docker stop [container_id_or_name]: Stops a running container gracefully.
• docker rm [container_id_or_name]: Removes a stopped container.
• docker rmi [image_id_or_name]: Removes a Docker image.

You have a simple web application with an app.py and requirements.txt. Arrange the steps in the correct order to containerize and run it using Docker.

Congratulations! You've learned the fundamentals of Dockerizing your application.

• Containers provide consistent environments.
• Images are blueprints, containers are instances.
• The Dockerfile defines how to build an image using instructions like FROM, WORKDIR, COPY, RUN, EXPOSE, and CMD.
• You build images with docker build and run containers with docker run.

This consistency is vital for deploying your SaaS application reliably across different environments!