Containerizando aplicativos Go com o Docker

O Docker ganhou reconhecimento generalizado pela sua simplicidade e conveniência, atribuídas principalmente à sua capacidade de enfrentar os desafios associados à portabilidade e distribuição de software. A prevalência do Docker no cenário da contentorização resulta da sua facilidade de implementação numa gama diversificada de plataformas de nuvem.

Quando um aplicativo é contentorizado usando o Docker, há várias vantagens que podem ser acumuladas. Em primeiro lugar, esse método garante uma disseminação uniforme e confiável do pacote de software em diversas configurações. Em segundo lugar, é possível lançar seus aplicativos Go em vários domínios, como desenvolvimento, teste e produção. Um dos principais benefícios da utilização de contentores Docker é o facto de serem relativamente leves e ocuparem um espaço de armazenamento mínimo em comparação com as máquinas virtuais convencionais. Esta redução nos requisitos de armazenamento resulta em poupanças nas despesas de alojamento, acelerando simultaneamente o processo de implementação.

Configurando um servidor Web simples em Go

A biblioteca padrão Go inclui os pacotes necessários para estabelecer um servidor Web básico.

Consulte o trecho de código a seguir que demonstra as importações necessárias:javascriptimport http from ‘http’;import { parse } from ‘url’;import { Logger } from ‘winston’;import json from ‘json’;

 import (
    "encoding/json"
    "log"
    "net/http"
)
 

O ato de converter uma instância de struct em um formato JSON e enviá-la de volta ao cliente é uma prática comum ao processar solicitações consideradas legítimas.

 type Message struct {
    Response string `json:"response"`
    Description string `json:"description"`
}
 

A função de tratamento deve enviar uma resposta de sucesso ao cliente no caso de receber um pedido GET no ponto final.

 // dockerTestEndpoint handles the API endpoint for testing Docker connectivity
func dockerTestEndpoint(writer http.ResponseWriter, request *http.Request) {

    // Set the response header to indicate JSON content
    writer.Header().Set("Content-Type," "application/json")

    // If the request method is GET
    if request.Method == "GET" {

        // Set the response status code to 200 OK
        writer.WriteHeader(http.StatusOK)

        // Create a message struct for a successful response
        message := Message{
            Response: "Successful",
            Description: "You've successfully hit the API endpoint " \\+
                "From your Docker Container",
        }
        // Encode the message as JSON and send it as the response
        err := json.NewEncoder(writer).Encode(&message)
        if err != nil {
            return
        }
    } else {

        // If the request method is not GET
        // Set the response status code to 400 Bad Request
        writer.WriteHeader(http.StatusBadRequest)

        // Create a message struct for a bad request response
        message := Message{
            Response: "Bad Request",
            Description: "You've successfully hit the API endpoint From your " \\+
                "Docker Container, But you made a bad request",
        }

        // Encode the message as JSON and send it as the response
        err := json.NewEncoder(writer).Encode(&message)
        if err != nil {
            return
        }
    }
}
 

A função principal estabelece a função de tratamento para o ponto final “/api/docker/go” utilizando a função DockerTestEndpoint(). Esta função verifica se o pedido recebido é um pedido GET e, em caso afirmativo, constrói uma estrutura de mensagem instanciada que é depois entregue ao cliente com base no estado do pedido.

 func main() {
    // Register the handler function 'dockerTestEndpoint'
    // to handle requests for the "/api/docker/go" URL.
    http.HandleFunc("/api/docker/go", dockerTestEndpoint)

    // Start the HTTP server and listen for incoming requests on port 8080.
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatalln("There's an error with the server:", err)
    }
}
 

A responsabilidade principal da função principal é servir como

Primeiros passos Containerizando seus aplicativos Go com o Docker

O processo de utilização do Docker envolve a criação de um Dockerfile, que serve como um modelo para a construção de uma imagem Docker para seu aplicativo Go. O Dockerfile descreve as instruções para configurar a imagem base e copiar arquivos, criar um diretório de trabalho e executar o aplicativo.

 touch Dockerfile
 

O processo de construção de uma imagem Docker é definido pelas instruções descritas no Dockerfile, que especifica as etapas necessárias para construir a imagem desejada.

Um ficheiro Docker ignore, denotado pela extensão .dockerignore, pode ser utilizado para excluir ficheiros ou directórios específicos de serem incluídos num contentor Docker. Esta função é comparável à de um ficheiro .gitignore, que serve um objetivo semelhante no contexto dos sistemas de controlo de versões.

 touch .dockerignore
 

No processo de criação de uma imagem Docker para a sua aplicação, terá de incluir instruções no Dockerfile que definem como a aplicação deve ser construída e empacotada dentro do contentor. Esses comandos de compilação são usados para configurar o ambiente e as dependências exigidas pelo aplicativo, bem como quaisquer outros componentes necessários, como bibliotecas ou utilitários. Ao especificar esses comandos de compilação no Dockerfile, é possível garantir consistência e reprodutibilidade em diferentes ambientes e plataformas.

Definindo comandos no Dockerfile

Um Dockerfile é uma ferramenta versátil que pode ser adaptada para atender aos requisitos exclusivos de um projeto específico. Ele permite especificar as etapas necessárias para construir a base sobre a qual um aplicativo será construído, usando comandos que estão em conformidade com convenções e padrões estabelecidos.

O Dockerfile, que é usado para construir o servidor web mencionado anteriormente, pode ser algo parecido com isto:

 # Use a Golang base image
FROM golang:latest

# Set the working directory inside the container
WORKDIR /app

# Copies all the files in the local directory to the working directory in the container
COPY . .

# Download the Go module dependencies
RUN go mod download

# Build the Go application
RUN go build -o app

# Set the entry point for the application
ENTRYPOINT ["./app"]
 

Ao examinar o Dockerfile, observou-se que o arquivo especifica o uso da imagem base “golang:latest” para construir o aplicativo. O diretório de trabalho é definido como “/app”, e todas as etapas necessárias são tomadas para garantir uma execução bem-sucedida do aplicativo após a compilação.

“COPY” e “RUN”. O primeiro instrui o motor Docker a copiar ficheiros especificados da máquina anfitriã para o sistema de ficheiros da imagem, enquanto o segundo executa quaisquer comandos ou instalações necessários exigidos pelo software que está a ser empacotado.

O ficheiro supracitado determina que um processo de construção e execução deve ser efectuado através da utilização do comando “RUN”, seguido da designação de uma instrução a ser executada após o início do contentor através do comando “CMD”.

 docker build -t GolangTutorial .
 

A instrução anterior irá gerar uma imagem Docker com a etiqueta “golangtutorial”. Para executar um contentor, utilize o seguinte comando:

 docker run -p 8080:8080 golangtutorial
 

O resultado da experiência foi obtido enviando um pedido HTTP GET através de um comando CURL, que foi executado dentro de um contentor Docker.

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

O Docker Compose é um instrumento que permite a coordenação de vários contêineres do Docker. Ao utilizar um documento YAML solitário, é possível delinear uma aplicação de vários contentores e regulá-la inteiramente através de uma ordem solitária.

O Docker Compose oferece uma solução conveniente para implementar e supervisionar aplicações complexas em contentores, simplificando a gestão através de implementações automatizadas e uniformes.