Containerização de aplicativos Go com Docker

O Docker é a tecnologia de conteinerização mais popular devido à sua simplicidade e facilidade de uso. O Docker alivia o estresse dos problemas de portabilidade no desenvolvimento e distribuição de software. Você pode implantar seus contêineres docker na maioria dos provedores de serviços em nuvem.

Conteinerizar seus aplicativos Go com o Docker pode ajudá-lo a garantir uma implantação consistente e confiável em diferentes ambientes. Você pode implantar seus aplicativos Go em diferentes ambientes, como desenvolvimento, preparação e produção. Os contêineres do Docker são leves e ocupam menos espaço do que as máquinas virtuais tradicionais. Isso pode economizar dinheiro em custos de hospedagem e também pode tornar suas implantações mais rápidas.

Configurando um servidor Web simples em Go

A biblioteca padrão Go contém os pacotes necessários para configurar um servidor web simples.

Primeiro, importe o http, registro, e json pacotes. você vai usar Pacote http do Go para configurar o servidor e PEGAR ponto final da solicitação. O registro pacote para registrar possíveis erros em seu console. O pacote json para codificar uma struct para JSON para o ponto de extremidade da API.

importar (
"codificação/json"
"registro"
"rede/http"
)

Você pode codificar uma instância struct como JSON para o cliente como uma resposta com base na validade da solicitação da seguinte forma:

tipo Mensagem estrutura {
 Resposta corda`json:"resposta"`
 Descrição corda`json:"descrição"`
}

A função do manipulador retornaria uma mensagem de sucesso para o cliente se a solicitação para o terminal fosse uma PEGAR solicitar.

// dockerTestEndpoint lida com o endpoint da API para testar a conectividade do Docker
funçãodockerTestEndpoint(escritor http. ResponseWriter, solicite *http. Solicitar) {
// Defina o cabeçalho de resposta para indicar o conteúdo JSON
 escritor. Cabeçalho().Set("Tipo de conteúdo,""aplicativo/json")
// Se o método de requisição for GET
se solicitar. Método == "PEGAR" {
// Defina o código de status da resposta para 200 OK
 escritor. WriteHeader (http. StatusOK)
// Cria uma estrutura de mensagem para uma resposta bem-sucedida
 mensagem := Mensagem{
 Resposta: "Bem-sucedido",
 Descrição: "Você atingiu com sucesso o endpoint da API" +
"Do seu contêiner do Docker",
 }
// Codifica a mensagem como JSON e envia como resposta
 erro := json. NewEncoder (gravador).Encode(&mensagem)
se erro != nada {
retornar
 }
 } outro {
// Se o método de requisição não for GET
// Defina o código de status da resposta para 400 Bad Request
 escritor. WriteHeader (http. StatusBadRequest)
// Cria uma estrutura de mensagem para uma resposta de solicitação inválida
 mensagem := Mensagem{
 Resposta: "Pedido ruim",
 Descrição: "Você atingiu com sucesso o endpoint da API do seu " +
"Docker Container, mas você fez uma solicitação incorreta",
 }
// Codifica a mensagem como JSON e envia como resposta
 erro := json. NewEncoder (gravador).Encode(&mensagem)
se erro != nada {
retornar
 }
 }
}

Você configura a função do manipulador na função principal com a rota como /api/docker/go. O dockerTestEndpoint A função do manipulador valida que a solicitação para o manipulador é uma solicitação GET. Se for uma solicitação GET, ela codifica uma instância Mensagem struct para o cliente com base no status da solicitação.

Veja como você pode montar a função do manipulador em uma rota e configurar o servidor para executar na porta 8080:

funçãoprincipal() {
// Registra a função do manipulador 'dockerTestEndpoint'
// para lidar com solicitações para a URL "/api/docker/go".
 http. HandleFunc("/api/docker/go", dockerTestEndpoint)
// Inicia o servidor HTTP e escuta as solicitações recebidas na porta 8080.
 erro := http. OuvirEServir(":8080", nada)
se erro != nada {
 registro. Fataln("Há um erro com o servidor:", erro)
 }
}

O principal função é o ponto de entrada do servidor, que escuta na porta 8080. O HandleFunc O método monta as rotas na função do manipulador. O OuvirEServir método inicia o servidor na porta do host local especificado 8080.

Introdução à conteinerização de seus aplicativos Go com o Docker

Depois de instalar e configurar o Docker, você precisará de um arquivo do Docker chamado Dockerfile para criar e construir uma imagem do Docker para seu aplicativo Go. Você especificará comandos para a imagem base e comandos para copiar os arquivos, adicionar o diretório de trabalho e executar o aplicativo no Dockerfile.

Execute este comando no terminal do seu espaço de trabalho para criar um Dockerfile.

toque em Dockerfile

Você especificará os comandos para criar sua imagem do Docker no Dockerfile.

Se houver algum arquivo que você deseja separar de sua imagem do Docker, você pode usar um .dockerignore arquivo. O .dockerignore os arquivos funcionam exatamente como .gitignore arquivos.

toque em .dockerignore

Em seguida, você especificará comandos de compilação em seu Dockerfile para conteinerizar seus aplicativos.

Definindo comandos no Dockerfile

Dockerfiles são personalizáveis ​​com base nas especificações do seu projeto. Você definirá comandos para criar a imagem base para criar o aplicativo.

Aqui está um exemplo do conteúdo de um Dockerfile que constrói o servidor web acima:

# Use uma imagem de base Golang
DE golang: mais recente
# Defina o diretório de trabalho dentro do contêiner
WORKDIR /app
# Copia todos os arquivos do diretório local para o diretório de trabalho no contêiner
CÓPIA DE. .
# Baixe as dependências do módulo Go
CORRER vá baixar o mod
# Crie o aplicativo Go
CORRER ir construir -o aplicativo
# Defina o ponto de entrada para o aplicativo
PONTO DE ENTRADA ["./aplicativo"]

O Dockerfile usa golang: mais recente imagem base, para construir o aplicativo depois de definir o diretório de trabalho para /app.

O Dockerfile copia os arquivos com a extensão CÓPIA DE comando e downloads de dependências com o CORRER comando.

O arquivo especifica uma operação de compilação e execução com o CORRER comando e, em seguida, define o comando para ser executado quando o contêiner iniciar com o CMD comando.

Salve o Dockerfile no mesmo diretório do seu go.mod e main.go arquivos; em seguida, execute este comando para criar uma imagem do Docker a partir deste Dockerfile:

docker build -t GolangTutorial .

O comando acima criará uma imagem do Docker com a tag golangtutorial. Você pode executar um contêiner com este comando:

docker run -p 8080:8080 golangtutorial

O comando mapeia a porta 8080 do contêiner para a porta 8080 no host local da máquina host. Você pode solicitar o servidor em execução no contêiner Docker da máquina host.

Aqui está o resultado de enviando a solicitação CURL para o servidor, desta vez rodando no Docker:

Você pode usar o Docker Compose para orquestração de contêineres

O Docker Compose é uma ferramenta que você pode usar para orquestrar (trabalhar com muitos) contêineres do Docker. O Docker Compose permite definir um aplicativo de vários contêineres em um único arquivo YAML. Você pode executar e gerenciar todo o aplicativo com um único comando.

Você pode usar o Docker Compose para implantar e gerenciar aplicativos complexos em contêineres. O Docker Compose simplifica o gerenciamento com implantações automatizadas e consistentes.