---
title: "Como instalar Gitea na VPS com Docker, HTTPS e SSH"
description: "Hospede seus repositórios Git na VPS com Gitea em Docker Compose, PostgreSQL ou SQLite, SSH do Git em porta separada, Nginx e HTTPS com Let's Encrypt."
url: "https://streethosting.com.br/guias/vps/instalar-gitea-vps"
category: "vps"
slug: "instalar-gitea-vps"
datePublished: "2026-09-28"
dateModified: "2026-09-28"
author: "Equipe StreetHosting"
difficulty: "intermediario"
language: "pt-BR"
keywords:
  - "instalar gitea vps"
  - "gitea docker compose"
  - "servidor git proprio"
  - "gitea nginx https"
  - "gitea ssh porta 2222"
---

# Gitea na VPS: seu próprio servidor Git com domínio e HTTPS

O Gitea é um servidor Git leve, com interface web, issues, pull requests e registro de pacotes. Veja como subir com Docker Compose, escolher o banco, separar o SSH do Git do SSH da VPS e publicar com domínio e HTTPS.

> **Resposta rápida**
>
> Para **instalar Gitea na VPS**, suba o container oficial com Docker Compose, use PostgreSQL (ou SQLite em uso pessoal), publique a interface web só em 127.0.0.1:3000 atrás do Nginx com HTTPS e exponha o SSH do Git em uma porta própria, como 2222, para não disputar a porta 22 com o SSH de administração. Para uma pessoa ou um time pequeno, 2 vCPU e 2 a 4 GB de RAM dão conta.

## O que o Gitea entrega e o que precisa

O Gitea é um servidor Git escrito em Go, distribuído como um único binário e leve o bastante para rodar ao lado de outras aplicações. Ele traz interface web para navegar no código, issues, pull requests, wiki, registro de pacotes e o Gitea Actions, que executa pipelines com sintaxe compatível com a do GitHub Actions. O Forgejo, derivado do Gitea mantido por uma comunidade independente, segue um processo de instalação muito parecido com o deste guia.

Os motivos para hospedar o próprio servidor Git costumam ser três: manter código sensível fora de plataformas de terceiros, não depender de limites de planos gratuitos e ter um espelho dos repositórios do GitHub como cópia de segurança. Antes de começar, tenha em mãos:

- [ ] VPS com Ubuntu 24.04 e acesso SSH por chave
- [ ] Docker Engine e o plugin Compose instalados
- [ ] Um subdomínio para o Gitea apontando para o IP da VPS
- [ ] Portas 80 e 443 livres para o Nginx
- [ ] Uma porta livre para o SSH do Git, como 2222

Se ainda não tem o Docker, siga o guia de [instalar Docker no Ubuntu](https://streethosting.com.br/guias/vps/instalar-docker-ubuntu-vps). Antes de emitir o certificado, o domínio já precisa de um registro A apontando para o IP da VPS.

## PostgreSQL ou SQLite

O Gitea guarda os repositórios em disco e usa um banco de dados para usuários, issues, permissões e metadados. As duas escolhas mais comuns em VPS são SQLite e PostgreSQL.

| Critério | SQLite | PostgreSQL |
| --- | --- | --- |
| Configuração | Nenhuma, é um arquivo dentro do volume | Um container a mais no compose |
| Gravações simultâneas | Uma por vez, com fila | Muitas em paralelo |
| Backup | Com o Gitea parado ou pelo comando de dump | pg_dump com o serviço no ar |
| Memória extra | Praticamente nenhuma | Algumas centenas de MB |
| Indicado para | Uso pessoal, até poucos usuários | Times, pipelines e integrações |

O limite do SQLite aparece quando várias coisas gravam ao mesmo tempo: pushes de pessoas diferentes, webhooks e runners atualizando status. Nesse ponto surgem erros de banco travado e lentidão. Se você já sabe que o uso vai crescer, comece com PostgreSQL e evite uma migração de banco depois. Quem prefere um PostgreSQL instalado direto no sistema, fora do Docker, encontra o passo a passo no guia de [instalar PostgreSQL na VPS Ubuntu](https://streethosting.com.br/guias/vps/instalar-postgresql-vps-ubuntu).

## Subir o Gitea com Docker Compose

Crie um diretório para o projeto e, dentro dele, o arquivo `compose.yaml`:

```
sudo mkdir -p /opt/gitea
cd /opt/gitea
sudo nano compose.yaml
```

```
services:
  server:
    image: docker.gitea.com/gitea:1.27
    container_name: gitea
    restart: always
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - GITEA__database__DB_TYPE=postgres
      - GITEA__database__HOST=db:5432
      - GITEA__database__NAME=gitea
      - GITEA__database__USER=gitea
      - GITEA__database__PASSWD=troque_esta_senha
      - GITEA__server__DOMAIN=git.seu-dominio.com.br
      - GITEA__server__SSH_DOMAIN=git.seu-dominio.com.br
      - GITEA__server__ROOT_URL=https://git.seu-dominio.com.br/
      - GITEA__server__SSH_PORT=2222
      - GITEA__server__SSH_LISTEN_PORT=22
    volumes:
      - ./gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "127.0.0.1:3000:3000"
      - "2222:22"
    depends_on:
      - db

  db:
    image: docker.io/library/postgres:16
    restart: always
    environment:
      - POSTGRES_USER=gitea
      - POSTGRES_PASSWORD=troque_esta_senha
      - POSTGRES_DB=gitea
    volumes:
      - ./postgres:/var/lib/postgresql/data
```

O que merece atenção em cada parte:

- **Tag da imagem:** a tag `1.27` recebe as correções dessa série sem pular para a próxima versão por conta própria. Confira a versão estável atual nas notas de lançamento antes de instalar e evite a tag `latest`.
- **Variáveis GITEA__:** cada uma vira uma linha do `app.ini`, no formato seção e chave. É assim que o banco e o domínio chegam configurados ao primeiro acesso.
- **USER_UID e USER_GID:** definem o dono dos arquivos em `./gitea`. 1000 costuma ser o primeiro usuário criado na VPS; confira com `id`.
- **Porta 3000 em 127.0.0.1:** as portas publicadas pelo Docker passam por fora das regras do UFW. Prender a interface web ao endereço local garante que ela só seja alcançada pelo Nginx.
- **Senha do banco:** use a mesma senha nos dois serviços e proteja o arquivo com `sudo chmod 600 compose.yaml`.

Para usar SQLite, apague o serviço *db*, o `depends_on` e as variáveis `GITEA__database__`: o Gitea usa SQLite por padrão, com o arquivo dentro de `./gitea`. Suba e acompanhe o log:

```
sudo docker compose up -d
sudo docker compose logs -f server
curl -I http://127.0.0.1:3000
```

## SSH do Git em porta separada

O SSH da VPS já ocupa a porta 22 para administração. O container do Gitea tem o próprio servidor SSH, que escuta na porta 22 dentro dele e é publicado na 2222 da VPS pela linha `"2222:22"`. As duas variáveis de SSH no compose separam essas ideias: o `SSH_PORT=2222` é a porta que aparece nas URLs de clone, e o `SSH_LISTEN_PORT=22` é a porta interna do container.

Como a porta foi publicada pelo Docker, ela já fica acessível de fora. Se o seu provedor ou a sua política de firewall exigir regra explícita, registre com `sudo ufw allow 2222/tcp`. Depois de cadastrar a sua chave pública nas configurações do usuário, na seção de chaves SSH, crie uma entrada no `~/.ssh/config` do seu computador para não precisar lembrar a porta:

```
Host git.seu-dominio.com.br
    User git
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
```

```
ssh -T git@git.seu-dominio.com.br
git clone ssh://git@git.seu-dominio.com.br:2222/usuario/projeto.git
```

O teste com `ssh -T` deve responder com uma saudação dizendo que você se autenticou e que o Gitea não oferece shell. Se pedir senha, a chave não foi cadastrada ou o cliente está oferecendo outra chave. Se a chave SSH ainda é novidade para você, veja [como configurar chave SSH](https://streethosting.com.br/guias/vps/configurar-chave-ssh-sem-senha-vps).

> **Dica**
>
> Existe a alternativa de compartilhar a porta 22 entre o SSH da VPS e o Gitea, chamada de passagem de SSH na documentação oficial. Ela deixa as URLs mais limpas, mas mexe no usuário *git* do sistema e é mais difícil de depurar. Para a maioria dos casos, a porta separada é o caminho mais seguro.

## Domínio, Nginx e HTTPS

Com o registro A do subdomínio apontando para a VPS, instale o Nginx e crie `/etc/nginx/sites-available/gitea`:

```
server {
    listen 80;
    server_name git.seu-dominio.com.br;

    client_max_body_size 512M;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Connection $http_connection;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
```

```
sudo ln -s /etc/nginx/sites-available/gitea /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d git.seu-dominio.com.br
sudo ufw allow "Nginx Full"
```

O `client_max_body_size` importa porque pushes por HTTPS e arquivos do Git LFS passam pelo Nginx; com o limite padrão de 1 MB, qualquer push maior falha com erro 413. Os cabeçalhos `X-Forwarded` dizem ao Gitea que a conexão original era HTTPS, o que mantém links e redirecionamentos corretos. Os detalhes do Certbot e da renovação automática estão no guia de [SSL com Let's Encrypt e Nginx](https://streethosting.com.br/guias/vps/certificado-ssl-vps-lets-encrypt-nginx).

Os três sintomas mais comuns nesta etapa e suas causas:

- **502 Bad Gateway:** o container não está de pé ou a porta 3000 não foi publicada em 127.0.0.1. Confira com `sudo docker compose ps` e com o *curl* local da seção anterior.
- **Links apontando para localhost:3000:** o `ROOT_URL` está errado ou não chegou ao *app.ini*. Corrija a variável e recrie o container.
- **URL de clone sem a porta 2222:** faltou o `GITEA__server__SSH_PORT`, e os clientes tentam a porta 22, que pertence ao SSH da VPS.

## Instalação inicial e segurança

Ao abrir `https://git.seu-dominio.com.br` pela primeira vez, o Gitea mostra a tela de instalação com o banco e o domínio já preenchidos pelas variáveis. Confira os campos, defina o nome do site e crie a conta de administrador na seção de configurações opcionais, antes de concluir.

> **Atenção**
>
> Enquanto a instalação inicial não for concluída, quem acessar o endereço primeiro pode terminar o processo e virar administrador. Conclua logo depois de subir o container. Se precisar de tempo, deixe o Nginx desligado e acesse por um túnel com `ssh -N -L 3000:127.0.0.1:3000 usuario@IP_DA_VPS`.

Com o administrador criado, feche o cadastro aberto, que por padrão deixa qualquer visitante criar conta. Acrescente ao `environment` do serviço *server* no `compose.yaml`:

```
      - GITEA__service__DISABLE_REGISTRATION=true
      - GITEA__service__REQUIRE_SIGNIN_VIEW=true
```

Depois rode `sudo docker compose up -d`, que recria o container com as novas variáveis.

A segunda linha esconde tudo de quem não fez login, útil quando a instância é só do seu time. Novos usuários passam a ser criados pelo painel de administração ou pela linha de comando, com `sudo docker exec -it -u git gitea gitea admin user create --username nome --email nome@seu-dominio.com.br --random-password`. Ative a autenticação em dois fatores para o administrador.

Para pipelines, o Gitea Actions precisa de um runner, o `act_runner`, registrado na instância. Como os jobs executam código dos repositórios, rode o runner isolado, de preferência em outra VPS ou em container próprio. A arquitetura de deploy automático está em [como configurar CI/CD em uma VPS](https://streethosting.com.br/guias/vps/configurar-ci-cd-vps).

## Backup e atualização

O que precisa ser salvo são duas coisas: o banco e o diretório `./gitea`, que contém repositórios, anexos, chaves e o `app.ini`. Parar o Gitea por alguns segundos durante a cópia evita capturar um push pela metade:

```
cd /opt/gitea
sudo mkdir -p /var/backups/gitea
sudo docker compose stop server
sudo docker compose exec -T db pg_dump -U gitea gitea | gzip | sudo tee /var/backups/gitea/banco_$(date +%F).sql.gz > /dev/null
sudo tar czf /var/backups/gitea/dados_$(date +%F).tar.gz -C /opt/gitea gitea
sudo docker compose start server
```

O Gitea também tem o comando `gitea dump`, que gera um único arquivo zip com banco, repositórios e configuração. Qualquer que seja o método, mande as cópias para fora da VPS, como mostra o guia de [backup automático com restic e cron](https://streethosting.com.br/guias/vps/automatizar-backup-vps-restic-cron), e teste a restauração em outra máquina de tempos em tempos.

Para atualizar, faça o backup, leia as notas da versão, troque a tag no `compose.yaml` e rode `sudo docker compose pull && sudo docker compose up -d`. O Gitea aplica as migrações do banco na inicialização; acompanhe o log até a interface voltar. A imagem do PostgreSQL só deve mudar de versão principal com dump e restauração, porque os dados de uma versão principal não abrem direto na seguinte.

## Qual VPS usar para o Gitea

O Gitea em si é leve. O que define o plano é o tamanho dos repositórios, o uso de Git LFS e, principalmente, se o runner de pipelines vai rodar na mesma máquina, porque compilar e testar código consome muito mais CPU e RAM que servir o Git. Nas [VPS da StreetHosting](https://streethosting.com.br/vps) você tem acesso root em KVM, NVMe, AntiDDoS e datacenter em São Paulo, com ativação em até 60 segundos.

| Cenário | Plano sugerido | Preço mensal |
| --- | --- | --- |
| Uso pessoal com SQLite | Xeon 2 vCPU, 2 GB, 20 GB NVMe | R$ 23,00 |
| Time pequeno com PostgreSQL | Xeon 3 vCPU, 4 GB, 40 GB NVMe | R$ 40,00 |
| Time com runner na mesma VPS | Xeon 6 vCPU, 8 GB, 80 GB NVMe | R$ 74,00 |
| Builds rápidos no runner | Ryzen 9 9950X 4 vCPU, 8 GB DDR5, 80 GB NVMe | R$ 114,00 |
| Muitos repositórios, LFS e artefatos | Xeon 9 vCPU, 16 GB, 160 GB NVMe | R$ 142,00 |

A [VPS Xeon](https://streethosting.com.br/vps/xeon) dá mais vCPU e disco por real, o que atende bem o servidor Git e o banco. A VPS Ryzen 9 9950X, com clock de até 5,7 GHz, encurta o tempo de compilação quando o runner roda junto. Se o espaço acabar, o upgrade pelo painel cobra só a diferença proporcional do ciclo e exige reiniciar a VM.

## Perguntas frequentes

### Gitea precisa de muito recurso na VPS?

Não. Para uso pessoal ou um time pequeno, 2 vCPU e 2 GB de RAM atendem com SQLite, e 4 GB deixam folga com PostgreSQL. O que mais cresce com o tempo é o disco, por causa dos repositórios, e a CPU quando você roda pipelines na mesma máquina.

### Devo usar SQLite ou PostgreSQL no Gitea?

SQLite serve para uso pessoal e poucos usuários, porque não exige outro serviço. Para times, integração contínua e muitas gravações simultâneas, prefira PostgreSQL, que lida melhor com concorrência e permite backup sem parar o Gitea.

### Por que usar a porta 2222 para o SSH do Gitea?

A porta 22 da VPS já é usada pelo SSH de administração. Publicar o SSH do container em outra porta, como 2222, evita conflito e mantém o acesso de administração separado do acesso aos repositórios.

### O Gitea tem algo parecido com o GitHub Actions?

Tem. O Gitea Actions usa uma sintaxe de workflow compatível com a do GitHub Actions, mas precisa de um runner separado, o act_runner, registrado na instância. Como os jobs executam código, rode o runner isolado, de preferência em outra VPS ou container.

### Como atualizar o Gitea no Docker?

Faça backup, troque a tag da imagem no compose.yaml pela versão nova, rode docker compose pull e docker compose up -d. O Gitea aplica as migrações do banco ao iniciar; leia as notas da versão antes de pular várias versões de uma vez.

## Guias relacionados

- [Como instalar Docker no Ubuntu 22.04 ou 24.04 em VPS (guia direto ao ponto)](https://streethosting.com.br/guias/vps/instalar-docker-ubuntu-vps.md)
- [Como configurar o Nginx como reverse proxy na VPS](https://streethosting.com.br/guias/vps/configurar-nginx-reverse-proxy-vps.md)
- [Certificado SSL na VPS com Let's Encrypt e Nginx](https://streethosting.com.br/guias/vps/certificado-ssl-vps-lets-encrypt-nginx.md)
- [Como configurar CI/CD na VPS com deploy automático](https://streethosting.com.br/guias/vps/configurar-ci-cd-vps.md)
- [Como instalar PostgreSQL na VPS Ubuntu com segurança](https://streethosting.com.br/guias/vps/instalar-postgresql-vps-ubuntu.md)

## Produtos citados

- https://streethosting.com.br/vps
- https://streethosting.com.br/vps/xeon
- https://streethosting.com.br/vps/ryzen

## Dados estruturados

```json
[
  {
    "@context": "https://schema.org",
    "@type": [
      "Article",
      "TechArticle"
    ],
    "headline": "Gitea na VPS: seu próprio servidor Git com domínio e HTTPS",
    "name": "Como instalar Gitea na VPS com Docker, HTTPS e SSH",
    "abstract": "O Gitea é um servidor Git leve, com interface web, issues, pull requests e registro de pacotes. Veja como subir com Docker Compose, escolher o banco, separar o SSH do Git do SSH da VPS e publicar com domínio e HTTPS.",
    "description": "Hospede seus repositórios Git na VPS com Gitea em Docker Compose, PostgreSQL ou SQLite, SSH do Git em porta separada, Nginx e HTTPS com Let's Encrypt.",
    "datePublished": "2026-09-28",
    "dateModified": "2026-09-28",
    "author": {
      "@type": "Organization",
      "name": "Equipe StreetHosting"
    },
    "publisher": {
      "@type": "Organization",
      "name": "StreetHosting",
      "url": "https://streethosting.com.br"
    },
    "inLanguage": "pt-BR",
    "mainEntityOfPage": {
      "@type": "WebPage",
      "@id": "https://streethosting.com.br/guias/vps/instalar-gitea-vps"
    }
  },
  {
    "@context": "https://schema.org",
    "@type": "FAQPage",
    "mainEntity": [
      {
        "@type": "Question",
        "name": "Gitea precisa de muito recurso na VPS?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "Não. Para uso pessoal ou um time pequeno, 2 vCPU e 2 GB de RAM atendem com SQLite, e 4 GB deixam folga com PostgreSQL. O que mais cresce com o tempo é o disco, por causa dos repositórios, e a CPU quando você roda pipelines na mesma máquina."
        }
      },
      {
        "@type": "Question",
        "name": "Devo usar SQLite ou PostgreSQL no Gitea?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "SQLite serve para uso pessoal e poucos usuários, porque não exige outro serviço. Para times, integração contínua e muitas gravações simultâneas, prefira PostgreSQL, que lida melhor com concorrência e permite backup sem parar o Gitea."
        }
      },
      {
        "@type": "Question",
        "name": "Por que usar a porta 2222 para o SSH do Gitea?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "A porta 22 da VPS já é usada pelo SSH de administração. Publicar o SSH do container em outra porta, como 2222, evita conflito e mantém o acesso de administração separado do acesso aos repositórios."
        }
      },
      {
        "@type": "Question",
        "name": "O Gitea tem algo parecido com o GitHub Actions?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "Tem. O Gitea Actions usa uma sintaxe de workflow compatível com a do GitHub Actions, mas precisa de um runner separado, o act_runner, registrado na instância. Como os jobs executam código, rode o runner isolado, de preferência em outra VPS ou container."
        }
      },
      {
        "@type": "Question",
        "name": "Como atualizar o Gitea no Docker?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "Faça backup, troque a tag da imagem no compose.yaml pela versão nova, rode docker compose pull e docker compose up -d. O Gitea aplica as migrações do banco ao iniciar; leia as notas da versão antes de pular várias versões de uma vez."
        }
      }
    ]
  }
]
```