Implantação de aplicação Go no Kubernetes: guia passo a passo

Introdução: por que Go e Kubernetes são a dupla ideal

Go (Golang) e Kubernetes são o padrão moderno para construir e implantar arquiteturas de microsserviços. Go compila para um binário estático, não requer dependências na máquina de destino, inicia rapidamente e usa memória de forma eficiente. Kubernetes, por sua vez, fornece automação para implantação, escalonamento e gerenciamento de contêineres.

Neste guia, vamos percorrer na prática o ciclo completo de implantação de uma aplicação Go simples no Kubernetes. Você aprenderá como escrever um Dockerfile, criar manifestos para Kubernetes (Deployment, Service, ConfigMap) e executar a aplicação em um cluster. Todos os exemplos de código podem ser usados imediatamente em seus projetos.

1. Preparando a aplicação Go para conteinerização

Para começar, vamos criar um servidor HTTP simples em Go que responderá a requisições e exibirá uma saudação. É importante que a aplicação escute na porta que especificaremos através de uma variável de ambiente. Esta é uma prática padrão para Kubernetes.

Crie o arquivo main.go:

package main

import (    "fmt"    "log"    "net/http"    "os")

func main() {    port := os.Getenv("PORT")    if port == "" {        port = "8080"    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {        name := os.Getenv("APP_NAME")        if name == "" {            name = "Go App"        }        fmt.Fprintf(w, "Saudações de %s! Trabalhando na porta %s", name, port)    })

    log.Printf("Servidor iniciado na porta %s", port)    log.Fatal(http.ListenAndServe(":"+port, nil))}

Este código lê as variáveis de ambiente PORT e APP_NAME, o que nos permitirá configurar a aplicação de forma flexível através do ConfigMap no Kubernetes.

2. Criando o Dockerfile para a aplicação Go

Para implantar no Kubernetes, precisamos de uma imagem Docker. Usaremos uma compilação em múltiplos estágios (multi-stage build) — isso reduzirá o tamanho da imagem e aumentará a segurança.

Crie o arquivo Dockerfile:

# Estágio de compilaçãoFROM golang:1.22-alpine AS builder

WORKDIR /appCOPY go.mod go.sum ./RUN go mod downloadCOPY . .RUN CGO_ENABLED=0 GOOS=linux go build -o /app/server .

# Imagem finalFROM alpine:latestRUN apk --no-cache add ca-certificatesWORKDIR /root/COPY --from=builder /app/server .EXPOSE 8080CMD ["./server"]

Compile a imagem e envie para um registro (por exemplo, Docker Hub):

docker build -t yourusername/go-k8s-app:latest .docker push yourusername/go-k8s-app:latest

3. Manifestos Kubernetes: Deployment, Service, ConfigMap

Agora vamos criar os manifestos para implantar a aplicação no cluster. Recomenda-se armazená-los na pasta k8s/.

3.1. ConfigMap para configuração

Vamos externalizar as configurações da aplicação para um ConfigMap — isso permitirá alterá-las sem reconstruir a imagem.

Arquivo k8s/configmap.yaml:

apiVersion: v1kind: ConfigMapmetadata:  name: go-app-configdata:  APP_NAME: "Minha aplicação Go"  PORT: "8080"

3.2. Deployment — descrição do pod

O Deployment gerencia as réplicas do pod e garante atualizações sem tempo de inatividade.

Arquivo k8s/deployment.yaml:

apiVersion: apps/v1kind: Deploymentmetadata:  name: go-app-deployment  labels:    app: go-appspec:  replicas: 2  selector:    matchLabels:      app: go-app  template:    metadata:      labels:        app: go-app    spec:      containers:      - name: go-app        image: yourusername/go-k8s-app:latest        ports:        - containerPort: 8080        envFrom:        - configMapRef:            name: go-app-config        livenessProbe:          httpGet:            path: /            port: 8080          initialDelaySeconds: 5          periodSeconds: 10\