---
title: "Como fazer deploy de um app Gin em 2026"
description: "Faça o deploy de um app Go Gin com um comando: o pethost deploy escreve o Dockerfile, faz o build do programa e o serve com HTTPS, por € 9,99 por mês."
---

[Blog](https://pethost.dev/pt/blog/) · Guias de deploy

# Como fazer deploy de um app Gin em 2026: um comando, HTTPS e um Dockerfile que fica com você

Pela equipe da Pethost · 10 de outubro de 2026 · Atualizado em 25 de outubro de 2026 · 9 min de leitura

Você tem um app Gin que roda no seu notebook e quer colocá-lo no ar em um endereço com HTTPS. No Pethost, isso é um comando, `pethost deploy`, rodado na pasta que tem o `go.mod`. Ele escreve o Dockerfile para você, faz o build do programa e mostra o endereço dele. O app do quickstart do próprio Gin teve o build feito e foi iniciado em 58 segundos na primeira vez, e em 2 segundos na segunda.

**Em resumo**

- **Um comando:** `pethost deploy` na pasta que tem o `go.mod`. Não há arquivo de configuração para escrever nem configurações de build para preencher.
- **O que ele faz:** lê a versão do Go no `go.mod`, escreve um Dockerfile que roda `go build` e inicia o programa.
- **A porta:** o Gin escuta na 8080, a não ser que a `PORT` diga outra. O Pethost encontra a porta em que o programa escuta, então você não configura nada.
- **O endereço:** `https://my-api.yourname.pethost.app`, com HTTPS na hora. Seu próprio domínio é um registro DNS.
- **O preço:** € 9,99 por mês por 2 vCPU, 3 GB e 30 GB, para esta API e todos os seus outros projetos. Não existe plano gratuito.

## O que você precisa para fazer deploy de um app Gin em 2026

Três coisas: o app, o comando `pethost` e uma conta no Pethost.

**O app** aqui é o que o quickstart do Gin deixa pronto: `go mod init my-api`, `go get github.com/gin-gonic/gin` e este `main.go`:

```
package main

import (
	"net/http"

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

func main() {
	router := gin.Default()
	router.GET("/ping", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"message": "pong",
		})
	})
	router.Run() // listens on 0.0.0.0:8080 by default
}
```

**O comando** é um programa, instalado com uma linha. Todos os comandos dele estão na [referência da CLI](https://pethost.dev/docs/cli/).

```
curl -fsSL https://pethost.dev/install.sh | sh      # macOS, Linux
irm https://pethost.dev/install.ps1 | iex           # Windows, in PowerShell
```

**A conta** precisa de um plano. Se você não entrou, o `pethost deploy` abre o seu navegador e faz o seu login. Se você ainda não tem um plano, ele mostra onde escolher um e espera.

## Faça o deploy do app Gin com um comando

Vá até a pasta que tem o `go.mod` e rode `pethost deploy`. Esta é a tela inteira, para o quickstart:

```
$ cd my-api
$ pethost deploy
Name it [my-api]:    it will live at https://my-api.sam.pethost.app
✓ Packed 3 files, 9 KB
✓ Uploaded straight to your machine
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
✓ Go program detected, wrote Dockerfile.
✓ Packed 4 files, 10 KB
✓ Uploaded straight to your machine
✓ Built and started in 58 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env
✓ app listens on 8080 → https://my-api.sam.pethost.app
  It answers 404.

https://my-api.sam.pethost.app

Wrote .pethost (commit it). Next:   pethost logs -f   ·   pethost open
```

1. **Ele pergunta uma coisa** O nome do projeto, que é a primeira palavra do endereço. Enter usa o nome da pasta.
2. **A máquina não encontra nada para rodar** A linha com o X é a resposta dela: um projeto roda a partir de um Dockerfile ou de um arquivo Compose, e a pasta ainda não tem nenhum dos dois.
3. **O pethost escreve o Dockerfile** Ele viu o `go.mod` e um `package main` ao lado, e envia a pasta de novo.
4. **A máquina faz o build e o inicia** Ela vê que o programa escuta na 8080 e manda o endereço para lá. Depois o pethost acessa o próprio endereço e mostra o que ele respondeu.

A resposta é 404 porque o quickstart não tem rota em `/`, só em `/ping`. Uma API sua muitas vezes vai dizer o mesmo, e isso quer dizer que o programa está no ar e respondendo. Acesse a rota que existe:

```
$ curl https://my-api.sam.pethost.app/ping
{"message":"pong"}
```

O arquivo `.pethost` diz qual projeto é esta pasta. Faça o commit dele junto com o Dockerfile, e o próximo deploy não pergunta nada.

## O Dockerfile que o pethost escreve para um programa Go

Este é o arquivo como foi escrito na pasta do quickstart, inteiro:

```
# Written by pethost deploy for this Go program: Go 1.25 (go.mod), its program is ..
# It is yours now: change it as you like. pethost does not write it again.

FROM golang:1.25
WORKDIR /app

COPY . .

RUN --mount=type=cache,target=/go/pkg/mod \
    --mount=type=cache,target=/root/.cache/go-build \
    go build -o /usr/local/bin/my-api .

CMD ["my-api"]
```

A primeira linha dele diz o que o pethost leu na sua pasta. Três coisas vêm de lá:

- **A versão do Go** é a da linha `go` do `go.mod`.
- **O programa** é o `package main` na raiz do módulo, ou a única pasta de `cmd/` que tem um. Quando `cmd/` tem vários, o pethost não escreve nada e diz por quê: qual programa os visitantes recebem é você quem decide.
- **O nome** é a última parte do caminho do módulo, como o `go install` o chamaria. Um `Procfile` com uma linha `web` inicia o programa como essa linha diz.

As duas montagens de cache guardam os módulos e o cache de build do Go na sua máquina entre um deploy e outro. É por isso que o segundo deploy levou 2 segundos. Se a máquina não consegue fazer o build ou iniciar o Dockerfile que o pethost escreveu, o pethost tira o arquivo da sua pasta e diz o que falhou.

## Defina o GIN_MODE e outras variáveis de ambiente

O Gin inicia em modo debug: as linhas de log dele começam com `[GIN-debug]`. O log também diz qual porta ele usou:

```
$ pethost logs
2026-10-10T11:15:22Z	app	[GIN-debug] GET    /ping                     --> main.main.func1 (3 handlers)
2026-10-10T11:15:22Z	app	[GIN-debug] Environment variable PORT is undefined. Using port :8080 by default
2026-10-10T11:15:22Z	app	[GIN-debug] Listening and serving HTTP on :8080
```

Uma variável é um comando. Ela vai para o arquivo `.env` do projeto na máquina, que todo deploy seguinte mantém, e o app reinicia com ela:

```
$ pethost env set GIN_MODE=release
my-api (.pethost)
✓ /.env has GIN_MODE now. Deployed in 4 s.
```

Só o nome, sem valor, faz o comando pedir o valor sem mostrá-lo, que é o jeito certo para um segredo: `pethost env set DATABASE_URL`. Você não precisa definir a `PORT`: com `router.Run()` o Gin usa a 8080, e com `router.Run(":3000")` a máquina encontra a 3000 do mesmo jeito.

## Altere o código e faça o deploy de novo

Edite um handler e rode o mesmo comando. A máquina guarda as camadas do build e os caches do Go:

```
$ pethost deploy
my-api (.pethost)
✓ Packed 5 files · uploaded · built and started in 2 s
  · kept the project's .env
  · wrote compose.yaml for the Dockerfile: the service app, reading .env
  · kept the project's x-pethost
  It answers 404.
https://my-api.sam.pethost.app
```

Para fazer o deploy a cada push, conecte o repositório uma vez:

```
pethost github sam/my-api          # from now on, every push deploys itself
```

O Pethost lê só os repositórios que você deu ao GitHub App dele. Se um deploy der errado, `pethost rollback` coloca de volta a versão anterior, e a sua máquina guarda as três versões antes da atual. Um agente de IA pode fazer tudo isso por você pelo servidor MCP do Pethost: [como um agente faz o deploy de um projeto e cuida dele](https://pethost.dev/pt/blog/hosting-for-ai-coding-agents/). O mesmo comando faz o deploy de um [app Fiber](https://pethost.dev/pt/blog/deploy-fiber-app/).

## Use seu próprio domínio na API

Qualquer nome sob o domínio da sua conta já é um endereço na hora, com HTTPS. Um domínio seu leva um comando e um registro DNS:

```
pethost domain add api.example.com
```

O comando mostra o registro a criar: um CNAME do seu nome para o nome da sua máquina. O certificado chega sozinho assim que o nome resolve, e se renova sozinho.

## O que você recebe pelo preço

O Pethost custa € 9,99 por mês por tudo o que você hospeda, com 2 vCPU, 3 GB de memória e 30 GB de disco. Um programa Gin é um binário pequeno, então a máquina tem espaço para o banco de dados dele, um worker e os seus outros projetos. Não há [taxa por projeto](https://pethost.dev/pt/blog/unlimited-projects-flat-monthly-fee/) e nada é medido: uma segunda API não custa nada a mais, e um Postgres ao lado dela [entra no mesmo preço](https://pethost.dev/pt/blog/european-hosting-postgres-flat-price/).

- **€ 9,99** por mês por todos os seus projetos, nada medido
- **58s** para fazer o build e iniciar o quickstart, na primeira vez
- **2s** para o deploy seguinte

O que já vem feito para você: HTTPS com certificados que se renovam sozinhos, deploys a partir do GitHub, backups noturnos guardados por 14 dias, SSH em qualquer container, e cada requisição contada. O painel mostra os caminhos mais acessados e a taxa de erros dos últimos 30 dias, que para uma API é a lista das rotas que as pessoas realmente chamam. A máquina está sempre ligada, então uma requisição [nunca espera um cold start](https://pethost.dev/pt/blog/always-on-hosting-no-cold-starts/). Os planos estão na parte de [preços](https://pethost.dev/pt/#pricing) da página inicial.

**Quais rotas são chamadas.** Os dez caminhos mais acessados de um projeto, com a fatia e os tempos de resposta de cada um, e o log de requisições individuais.

![O painel do Pethost: os dez caminhos mais acessados de um projeto, com fatia, contagem e tempos de resposta, e o log de requisições individuais.](https://pethost.dev/shots/traffic.webp)

### O Pethost é a melhor escolha para

- **Desenvolvedores Go com uma API pequena**: o programa, o banco de dados e o worker em uma máquina, em uma só fatura
- **Desenvolvedores solo** com vários projetos paralelos, cada um no seu próprio endereço
- **Quem deixa o agente fazer o deploy**: o Claude Code ou o Codex coloca a API no ar e lê os logs dela
- **Startups no começo** que querem um custo mensal fixo enquanto o produto é pequeno

### Procure outra opção se

- Sua aplicação precisa de várias regiões ou de autoscaling

## Perguntas

### Um app Gin precisa de Dockerfile para fazer deploy?

No Pethost, um projeto roda a partir de um Dockerfile ou de um arquivo Compose, e você não precisa escrevê-lo: em uma pasta que não tem nenhum dos dois, o `pethost deploy` escreve o Dockerfile de um programa Go e faz o deploy. O arquivo fica na sua pasta, e você pode alterá-lo.

### Em qual porta um app Gin deve escutar?

Em qualquer uma. Com `router.Run()` o Gin escuta na 8080, ou na porta que a variável `PORT` indicar. O Pethost encontra a porta em que o programa escuta e manda o endereço para lá, com HTTPS.

### Como definir GIN_MODE=release em produção?

Rode `pethost env set GIN_MODE=release` na pasta do projeto. A variável vai para o arquivo `.env` do projeto na máquina, o app reinicia com ela, e os próximos deploys a mantêm.

### Por que o pethost deploy diz “It answers 404” para a minha API Gin?

Depois de um deploy, o pethost acessa o endereço `/` e mostra a resposta. Uma API sem rota em `/` responde 404 ali, o que ainda mostra que o programa está no ar. Acesse uma das suas rotas para ver que funciona.

### Dá para fazer deploy de um app Gin do GitHub a cada push?

Sim. Faça o deploy da pasta uma vez com `pethost deploy` e depois rode `pethost github owner/repository`. A partir daí, cada push no repositório faz o deploy sozinho, e `pethost rollback` volta para um commit anterior.

### Quanto custa hospedar uma API Gin no Pethost?

€ 9,99 por mês no Starter, com 2 vCPU, 3 GB e 30 GB e sem taxa por projeto: suas outras APIs, sites e bancos de dados também rodam lá. Não existe plano gratuito. Os preços são sem IVA.

As telas são deploys do app que o quickstart do Gin escreve, com o Gin 1.12.0, o Go 1.25 e o pethost 0.2.1, em uma máquina de teste nossa que nunca tinha feito build de nada. A conta nelas é a de exemplo, `sam`.

1. [Gin: quickstart](https://gin-gonic.com/en/docs/quickstart/)
2. [Gin: deploy](https://gin-gonic.com/en/docs/deployment/)
3. [pethost, a linha de comando do Pethost](https://pethost.dev/docs/cli/)

## Coloque seus projetos no ar hoje

Publique apps, bots e bancos de dados pelo seu agente, pelo GitHub ou pelo navegador, quantos couberem, a um preço fixo. Nada medido, nada cobrado à parte.

[Hospede tudo por € 9,99/mês](https://console.pethost.dev/)

## Continue lendo

- 10 de outubro de 2026 [Como fazer deploy de um app Go Fiber em 2026: um comando, HTTPS e um Dockerfile que fica com você](https://pethost.dev/pt/blog/deploy-fiber-app/) Faça o deploy de um app Go Fiber com um comando: o pethost deploy escreve o Dockerfile, faz o build em 45 segundos e o serve com HTTPS, por € 9,99 por mês.
- 10 de outubro de 2026 [Como fazer deploy de um app Nuxt em 2026: um comando, um servidor Node e HTTPS](https://pethost.dev/pt/blog/deploy-nuxt-app/) Faça o deploy de um app Nuxt 4 com um comando: o pethost deploy escreve o Dockerfile, roda o nuxt build e inicia o servidor Node com HTTPS, por € 9,99 por mês.
- 10 de outubro de 2026 [Como fazer deploy de um app React Router em 2026: o Dockerfile do template, um comando e HTTPS](https://pethost.dev/pt/blog/deploy-react-router-app/) Faça o deploy de um app React Router renderizado no servidor: o pethost deploy faz o build do Dockerfile do template e serve com HTTPS em 11 s, por € 9,99/mês.
- 10 de outubro de 2026 [Como fazer deploy de um app TanStack Start em 2026: Nitro, um script start e um comando](https://pethost.dev/pt/blog/deploy-tanstack-start-app/) Deploy do TanStack Start em um servidor Node: adicione o Nitro e um script start, rode pethost deploy, e o app fica no ar com HTTPS em 29s, por € 9,99 por mês.

[Todos os artigos](https://pethost.dev/pt/blog/) · [Sobre a Pethost](https://pethost.dev/about/) · [Preços](https://pethost.dev/pt/#pricing)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Templates](https://pethost.dev/pt/templates/)
- [Sobre nós](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/pt/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Termos](https://pethost.dev/terms/)
- [Privacidade](https://pethost.dev/privacy/)
- [Reembolsos](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bancos de dados

- [Postgres](https://pethost.dev/pt/postgres/)

Comparativos

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/pt/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/pt/blog/coolify-cloud-vs-dokploy-cloud/)
- [Preços Railway vs Render vs Fly.io](https://pethost.dev/pt/blog/railway-vs-render-vs-fly-io-pricing/)
- [Hospedagem gerenciada de Docker Compose](https://pethost.dev/pt/blog/managed-docker-compose-hosting/)

Alternativas

- [Alternativas ao Railway](https://pethost.dev/pt/blog/railway-alternatives/)
- [Alternativas ao Heroku](https://pethost.dev/pt/blog/heroku-alternatives/)
- [Alternativas ao Dokploy](https://pethost.dev/pt/blog/dokploy-alternatives/)
- [Alternativas ao Coolify](https://pethost.dev/pt/blog/coolify-alternatives/)
- [Alternativas ao Render](https://pethost.dev/pt/blog/render-alternatives/)
- [Alternativas ao Sliplane](https://pethost.dev/pt/blog/sliplane-alternatives/)