Introdução

Neste tutorial, você aprenderá a construir uma API RESTful completa utilizando a linguagem Go e o framework Gin. Iremos abordar desde a configuração inicial do ambiente, criação do projeto, desenvolvimento de endpoints, até a execução de testes e deployment da aplicação utilizando Docker. Este guia é projetado para desenvolvedores que desejam aprimorar suas habilidades em Go, criando aplicações eficientes e escaláveis seguindo as melhores práticas. Ao final deste tutorial, você terá uma API pronta e testada, além de conhecimentos sobre a integração do Gin com o Docker para facilitar o deployment em diferentes ambientes.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de que o Go e o Docker estejam instalados em sua máquina. Use o comando `go version` para verificar a instalação do Go. Caso ainda não tenha, siga as instruções no site oficial do Go. Para o Docker, você pode verificar a instalação com `docker –version`. Instale as dependências necessárias do Gin utilizando o comando `go get -u github.com/gin-gonic/gin`.

    commands
    # Verificar a instalação do Go
    go version
    # Verificar a instalação do Docker
    docker --version
    # Instalar o Gin
    go get -u github.com/gin-gonic/gin

  2. Criação do Projeto

    Crie uma nova pasta para o seu projeto e inicie um módulo Go usando `go mod init nome-do-projeto`. Em seguida, crie o arquivo principal `main.go` onde irá configurar o servidor e os endpoints da API.

    commands
    mkdir api-restful-go && cd api-restful-go
    go mod init api-restful-go
    touch main.go

    main.go
    package main

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

func main() {
	r := gin.Default()
	r.Run(':8080')
}

  3. Implementação da Estrutura do Projeto

    Crie as pastas `models`, `controllers`, e `routes` para organizar a estrutura do projeto. No diretório `models`, criaremos o arquivo `produto.go` onde definiremos a estrutura do nosso modelo de dados.

    commands
    mkdir models controllers routes
    touch models/produto.go

    produto.go
    package models

import "time"

type Produto struct {
	ID        uint      `json:"id"`
	Nome      string    `json:"nome"`
	Preco     float64   `json:"preco"`
	CreatedAt time.Time  `json:"-"`
}

  4. Implementação do Controller

    Crie o arquivo `produto_controller.go` dentro da pasta `controllers`. Neste arquivo, iremos implementar as funções para manejar as requisições HTTP.

    commands
    touch controllers/produto_controller.go

    produto_controller.go
    package controllers

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

var produtos []models.Produto

func GetProdutos(c *gin.Context) {
	c.JSON(200, produtos)
}

func CreateProduto(c *gin.Context) {
	var novoProduto models.Produto
	if err := c.ShouldBindJSON(&novoProduto); err == nil {
		produtos = append(produtos, novoProduto)
		c.JSON(201, novoProduto)
	} else {
		c.JSON(400, err)
	}
}

  5. Configuração das Rotas

    No diretório `routes`, crie o arquivo `routes.go` para definir as rotas da sua API. Vamos conectar as funções do controller com as rotas correspondentes.

    commands
    touch routes/routes.go

    routes.go
    package routes

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

func SetupRoutes(r *gin.Engine) {
	r.GET("/produtos", controllers.GetProdutos)
	r.POST("/produtos", controllers.CreateProduto)
}

  6. Integrando Roteamento no main.go

    Volte ao arquivo `main.go` e ajuste-o para utilizar as rotas que acabamos de criar. Isso garantirá que o servidor utilize as definições do controller e das rotas.

    main.go
    package main

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

func main() {
	r := gin.Default()
	routes.SetupRoutes(r)
	r.Run(':8080')
}

  7. Testando a API

    Utilize o Postman ou cURL para testar os endpoints criados. Verifique se o endpoint de listagem e criação de produtos funciona conforme o esperado.

    commands
    # Testar o endpoint GET
    curl -X GET http://localhost:8080/produtos
    # Testar o endpoint POST
    curl -X POST -H 'Content-Type: application/json' -d '{"nome": "Produto 1", "preco": 10.0}' http://localhost:8080/produtos

  8. Configurando Docker

    Crie um arquivo `Dockerfile` para definir a imagem do seu aplicativo. Além disso, crie um arquivo `docker-compose.yml` para facilitar a execução do contêiner Docker.

    Dockerfile
    FROM golang:1.17 as builder
WORKDIR /app
COPY go.mod .
COPY go.sum .
RUN go mod download
COPY . .
RUN go build -o myapp

FROM alpine:latest
WORKDIR /root/
COPY --from=builder /app/myapp .
CMD ["./myapp"]

    docker-compose.yml
    version: '3'
services:
  api:
    build: .
    ports:
      - '8080:8080'

  9. Construindo e Executando o Contêiner Docker

    Utilize os comandos do Docker para construir a imagem e executar o contêiner. Isso irá permitir que você teste sua API em um ambiente isolado.

    commands
    # Construir a imagem Docker
    docker-compose build
    # Executar o contêiner
    docker-compose up

  10. Executando Testes Unitários

    Crie testes unitários para as funções do controller utilizando o pacote `testing` do Go. Isso garante que suas funções estejam funcionando corretamente.

    commands
    # Criar um arquivo de teste
    touch controllers/produto_controller_test.go

    produto_controller_test.go
    package controllers

import (
	"net/http"
	"net/http/httptest"
	"testing"
	"github.com/gin-gonic/gin"
)

func TestGetProdutos(t *testing.T) {
	// Preparação para o teste
	// Verificando a resposta e as funções chamando o GET
}

Conclusão

Neste tutorial, você aprendeu a desenvolver uma API RESTful utilizando Go, Gin e Docker, desde a configuração do ambiente até o deployment da aplicação. Vimos como estruturar o projeto, criar endpoints, realizar testes e colocar a aplicação em um contêiner Docker. Com esta base, você está preparado para criar aplicações mais complexas e robustas, além de explorar mais funcionalidades do Gin e avançar ainda mais em seus projetos em Go.

Hashtags

#Go #Gin #Docker #APIs #DesenvolvimentoDeSoftware #RESTful