Fala empoderadas(os),
Esse é meu segundo artigo sobre a ferramenta Docker, para quem não leu o primeiro e tem dúvidas sobre como construir um container, é só clicar aqui.

Sempre tem aquele famoso problema no mundo de TI, onde quando vamos rodar a aplicação ela não funciona na nossa máquina e o colega diz a seguinte frase “Ah, mas na minha máquina está funcionando”, quem nunca ouviu ou disse essa frase que atire a primeira pedra!!

Pois bem, ao utilizar o Docker, temos uma vantagem e ela se chama “imagem”. No artigo anterior dei uma breve introdução sobre ela, que seria basicamente uma receita de bolo composta por camadas para a construção de um container.

Tá, mas qual a vantagem de eu utilizá-la?

Simples, vários containers podem ser construídos a partir de uma única imagem, ou seja a mesma estrutura que tem na aplicação que você construiu, terá nos containers das pessoas do seu time, o que diminui drasticamente o tempo de deploy de um ambiente para o outro.

Além disso você não precisa se preocupar com desvios de ambiente, ou seja diferentes versões das dependências instaladas em todos os ambientes que você implanta.
Tendo em mente tudo isso, vale ressaltar que as imagens são geradas a partir de comando docker, exemplo “docker run node”, ou a partir do momento em que o Dockerfile estiver rodando.

Mas o que é Dockerfile?

Dockerfile é um arquivo feito para automatizar o processo de execução de tarefas no Docker, ou seja ele contém uma série de instruções, comandos que você faria manualmente só que de uma forma automatizada.
Ele pode ser compartilhado através do repositório aberto chamado Docker Hub, onde você pode fazer upload e utilizar quando necessitar.
Neste arquivo iremos descrever todas as especificações que temos na aplicação.

Mas como eu crio uma imagem então?!

Calma pessoal, antes vamos criar um projeto com um arquivo chamado “app.py” e colar o código abaixo, onde utilizamos o Flask, um framework em python, você não precisar ter um conhecimento em python tá galera?!

from flask import Flask
app = Flask(__name__)
@app.route(“/”)
def hello():
return “Hello World”
if __name__ == “__main__”:
app.run(host=”0.0.0.0")

O que você precisa saber sobre este código é que criamos um site que responde na porta default 5000, e para rodá-lo digitamos no prompt de comando:
“python app.py”
E colocar no navegador “localhost:5000”

Quando criamos um container, temos esta saída gerada:

Vocês estão vendo cada pedaço que ele está instalando? Se chamam camadas, são elas que constroem a imagem e é o que iremos definir no Dockerfile, cada comando é uma camada na imagem.

Então vamos criar um arquivo chamado “dockerfile” no mesmo projeto que está meu código.

Neste arquivo, vamos colocar as dependências do projeto com a seguinte sintaxe:

FROM …
RUN …
ENTRYPOINT …
COPY …

· FROM: declaramos a imagem inicial para a construção do comtainer, no nosso caso seria o python com a versão 3.6.1-alpine. É adicionado uma camada na imagem.

· RUN: instala as depedências. No nosso caso queremos que ele instale o Flask antes de executar o nosso código, portanto “pip install flask”. É adicionado mais uma camada na imagem.

· ENTRYPOINT: executa um comando quando o container é iniciado. No nosso caso queremos que ele rode o código, então “python app.py”.

· COPY: copia o arquivo app.py do seu computador para a imagem do docker. Adiciona mais uma camada na imagem.

Então nosso Dockerfile fica assim:

FROM python:3.6.1-alpine
RUN pip install flask
ENTRYPOINT [“python”, “app.py”]
COPY app.py /app.py

Para encapsular cada camada para a imagem, dentro da sua pasta digite o seguinte código:

docker build -f dockerfile -t seu_User_Docker_Hub/nomedaImg .

-f: passar o nome do meu dockerfile
-t: passar o nome da imagem, como boa prática é recomendado colocar o usuário do Docker Hub/nome da imagem
. : pegar o arquivo do diretório local

Podemos listar as imagens que você tem no Docker e notar que a imagem que acabamos de criar está disponível para utilizarmos:
docker image ls

Vamos testar para ver se a aplicação está funcionando?

Para isso precisamos criar um container com a imagem criada. Lembra que nossa aplicação roda na porta 5000? Então, precisamos definir na criação do container a porta que ele vai rodar

docker run -p 5000:5000 seuNome/nomedaImg

Ao digitar a url “localhost:5000”, você verá que ela está rodando normalmente!

Boa! Acabamos de criar uma imagem que roda localmente. Vamos agora disponibilizar o nosso Dockerfile no Docker Hub, para que outras pessoas possam utilizá-la também.

Para isso, você vai precisar seguir os seguintes passos:

1. Logar no Docker Hub: docker login
2. Criar uma tag para sua imagem docker tag seu_User_Docker_Hub/nomedaImg python-hello-world
3. Subir no Docker Hub docker push seu_User_Docker_Hub/nomedaImg

1. Validar no seu Docker Hub

Parabéns pessoal, vocês acabaram de subir o Dockerfile de vocês, se uma pessoa quiser criar um container igual a imagem que rodamos anteriormente, ela conseguirá executar a aplicação!!

LinkedIn
Medium