Guia de Implementação: Microsserviços em Go (Golang) de Alta Performance no Locaweb Cloud

[Informação!]

A arquitetura de microsserviços foca em eficiência. O Go (Golang) é ideal por criar binários leves e nativos, dispensando interpretadores ou máquinas virtuais pesadas.

1. Pré-requisitos

Para que a sua aplicação funcione em alta performance e sem gargalos técnicos, valide os seguintes requisitos antes de iniciar:

• Conta ativa no painel do Locaweb Cloud.
• Uma máquina virtual (VM) ativa (recomendamos o Ubuntu 22.04 LTS).
• Chave privada SSH (.key ou .pem) salva localmente com permissão restrita (chmod 400).
• Ambiente local com Go instalado (caso utilize o método de deploy manual).
• Repositório Git com o código-fonte (caso utilize o método com Docker e GitHub Actions).

 

2. Configuração de Infraestrutura (painel)

Prepare toda a arquitetura de rede no painel do Locaweb Cloud antes de abrir o terminal de comandos. Por padrão, sua instância nasce protegida e isolada de qualquer tráfego externo.

Passo 1: Configurar o Encaminhamento de Portas (Port Forwarding)

O encaminhamento de portas direciona o tráfego recebido no seu IP público fixo diretamente para as portas privadas da sua VM:

Protocolo	Porta Pública	Porta Privada	VM de Destino	Finalidade
TCP	8080	8080	Sua VM Go	Tráfego público do microsserviço
TCP	22	22	Sua VM Go	Acesso SSH Administrativo

 

[Aviso!] Jamais exponha a porta padrão (5432) do seu banco de dados PostgreSQL em regras de port forwarding público. O banco deve operar de forma invisível na rede interna para eliminar os riscos de uma operação fragmentada ou vulnerável.

Passo 2: Configurar as Regras de Firewall de Entrada

Na aba Firewall do seu IP público, libere explicitamente a entrada de tráfego para validar o tráfego de rede:

CIDR de Origem	Protocolo	Porta Inicial	Porta Final	Finalidade
0.0.0.0/0	TCP	8080	8080	Acesso público ao microsserviço
<SEU_IP_DE_ADMIN>/32	TCP	22	22	SSH restrito à sua rede de TI

 

3. Configuração de Sistema (Terminal)

Com as portas configuradas, conecte-se à instância via SSH pelo terminal local e atualize os índices de pacotes do sistema operacional para garantir a estabilidade do ecossistema:

Bash

 

# Conecta-se à VM utilizando sua chave privada

ssh -i ~/.ssh/sua-chave.key ubuntu@<SEU_IP_PUBLICO>


# Atualiza a lista de pacotes locais do Ubuntu

sudo apt-get update

4. Banco de dados: PostgreSQL

Para centralizar os dados de forma segura, o banco de dados rodará localmente na mesma VM da aplicação, respondendo apenas ao endereço de loopback (localhost), o que impede acessos vindos da internet.

Passo 1: Instalação do serviço

Instale o PostgreSQL e seus utilitários complementares através dos repositórios oficiais:

Bash

 

sudo apt-get install -y postgresql postgresql-contrib


# Habilita e inicializa o serviço junto ao systemd

sudo systemctl enable --now postgresql

Passo 2: Criação do usuário e da base de dados

Acesse o console interativo SQL e configure o ambiente do microsserviço:

Bash

sudo -u postgres psql

SQL

-- Comandos executados dentro do prompt postgres=#

CREATE DATABASE microsservico_db;

CREATE USER appgo WITH ENCRYPTED PASSWORD 'TroqueEstaSenha_2026!';

GRANT ALL PRIVILEGES ON DATABASE microsservico_db TO appgo;

\c microsservico_db

GRANT ALL ON SCHEMA public TO appgo;

\q

Passo 3: Ajuste de isolamento de rede

Abra o arquivo principal de configuração para garantir que o serviço escute apenas o tráfego em localhost:

Bash

sudo nano /etc/postgresql/14/main/postgresql.conf

Ini, TOML

listen_addresses = 'localhost'

Em seguida, valide o arquivo pg_hba.conf para exigir autenticação por senha criptografada robusta:

Bash

sudo nano /etc/postgresql/14/main/pg_hba.conf

# Mantenha a linha de conexões locais com o método scram-sha-256

host    all    all    127.0.0.1/32    scram-sha-256

Aplique as alterações reiniciando o serviço:

Bash

sudo systemctl restart postgresql

Sua aplicação Go se conectará ao banco através da seguinte string de conexão em ambiente local:

 

DATABASE_URL=postgres://appgo:TroqueEstaSenha_2026!@localhost:543
2/microsservico_db?sslmode=disable

5. Deploy do microsserviço

Método 1 (Recomendado): Docker Multi-stage e GitHub Actions

A conteinerização e a automação via CI/CD eliminam erros de configuração e otimizam seu time-to-market. Instale o Docker utilizando o repositório oficial assinado da plataforma:

Bash

sudo apt-get install -y ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | 
sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg




echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt
/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu 
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee 
/etc/apt/sources.list.d/docker.list > /dev/null




sudo apt-get update && sudo apt-get install -y 
docker-ce docker-ce-cli containerd.io docker-buildx-plugin 
docker-compose-plugin

sudo systemctl enable --now docker && sudo usermod -aG docker $USER

Crie um arquivo chamado Dockerfile na raiz do seu projeto local. Utilizaremos o build multi-stage para compilar o binário em um estágio e rodá-lo em uma imagem Alpine minimalista no segundo estágio, reduzindo o tamanho final do contêiner:

Dockerfile

# Estágio 1: Compilação do binário estático Go

FROM golang:1.22-alpine AS builder

WORKDIR /app

COPY go.mod go.sum ./

RUN go mod download

COPY . .

RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o microsservico .




# Estágio 2: Imagem final enxuta para execução

FROM alpine:3.20

WORKDIR /app

COPY --from=builder /app/microsservico .

EXPOSE 8080

CMD ["./microsservico"]

Na pasta /opt/microsservico da sua VM, configure o arquivo docker-compose.yml utilizando o gateway nativo para alcançar o PostgreSQL do host de forma segura:

YAML

services:

  app:

    build: .

    restart: always

    ports:

      - "8080:8080"

    environment:

      DATABASE_URL: "postgres://appgo:TroqueEstaSenha_2026
!@host.docker.internal:5432/microsservico_db?sslmode=disable"

    extra_hosts:

      - "host.docker.internal:host-gateway"

Para automatizar o fluxo, salve o workflow .github/workflows/deploy.yml no seu repositório Git, configurando as variáveis secretas (SSH_HOST, SSH_USER, SSH_KEY) para reconstruir o contêiner de forma 100% self-service a cada push na branch main.

Método 2: Deploy manual com binário compilado

Se preferir rodar a aplicação diretamente no Linux sem contêineres, execute a compilação cruzada na sua máquina de desenvolvimento local para gerar o binário estático do sistema:

Bash

# Executado na sua máquina local de desenvolvimento

CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o meumicrosservico 
main.go



# Transfere o binário compilado de forma criptografada para o servidor

scp -i ~/.ssh/sua-chave.key meumicrosservico ubuntu@<SEU_IP_PUBLICO>:
/tmp/meumicrosservico

No terminal da VM, mova o arquivo e crie um usuário de sistema sem privilégios para executar os processos com segurança:

Bash

sudo mv /tmp/meumicrosservico /usr/local/bin/meumicrosservico

sudo useradd -r -s /bin/false appgo

sudo chown appgo:appgo /usr/local/bin/meumicrosservico

sudo chmod +x /usr/local/bin/meumicrosservico

Crie o arquivo de configuração da unidade de serviço no systemd para garantir a resiliência em segundo plano:

Bash

sudo nano /etc/systemd/system/meumicrosservico.service

Ini, TOML

[Unit]

Description=Microsservico em Go de Baixa Latencia

After=network.target postgresql.service




[Service]

Type=simple

User=appgo

Group=appgo

Restart=on-failure

RestartSec=5

Environment=DATABASE_URL=postgres://appgo:TroqueEstaSenha_2026!
@localhost:5432/microsservico_db?sslmode=disable

ExecStart=/usr/local/bin/meumicrosservico

WorkingDirectory=/usr/local/bin




[Install]

WantedBy=multi-user.target

Bash

# Recarrega o daemon, habilita o boot automático e inicializa 
o microsserviço

sudo systemctl daemon-reload

sudo systemctl enable meumicrosservico

sudo systemctl start meumicrosservisons

7. Validação 

Testes de resposta interna

Na VM da aplicação, valide se a API e as tabelas do PostgreSQL estão se comunicando de forma ágil localmente:

Bash

# Para deploys manuais:

sudo systemctl status meumicrosservico




# Para deploys via Docker:

docker ps




# Realiza uma requisição de cabeçalho local (Deve retornar HTTP 200 OK)

curl -I http://localhost:8080

Teste de acesso externo e isolamento

Do terminal da sua máquina local de trabalho, execute os testes finais de rede pública para certificar-se da integridade do ecossistema:

Bash

# Testa o tráfego público entregue com baixíssima latência nacional

curl -I http://<SEU_IP_PUBLICO>:8080



# Deve resultar em falha de conexão (Timeout), 
provando o isolamento do banco

nc -zv <SEU_IP_PUBLICO> 5432

8. Solução de problemas (Troubleshooting)

• Conexão SSH administrativa recusada por timeout: Acesse o painel CloudStack e verifique na aba de IPs Públicos se a regra de Port Forwarding da porta 22 está apontando para a sua VM e se o seu IP administrativo está correto no Firewall.
• Erros de “connection refused” nos logs do microsserviço: Certifique-se de que a variável DATABASE_URL está preenchida corretamente e que o arquivo pg_hba.conf do PostgreSQL possui a regra de liberação ativa.
• Comandos do Docker gerando erros de permissão negada: Indica que o seu terminal ainda está rodando com as credenciais antigas de login. Digite exit para derrubar a sessão SSH e realize uma nova conexão ao servidor.