Seu Primeiro CRUD em GO: Guia Completo e Sem Enrolação

Criar “Seu primeiro CRUD em GO” é um daqueles ritos de passagem para quem está se aventurando no mundo desse linguajar minimalista e poderoso. Contudo, como todo bom dev iniciante descobre cedo ou tarde, é bem fácil se perder no meio de tantas pastas, pacotes e ciclos de dependências malucos. Por isso, não se preocupe, meu jovem Padawan, porque eu vou te guiar por esse labirinto com exemplos diretos, sem frescura e recheados com os melhores memes dev.

Por onde começar seu primeiro CRUD em GO?

Antes de tudo, vamos colocar ordem no barraco. Se você ainda não fez, instale o Go aí. Para isso, acesse a página oficial (golang.org), baixe e siga os passos do instalador. Assim que fizer isso, podemos seguir para a próxima etapa. Então, bora iniciar o projeto.

Iniciando o módulo

O primeiro passo é criar um módulo. Por quê? Porque assim o Go resolve sozinho aquelas tretas de achar pacotes, independente de onde a sua pasta esteja. No terminal:

go mod init github.com/seuuser/seu-projeto

Esse comando cria um arquivo go.mod que é tipo o mapa do tesouro para as dependências do seu projeto. Dessa forma, você pode dormir tranquilo sabendo que o Go sabe onde está cada coisa.

• 
  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

Escolhendo o framework para o seu primeiro CRUD em GO

Você poderia usar o pacote nativo net/http para criar endpoints, mas não estamos aqui para reinventar a roda. Vamos usar o Gin, que é simples, eficiente e perfeito para pequenos projetos (e até uns maiores, dependendo da vibe). Para instalar:

go get -u github.com/gin-gonic/gin

Isso baixa o pacote e já deixa ele pronto para uso. Aliás, é importante lembrar: esse pacote vai ficar em algum lugar perdido na sua $GOPATH. Se quiser organizar, depois falamos sobre o comando go mod vendor.

Estruturando seu projeto

Aqui entra a mágica da organização. Afinal, não queira fazer tudo na mesma pasta, senão o caos te engole mais rápido que um segfault. Portanto, vamos usar essa estrutura:

project/
├── cmd/
│   └── api/
│       └── main.go
├── internal/
│   ├── database/
│   │   └── connection.go
│   └── posts/
│       └── repository.go
├── pkg/
     └── models/
         └── post.go

Parece complexo, mas fica suave quando você separa cada função no seu cantinho.

Main: a entrada do seu projeto CRUD

O arquivo main.go vai ser o coração da parada. Aqui, você inicializa o servidor HTTP e define os endpoints principais:

package main

import (
    "github.com/gin-gonic/gin"
    "project/internal/posts"
)

func main() {
    r := gin.Default()

    posts.SetRoutes(r)

    r.Run(":8080") // Roda na porta 8080
}

Com isso, a organização das rotas fica fora da main, num pacote separado. Assim, o código fica mais limpo e fácil de manter.

Conectando com o banco de dados no seu primeiro CRUD em GO

Aqui vem um dos pontos mais chatos: banco de dados. Não é porque o Go é minimalista que ele vai te poupar do trabalho. Portanto, vamos usar o Postgres como exemplo e o pacote pgx para conectar:

go get github.com/jackc/pgx/v5

Crie o arquivo connection.go dentro de internal/database/:

package database

import (
    "context"
    "github.com/jackc/pgx/v5/pgxpool"
    "log"
)

var db *pgxpool.Pool

func NewConnection(connStr string) *pgxpool.Pool {
    var err error
    db, err = pgxpool.New(context.Background(), connStr)
    if err != nil {
        log.Fatalf("Não conseguiu conectar: %v", err)
    }
    return db
}

Assim, sua conexão estará configurada.

Criando a estrutura de posts

No arquivo post.go dentro de pkg/models/, defina a estrutura do seu post:

package models

type Post struct {
    ID      int    `json:"id"`
    Message string `json:"message"`
    User    string `json:"user"`
    Created string `json:"created"`
}

Essa é a base para o que vai ser armazenado no banco e retornado nas requisições HTTP.

O repositório: onde a magia do CRUD acontece

Dentro de internal/posts/repository.go, crie as funções para interagir com o banco:

package posts

import (
    "context"
    "project/internal/database"
    "project/pkg/models"
)

type Repository struct {
    DB *database.DB
}

func (r *Repository) Create(ctx context.Context, post models.Post) error {
    query := "INSERT INTO posts (message, user, created) VALUES ($1, $2, $3)"
    _, err := r.DB.Exec(ctx, query, post.Message, post.User, post.Created)
    return err
}

func (r *Repository) GetByID(ctx context.Context, id int) (models.Post, error) {
    var post models.Post
    query := "SELECT id, message, user, created FROM posts WHERE id=$1"
    err := r.DB.QueryRow(ctx, query, id).Scan(&post.ID, &post.Message, &post.User, &post.Created)
    return post, err
}

func (r *Repository) Delete(ctx context.Context, id int) error {
    query := "DELETE FROM posts WHERE id=$1"
    _, err := r.DB.Exec(ctx, query, id)
    return err
}
}

Portanto, com isso, temos os métodos principais do CRUD.

Definindo os endpoints do CRUD

Agora é hora de mapear as rotas HTTP no arquivo routes.go dentro de internal/posts/:

package posts

import (
    "net/http"
    "github.com/gin-gonic/gin"
    "project/pkg/models"
)

func SetRoutes(r *gin.Engine) {
    r.POST("/posts", createPost)
    r.GET("/posts/:id", getPost)
    r.DELETE("/posts/:id", deletePost)
}

func createPost(c *gin.Context) {
    var post models.Post
    if err := c.ShouldBindJSON(&post); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    // Lógica para salvar o post
    c.JSON(http.StatusCreated, post)
}

func getPost(c *gin.Context) {
    id := c.Param("id")
    // Lógica para buscar o post
    c.JSON(http.StatusOK, gin.H{"id": id})
}

func deletePost(c *gin.Context) {
    id := c.Param("id")
    // Lógica para deletar o post
    c.Status(http.StatusNoContent)
}

Melhorias para o futuro

Agora que você tem seu primeiro CRUD em GO rodando, pode pensar em algumas melhorias, como:

• Usar variáveis de ambiente para a string de conexão do banco.
• Implementar autenticação nos endpoints.
• Testes unitários (porque dev que não testa, nem Deus confia).

E claro, explore mais o potencial do Go. Afinal, o código aqui é só a base, mas a criatividade é sua!

É isso, dev! Bora compilar, rodar e testar tudo. Portanto, se deu erro, bom… Bem-vindo ao mundo real. E não esquece: “Seu primeiro CRUD em GO” é só o começo. Depois é só descer a ladeira. Boa sorte!

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