Go: boas práticas em projetos

Qualidade e Manutenção - Apresentação

Introdução e Objetivos do Curso

Olá! Meu nome é Guilherme Lima, sou professor e estou muito feliz que você queira aprender mais sobre GO e boas práticas em projetos.

Audiodescrição: Guilherme é um homem com barba, cabelo curto e usa óculos. Ele veste uma camiseta branca.

Exploração de Projeto e Boas Práticas

Neste curso, vamos explorar um projeto que possui uma API, assunto que abordamos nos cursos de fundamentos de GO. Em praticamente todos os cursos de GO, discutimos esse tema. Nosso objetivo será pegar um código que já funciona e começar a pensar em projeto.

Preparação para Colaboração e Segurança

Como preparamos essa aplicação para trabalhar com outras pessoas? Quais são as boas práticas para pegarmos nosso código e enviá-lo para o GitHub, tomando cuidado com segurança e legibilidade? Como utilizamos o GitHub Actions? Por exemplo, fazemos o envio do nosso código local para o GitHub, mas queremos que ele seja aceito apenas se passar nos testes e se as configurações e convenções do GO estiverem sendo aplicadas.

Integração Contínua e Estruturação de Projetos

Vamos falar também sobre integração contínua. A partir deste curso, vamos estruturar nosso projeto em GO. Já sabemos criar uma API com GO e criar camadas de responsabilidades. Agora, o objetivo é pensar no projeto como um todo. Como pegamos esse projeto, convidamos pessoas para trabalhar conosco e compartilhamos esse código, assim como acontece no mercado? Vamos aprender isso, será muito interessante. Venha conosco!

Qualidade e Manutenção - Projeto Base

Introdução ao Projeto Go

Vamos iniciar nossos estudos em Go, abordando boas práticas para garantir que não apenas nosso código, mas todo o projeto Go siga as principais convenções. Para começar, recomendamos que façamos o download da atividade anterior a este vídeo, chamada "Preparando Ambiente". Já baixamos o projeto que utilizaremos como referência, nomeado como Go 2 Projeto Inicial. Este projeto servirá como base para desenvolvermos várias melhorias e sugestões na área de engenharia, não apenas relacionadas ao código e à linguagem, mas ao projeto como um todo.

Configuração do Ambiente de Desenvolvimento

Utilizaremos o Visual Studio Code, que já está aberto, para acompanhar este curso. Apesar de ser um projeto didático, nosso objetivo é que compreendamos os principais conceitos, aplicando-os de forma prática. Para isso, utilizaremos o Docker para executar o banco de dados, carregar a API que analisaremos e torná-la ainda mais legível e eficiente. O Docker já está em execução, e o Visual Studio Code será nosso editor principal para este curso. Vamos abrir o projeto Go 2 Projeto Inicial no Visual Studio Code e começar a analisá-lo.

Estrutura do Projeto

Ao abrir o projeto, encontramos várias pastas e arquivos. Vamos entender melhor do que se trata esta aplicação. Temos uma pasta chamada "internal", que contém várias camadas: configuração, handler, middleware, modelos, repositórios, rotas e serviços. O arquivo main.go é nosso ponto de partida da aplicação. Assim que o projeto é iniciado, ele acessa o pacote de configuração e executa a função connectDatabase, conectando-se ao banco de dados que utilizaremos. Em seguida, carrega as rotas da aplicação e exibe uma mensagem indicando que está sendo executado na porta 8080.

Análise e Melhorias no Código

Vamos analisar o arquivo database.go e buscar melhorias no código. Dentro da pasta "internal", em "config", acessamos o database.go para conhecer melhor a aplicação. Vamos minimizar tudo ao redor para focarmos no código. Encontramos uma variável DB, que representa nosso banco de dados, utilizando o ORM do Go, o Gorm. A função connectDatabase apresenta algo estranho. Na linha 15, foi criada uma variável chamada DSN, que contém toda a string de conexão, incluindo hostDB, usuário, senha, DBName, porta e outras informações.

Proteção de Dados Sensíveis

O principal problema dessa abordagem é que, se colocarmos esse código no GitHub, todos teriam acesso ao banco de dados e suas informações, o que não é ideal. Precisamos considerar uma forma de proteger esses dados, talvez utilizando algum recurso que o Docker possa oferecer. No arquivo docker-compose.yml, observamos algumas configurações que podem ser úteis.

Configuração de Variáveis de Ambiente

Nós temos a configuração do PostgreSQL e a configuração de variáveis de ambiente do Docker. As variáveis incluem POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB, entre outros nomes. Por que não estamos usando nomes melhores? Porque ainda estamos no ambiente de desenvolvimento. No entanto, aos poucos, vamos começar a melhorar esses passos também.

Utilização de Variáveis de Ambiente no Código

Na linha 12, temos uma variável chamada dbDSN. O que significa dbDSN? O DSN (Data Source Name) simboliza o nome da fonte de dados, ou seja, é a variável que nos permite realizar a conexão com o banco de dados. Suponhamos que, por algum motivo, mudamos o usuário, e agora ele se chama Guilherme. Já temos esse nome atualizado corretamente. Da forma como nosso código está, teríamos que, manualmente, alterar o user para Guilherme. Isso demonstra uma dependência do nosso código em relação a outras partes.

O que queremos fazer? Em vez de usar toda essa estrutura manualmente, queremos pegar essa variável diretamente no nosso código. Para isso, utilizaremos o pacote os, que nos permite acessar variáveis de ambiente. Ao escrever os.Getenv, podemos pegar a variável de ambiente desejada, que contém informações como host, usuário, senha, entre outras. Voltamos ao nosso código e colocamos dbDSN. Essa alteração significa que, a partir de agora, qualquer modificação nas variáveis de ambiente do Docker será refletida na nossa aplicação.

Testando a Aplicação

Quando subirmos essa aplicação no GitHub, não deixaremos a senha do ambiente no Docker visível. Vamos pensar nisso mais adiante. Agora, queremos testar. Vamos executar a aplicação e verificar como ela está. Abrimos o terminal com o comando J, lembrando que o Docker já está funcionando, e executamos o comando docker compose-up --build. O --build é necessário para construir a imagem, já que é a primeira execução. Após carregar as informações, esperamos um pouco.

Verificação das Rotas da API

Assim que finalizar, nossa aplicação estará sendo executada na porta 8080. Vamos utilizar o Thunderclient para verificar o projeto. Acessamos o projeto para entender as rotas disponíveis, especificamente o arquivo de rotas item.go. Temos a rota /api/itens no método GET, que devolve uma lista de itens. Queremos testar essa rota. No Thunderclient, deixamos na atividade "Preparando Ambiente" para facilitar o acesso. Fechamos a mensagem e acessamos o GET para localhost:8080/api/itens, para listar todos os itens da nossa API. Ao clicar em "Send", vemos que já temos uma lista de itens carregados.

Conclusão

Em resumo, nosso banco de dados está ativo, aceitando conexões, e nossa API está funcionando corretamente.

Qualidade e Manutenção - Testes no Go

Criação do Arquivo de Teste

Vamos começar a criar nosso teste para verificar a conexão com o banco de dados. Primeiro, precisamos criar um novo arquivo no pacote "config", que chamaremos de Database_teste.go. Dentro desse arquivo, vamos definir que ele pertence ao pacote "config" e começar a desenvolver nosso teste.

Definição da Função de Teste

Para começar, criaremos uma função chamada TestConnectDatabase. Essa função será responsável por verificar se o banco de dados do Postgres tem uma conexão correta e se tudo funciona como esperado. A assinatura da função será a seguinte:

package config

import (
    "testing"
)

func TestConnectDatabase(t *testing.T) {
    // Código do teste será inserido aqui
}

Configuração da Conexão com o Banco de Dados

Dentro dessa função, vamos pegar o DSN da variável de ambiente, fazer a conexão com o Gorm e, caso a conexão não funcione, teremos uma mensagem de erro. Vamos copiar as linhas do Database.go, das linhas 16 até 20, e colocá-las aqui. Assim que salvarmos, os imports necessários serão trazidos automaticamente.

import (
    "log"
    "os"
    "testing"

    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

func TestConnectDatabase(t *testing.T) {
    dsn := os.Getenv("DSN")
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        t.Fatalf("Erro ao conectar com banco de dados: %v", err)
    }
}

Verificação da Conexão Estabelecida

Agora, podemos verificar se a conexão foi estabelecida. Para isso, criaremos uma variável chamada sqldb e uma variável de erro. Diremos: "db, conecta aí com o banco de dados, db.DB". Caso haja um problema, se o erro não for igual a nil, pediremos ao t.Fatalf para nos indicar qual foi o erro.

    sqldb, err := db.DB()
    if err != nil {
        t.Fatalf("Erro ao obter uma conexão com o banco de dados: %v", err)
    }

Teste de Resposta do Banco de Dados

O próximo passo é verificar se o banco de dados está respondendo. Utilizaremos o comando ping para isso. Se o erro que encontramos não for igual a nil, significa que houve um problema.

    if err := sqldb.Ping(); err != nil {
        t.Fatalf("Erro ao pingar o banco de dados: %v", err)
    }

Fechamento da Conexão

A última etapa para finalizar nosso teste de conexão com o banco é fechar essa conexão, pois não precisamos mais mantê-la aberta. Para isso, utilizamos a função defer e passamos uma função anônima.

    defer func() {
        if err := sqldb.Close(); err != nil {
            t.Fatalf("Erro ao fechar a conexão com o banco de dados: %v", err)
        }
    }()
}

Conclusão do Teste

Com isso, cobrimos a maior parte dos cenários possíveis. Temos nosso primeiro teste que verifica a conexão com o banco de dados. Na sequência, vamos executar esse teste para garantir que tudo está funcionando corretamente.

Sobre o curso Go: boas práticas em projetos

O curso Go: boas práticas em projetos possui 109 minutos de vídeos, em um total de 50 atividades. Gostou? Conheça nossos outros cursos de GoLang em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Qualidade e Manutenção
• Arquitetura limpa
• Refatoração e legibilidade
• Validações e responsabilidades
• Service, GitHub e CI