Criando o seu primeiro Docker Container

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…

Na minha máquina funciona!

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.

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!