Introdução

Neste tutorial, iremos explorar como desenvolver uma API RESTful utilizando a linguagem Go e as bibliotecas Gin e GORM, bem como Docker para facilitar a configuração do ambiente. O objetivo deste guia é proporcionar uma visão prática e passo a passo para criar uma aplicação robusta e escalável, abordando conceitos fundamentais como roteamento, manipulação de dados e estruturação de código. A API que construiremos gerenciará uma lista de produtos, permitindo operações básicas de CRUD (Criar, Ler, Atualizar e Remover). Através deste tutorial, você ganhará confiança na utilização dessas tecnologias populares e aprenderá a otimizar seu fluxo de trabalho com Docker.

Etapas

  1. Configuração do Ambiente

    Antes de começarmos, é essencial ter o Go instalado em sua máquina. Você pode verificar a instalação executando o comando `go version`. Além disso, instale o Docker e verifique a instalação do Docker com `docker –version`. Caso não tenha essas ferramentas instaladas, consulte a documentação oficial para obter instruções detalhadas.

    commands
    # Verificar a versão do Go
    go version
    # Verificar a versão do Docker
    docker --version

  2. Criando o Projeto Go

    Crie um diretório para o seu projeto de API e inicie um novo módulo Go. Neste exemplo, chamaremos o projeto de `api-restful-go`. No terminal, execute os seguintes comandos:

    commands
    mkdir api-restful-go
    cd api-restful-go
    go mod init api-restful-go

  3. Instalação das Dependências

    Usaremos o Gin e GORM. Utilize o seguinte comando para instalar as dependências:`

    commands
    go get -u github.com/gin-gonic/gin
    go get -u gorm.io/gorm
    go get -u gorm.io/driver/sqlite

  4. Criando a Estrutura de Diretórios

    Organize seu projeto criando as pastas para os modelos, controladores e rotas. Execute os seguintes comandos:

    commands
    mkdir models controllers routes

  5. Definindo o Modelo de Dados

    Crie um arquivo `product.go` no diretório `models` para definir a estrutura do produto. Esta estrutura será mapeada na tabela do banco de dados.

    models/product.go
    package models

import "gorm.io/gorm"

// Product representa um produto na API
type Product struct {
    gorm.Model
    Name  string  `json:"name"`  
    Price float64 `json:"price"`
}

  6. Configurando a Conexão com o Banco de Dados

    No arquivo `main.go`, configure a conexão com o banco de dados usando GORM e sqlite como banco de dados.

    main.go
    package main

import (
    "github.com/gin-gonic/gin"
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
    "api-restful-go/models"
)

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

    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }

    db.AutoMigrate(&models.Product{})

    // Rotas irão aqui
    r.Run() // escuta e serve na 0.0.0.0:8080
}

  7. Criando as Rotas da API

    Crie um arquivo `routes.go` onde definiremos as rotas para a API de produtos. Este arquivo irá mapear as operações básicas do CRUD.

    routes/routes.go
    package routes

import (
    "github.com/gin-gonic/gin"
    "api-restful-go/models"
    "gorm.io/gorm"
)

func RegisterRoutes(r *gin.Engine, db *gorm.DB) {
    r.GET("/products", func(c *gin.Context) {
        var products []models.Product
        db.Find(&products)
        c.JSON(200, products)
    })
    // Rotas para Create, Update e Delete vão aqui
}

  8. Implementando os Endpoints REST

    Neste passo, complete a implementação dos endpoints de CRUD em `routes.go` e conecte as rotas ao seu servidor.

    routes/routes.go
    // Continuando de onde paramos
    r.POST("/products", func(c *gin.Context) {
        var product models.Product
        if err := c.ShouldBindJSON(&product); err == nil {
            db.Create(&product)
            c.JSON(200, product)
        } else {
            c.JSON(400, gin.H{"message": "Error"})
        }
    })
    // Complete com PUT e DELETE

  9. Configurando o Docker

    Crie um arquivo `Dockerfile` para construir a imagem do seu aplicativo Go. Você pode usar o seguinte conteúdo:

    Dockerfile
    FROM golang:1.20 AS builder
WORKDIR /app
COPY . .
RUN go mod tidy
RUN go build -o api-restful-go

FROM alpine
WORKDIR /root/
COPY --from=builder /app/api-restful-go .
CMD ["./api-restful-go"]

  10. Executando com Docker

    Para construir e rodar a aplicação com Docker, execute os seguintes comandos:

    commands
    docker build -t api-restful-go .
    docker run -p 8080:8080 api-restful-go

  11. Testando a API

    Utilize ferramentas como Postman ou cURL para testar os endpoints da sua API. Por exemplo, para listar produtos você pode usar o seguinte comando:

    commands
    curl -X GET http://localhost:8080/products
    curl -X POST -H "Content-Type: application/json" -d '{"name":"Produto 1", "price":10.99}' http://localhost:8080/products

Conclusão

Neste tutorial, você aprendeu a desenvolver uma API RESTful completa utilizando Go com Gin e GORM, e como otimizar o fluxo de trabalho com Docker. Cobrir as etapas desde a instalação do ambiente até a execução e teste da aplicação é fundamental para garantir que você tenha uma base sólida sobre como construir aplicações com Go. Agora, você pode expandir suas habilidades, aprofundando-se em funcionalidades mais avançadas e personalizando sua API conforme necessário.

Hashtags

#GoLang #Gin #GORM #Docker #APIs #DesenvolvimentoDeSoftware