Criando o seu primeiro Docker Container

Docker é uma plataforma de código aberto que permite aos desenvolvedores criar, publicar e executar facilmente aplicativos de forma isolada. Os containers são leves e portáteis porque suas configurações e sistema operacional são encapsulados, permitindo que sejam executados de forma consistente, independentemente da infraestrutura e respeitando sua arquitetura (x86_64, amd64 e arm).

A plataforma facilita o empacotamento de um aplicativo em uma imagem de container com garantia de execução em qualquer sistema operacional compatível com o Docker. Isso significa que podemos criar um aplicativo, empacotar e garantir que ele seja executado em qualquer servidor de produção ou até mesmo seu laptop. Esse é o fim desta história…

O Docker usa uma arquitetura de cliente e servidor para se comunicar com o daemon, um recurso que tem foi muito falado e é o motivo pelo qual não é mais suportado no Kubernetes, mas vamos guardá-lo para o artigo sobre Podman.

How to run Secure Pods with Podman

O grande recurso que impulsionou a popularidade dos containers foi o Docker CLI. Antes da introdução do Docker, o kernel do Linux passou por atualizações que possibilitaram a execução de processos isolados que chamamos de "containers", mas fazer essa execução isolada era um assunto bastante avançado, não tínhamos o DockerHub e apenas um monte de scripts. A CLI tornou isso fácil e rico em detalhes. Além da orquestração, podemos extrair logs, automatizar processos de desenvolvimento e entrega contínua.

A popularidade do Docker é tão grande que podemos dizer que ele se tornou a ferramenta padrão para a criação de ambientes de desenvolvimento. Antes do Docker quando tudo era mato! Havia a necessidade de instalar nossas ferramentas de trabalho como bancos de dados, serviços de cache, serviços de mensagens, linguagens de programação e outras ferramentas diretamente na instância de trabalho e muitas vezes tínhamos dificuldade em preparar o ambiente. O Docker é utilizado por empresas de diversos portes que desejam reduzir e entender seus custos.

Sem mais delongas, iremos criar nosso primeiro container.

Instale o Docker primeiro, a documentação oficial cobre todas os sabores de distribuições e métodos de instalação, saiba mais clicando aqui.

1. Escolher uma imagem

Ao trabalhar com Docker, o tamanho da imagem também é um fator muito relevante e deve ser levado em consideração, por isso vamos trabalhar com Alpine Linux, que tem um tamanho virtual em torno de 40MB e se mantém constantemente atualizado.

Neste momento a última versão do alpine é 3.17.2.

2. Criar um Dockerfile

Para manter tudo em casa, construiremos uma aplicação em Go, a linguagem em que o Docker foi escrito.

Abaixo temos alguns arquivos necessários para compilar nossa aplicação em Go.

• go.mod

module flip_coin

go 1.20

• flip_coin.go

package main

import (
	"fmt"
	"net/http"
	"math/rand"
	"time"
)


func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		coin := []string{
			"heads",
			"tails",
		}
	
		rand.Seed(time.Now().UnixNano())
		side := coin[rand.Intn(len(coin))]

        fmt.Fprintf(w, "You got %s\n", side)
    })

	http.ListenAndServe(":3000", nil)
}

Pronto hora de escrever nosso Dockerfile.

FROM golang:alpine3.17

MAINTAINER [email protected]

WORKDIR /app

COPY flip_coin.go go.mod ./

RUN go build -o /flip_coin

EXPOSE 3000

CMD [ "/flip_coin" ]

• FROM imagem base para compilação;
• MAINTAINER e-mail do responsável pela imagem;
• WORKDIR diretório de execução;
• COPY arquivos que serão copiados para o diretório de execução;
• RUN executa comandos antes da execução do container;
• EXPOSEindica quais portas esse container irá utilizar ou escutar;
• CMD indica qual será o comando para execução do container;

Existem outras instruções utilizadas para o Dockerfile como ADD, ENTRYPOINT, ENV, entre outros veja mais na documentação oficial.

3. Compilar a imagem

Nesta etapa iremos utilzar o comando build para compilar nosso Docker file e transformar em uma imagem nomeada my-first-container.

docker build -t [nome-da-image] [diretório-base]

docker build -t my-first-container .

4. Executar o container

Podemos executar o container no modo "attached", podemos chamar de modo síncrono, ou "detached" seria o modo background.

docker run --name [nome-do-container] [nome-da-imagem]

# attached
docker run --name my-first-container --rm -p 3001:3000 my-first-container

# detached
docker run -d --name my-first-container -p 3001:3000 my-first-container

• --name atribui um nome que deve ser único a container;
• --rm remove o container após a execução
• -p 3001:3000 informa que a porta pública 3001 será encaminhada para a porta privada 3000 do container;
• -d roda no modo "detached" desta forma a execução seu terminal fica livre e a execução ocorre em background;

Testando o container

Iremos executar uma requisição na URL http://localhost:3001/, onde iremos obter a resposta do cara ou coroa.

curl  --location  http://localhost:3001/
> You got tails

Inspecionando

docker ps -a
docker images

• ps lista os containers, o parâmetro -a informa que desejamos a lista completa inclusive os que não estão em execução;
• images lista container images baixados e compilados localmente.

Removendo tudo

docker stop my-first-container
docker rm my-first-container
docker rmi my-first-container

• stop para a execução do container;
• rm remove o container;
• rmi remove a imagem compilada do container;

Outros artigos

Docker é um dos temas que tenho dedicado bastante ultimamente, existem outros artigos que podem complementar este estudo como: Volumes, Logs, Network e outros recursos, veja mais no link abaixo.

• Artigos relacionados ao Docker

Fim!

Espero que este artigo seja de grande ajuda para você que está entrando neste mundo de tecnologia onde um framework ou linguagem nasce a cada minuto.

Até a próxima, Deus abençoe seu dia e mantenha seu kernel atualizado!