Docker

Docker é uma plataforma para desenvolvedores e administradores de sistemas criarem, enviarem e executarem aplicativos que:

• Permite que você monte aplicativos rapidamente a partir de componentes e elimina o atrito que pode surgir ao enviar o código.

• Permite que você teste e implante seu código em produção o mais rápido possível.

Docker simplifica a entrega de software, tornando mais fácil construir e compartilhar imagens que contêm todo o ambiente do seu aplicativo ou sistema operacional do aplicativo.

Instalando o Docker

• Docker Desktop: https://docs.docker.com/get-docker/

Docker HUB

O Docker Hub é um serviço fornecido pela Docker Inc para localizar e compartilhar imagens de containers.

Criar conta em: https://hub.docker.com/signup

• dockerID: nome do seu repositório que será usado para encontrar suas imagens compartilhadas.

Play with Docker (lab online)

• https://labs.play-with-docker.com/

Docker Engine

Imagem

É o componente de construção do Docker.

Imagens são templates somente leitura que definem um sistema operacional de aplicativo a partir dos quais os containers do Docker são iniciados.

Cada imagem começa a partir de uma imagem base, por exemplo ubuntu, uma imagem base do Ubuntu, ou fedora, uma imagem base do Fedora. Você também pode usar suas próprias imagens como base para uma nova imagem, por exemplo, se você tiver uma imagem base de Go, poderá usá-la como base para todas as imagens de seus aplicativos.

Baixando uma Imagem

O comando docker pull faz download de uma imagem compartilhada no docker hub

docker pull hello-world

Listando Imagens

docker images

ou

docker image ls

Outros comandos

docker image

Container

Container é o componente de execução do Docker e é criado a partir de uma imagem. Essa imagem informa ao Docker o que o container contém, qual processo executar quando for iniciado e uma variedade de outros dados de configuração. A imagem Docker é somente leitura. Quando o Docker executa um container a partir de uma imagem, ele adiciona uma camada de leitura e gravação na parte superior da imagem na qual seu aplicativo pode ser executado.

Um container pode ser executado, iniciado, parado, movido e excluído.

Executando um Container

O Docker Engine tenta encontrar uma imagem chamada hello-world. Ele encontra a imagem e a executa em um container. A única função do hello-world é enviar o texto que você vê em seu terminal.

docker run hello-world

Listando Containers em Execução

docker ps

ou

docker container ls

Listando todos os Containers

docker ps -a

Outros comandos de Container

docker container

Criando uma Imagem

Dockerfile

Docker constrói imagens lendo as instruções de um Dockerfile.

Um Dockerfile é um documento de texto que contém todos os comandos que um usuário pode chamar na linha de comando para montar uma imagem.

O comando docker image build usa esse arquivo e executa todos os comandos em sucessão para criar a imagem.

Comandos do Dockerfile

FROM -> Diz qual imagem base será utilizada

COPY -> Copia multiplos arquivos do contexto local para o container

ENV -> Seta uma variável de ambiente

RUN -> Executa um comando

CMD -> Define o comando a ser executado pelo container

EXPOSE -> Informa as portas de rede que estão escutando

Criando uma Imagem

Crie um diretório chamado helloworld

Abra um editor de texto e crie um arquivo chamado Dockerfile dentro de helloworld com o seguinte conteudo:

FROM ubuntu:latest

CMD ["/bin/echo", "hello world =)"]

Gerando a Imagem

O docker build vai criar uma imagem de nome myhelloworld utilizando o contexto local (.)

docker image build -t myhelloworld .

Listando a Imagem

docker image ls

Rodando o Container

docker run myhelloworld

LetsGo WWG APP

Agora vamos criar uma imagem para compilar e executar nossa APP.

Clonando o repositório

git clone https://github.com/womenwhogocwb/lets-go-wwg-app.git

Criando o Dockerfile

Entre na pasta lets-go-wwg-app e crie um arquivo com o nome Dockerfile com o seguinte conteudo:

FROM golang:latest
RUN mkdir /app
COPY . /app
WORKDIR /app
RUN go build -o build/api cmd/main.go
EXPOSE 3000
CMD ["/app/build/api"]

Gerando a Imagem

docker build -t letsgo-app .

Executando o Container

Estamos executando o container no modo interativo sem mapear nenhuma porta

docker run -it letsgo-app

Agora estamos mapeando a porta 3000 do container para a porta 8080 na maquina host

docker run -it -p 8080:3000 letsgo-app

Mapeando para uma porta aleatória na maquina host (só é possivel por causa do EXPOSE)

docker run -it -P letsgo-app

Executando o Container como Daemon e não mais de forma interativa

docker run -d -p 8080:3000 letsgo-app

Testando

Em outro terminal execute:

curl -i 127.0.0.1:8080/games

Conteúdos Extras

• https://github.com/badtuxx/DescomplicandoDocker#sum%C3%A1rio

• https://training.play-with-docker.com/go-docker/

• https://www.docker.com/blog/tag/go-env-series/

• https://training.play-with-docker.com/