DEV Community: David Barenco

Docker do Zero

David Barenco — Tue, 23 Jul 2024 20:11:10 +0000

Quem nunca ouviu a frase: "Na minha máquina funciona...". Esse é (ou era) um problema comum aos desenvolvedores, pois cada máquina tem configurações diferentes e na hora de rodar a aplicação, muitas variáveis podiam levar ela a falhar. Dessa forma, o Docker surge como uma forma de padronizar o ambiente de desenvolvimento para, com poucos comandos, subirmos a aplicação inteira, com suas dependências e conexões.

De início pode parecer complicado, mas entendendo alguns conceitos e comandos, rapidamente conseguimos extrair o melhor que o Docker tem a oferecer e facilitar muito nossa vida.

O docker roda uma máquina linux virtualmente , então é recomendado conhecer um pouco de Linux e comandos do terminal.

Mas antes de aprender a criar ou executar os comandos, vamos entender alguns conceitos iniciais:

Construindo uma casa

Pra entender o funcionamento do Docker na nossa máquina e seu uso, eu gosto de usar a analogia de quando construímos uma casa. No caso, vamos pensar que temos um terreno que é um condomínio de casas, e lá vamos construir várias casas. As casa terão um padrão pra estrutura principal, e depois poderemos personalizar cada uma com móveis e etc.

Primeiramente precisamos pensar no tamanho da nossa casa, as paredes, portas e janelas. Onde ficarão a parte hidráulica e elétrica.
Após isso definido, passamos pro arquiteto ou engenheiro construir a planta das casas.
Com isso, podemos construir uma ou várias casa baseadas na planta da casa.
E depois podemos entrar em cada casa e colocar o que quisermos dentro. Até modificar uma porta ou janela. Enfim, trabalhar cada casa individualmente. Podemos também demolir uma casa e construir outra no mesmo local, com base na planta inicial.
Uma questão além disso são as contas (luz, água). Vamos supor que queremos sempre ter o total de quanto estamos gastando no condomínio. Se demolirmos uma casa, não podemos perder esse valor. Então precisamos ter um local para armazenar as contas fora de cada casa, além de ter uma cópia na própria casa.

Agora que temos uma ideia dos passos hipotéticos pra construir nosso condomínio de casas, vamos relacioná-los a subir uma aplicação com Docker.

Primeiro, definimos os passos pra construir uma image, ou seja, a planta da casa. Esses passos ficam salvos num Dockerfile, um arquivo onde fica definido o que vamos precisar subir na(s) máquina(s) que vamos subir.
Desse arquivo, buildamos a image, a planta da nossa casa. Uma image é basicamente um template pra criação de containers.
Já os containers são nossas casas. Eles são instâncias de uma máquina virtual rodando na nossa máquina, com as configurações especificadas na nossa image. Podemos subir um container e acessá-lo através do terminal. Lá, podemos modificá-lo como quisermos, instalando novas aplicações ou bibliotecas, executar aplicações, criar banco de dados, etc.
Por fim, podemos remover um container. Isso irá apagar qualquer arquivo ou instalação que tivermos feito dentro dele. Ao subirmos um novo container, teremos as especificações iniciais definidas na nossa image.
E se quisermos manter dados do nosso container pro próximo? Podemos utilizar os volumes, para isso. Como a contas da casa, precisamos salvar as informações fora do container para persistí-los. Dessa forma, fazemos uma "ponte" entre nossa máquina e o container, copiando tudo de um pro outro. Ao removermos os containers, mantemos os dados na nossa máquina e podemos usá-los novamente.

Fluxo de trabalho

Depois de entender esses conceitos, fica mais fácil entender um fluxo de trabalho utilizando Docker. Os comandos abaixo estão melhor descritos no fim desse post.

Primeiramente, precisamos de uma image pra trabalhar. Podemos criar um Dockerfile para buildar (docker build) uma ou baixar uma do Docker Hub (docker pull).
Após termos a image (docker images), podemos executá-la (docker run) e gerar um container, uma máquina virtual com as configurações definidas na image.
Container pode executar uma vez e parar, ou ficar rodando na nossa máquina (docker ps). Podemos acessar o container (docker exec) e rodar comandos dentro dele (lembrando que qualquer alteração será perdida quando matarmos o container).
Após utilizar, podemos matar o container (docker stop) (docker rm). E caso desejamos, também remover a image (docker rmi), se não formos mais utilizá-la para criar novos containers.

Criando um Dockerfile

Ao criamos um arquivo, como o exemplo acima, podemos buildar o Dockerfile numa image, rodando docker build -t <NOME-DA-IMAGEM>:<VERSÃO> <DIRETÓRIO-DO-DOCKERFILE>. Isso cria a image com os comandos e instalações especificadas no Dockerfile já executados.

A partir daí, podemos definir os passos para configurar a image com as configurações iniciais. Sempre usamos uma image como base com o comando FROM. O RUN, por exemplo, executa os comandos.

Principais instruções do Dockerfile

FROM: image que vamos utilizar de base.
WORKDIR: Define a pasta que vamos executar os comandos no container.
RUN: Roda os comandos especificados.
COPY: Copia arquivos da nossa máquina pro image.
ENTRYPOINT: Comando a ser executado quando inicializamos o container.

Algumas outras podem ser conferidas aqui.

Principais comandos Docker que utilizo

Abaixo, separei algumas das principais funcionalidades que utilizo no dia-a-dia.

Utilizando Imagens

docker pull <NOME-DA-IMAGEM>:<VERSÃO>: Puxa a image pra nossa máquina local. Se a versão não for passada, se utiliza a latest.
docker build <CAMINHO-DO-DOCKERFILE>: Buildamos em uma image o Dockerfile
- -t <NOME-DA-IMAGEM>:<VERSÃO>: Criamos um nome da image. É interessante utilizar o nome do nosso usuário no Docker Hub seguido de / e um nome da image: user/project-abc:v1
docker images: Lista as imagens baixadas na máquina.
docker rmi <IMAGE-ID>: Remove a image.

Listagem e remoção de containers.

docker ps: Lista os containers que estão rodando.
- -a: Mostra os containers ativos ou que já foram executados.
- -q: Lista os ids dos containers.
docker stop <ID-DO-CONTAINER>: Para o container que esteja rodando.
docker rm <ID-DO-CONTAINER>: Remove o container que está parado.
- -f: Força a remoção, mesmo se o container estiver rodando.

Para remover todos os containers ativos e não ativos:

docker rm -f $(docker ps -aq)

Manipulando containers

docker run <IMAGE> <COMANDO>: Roda a image em nosso terminal com o comando informado.
- -i: Modulo interativo, mantendo o processo rodando.
- -t: Permite digitar coisas no terminal.
- -p: Aponta para porta a ser mapeada.
- -d: Desatacha o terminal do processo.
- -v: Volume para persistência de dados. Passamos o caminho local, com ':' separando o caminho no container. As mudanças na pasta do container persistirão na máquina local.
- --rm: Remove o container após terminar de executá-lo.
- --name: Define um nome para o container.
- Exemplo: docker run -it ubuntu bash rodamos uma image do Ubuntu e executamos o bash, permitindo-nos executar códigos no terminal dentro do container.
- Exemplo: docker run -d -p 8080:80 nginx rodamos o nginx e mapeamos a porta 8080 da nossa máquina pra porta 80 do container.
docker exec <NOME-DO-CONTAINER> <COMANDO>: Executa um comando no nosso container já ativo. (Podemos usar as mesmas flags do docker run, como por exemplo, a -it)

Trabalhando com volumes

docker volume ls: Lista volumes.
docker volume create <NOME-DO-VOLUME>: Cria um volume.
docker volume inspect <NOME-DO-VOLUME>: Mostra dados do volume.
docker volume prune: Remove os volumes e libera espaço.

Com isso, podemos criar um volume passando a flag --mount com o nome do volume criado. Exemplo:

docker run -d -p 8080:80 --mount type=volume,source=<NOME-DO-VOLUME>,target=/app nginx

Ou com a flag -v:

docker run -d -p 8080:80 -v <NOME-DO-VOLUME>:/app nginx

Considerações

Tentei resumir bem os conceitos e principais comandos que uso do Docker. Vale a pena se aprofundar e praticar subindo imagens para uso pessoal. Outro ponto é estudar sobre Docker Compose, que orquestra múltiplos containers Docker para funcionarem juntos.
Qualquer dúvida ou comentário, escreve aqui em baixo que ficarei feliz em responder.

Docker from Zero

David Barenco — Tue, 23 Jul 2024 20:11:05 +0000

Who has never heard the phrase: "It works on my machine...". This is (or was) a common problem for developers, as each machine has different configurations and when running the application, many variables could cause its failure. In this way, Docker appears as a way of standardizing the development environment so that, with just a few commands, we can run the entire application, with its dependencies and connections.

It may seem complicated at first, but understanding some concepts and commands, we can quickly extract the best that Docker has to offer and make our lives much easier.

Docker runs a virtual Linux machine, so it's recommended to know a little about Linux and terminal commands.

But before learning how to create or execute commands, let's understand some initial concepts:

Building a house

To understand how Docker works on our machine and its use, I like to use the analogy of when we're building a house. In this case, let's think that we have a piece of land that is a condominium of houses, and we are going to build several houses there. The houses will have a standard for the main structure, and then we can customize each one with furniture, etc.

Firstly we need to think about the size of our house, the walls, doors and windows. Where the hydraulic and electrical parts will be located.
After this is defined, we pass it on to the architect or engineer to build the house blueprint.
With this, we can build one or several houses based on the house blueprint.
And then we can enter each house and put whatever we want inside. Even modify a door or window, work on each house individually. We can also demolish a house and build another in the same location, based on the initial blueprint.
Another issue is the bills (electricity, water). Let's assume that we always want to have a total of how much we are spending on the condominium. If we demolish a house, we cannot lose that value. So we need to have a place to store the bills outside each house, in addition to having a copy in the house itself.

Now that we have an idea of the hypothetical steps to build our condominium of houses, let's relate them to running an application with Docker.

First, we define the steps to build an image, that is, the house blueprint. These steps are saved in a Dockerfile, a file where is defined what we will need to have on the machine(s) we are going to run .
From this file, we built the image, the blueprint of our house. An image is basically a template for creating containers.
The containers are our homes. They are instances of a virtual machine running on our machine, with the settings specified in our image. We can upload a container and access it through the terminal. There, we can modify it as we want, installing new applications or libraries, running applications, creating a database, etc.
Finally, we can remove a container. This will erase any files or installations we have made inside it. When we upload a new container, we will have the initial specifications defined in our image.
What if we want to keep data from our container to the next one? We can use volumes for this. Like house bills, we need to save the information outside the container to persist it. This way, we create a "bridge" between our machine and the container, copying everything from one to the other. By removing the containers, we keep the data on our machine and can use it again.

Workflow

Once you understand these concepts, it becomes easier to understand a workflow using Docker. The commands below are better described at the end of this post.

Firstly, we need an image to work with. We can create a Dockerfile to build (docker build) one or download one from Docker Hub (docker pull).
After we have the image (docker images), we can run it (docker run) and generate a container, a virtual machine with the settings defined in the image.
Container can run once and stop, or keep running on our machine (docker ps). We can access the container (docker exec) and run commands inside it (remembering that any changes will be lost when we kill the container).
After using the container, we can kill it (docker stop) (docker rm). And if we wish, we can also remove the image (docker rmi), if we are no longer going to use it to create new containers.

Creating a Dockerfile

When creating a file, like the example above, we can build the Dockerfile into an image, running docker build -t <IMAGE-NAME>:<VERSION> <DOCKERFILE-DIRECTORY>. This creates the image with the commands and installations specified in the Dockerfile already executed.

From there, we can define the steps to configure the image with the initial settings. We always use an image as a base with the FROM command. RUN, for example, executes the commands.

Dockerfile main instructions

FROM: image that we will use as base.
WORKDIR: Defines the folder where we will execute the commands in the container.
RUN: Runs the specified commands.
COPY: Copies files from our pro image machine.
ENTRYPOINT: Command to be executed when we initialize the container.

Some others can be seen here.

Main Docker commands I use

Below, I have separated some of the main features that I use on a daily basis.

Using Images

docker pull <IMAGE-NAME>:<VERSION>: Pulls the image to our local machine. If the version is not passed, latest is used.
docker build <DOCKERFILE-PATH>: We build the Dockerfile in an image
- -t <IMAGE-NAME>:<VERSION>: We create an image name. It is interesting to use our Docker Hub user name followed by / and an image name: user/project-abc:v1
docker images: Lists the images downloaded to the machine.
docker rmi <IMAGE-ID>: Removes the image.

Listing and removal of containers.

docker ps: Lists the containers that are running.
- -a: Shows active containers or those that have already been run.
- -q: Lists container ids.
docker stop <CONTAINER-ID>: Stops the container that is running.
docker rm <CONTAINER-ID>: Removes the stopped container.
- -f: Forces removal, even if the container is running.

To remove all active and non-active containers:

docker rm -f $(docker ps -aq)

Manipulating containers

docker run <IMAGE> <COMMAND>: Run the image in our terminal with the given command.
- -i: Interactive module, keeping the process running.
- -t: Allows you to type things in the terminal.
- -p: Points to the port to be mapped.
- -d: Detaches the terminal from the process.
- -v: Volume for data persistence. We pass the local path, with ':' separating the path in the container. Changes to the container folder will persist on the local machine.
- --rm: Removes the container after finishing running it.
- --name: Defines a name for the container.
- Example: docker run -it ubuntu bash we run an Ubuntu image and run bash, allowing us to execute code in the terminal inside the container.
- Example: docker run -d -p 8080:80 nginx we run nginx and map port 8080 on our machine to port 80 on the container.
docker exec <CONTAINER-NAME> <COMMAND>: Executes a command in our already active container. (We can use the same flags as docker run, such as -it)

Working with volumes

docker volume ls: List volumes.
docker volume create <VOLUME-NAME>: Creates a volume.
docker volume inspect <VOLUME-NAME>: Shows volume data.
docker volume prune: Removes volumes and frees up space.

With this, we can create a volume by passing the --mount flag with the name of the volume created. Example:

docker run -d -p 8080:80 --mount type=volume,source=<VOLUME-NAME>,target=/app nginx

Or with the -v flag:

docker run -d -p 8080:80 -v <VOLUME-NAME>:/app nginx

Considerations

I tried to summarize the concepts and main commands I use in Docker. It's worth delving deeper and practicing uploading images for personal use. Another point is to study Docker Compose, which orchestrates multiple Docker containers to work together.
If you have any questions or comments, write them below and I will be happy to answer them.