Criar API com Golang: Guia Completo com Docker e PostgreSQL

Se liga, dev! Hoje eu vou te ensinar como criar uma API completa em Golang, com direito a banco PostgreSQL e Docker rodando tudo bonitinho em contêiner. Essa é daquelas que você guarda no portfólio para impressionar o recrutador que só falta pedir API rodando na Lua. Então, sem perder tempo, bora lá!

Por que escolher Golang para criar API com Golang?

Antes de meter a mão no código, vamos falar sobre o Golang. Essa linguagem criada pelo Google é famosa pela simplicidade, performance e suporte nativo para concorrência. Portanto, ela é perfeita para criar APIs rápidas e escaláveis. Além disso, o ecossistema de bibliotecas e frameworks facilita ainda mais o desenvolvimento.

Ferramentas essenciais para criar API com Golang e PostgreSQL

• Golang: A linguagem parruda que vai sustentar nossa API.
• PostgreSQL: Banco de dados relacional para guardar nossas informações.
• Docker: Para isolar tudo em contêiner e simplificar a distribuição.

O que essa API vai fazer:

1. Criar produtos.
2. Listar todos os produtos salvos no banco.
3. Buscar um produto por ID.

Tudo isso com uma arquitetura limpa e organizada. Isso não apenas facilita a manutenção, mas também melhora a escalabilidade. Entretanto, você também aprenderá como integrar as ferramentas de forma eficiente.

1. Configuração inicial do projeto para criar API com Golang

Primeiramente, crie uma pasta para o projeto e abra no VS Code. Em seguida, inicialize o módulo Go:

go mod init go-api

Crie uma pasta cmd e, dentro dela, o arquivo main.go com o seguinte código:

package main

import (
    "fmt"
    "log"
)

func main() {
    fmt.Println("Hello, API!")
}

Logo após, instale o framework Gin, que será usado para construir nossa API:

go get github.com/gin-gonic/gin

Adicione uma rota de teste no main.go:

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    server := gin.Default()
    server.GET("/ping", func(ctx *gin.Context) {
        ctx.JSON(200, gin.H{"message": "pong"})
    })
    server.Run(":8000")
}

Para garantir que tudo está funcionando, teste no navegador ou no Postman acessando http://localhost:8000/ping. Se aparecer “pong”, estamos no caminho certo. Contudo, ainda temos muito a fazer!

2. Configurando o PostgreSQL com Docker para criar API com Golang

Configuração do PostgreSQL

Crie um arquivo docker-compose.yml na raiz do projeto:

version: "3.8"
services:
  db:
    image: postgres:12
    container_name: go_db
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: 1234
      POSTGRES_DB: products
    volumes:
      - postgres_data:/var/lib/postgresql/data
volumes:
  postgres_data:

Depois de criar o arquivo, execute o seguinte comando para iniciar o contêiner do PostgreSQL:

docker-compose up -d

Com o banco rodando, conecte-se ao PostgreSQL usando uma ferramenta como o DBeaver. Configure a conexão com as credenciais do docker-compose e crie a tabela product:

CREATE TABLE product (
    id SERIAL PRIMARY KEY,
    name VARCHAR(50) NOT NULL,
    price NUMERIC(10, 2) NOT NULL
);

Logo após, insira alguns produtos iniciais para teste:

INSERT INTO product (name, price) VALUES ('Sushi', 100.00), ('Pizza', 50.00);

Agora que o banco está configurado, podemos passar à próxima etapa.

3. Conectando o PostgreSQL para criar API com Golang

Crie uma pasta db e dentro dela um arquivo connect.go para gerenciar a conexão com o banco:

package db

import (
    "database/sql"
    _ "github.com/lib/pq"
    "fmt"
)

const (
    host     = "localhost"
    port     = 5432
    user     = "postgres"
    password = "1234"
    dbname   = "products"
)

func ConnectDB() (*sql.DB, error) {
    dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
    db, err := sql.Open("postgres", dsn)
    if err != nil {
        return nil, err
    }
    if err := db.Ping(); err != nil {
        return nil, err
    }
    return db, nil
}

No main.go, teste a conexão:

import "go-api/db"

func main() {
    _, err := db.ConnectDB()
    if err != nil {
        log.Fatal("Erro ao conectar no banco: ", err)
    }
    fmt.Println("Banco conectado com sucesso!")
}

Se a mensagem “Banco conectado com sucesso!” aparecer, significa que a conexão está funcionando. Contudo, precisamos estruturar a API em camadas antes de seguir.

• 
  Melhor Linguagem de Programação 2025: Explorando as Opções para sua Carreira em Tecnologia
• 
  Hidratação no Front-End: O que é e como ela resolve problemas de SSR e CSR
• 
  Como Sair de Pleno para Senior em 2025: O Guia Definitivo Sem Ficar Batendo Cabeça
• 
  Guia Definitivo: Como e Quando Usar find e findIndex no JavaScript
• 
  Diferença entre every e some no JavaScript: O Guia Definitivo para Quem Já Quebrou a Cabeça com Arrays
• 
  Testes Unitários no Angular: Chega de Código Porco

4. Estruturando camadas para criar API com Golang

Por que dividir em camadas?

Dividir a API em camadas como Repository, Use Case e Controller torna o código mais organizado. Isso facilita tanto a manutenção quanto a adicião de novas funcionalidades. Vamos implementar cada camada.

4.1 Repository

Na pasta repository, crie o arquivo product_repository.go:

package repository

import (
    "database/sql"
    "go-api/models"
)

type ProductRepository struct {
    db *sql.DB
}

func NewProductRepository(db *sql.DB) *ProductRepository {
    return &ProductRepository{db}
}

func (r *ProductRepository) GetProducts() ([]models.Product, error) {
    rows, err := r.db.Query("SELECT id, name, price FROM product")
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    var products []models.Product
    for rows.Next() {
        var p models.Product
        err := rows.Scan(&p.ID, &p.Name, &p.Price)
        if err != nil {
            return nil, err
        }
        products = append(products, p)
    }
    return products, nil
}

4.2 Use Case

Na pasta usecase, crie o arquivo product_usecase.go:

package usecase

import (
    "go-api/models"
    "go-api/repository"
)

type ProductUseCase struct {
    repository *repository.ProductRepository
}

func NewProductUseCase(repo *repository.ProductRepository) *ProductUseCase {
    return &ProductUseCase{repo}
}

func (u *ProductUseCase) GetAllProducts() ([]models.Product, error) {
    return u.repository.GetProducts()
}

4.3 Controller

Na pasta controllers, crie o arquivo product_controller.go:

package controllers

import (
    "go-api/usecase"
    "github.com/gin-gonic/gin"
)

type ProductController struct {
    useCase *usecase.ProductUseCase
}

func NewProductController(uc *usecase.ProductUseCase) *ProductController {
    return &ProductController{uc}
}

func (c *ProductController) GetProducts(ctx *gin.Context) {
    products, err := c.useCase.GetAllProducts()
    if err != nil {
        ctx.JSON(500, gin.H{"error": err.Error()})
        return
    }
    ctx.JSON(200, products)
}

4.4 Integração das camadas no main.go

No main.go, importe as camadas e configure as rotas:

import (
    "go-api/controllers"
    "go-api/db"
    "go-api/repository"
    "go-api/usecase"
)

func main() {
    conn, err := db.ConnectDB()
    if err != nil {
        log.Fatal("Erro ao conectar no banco: ", err)
    }

    repo := repository.NewProductRepository(conn)
    uc := usecase.NewProductUseCase(repo)
    ctrl := controllers.NewProductController(uc)

    server := gin.Default()
    server.GET("/products", ctrl.GetProducts)
    server.Run(":8000")
}

Com isso, sua API está funcional e preparada para listar produtos!

5. Executando a API com Golang no Docker

Adicione um Dockerfile na raiz do projeto:

FROM golang:1.19
WORKDIR /app
COPY . .
RUN go mod tidy
RUN go build -o main .
CMD ["./main"]

Atualize o docker-compose.yml para incluir o serviço da API:

  app:
    build: .
    ports:
      - "8000:8000"
    depends_on:
      - db

Finalmente, levante tudo:

docker-compose up --build

Teste as rotas no Postman. Caso tudo esteja funcionando, você finalizou a criação de uma API completa com Golang, Docker e PostgreSQL!

Desafios Extras

1. Adicione rotas para atualizar e deletar produtos.
2. Implemente autenticação JWT.
3. Documente a API usando Swagger.

Seguindo essas dicas, sua API estará pronta para arrasar em qualquer portfólio. Bora codar e mandar bem! 🚀

Angular performance Angular Signals Apps Multiplataforma automação de tarefas Backend Boas Práticas boas práticas Git controle de versão desenvolvedores desenvolvimento backend Desenvolvimento de Software Desenvolvimento Frontend Desenvolvimento Mobile Desenvolvimento Web desenvolvimento ágil devops dicas para devs escalabilidade ferramentas de Git ferramentas de programação Front-end Git Hooks integração contínua inteligência artificial JavaScript Linguagens de Programação Media Queries mercado de tecnologia Mercado de Trabalho Tech Node.js produtividade dev Programação Programação Orientada a Objetos programação para iniciantes programação reativa Python React React Suspense Rust Tecnologia Trunk-Based Development web development workflow Git workflows Git