Instalar e configurar Gogs no CentOS 7 — guia passo a passo

O que este guia cobre

• Pré-requisitos e preparação do sistema
• Instalação do PostgreSQL e criação do banco para Gogs
• Instalação do Go, Git e compilação do Gogs a partir do código
• Execução do Gogs como serviço systemd
• Configuração do Nginx como reverse proxy
• Testes, troubleshooting, checklist e práticas de segurança

Principais termos: Go — linguagem de programação usada para compilar o Gogs. Reverse proxy — servidor (Nginx) que encaminha requisições para o Gogs em porta interna.

Importante: execute os comandos com privilégios root ou sudo quando indicado.

Pré-requisitos

• Servidor CentOS 7 atualizado
• Acesso root ou sudo
• Conectividade de rede para baixar pacotes e binários

Etapas resumidas

1. Instalar repositório EPEL
2. Instalar e configurar PostgreSQL
3. Instalar Go e Git
4. Baixar e compilar Gogs
5. Customizar configuração do Gogs
6. Executar Gogs como serviço systemd
7. Instalar Nginx como reverse proxy
8. Testar a instalação

Passo 1 - Instalar repositório EPEL

Adicione o repositório EPEL para obter pacotes adicionais:

sudo yum -y install epel-release

Resultado: o repositório EPEL foi adicionado ao CentOS 7.

Passo 2 - Instalar e configurar PostgreSQL

Gogs suporta vários bancos (MySQL, PostgreSQL, SQLite3, MSSQL, TiDB). Este guia usa PostgreSQL.

Instale o servidor PostgreSQL:

sudo yum -y install postgresql-server postgresql-contrib

Inicialize o banco:

sudo postgresql-setup initdb

Configure o PostgreSQL para escutar apenas no IP local e exigir senha (md5):

su - postgres

Vá ao diretório de dados e edite o postgresql.conf:

cd data/
vim postgresql.conf

Altere a linha listen_addresses para:

listen_addresses = '127.0.0.1'

Edite o arquivo de regras de autenticação pg_hba.conf:

vim pg_hba.conf

Na configuração de host local (127.0.0.1/32), defina o método como md5:

host    all             all             127.0.0.1/32            md5

Inicie e habilite o serviço para iniciar automaticamente:

sudo systemctl start postgresql
sudo systemctl enable postgresql

Verifique o netstat para confirmar a porta 5432 ligada ao IP 127.0.0.1:

netstat -plntu

Crie o usuário e o banco para o Gogs:

su - postgres
psql
CREATE USER git CREATEDB;
\password git
CREATE DATABASE gogs_production OWNER git;
exit

Passo 3 - Instalar Go e Git

Instale o Git do repositório:

sudo yum -y install git

Crie o usuário do sistema que será dono dos repositórios:

useradd -m -s /bin/bash git
passwd git

Logue como o usuário git e crie uma pasta local para downloads:

su - git
mkdir -p /home/git/local
cd ~/local

Baixe a versão do Go usada no exemplo (mantenha a URL conforme o exemplo):

wget https://dl.google.com/go/go1.9.2.linux-amd64.tar.gz

Extraia e remova o arquivo compactado:

tar -xf go1.9.2.linux-amd64.tar.gz
rm -f go1.9.2.linux-amd64.tar.gz

Configure as variáveis de ambiente para o usuário git (GOROOT e GOPATH):

cd ~/
echo 'export GOROOT=$HOME/local/go' >> $HOME/.bashrc
echo 'export GOPATH=$HOME/go' >> $HOME/.bashrc
echo 'export PATH=$PATH:$GOROOT/bin:$GOPATH/bin' >> $HOME/.bashrc
source ~/.bashrc

Confirme que o shell é bash e verifique a versão do Go:

go version

Observação: adaptar a versão do Go a releases mais recentes é recomendado para segurança e compatibilidade.

Passo 4 - Instalar Gogs

Ainda como usuário git, baixe o código do Gogs e compile:

su - git
go get -u github.com/gogits/gogs
cd $GOPATH/src/github.com/gogits/gogs
go build

Execute o binário para testes (modo web):

./gogs web

Por padrão, Gogs inicia na porta 3000 em todas as interfaces, a menos que configurado para 127.0.0.1.

Acesse no navegador: http://192.168.33.10:3000/ (substitua pelo IP do seu servidor).

Pressione Ctrl+C no terminal para parar o processo e prosseguir com a instalação como serviço.

Passo 5 - Configurar o Gogs

Crie um diretório customizado para a configuração e copie o app.ini padrão:

cd $GOPATH/src/github.com/gogits/gogs
mkdir -p custom/conf/
cp conf/app.ini custom/conf/app.ini
vim custom/conf/app.ini

Edite a seção [server] para que o Gogs escute somente no localhost e use porta 3000:

[server]
 PROTOCOL = http
 DOMAIN = localhost
 ROOT_URL = %(PROTOCOL)s://%(DOMAIN)s:%(HTTP_PORT)s/
 HTTP_ADDR = 127.0.0.1
 HTTP_PORT = 3000

Na seção [database], configure com os dados do PostgreSQL que criou:

[database]
 DB_TYPE = postgres
 HOST = 127.0.0.1:5432
 NAME = gogs_production
 USER = git
 PASSWD = aqwe123@

Salve e execute para verificar:

./gogs web

Importante: nunca deixe senhas em arquivos sob controle de versão sem proteção. Use permissões restritas no arquivo custom/conf/app.ini (chmod 600).

Passo 6 - Executar Gogs como serviço (systemd)

Crie o arquivo de serviço systemd para executar o Gogs automaticamente:

cd /etc/systemd/system
vim gogs.service

Cole a configuração abaixo (ajuste caminhos se o GOPATH for diferente):

[Unit]
 Description=Gogs
 After=syslog.target
 After=network.target
 After=mariadb.service mysqld.service postgresql.service memcached.service redis.service

 [Service]
 # Modify these two values and uncomment them if you have
 # repos with lots of files and get an HTTP error 500 because
 # of that
 ###
 #LimitMEMLOCK=infinity
 #LimitNOFILE=65535
 Type=simple
 User=git
 Group=git
 WorkingDirectory=/home/git/go/src/github.com/gogits/gogs
 ExecStart=/home/git/go/src/github.com/gogits/gogs/gogs web
 Restart=always
 Environment=USER=git HOME=/home/git

 [Install]
 WantedBy=multi-user.target

Recarregue o systemd e inicie o serviço:

systemctl daemon-reload
systemctl start gogs
systemctl enable gogs

Verifique o status e as portas:

netstat -plntu
systemctl status gogs

Passo 7 - Instalar e configurar Nginx como reverse proxy

Instale o Nginx via EPEL:

yum -y install nginx

Crie um virtual host para encaminhar requests ao Gogs em 127.0.0.1:3000:

cd /etc/nginx/
vim conf.d/gogs.conf

Cole a configuração (substitua server_name pelo seu domínio):

server {
    listen 80;
    server_name git.hakase-labs.co;

    location / {
        proxy_pass http://127.0.0.1:3000;
    }
}

Teste a configuração e reinicie o Nginx:

nginx -t
systemctl restart nginx
systemctl enable nginx

Verifique netstat para a porta 80:

netstat -plntu

Dica: para produção, coloque HTTPS (Let’s Encrypt/Certbot) e redirecione HTTP para HTTPS.

Passo 8 - Testes finais

Acesse o domínio configurado:

http://git.hakase-labs.co/

Na tela de instalação, preencha os dados de conexão PostgreSQL e crie a conta de administrador.

Preencha as configurações da conta admin e finalize a instalação.

Após a instalação, você será redirecionado ao dashboard do usuário.

Gogs está instalado com PostgreSQL e Nginx no CentOS 7.

Solução de problemas comum

• Erro 502/504 no Nginx: verifique se o Gogs está escutando em 127.0.0.1:3000 e se o serviço systemd está ativo (systemctl status gogs). Confirme proxy_pass no arquivo do Nginx.
• Banco não conecta: confira host/porta/usuário/senha no custom/conf/app.ini. Teste conexão psql com o usuário git.
• Erro 500 ao servir repositórios grandes: aumente LimitNOFILE no unit file e reinicie systemd.
• Permissões de arquivo: garanta que o usuário git seja dono do diretório de repositórios e do custom/conf/app.ini. Use chown -R git:git .
• Portas em uso: netstat -plntu mostra serviços e portas. Altere HTTP_PORT se necessário.

Abordagens alternativas e quando usar

• Usar SQLite: simples para testes e instalações pequenas. Facilita backup mas não é recomendado para cargas concorrentes altas.
• Usar MySQL/MariaDB: escolha se já tem infraestrutura MySQL; ajuste DB_TYPE e credenciais.
• Usar binário pré-compilado: baixar release oficial do Gogs evita compilar localmente. Útil quando não quer instalar Go no servidor.
• Implantação via container (Docker): conveniente para isolamento e replicação. Prefira containers se já usar orquestradores.

Quando a compilação falha: atualizar a versão do Go costuma resolver incompatibilidades de dependências.

Checklist por função

Administrador

• Criar usuário git e definir senha segura
• Configurar firewall para permitir apenas as portas necessárias (80/443)
• Habilitar backup do banco e diretório de repositórios

Operações (Ops)

• Configurar systemd e monitoramento (healthchecks)
• Configurar HTTPS, renovar certificados automaticamente
• Implementar logs rotacionados e SLI/SLO básicos

Desenvolvedor

• Testar push/pull com chaves SSH
• Validar hooks e permissões de repositório

Playbook de implantação (resumo rápido)

1. Preparar sistema (EPEL, atualizações)
2. Instalar e configurar PostgreSQL
3. Criar usuário git e baixar Go (ou usar binário)
4. Baixar e compilar Gogs ou usar release
5. Criar custom/conf/app.ini com dados do banco e IP 127.0.0.1
6. Criar gogs.service e habilitar
7. Configurar Nginx com proxy_pass para 127.0.0.1:3000
8. Testar instalação e criar conta admin
9. Habilitar HTTPS e backups

Runbook de incidente rápido

Situação: Gogs não responde

1. systemctl status gogs
2. journalctl -u gogs -n 200
3. netstat -plntu | grep 3000
4. systemctl restart gogs && systemctl status gogs
5. Se falhar, reverter config recente em custom/conf/app.ini e restaurar backup do DB

Rollback: pare o serviço, restaure o diretório de repositórios e o dump do banco, e reinicie o serviço.

Segurança e privacidade

• Use HTTPS em produção. Não exponha Gogs diretamente sem TLS.
• Restringir o acesso ao banco ao IP local (127.0.0.1) quando Nginx e Gogs residem no mesmo host.
• Permissões: app.ini deve ter permissão 600 e pertencer ao usuário git.
• Backup e retenção: faça backups regulares do banco e dos repositórios git (gitosis, rsync ou dump do PostgreSQL).
• GDPR / Privacidade: informe usuários sobre logs e retenção de dados. Proteja e minimize dados pessoais (e-mails, nomes) conforme a legislação aplicável.

Tabela comparativa rápida de bancos (síntese)

Fatos rápidos

• Portas padrão: HTTP 80, Gogs 3000 (interna), PostgreSQL 5432
• Usuário padrão do sistema para Gogs: git
• Nome do serviço systemd sugerido: gogs

Glossário rápido

• Gogs: serviço Git self-hosted escrito em Go.
• GOPATH: diretório de trabalho do Go onde o código-fonte e binários ficam por padrão.
• Reverse proxy: servidor (ex.: Nginx) que encaminha requisições para um serviço interno.

Testes/critérios de aceitação básicos

• Acesso à URL pública redireciona para a interface do Gogs e permite criar admin.
• Clonar e fazer push/pull em repositório de teste funciona via HTTP e/ou SSH.
• Serviço gogs está sempre ativo após reboot (systemctl enable + status ok).

Notas finais e referências

Resumo: você instalou e configurou Gogs no CentOS 7 com PostgreSQL e Nginx. Para produção, adicione HTTPS, monitoramento, backups e revisão de permissões. Use containers se quiser isolamento e facilidade de migração.

Referência oficial: https://gogs.io/docs/installation