---
title: "Setup do Rest PKI Core em Docker"
description: "Instalação do Rest PKI Core on-premises em Docker: imagem no Docker Hub, tags móveis e requisitos como blob storage e connection string do banco de dados."
canonical: "https://docs.lacunasoftware.com/articles/rest-pki/core/on-premises/docker"
locale: "pt-BR"
product: "Rest PKI Core"
last_updated: "2026-09-15"
---

# Setup do Rest PKI Core em Docker

Para instalar uma instância [*on premises*](https://docs.lacunasoftware.com/articles/rest-pki/core/on-premises) do [Rest PKI Core](https://docs.lacunasoftware.com/articles/rest-pki/core) em Docker, siga os passos abaixo. Para outros ambientes, [clique aqui](https://docs.lacunasoftware.com/articles/rest-pki/core/on-premises#platforms).

A imagem de Docker do Rest PKI Core encontra-se disponível no Docker Hub:

**[Rest PKI Core Docker image](https://hub.docker.com/r/lacunasoftware/restpkicore)**

A imagem atualmente recomendada é a `lacunasoftware/restpkicore:5.0`

Tags móveis disponíveis:

* A tag `5.0` aponta para a última imagem 5.0.x **(recomendada)**
* A tag `5` aponta para a última imagem 5.x
* A tag `stable` aponta para a última imagem estável

Esta imagem requer:

* Um **blob storage** compartilhado entre todos os containers rodando a imagem -- veja [Configuração de Blob Storage](https://docs.lacunasoftware.com/articles/rest-pki/core/on-premises/configure-blob-storage)

* **Connection string** para um [banco de dados SQL Server ou PostgreSQL criado previamente](https://docs.lacunasoftware.com/articles/rest-pki/core/on-premises/prepare-database)
* Licença de uso da biblioteca **PKI SDK** (em formato binário/Base64)
* Licença de uso do componente **Web PKI** (em formato binário/Base64)

## Configuração

Esta imagem é configurada utilizando variáveis de ambiente. Obtenha o [**arquivo de configuração de exemplo**](https://cdn.lacunasoftware.com/restpkicore/docker/restpkicore.env)
para um guia de como preencher os parâmetros necessários.

Para preencher o parâmetro `General__EncryptionKey`, gere uma chave de 256 bits para encriptar dados sensíveis armazenados no banco de dados:

```sh
docker run lacunasoftware/restpkicore:5.0 -- gen-enc-key
```

Para preencher o parâmetro `General__RootPasswordHash`, escolha uma senha forte para acesso à interface de gerenciamento como *root* e calcule o hash dela:

```sh
docker run -i lacunasoftware/restpkicore:5.0 -- hash-root-pass
```

## Portas

A imagem escuta na **porta 80**.

É recomendado configurar um proxy reverso ou balanceador de carga escutando nas portas padrão HTTP (80) e HTTPS (443), redirecionando o tráfego em
ambas portas para a porta 80 do Rest PKI Core. Ademais, seu proxy deve preencher os *request headers*
[X-Forwarded-Proto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Proto),
[X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For) e, opcionalmente, `X-Forwarded-Port`.
A configuração `Bindings__UseReverseProxy=True` instrui o Rest PKI Core a confiar nas informações preenchidas nestes headers.

## Exemplo

Em um ambiente de produção, tipicamente se utilizaria um orquestrador de Docker e um SGBD dedicado ou em nuvem (IaaS).
Entretanto, para fins de teste, utilizando apenas o Docker é possível rodar uma instância do Rest PKI Core com um banco de dados PostgreSQL local.

Comece criando um volume para o banco de dados:

```sh
docker volume create restpkicore_sql
```

Inicie o SGBD com uma senha da sua preferência (substitua `SOME_PASS` abaixo):

```sh
docker run --name restpkicore_sql -v restpkicore_sql:/var/lib/postgresql/data -p 5432:5432 -e "POSTGRES_PASSWORD=SOME_PASS" -d postgres
```

Verifique os logs do container para eventuais erros:

```sh
docker logs -f restpkicore_sql
```

Esse processo pode levar alguns minutos. Uma vez que o SGBD esteja executando, pressione CTRL+C para sair dos logs.

Crie um volume para utilizar como *blob storage*:

```sh
docker volume create restpkicore_data
```

Em seguida, baixe o [arquivo de configuração de exemplo](https://cdn.lacunasoftware.com/restpkicore/docker/restpkicore.env), salve-o com nome
*restpkicore.env* e preencha-o.

Na configuração da *connection string*, use o valor abaixo substituindo `HOST_IP` pelo endereço de IP da máquina *host* e `SOME_PASS`
pela senha escolhida para o banco de dados:

```sh
ConnectionStrings__DefaultConnection=Host=HOST_IP;Database=restpkicore;Username=postgres;Password=SOME_PASS
ConnectionStrings__DefaultConnection_ProviderName=Postgres
```

Na configuração de *blob storage*, deixe os parâmetros padrões, pois montaremos o volume criado em `/var/app`:

```sh
BlobStorage__Type=FileSystem
BlobStorage__Path=/var/app
```

Por fim, execute um container com a imagem usando o arquivo de configuração, montando o volume `restpkicore_data` em `/var/app` e expondo a aplicação (que escuta
na porta 80) na porta 8080 da máquina *host*:

```sh
docker run --name restpkicore --env-file restpkicore.env -v restpkicore_data:/var/app -p 8080:80 -d lacunasoftware/restpkicore:5.0
```

> **Dica**
>
> Caso tenha privilégios suficientes, o Rest PKI Core tentará criar o banco de dados no servidor caso ele não exista (é isso que acontecerá nesse caso)

Verifique os logs do container para eventuais erros de configuração:

```sh
docker logs -f restpkicore
```

Se tudo estiver configurado corretamente, você deve ter uma instância do Rest PKI Core rodando em [localhost:8080](http://localhost:8080/)

## Veja também

* [Configuração de gerenciamento de usuários](https://docs.lacunasoftware.com/articles/rest-pki/core/on-premises/configure-oidc)