# Execute o IronPDF como um contêiner remoto.
O IronPdfEngine é um serviço independente capaz de criar, escrever, editar e ler PDFs. O IronPDF Docker está pronto para executar serviços Docker com versões compatíveis do IronPDF (v2023.2.x e superiores). Isso ajudará os desenvolvedores a eliminar problemas de implantação que possam estar enfrentando com o IronPDF.
## Por que executar o IronPDF como um contêiner separado é uma boa ideia
O IronPDF requer os binários do Chrome e do Pdfium para funcionar, e ambos possuem um tamanho de arquivo enorme (centenas de MB). Também requer a instalação de diversas dependências na máquina.
Ao utilizar este método, seu cliente ocupará apenas uma fração do tamanho (em MB).
### Evite problemas de implantação
Configurar o ambiente/container para incluir todas as dependências corretamente pode ser um desafio. Ao usar o contêiner Docker do IronPDF , o IronPDF já vem _pré-instalado_ e _com funcionamento garantido_, evitando todas as dores de cabeça com implantação e dependências.
## Versões
A tag Docker do IronPDF é baseada na versão do próprio IronPdfEngine. Não é a mesma versão do produto IronPDF .
Cada versão do IronPDF terá sua própria versão associada do IronPdfEngine. O número da versão **deve** corresponder à versão do IronPDF Docker.
Por exemplo, a versão `IronPDF for Java` requer a versão `2023.2.1` do IronPdfEngine. **Não é possível** usar versões incompatíveis do IronPdfEngine e do IronPDF .
<hr />
## Como usar o IronPDF no Docker
### Instale o IronPDF
Adicione o pacote NuGet IronPDF .Slim ao seu projeto.
[NuGet](https://www.nuget.org/packages/IronPdf.Slim/)
**Nota: Os pacotes `IronPdf`, `IronPdf.Linux` e `IronPdf.MacOs` contêm IronPdf.Slim.**
Para reduzir o tamanho do seu aplicativo, recomendamos instalar apenas o IronPdf.Slim. O pacote `IronPdf.Native.Chrome.xxx` não é mais utilizado, portanto você pode removê-lo do seu projeto.
### Determine a versão do contêiner necessária.
Por padrão, a versão do IronPDF para Docker corresponderá à versão atual do IronPDF no NuGet. Você pode usar o código abaixo para verificar a versão manualmente:
```csharp
string ironPdfEngineVersion = IronPdf.Installation.IronPdfEngineVersion;
```
### Configurar o IronPDF para contêineres Docker
#### Sem Docker Compose
Execute o contêiner Docker usando a versão da etapa anterior.
* O Docker precisa estar instalado.
**Configurar**
1. Acesse[https://hub.docker.com/r/ironsoftwareofficial/ironpdfengine](https://hub.docker.com/r/ironsoftwareofficial/ironpdfengine)
2. Baixe a imagem mais recente do ironsoftwareofficial/ironpdfengine.
```shell
docker pull ironsoftwareofficial/ironpdfengine
```
Ou baixe a versão específica (recomendado).
```shell
docker pull ironsoftwareofficial/ironpdfengine:2025.3.6
```
3. Execute o contêiner ironsoftwareofficial/ironpdfengine.
Este comando criará um contêiner e o executará em segundo plano na porta 33350.
```shell
docker run -d -p 33350:33350 -e IRONPDF_ENGINE_LICENSE_KEY=MY_LICENSE_KEY ironsoftwareofficial/ironpdfengine:2025.3.6
```
### Como configuro os parâmetros de tempo de execução do IronPdfEngine?
Os parâmetros de tempo de execução podem ser passados diretamente para o contêiner como pares `key=value` após o nome da imagem. Essas configurações definem o comportamento do mecanismo sem a necessidade de reconstruir a imagem.
```shell
docker run -d -p 33350:33350 ironsoftwareofficial/ironpdfengine:2025.3.6 \
license_key="YOUR_LICENSE_KEY" \
enable_debug=true \
chrome_browser_limit=8
```
Os seguintes parâmetros estão disponíveis:
| Parâmetro | Tipo | Default | Descrição |
|-----------|------|---------|-------------|
| `port` | int | `33350` | porta de escuta gRPC |
| `license_key` | string | - | Chave de licença do IronPDF |
| `enable_debug` | bool | `false` | Ativar registro de depuração completo |
| `log_path` | path | - | Caminho do arquivo de log (também habilita o registro de depuração completo) |
| `logging_mode` | string | `Console` | Modo de registro: Nenhum, Console, Personalizado, Janela de saída de depuração, Arquivo, Todos |
| `chrome_browser_limit` | int | - | Número máximo de instâncias simultâneas do navegador Chrome |
| `chrome_cache_path` | path | - | Diretório para cache do navegador Chrome |
| `chrome_gpu_mode` | int | `0` | Modo GPU: 0 Desativado, 1 Hardware, 2 Hardware Total, 3 Software |
| `chrome_custom_deployment_dir` | path | - | Diretório personalizado para binários de implantação do Chrome |
| `temp_folder_path` | path | - | Substituir diretório temporário |
| `skip_shutdown` | bool | `false` | Impede que o motor desligue quando estiver em marcha lenta. |
| `skip_initialization` | bool | `false` | Ignorar a inicialização do Chrome/Pdfium na inicialização. |
| `keep_alive` | bool | `false` | Manter o motor em funcionamento após a desconexão do cliente |
| `single_process` | bool | - | Execute o Chrome em modo de processo único |
| `linux_and_docker_auto_config` | bool | `true` | Configuração automática de dependências Linux/Docker (definidas automaticamente pelo ponto de entrada do Docker) |
| `send_anonymous_analytics_and_crash_data` | bool | - | Ativar ou desativar a telemetria anônima |
[[i:(O parâmetro `linux_and_docker_auto_config` é definido como verdadeiro automaticamente pelo ponto de entrada do Docker. Você não precisa passar isso manualmente. O parâmetro `chrome_gpu_mode` deve permanecer 0 (Desativado) no Docker, a menos que seu host forneça passagem direta de GPU.
)]]
A variável de ambiente `IRONPDF_ENGINE_LICENSE_KEY` também pode ser usada para definir a chave de licença via `-e` ou `environment:` no Docker Compose. Os parâmetros da linha de comando têm precedência sobre as variáveis de ambiente quando ambos estão definidos.
**Exemplo de produção:**
```shell
docker run -d --restart=unless-stopped \
-p 33350:33350 \
-e IRONPDF_ENGINE_LICENSE_KEY=MY_KEY \
ironsoftwareofficial/ironpdfengine \
chrome_browser_limit=8 skip_shutdown=true
```
**Exemplo de depuração:**
```shell
docker run -p 33350:33350 \
ironsoftwareofficial/ironpdfengine \
enable_debug=true log_path=/app/logs/engine.log
```
#### Com Docker Compose
A chave é configurar uma rede Docker que permita que o IronPdfEngine e seu aplicativo se comuniquem. Defina 'depends_on' para garantir que o IronPdfEngine esteja em execução antes que seu aplicativo seja iniciado.
**Configurar**
1. Comece criando um arquivo `docker-compose.yml`. Configure seu arquivo Docker Compose usando o seguinte modelo:
```yml
version: '3.6'
services:
myironpdfengine:
container_name: ironpdfengine
image: ironsoftwareofficial/ironpdfengine:latest
ports:
- '33350:33350'
networks:
- ironpdf-network
myconsoleapp:
container_name: myconsoleapp
build:
# enter YOUR project directory path here
context: ./MyConsoleApp/
# enter YOUR dockerfile name here, relative to project directory
dockerfile: Dockerfile
networks:
- ironpdf-network
depends_on:
myironpdfengine:
condition: service_started
networks:
ironpdf-network:
driver: 'bridge'
```
1. Defina o endereço do IronPdfEngine dentro do seu aplicativo (myconsoleapp) para "myironpdfengine:33350"
2. Execute o docker compose.
```shell
docker compose up --detach --force-recreate --remove-orphans --timestamps
```
### Conecte-se ao IronPdfEngine
Execute seu código IronPDF ; Seu aplicativo agora se comunica com o IronPdfEngine no Docker!
```csharp
using IronPdf;
using IronPdf.GrpcLayer;
// Configure for Docker container
var config = IronPdfConnectionConfiguration.Docker;
config.Host = "localhost";
IronPdf.Installation.ConnectToIronPdfHost(config);
// Use IronPDF
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF Docker!<h1>");
pdf.SaveAs("ironpdf.pdf");
```
<hr />
### Tipo de conexão
Existem vários `IronPdfConnectionType` que você pode atribuir dependendo do tipo de conexão que deseja fazer.
Segue uma lista dos imóveis disponíveis:
**LocalExecutable** : Para conectar-se a um "servidor" IronPdfEngine que esteja executando um arquivo executável em sua máquina local, usamos esta opção. Um exemplo rápido seria um aplicativo de faturamento WinForms que gera PDFs localmente sem depender de serviços em nuvem.
**Docker** : Esta opção deve ser usada ao tentar conectar-se a um contêiner Docker, seja localmente ou na nuvem.
**RemoteServer** : Esta opção é usada para o IronPdfEngine na nuvem. Isso se conecta a uma instância do IronPdfEngine hospedada na nuvem (por exemplo, Docker) por meio do protocolo HTTP ou HTTPS. Note que, como se trata de uma conexão com um servidor remoto, o URL completo é necessário (incluindo o protocolo HTTP ou HTTPS).
**Personalizado** : Para controle e personalização completos da conexão, você pode usar esta opção. Esta opção utiliza o seu **Grpc.Core.ChannelBase** personalizado em vez das outras opções definidas acima. Os desenvolvedores podem criar um novo canal criando um novo objeto **Grpc.Core.Channel** ou usando **.NET(System.String)** para personalizar e ter controle total sobre o canal gRPC.
#### .NET Framework com NetFrameworkChannel
Para o .NET Framework, precisamos de uma configuração diferente porque o gRPC funciona de maneira distinta em projetos .NET Framework .
Para que este método funcione, certifique-se de que o pacote NuGet [**Grpc.Core**](https://www.nuget.org/packages/grpc.core) esteja instalado. Para esta configuração específica, utilizaremos um canal gRPC personalizado derivado de **Grpc.Core.ChannelBase** .
Vamos examinar este exemplo, onde implementaremos o canal de conexão para criar e salvar um PDF usando o IronPDFEngine.
Como o gRPC funciona de forma diferente em projetos .NET Framework , se o código a seguir não funcionar, tente remover o prefixo `<http>` ou `<https>` do endereço.
[[w:(Observe que este `pdf.Dispose` é necessário neste caso.)]]
```csharp
using IronPdf;
// This code demonstrates how to use IronPdf with gRPC in a .NET Framework application.
// 1. Configure connection to use local IronPdfEngine executable
var config = IronPdf.GrpcLayer.IronPdfConnectionConfiguration.Executable;
// 2. Connect to the IronPDF host with the executable configuration
IronPdf.Installation.ConnectToIronPdfHost(config);
// 3. Create a PDF renderer instance
ChromePdfRenderer renderer = new ChromePdfRenderer();
// 4. Render HTML string as PDF document
PdfDocument pdf = renderer.RenderHtmlAsPdf("Hello world");
// 5. Save the PDF to disk
pdf.SaveAs("output.pdf");
// 6. Clean up , this is needed to work
pdf.Dispose();
```
#### Método alternativo com WithCustomChannel
Um método alternativo seria utilizar o método `WithCustomChannel` fornecido pelo `IronPdf.GrpcLayer`.
O `WithCustomChannel` recebe dois parâmetros, o `customChannel`, que é o seu canal gRPC personalizado, e o `metadata`. O parâmetro `metadata` é opcional e está definido como `null` por padrão.
```csharp
using IronPdf;
using IronPdf.GrpcLayer;
using Grpc.Core;
// 1. Create custom gRPC channel (.NET Framework style)
var channel = new Channel("123.456.7.8:80", ChannelCredentials.SecureSsl);
// 2. (Optional) Add metadata headers if needed
var metadata = new Metadata
{
{ "Authorization", "Bearer your_token_here" }
};
// 3. Configure IronPDF with custom channel
var config = IronPdfConnectionConfiguration.WithCustomChannel(channel, metadata);
IronPdf.Installation.ConnectToIronPdfHost(config);
// 4. Generate PDF
var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("Hello world");
// 5. Save the PDF to disk
pdf.SaveAs("output.pdf");
// 6. Clean up , this is needed to work
pdf.Dispose();
```
<hr />
## Implante o IronPdfEngine no AWS ECS.
### Pré-requisitos
* Faça o download da imagem Docker do IronPdfEngine. Isso está descrito na [seção "Configuração do IronPDF para contêiner Docker"](#anchor-setup-ironpdf-for-docker-container) acima.
* Uma conta da AWS com acesso ao ECS.
### Configurar
1. Crie um cluster ECS. Siga este guia [para criar um cluster para os tipos de inicialização Fargate e External usando o console](https://docs.aws.amazon.com/AmazonECS/latest/userguide/create-cluster-console-v2.html) .
2. Crie uma definição de tarefa. Siga este guia para [criar uma definição de tarefa usando o console](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-task-definition.html) .
Configurações recomendadas:
- **AWS Fargate**
Recomenda-se um mínimo de 1 vCPU com 2 GB de RAM. Dependendo da sua carga de trabalho, se você estiver trabalhando com PDFs contendo mais de 10 páginas ou enfrentando um grande volume de solicitações, selecione um plano superior.
- **Modo de rede** : awsvpc
- **Mapeamento de portas** :
```json
{
"containerPort": 33350,
"hostPort": 33350,
"protocol": "tcp",
"appProtocol": "grpc"
}
```
- **URI da imagem** : aponte para qualquer IronPdfEngine fornecido por nós. Por exemplo, "ironsoftwareofficial/ironpdfengine:2024.1.20" (do DockerHub)
- As permissões e **a configuração de rede** **da AWS** são de sua responsabilidade.
É recomendável **ativar o Amazon CloudWatch** . (Enable logging)
- **A ordem de inicialização do contêiner** é necessária se você quiser implantar o contêiner do seu aplicativo na mesma definição de tarefa.
3. Execute uma definição de tarefa. Você pode executar uma definição de tarefa como uma **Tarefa** ou **um Serviço** . Siga este guia sobre [como criar um serviço usando o console](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html) .
Configurações recomendadas:
* Tipo de lançamento: **AWS Fargate**
* IP público: **ativado** para testes e **desativado** para produção. Segurança e rede AWS são de sua responsabilidade.
4. Aproveite! O contêiner Docker do IronPdfEngine está instalado e funcionando na sua AWS!
[[i:(O próprio contêiner Docker do IronPdfEngine não suporta escalonamento horizontal; Ele foi projetado como um serviço de backend de instância única. Seu aplicativo que utiliza a biblioteca IronPDF (com ou sem IronPdfEngine) ainda pode ser escalado horizontalmente com a implantação de múltiplas instâncias do aplicativo. Consulte a [seção Limitações do IronPdfEngine](/get-started/ironpdfengine/#anchor-ironpdfengine-limitation) para obter mais detalhes.
)]]
<hr />
## Implantar o IronPdfEngine em instâncias de contêiner do Azure
### Pré-requisitos
* Faça o download da imagem Docker do IronPdfEngine. Isso está descrito na [seção "Configuração do IronPDF para contêiner Docker"](#anchor-setup-ironpdf-for-docker-container) acima.
* Conta do Azure
### Configurar
1. Crie um contêiner do Azure. Siga este [guia de início rápido sobre como implantar uma instância de contêiner no Azure usando o portal do Azure](https://learn.microsoft.com/en-us/azure/container-instances/container-instances-quickstart-portal) .
Configurações recomendadas:
- **Fonte da imagem** : Outro registro
- **Imagem** : **ironsoftwareofficial/ironpdfengine:2024.1.20** (do Docker Hub)
- **Tipo de sistema operacional** : Linux
- **Tamanho** : Mínimo de 1 vCPU e 2 GiB de memória, ou superior.
- **Porta** : Porta TCP 33350
2. Aproveite! O contêiner Docker do IronPdfEngine já está em execução em suas instâncias de contêiner do Azure!
[[i:(O contêiner Docker do IronPdfEngine não suporta escalonamento horizontal; Projetado como um serviço de backend de instância única, seu aplicativo que utiliza a biblioteca IronPDF (com ou sem IronPdfEngine) ainda pode ser escalado horizontalmente com a implantação de múltiplas instâncias do aplicativo. Consulte a [seção Limitações do IronPdfEngine](/get-started/ironpdfengine/#anchor-ironpdfengine-limitation) para obter mais informações.
)]]
<hr />
## Obtendo o IronPdfEngine na Galeria Pública do AWS ECR
### Pré-requisito
* O Docker precisa estar instalado.
### Configurar
1. Acesse[https://gallery.ecr.aws/v1m9w8y1/ironpdfengine](https://gallery.ecr.aws/v1m9w8y1/ironpdfengine)
2. Extraia a imagem v1m9w8y1/ironpdfengine.
```shell
docker pull https://gallery.ecr.aws/v1m9w8y1/ironpdfengine
```
Ou baixe a versão específica (recomendado).
```shell
docker pull https://gallery.ecr.aws/v1m9w8y1/ironpdfengine:2023.12.6
```
3. Execute o contêiner do ironpdfengine.
Este comando criará um contêiner e o executará em segundo plano na porta 33350.
```shell
docker run -d -p 33350:33350 ironsoftwareofficial/ironpdfengine
```
Aprenda como configurar o cliente IronPDF para utilizar o IronPdfEngine navegando até a seção " [Atualizar o código para usar o IronPdfEngine](#anchor-update-the-code-to-use-ironpdfengine) ".
<hr />
## Obtenha o IronPdfEngine no Marketplace.
Para ajudar você a começar rapidamente, configuramos o IronPdfEngine nos marketplaces da Azure e da AWS.
### Azure Marketplace
<div class="content-img-align-center">
<div class="center-image-wrapper">
<a href="https://azuremarketplace.microsoft.com/en-us/marketplace/apps/ironsoftwarecoltd1682560478296.ironpdf-docker-container-v1?tab=Overview"><img src="/static-assets/pdf/how-to/pull-run-ironpdfengine/azure-marketplace.webp" alt="Azure Marketplace" class="img-responsive add-shadow" /></a>
</div>
</div>
**Configurar**
1. Acesse o [contêiner Docker do IronPDF no Azure Marketplace](https://azuremarketplace.microsoft.com/en-us/marketplace/apps/ironsoftwarecoltd1682560478296.ironpdf-docker-container-v1?tab=Overview) . Clique em "Obter agora" e "Continuar".
2. Conclua as seções "Informações básicas", "Detalhes do cluster" e "Detalhes do aplicativo" para criar o serviço Kubernetes.
3. Após a conclusão da implantação, navegue até a barra lateral esquerda e selecione Recursos do Kubernetes > Executar comando. Execute o seguinte comando:
```shell
kubectl get services
```
<div class="content-img-align-center">
<div class="center-image-wrapper">
<img src="/static-assets/pdf/how-to/pull-run-ironpdfengine/azure-market-run-command.webp" alt="Serviço Kubernetes - executar comando" class="img-responsive add-shadow" />
</div>
</div>
Com as informações de IP externo e porta(s), você pode configurar a conexão do IronPDFEngine adequadamente.
```csharp
using IronPdf;
using IronPdf.GrpcLayer;
IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY-1EF01";
IronPdfConnectionConfiguration configuration = new IronPdfConnectionConfiguration();
configuration.ConnectionType = IronPdfConnectionType.RemoteServer;
configuration.Host = "http://48.216.143.233";
configuration.Port = 80;
IronPdf.Installation.ConnectToIronPdfHost(configuration);
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
pdf.SaveAs("output.pdf");
```
### AWS Marketplace
<div class="content-img-align-center">
<div class="center-image-wrapper">
<a href="https://aws.amazon.com/marketplace/pp/prodview-t66wmni5ri7ve?sr=0-1&ref_=beagle&applicationId=AWSMPContessa"><img src="/static-assets/pdf/how-to/pull-run-ironpdfengine/aws-marketplace.webp" alt="aws marketplace" class="img-responsive add-shadow" /></a>
</div>
</div>
**Pré-requisitos**
* O Docker precisa estar instalado.
* É necessário que a AWS CLI esteja instalada e que você tenha feito login.
**Configurar**
1. Acesse o [IronPdfEngine no marketplace da AWS](https://aws.amazon.com/marketplace/pp/prodview-t66wmni5ri7ve?sr=0-1&ref_=beagle&applicationId=AWSMPContessa) . Clique em "Continuar para assinar".
3. Aceite os Termos.
<div class="content-img-align-center">
<div class="center-image-wrapper">
<img src="/static-assets/pdf/how-to/pull-run-ironpdfengine/accept-EULA.webp" alt="Aceitar o EULA" class="img-responsive add-shadow" />
</div>
</div>
4. Continue para a Configuração.
<div class="content-img-align-center">
<div class="center-image-wrapper">
<img src="/static-assets/pdf/how-to/pull-run-ironpdfengine/subscribe-complete.webp" alt="Assinar completamente" class="img-responsive add-shadow" />
</div>
</div>
5. Obtenha a imagem do ironpdfengine. Esta etapa mostrará um comando para obter a imagem do ironpdfengine.
<div class="content-img-align-center">
<div class="center-image-wrapper">
<img src="/static-assets/pdf/how-to/pull-run-ironpdfengine/launch-this-software.webp" alt="Inicie este software" class="img-responsive add-shadow" />
</div>
</div>
Por exemplo:
```shell
aws ecr get-login-password \
--region us-east-1 | docker login \
--username AWS \
--password-stdin 000000000000.dkr.ecr.us-east-1.amazonaws.com
CONTAINER_IMAGES="000000000000.dkr.ecr.us-east-1.amazonaws.com/iron-software/ironpdfengine:2024.1.15"
for i in $(echo $CONTAINER_IMAGES | sed "s/,/ /g"); do docker pull $i; done
```
6. Execute o contêiner ironpdfengine. Este comando criará um contêiner e o executará em segundo plano na porta 33350.
```shell
docker run -d -p 33350:33350 000000000000.dkr.ecr.us-east-1.amazonaws.com/iron-software/ironpdfengine:2024.1.15
```
## Verificação de integridade do IronPdfEngine
Verificar a integridade do seu contêiner Docker é crucial para garantir confiabilidade e disponibilidade em um ambiente de produção. A capacidade de verificar o contêiner Docker do IronPdfEngine permite que os desenvolvedores reiniciem o serviço em caso de falha, além de dimensionar os recursos conforme a demanda aumenta, juntamente com o monitoramento contínuo da aplicação.
Para verificar o estado do seu IronPdfEngine, podemos enviar uma solicitação gRPC para a mesma porta do IronPdfEngine (por padrão, seria a 33350) para verificar se recebemos uma resposta.
### Verificação de saúde com gRPC
O IronPdfEngine segue o padrão de verificação de integridade gRPC padrão, utilizando a seguinte estrutura de protocolo.
```protobuf
message HealthCheckRequest {
string service = 1; // Name of the service to check (e.g., "IronPdfEngine")
}
```
Como estamos verificando o IronPdfEngine, substituímos o nome do serviço por `IronPdfEngine`.
Aqui está um exemplo usando JavaScript com [o Postman](https://www.postman.com) para enviar uma solicitação gRPC ao serviço local IronPdfEngine com o número padrão 33350.
<div class="content-img-align-center">
<div class="center-image-wrapper">
<img src="/static-assets/pdf/how-to/Ironpdfengine-docker/servicestatus.webp" alt="Status" class="img-responsive add-shadow" />
</div>
</div>
Como você pode ver na resposta, o status é `SERVING`, indicando que o serviço está ativo e funcionando. Se o contêiner não estiver íntegro, a resposta de status será `NOT_SERVING`.
### Verificação de integridade com configuração do Kubernetes
Para configurações do Kubernetes, podemos usar o seguinte para verificar se o serviço está íntegro ou não.
```yaml
livenessProbe:
exec:
command:
- /bin/grpc_health_probe
- -addr=:33350
- -rpc-timeout=5s
```
O IronPdfEngine é um serviço independente capaz de criar, escrever, editar e ler PDFs. O IronPDF Docker está pronto para executar serviços Docker com versões compatíveis do IronPDF (v2023.2.x e superiores). Isso ajudará os desenvolvedores a eliminar problemas de implantação que possam estar enfrentando com o IronPDF.
Por que executar o IronPDF como um contêiner separado é uma boa ideia
O IronPDF requer os binários do Chrome e do Pdfium para funcionar, e ambos possuem um tamanho de arquivo enorme (centenas de MB). Também requer a instalação de diversas dependências na máquina.
Ao utilizar este método, seu cliente ocupará apenas uma fração do tamanho (em MB).
Evite problemas de implantação
Configurar o ambiente/container para incluir todas as dependências corretamente pode ser um desafio. Ao usar o contêiner Docker do IronPDF , o IronPDF já vem pré-instalado e com funcionamento garantido, evitando todas as dores de cabeça com implantação e dependências.
Versões
A tag Docker do IronPDF é baseada na versão do próprio IronPdfEngine. Não é a mesma versão do produto IronPDF .
Cada versão do IronPDF terá sua própria versão associada do IronPdfEngine. O número da versão deve corresponder à versão do IronPDF Docker.
Por exemplo, a versão IronPDF for Java requer a versão 2023.2.1 do IronPdfEngine. Não é possível usar versões incompatíveis do IronPdfEngine e do IronPDF .
Como usar o IronPDF no Docker
Instale o IronPDF
Adicione o pacote NuGet IronPDF .Slim ao seu projeto.
Nota: Os pacotes IronPdf, IronPdf.Linux e IronPdf.MacOs contêm IronPdf.Slim.
Para reduzir o tamanho do seu aplicativo, recomendamos instalar apenas o IronPdf.Slim. O pacote IronPdf.Native.Chrome.xxx não é mais utilizado, portanto você pode removê-lo do seu projeto.
Determine a versão do contêiner necessária.
Por padrão, a versão do IronPDF para Docker corresponderá à versão atual do IronPDF no NuGet. Você pode usar o código abaixo para verificar a versão manualmente:
Execute o contêiner ironsoftwareofficial/ironpdfengine.
Este comando criará um contêiner e o executará em segundo plano na porta 33350.
docker run -d -p 33350:33350 -e IRONPDF_ENGINE_LICENSE_KEY=MY_LICENSE_KEY ironsoftwareofficial/ironpdfengine:2025.3.6
docker run -d -p 33350:33350 -e IRONPDF_ENGINE_LICENSE_KEY=MY_LICENSE_KEY ironsoftwareofficial/ironpdfengine:2025.3.6
SHELL
Como configuro os parâmetros de tempo de execução do IronPdfEngine?
Os parâmetros de tempo de execução podem ser passados diretamente para o contêiner como pares key=value após o nome da imagem. Essas configurações definem o comportamento do mecanismo sem a necessidade de reconstruir a imagem.
Diretório personalizado para binários de implantação do Chrome
temp_folder_path
path
-
Substituir diretório temporário
skip_shutdown
bool
false
Impede que o motor desligue quando estiver em marcha lenta.
skip_initialization
bool
false
Ignorar a inicialização do Chrome/Pdfium na inicialização.
keep_alive
bool
false
Manter o motor em funcionamento após a desconexão do cliente
single_process
bool
-
Execute o Chrome em modo de processo único
linux_and_docker_auto_config
bool
true
Configuração automática de dependências Linux/Docker (definidas automaticamente pelo ponto de entrada do Docker)
send_anonymous_analytics_and_crash_data
bool
-
Ativar ou desativar a telemetria anônima
Observe: O parâmetro linux_and_docker_auto_config é definido como verdadeiro automaticamente pelo ponto de entrada do Docker. Você não precisa passar isso manualmente. O parâmetro chrome_gpu_mode deve permanecer 0 (Desativado) no Docker, a menos que seu host forneça passagem direta de GPU.
A variável de ambiente IRONPDF_ENGINE_LICENSE_KEY também pode ser usada para definir a chave de licença via -e ou environment: no Docker Compose. Os parâmetros da linha de comando têm precedência sobre as variáveis de ambiente quando ambos estão definidos.
docker run -p 33350:33350 \ ironsoftwareofficial/ironpdfengine \ enable_debug=true log_path=/app/logs/engine.log
docker run -p 33350:33350 \
ironsoftwareofficial/ironpdfengine \
enable_debug=true log_path=/app/logs/engine.log
SHELL
Com Docker Compose
A chave é configurar uma rede Docker que permita que o IronPdfEngine e seu aplicativo se comuniquem. Defina 'depends_on' para garantir que o IronPdfEngine esteja em execução antes que seu aplicativo seja iniciado.
Configurar
Comece criando um arquivo docker-compose.yml. Configure seu arquivo Docker Compose usando o seguinte modelo:
version: '3.6'services: myironpdfengine: container_name: ironpdfengine image: ironsoftwareofficial/ironpdfengine:latest ports: - '33350:33350' networks: - ironpdf-network myconsoleapp: container_name: myconsoleapp build: # enter YOUR project directory path here context: ./MyConsoleApp/ # enter YOUR dockerfile name here, relative to project directory dockerfile: Dockerfile networks: - ironpdf-network depends_on: myironpdfengine: condition: service_startednetworks: ironpdf-network: driver: 'bridge'
version: '3.6'
services:
myironpdfengine:
container_name: ironpdfengine
image: ironsoftwareofficial/ironpdfengine:latest
ports:
- '33350:33350'
networks:
- ironpdf-network
myconsoleapp:
container_name: myconsoleapp
build:
# enter YOUR project directory path here
context: ./MyConsoleApp/
# enter YOUR dockerfile name here, relative to project directory
dockerfile: Dockerfile
networks:
- ironpdf-network
depends_on:
myironpdfengine:
condition: service_started
networks:
ironpdf-network:
driver: 'bridge'
Text
Defina o endereço do IronPdfEngine dentro do seu aplicativo (myconsoleapp) para "myironpdfengine:33350"
Execute o docker compose.
docker compose up --detach --force-recreate --remove-orphans --timestamps
docker compose up --detach --force-recreate --remove-orphans --timestamps
SHELL
Conecte-se ao IronPdfEngine
Execute seu código IronPDF ; Seu aplicativo agora se comunica com o IronPdfEngine no Docker!
using IronPdf;using IronPdf.GrpcLayer;// Configure for Docker containervar config = IronPdfConnectionConfiguration.Docker;config.Host = "localhost";IronPdf.Installation.ConnectToIronPdfHost(config);// Use IronPDFChromePdfRenderer renderer = new ChromePdfRenderer();PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF Docker!<h1>");pdf.SaveAs("ironpdf.pdf");
using IronPdf;
using IronPdf.GrpcLayer;
// Configure for Docker container
var config = IronPdfConnectionConfiguration.Docker;
config.Host = "localhost";
IronPdf.Installation.ConnectToIronPdfHost(config);
// Use IronPDF
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF Docker!<h1>");
pdf.SaveAs("ironpdf.pdf");
ImportsIronPdfImportsIronPdf.GrpcLayer' Configure for Docker containerPrivate config = IronPdfConnectionConfiguration.Dockerconfig.Host = "localhost"IronPdf.Installation.ConnectToIronPdfHost(config)' Use IronPDFDim renderer As New ChromePdfRenderer()Dim pdf AsPdfDocument = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF Docker!<h1>")pdf.SaveAs("ironpdf.pdf")
Imports IronPdf
Imports IronPdf.GrpcLayer
' Configure for Docker container
Private config = IronPdfConnectionConfiguration.Docker
config.Host = "localhost"
IronPdf.Installation.ConnectToIronPdfHost(config)
' Use IronPDF
Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF Docker!<h1>")
pdf.SaveAs("ironpdf.pdf")
Tipo de conexão
Existem vários IronPdfConnectionType que você pode atribuir dependendo do tipo de conexão que deseja fazer.
Segue uma lista dos imóveis disponíveis:
LocalExecutable : Para conectar-se a um "servidor" IronPdfEngine que esteja executando um arquivo executável em sua máquina local, usamos esta opção. Um exemplo rápido seria um aplicativo de faturamento WinForms que gera PDFs localmente sem depender de serviços em nuvem.
Docker : Esta opção deve ser usada ao tentar conectar-se a um contêiner Docker, seja localmente ou na nuvem.
RemoteServer : Esta opção é usada para o IronPdfEngine na nuvem. Isso se conecta a uma instância do IronPdfEngine hospedada na nuvem (por exemplo, Docker) por meio do protocolo HTTP ou HTTPS. Note que, como se trata de uma conexão com um servidor remoto, o URL completo é necessário (incluindo o protocolo HTTP ou HTTPS).
Personalizado : Para controle e personalização completos da conexão, você pode usar esta opção. Esta opção utiliza o seu Grpc.Core.ChannelBase personalizado em vez das outras opções definidas acima. Os desenvolvedores podem criar um novo canal criando um novo objeto Grpc.Core.Channel ou usando .NET(System.String) para personalizar e ter controle total sobre o canal gRPC.
.NET Framework com NetFrameworkChannel
Para o .NET Framework, precisamos de uma configuração diferente porque o gRPC funciona de maneira distinta em projetos .NET Framework .
Para que este método funcione, certifique-se de que o pacote NuGet Grpc.Core esteja instalado. Para esta configuração específica, utilizaremos um canal gRPC personalizado derivado de Grpc.Core.ChannelBase .
Vamos examinar este exemplo, onde implementaremos o canal de conexão para criar e salvar um PDF usando o IronPDFEngine.
Como o gRPC funciona de forma diferente em projetos .NET Framework , se o código a seguir não funcionar, tente remover o prefixo <http> ou <https> do endereço.
Aviso: Observe que este pdf.Dispose é necessário neste caso.
using IronPdf;// This code demonstrates how to use IronPdf with gRPC in a .NET Framework application.// 1. Configure connection to use local IronPdfEngine executablevar config = IronPdf.GrpcLayer.IronPdfConnectionConfiguration.Executable;// 2. Connect to the IronPDF host with the executable configurationIronPdf.Installation.ConnectToIronPdfHost(config);// 3. Create a PDF renderer instanceChromePdfRenderer renderer = new ChromePdfRenderer();// 4. Render HTML string as PDF documentPdfDocument pdf = renderer.RenderHtmlAsPdf("Hello world");// 5. Save the PDF to diskpdf.SaveAs("output.pdf");// 6. Clean up , this is needed to workpdf.Dispose();
using IronPdf;
// This code demonstrates how to use IronPdf with gRPC in a .NET Framework application.
// 1. Configure connection to use local IronPdfEngine executable
var config = IronPdf.GrpcLayer.IronPdfConnectionConfiguration.Executable;
// 2. Connect to the IronPDF host with the executable configuration
IronPdf.Installation.ConnectToIronPdfHost(config);
// 3. Create a PDF renderer instance
ChromePdfRenderer renderer = new ChromePdfRenderer();
// 4. Render HTML string as PDF document
PdfDocument pdf = renderer.RenderHtmlAsPdf("Hello world");
// 5. Save the PDF to disk
pdf.SaveAs("output.pdf");
// 6. Clean up , this is needed to work
pdf.Dispose();
ImportsIronPdf' This code demonstrates how to use IronPdf with gRPC in a .NET Framework application.' 1. Configure connection to use local IronPdfEngine executableDim config = IronPdf.GrpcLayer.IronPdfConnectionConfiguration.Executable' 2. Connect to the IronPDF host with the executable configurationIronPdf.Installation.ConnectToIronPdfHost(config)' 3. Create a PDF renderer instanceDim renderer As New ChromePdfRenderer()' 4. Render HTML string as PDF documentDim pdf AsPdfDocument = renderer.RenderHtmlAsPdf("Hello world")' 5. Save the PDF to diskpdf.SaveAs("output.pdf")' 6. Clean up, this is needed to workpdf.Dispose()
Imports IronPdf
' This code demonstrates how to use IronPdf with gRPC in a .NET Framework application.
' 1. Configure connection to use local IronPdfEngine executable
Dim config = IronPdf.GrpcLayer.IronPdfConnectionConfiguration.Executable
' 2. Connect to the IronPDF host with the executable configuration
IronPdf.Installation.ConnectToIronPdfHost(config)
' 3. Create a PDF renderer instance
Dim renderer As New ChromePdfRenderer()
' 4. Render HTML string as PDF document
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("Hello world")
' 5. Save the PDF to disk
pdf.SaveAs("output.pdf")
' 6. Clean up, this is needed to work
pdf.Dispose()
Método alternativo com WithCustomChannel
Um método alternativo seria utilizar o método WithCustomChannel fornecido pelo IronPdf.GrpcLayer.
O WithCustomChannel recebe dois parâmetros, o customChannel, que é o seu canal gRPC personalizado, e o metadata. O parâmetro metadata é opcional e está definido como null por padrão.
using IronPdf;using IronPdf.GrpcLayer;using Grpc.Core;// 1. Create custom gRPC channel (.NET Framework style)var channel = new Channel("123.456.7.8:80", ChannelCredentials.SecureSsl);// 2. (Optional) Add metadata headers if neededvar metadata = new Metadata{ { "Authorization", "Bearer your_token_here" }};// 3. Configure IronPDF with custom channelvar config = IronPdfConnectionConfiguration.WithCustomChannel(channel, metadata);IronPdf.Installation.ConnectToIronPdfHost(config);// 4. Generate PDFvar renderer = new ChromePdfRenderer();PdfDocument pdf = renderer.RenderHtmlAsPdf("Hello world");// 5. Save the PDF to diskpdf.SaveAs("output.pdf");// 6. Clean up , this is needed to workpdf.Dispose();
using IronPdf;
using IronPdf.GrpcLayer;
using Grpc.Core;
// 1. Create custom gRPC channel (.NET Framework style)
var channel = new Channel("123.456.7.8:80", ChannelCredentials.SecureSsl);
// 2. (Optional) Add metadata headers if needed
var metadata = new Metadata
{
{ "Authorization", "Bearer your_token_here" }
};
// 3. Configure IronPDF with custom channel
var config = IronPdfConnectionConfiguration.WithCustomChannel(channel, metadata);
IronPdf.Installation.ConnectToIronPdfHost(config);
// 4. Generate PDF
var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("Hello world");
// 5. Save the PDF to disk
pdf.SaveAs("output.pdf");
// 6. Clean up , this is needed to work
pdf.Dispose();
ImportsIronPdfImportsIronPdf.GrpcLayerImportsGrpc.Core' 1. Create custom gRPC channel (.NET Framework style)Dim channel As New Channel("123.456.7.8:80", ChannelCredentials.SecureSsl)' 2. (Optional) Add metadata headers if neededDim metadata As New MetadataFrom { {"Authorization", "Bearer your_token_here"}}' 3. Configure IronPDF with custom channelDim config AsIronPdfConnectionConfiguration = IronPdfConnectionConfiguration.WithCustomChannel(channel, metadata)IronPdf.Installation.ConnectToIronPdfHost(config)' 4. Generate PDFDim renderer As New ChromePdfRenderer()Dim pdf AsPdfDocument = renderer.RenderHtmlAsPdf("Hello world")' 5. Save the PDF to diskpdf.SaveAs("output.pdf")' 6. Clean up, this is needed to workpdf.Dispose()
Imports IronPdf
Imports IronPdf.GrpcLayer
Imports Grpc.Core
' 1. Create custom gRPC channel (.NET Framework style)
Dim channel As New Channel("123.456.7.8:80", ChannelCredentials.SecureSsl)
' 2. (Optional) Add metadata headers if needed
Dim metadata As New Metadata From {
{"Authorization", "Bearer your_token_here"}
}
' 3. Configure IronPDF with custom channel
Dim config As IronPdfConnectionConfiguration = IronPdfConnectionConfiguration.WithCustomChannel(channel, metadata)
IronPdf.Installation.ConnectToIronPdfHost(config)
' 4. Generate PDF
Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("Hello world")
' 5. Save the PDF to disk
pdf.SaveAs("output.pdf")
' 6. Clean up, this is needed to work
pdf.Dispose()
AWS Fargate
Recomenda-se um mínimo de 1 vCPU com 2 GB de RAM. Dependendo da sua carga de trabalho, se você estiver trabalhando com PDFs contendo mais de 10 páginas ou enfrentando um grande volume de solicitações, selecione um plano superior.
URI da imagem : aponte para qualquer IronPdfEngine fornecido por nós. Por exemplo, "ironsoftwareofficial/ironpdfengine:2024.1.20" (do DockerHub)
As permissões e a configuração de rededa AWS são de sua responsabilidade.
É recomendável ativar o Amazon CloudWatch . (Enable logging)
A ordem de inicialização do contêiner é necessária se você quiser implantar o contêiner do seu aplicativo na mesma definição de tarefa.
Execute uma definição de tarefa. Você pode executar uma definição de tarefa como uma Tarefa ou um Serviço . Siga este guia sobre como criar um serviço usando o console .
Configurações recomendadas:
Tipo de lançamento: AWS Fargate
IP público: ativado para testes e desativado para produção. Segurança e rede AWS são de sua responsabilidade.
Aproveite! O contêiner Docker do IronPdfEngine está instalado e funcionando na sua AWS!
Observe: O próprio contêiner Docker do IronPdfEngine não suporta escalonamento horizontal; Ele foi projetado como um serviço de backend de instância única. Seu aplicativo que utiliza a biblioteca IronPDF (com ou sem IronPdfEngine) ainda pode ser escalado horizontalmente com a implantação de múltiplas instâncias do aplicativo. Consulte a seção Limitações do IronPdfEngine para obter mais detalhes.
Implantar o IronPdfEngine em instâncias de contêiner do Azure
Imagem : ironsoftwareofficial/ironpdfengine:2024.1.20 (do Docker Hub)
Tipo de sistema operacional : Linux
Tamanho : Mínimo de 1 vCPU e 2 GiB de memória, ou superior.
Porta : Porta TCP 33350
Aproveite! O contêiner Docker do IronPdfEngine já está em execução em suas instâncias de contêiner do Azure!
Observe: O contêiner Docker do IronPdfEngine não suporta escalonamento horizontal; Projetado como um serviço de backend de instância única, seu aplicativo que utiliza a biblioteca IronPDF (com ou sem IronPdfEngine) ainda pode ser escalado horizontalmente com a implantação de múltiplas instâncias do aplicativo. Consulte a seção Limitações do IronPdfEngine para obter mais informações.
Obtendo o IronPdfEngine na Galeria Pública do AWS ECR
Conclua as seções "Informações básicas", "Detalhes do cluster" e "Detalhes do aplicativo" para criar o serviço Kubernetes.
Após a conclusão da implantação, navegue até a barra lateral esquerda e selecione Recursos do Kubernetes > Executar comando. Execute o seguinte comando:
kubectl get services
kubectl get services
SHELL
Com as informações de IP externo e porta(s), você pode configurar a conexão do IronPDFEngine adequadamente.
using IronPdf;using IronPdf.GrpcLayer;IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY-1EF01";IronPdfConnectionConfiguration configuration = new IronPdfConnectionConfiguration();configuration.ConnectionType = IronPdfConnectionType.RemoteServer;configuration.Host = "http://48.216.143.233";configuration.Port = 80;IronPdf.Installation.ConnectToIronPdfHost(configuration);ChromePdfRenderer renderer = new ChromePdfRenderer();PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");pdf.SaveAs("output.pdf");
using IronPdf;
using IronPdf.GrpcLayer;
IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY-1EF01";
IronPdfConnectionConfiguration configuration = new IronPdfConnectionConfiguration();
configuration.ConnectionType = IronPdfConnectionType.RemoteServer;
configuration.Host = "http://48.216.143.233";
configuration.Port = 80;
IronPdf.Installation.ConnectToIronPdfHost(configuration);
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
pdf.SaveAs("output.pdf");
ImportsIronPdfImportsIronPdf.GrpcLayerIronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY-1EF01"Dim configuration As New IronPdfConnectionConfiguration()configuration.ConnectionType = IronPdfConnectionType.RemoteServerconfiguration.Host = "http://48.216.143.233"configuration.Port = 80IronPdf.Installation.ConnectToIronPdfHost(configuration)Dim renderer As New ChromePdfRenderer()Dim pdf AsPdfDocument = renderer.RenderHtmlAsPdf("<h1>testing</h1>")pdf.SaveAs("output.pdf")
Imports IronPdf
Imports IronPdf.GrpcLayer
IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY-1EF01"
Dim configuration As New IronPdfConnectionConfiguration()
configuration.ConnectionType = IronPdfConnectionType.RemoteServer
configuration.Host = "http://48.216.143.233"
configuration.Port = 80
IronPdf.Installation.ConnectToIronPdfHost(configuration)
Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>testing</h1>")
pdf.SaveAs("output.pdf")
AWS Marketplace
Pré-requisitos
O Docker precisa estar instalado.
É necessário que a AWS CLI esteja instalada e que você tenha feito login.
Obtenha a imagem do ironpdfengine. Esta etapa mostrará um comando para obter a imagem do ironpdfengine.
Por exemplo:
aws ecr get-login-password \ --region us-east-1 | docker login \ --username AWS \ --password-stdin 000000000000.dkr.ecr.us-east-1.amazonaws.comCONTAINER_IMAGES="000000000000.dkr.ecr.us-east-1.amazonaws.com/iron-software/ironpdfengine:2024.1.15" for i in $(echo $CONTAINER_IMAGES | sed "s/,/ /g"); do docker pull $i; done
aws ecr get-login-password \
--region us-east-1 | docker login \
--username AWS \
--password-stdin 000000000000.dkr.ecr.us-east-1.amazonaws.com
CONTAINER_IMAGES="000000000000.dkr.ecr.us-east-1.amazonaws.com/iron-software/ironpdfengine:2024.1.15"
for i in $(echo $CONTAINER_IMAGES | sed "s/,/ /g"); do docker pull $i; done
SHELL
Execute o contêiner ironpdfengine. Este comando criará um contêiner e o executará em segundo plano na porta 33350.
docker run -d -p 33350:33350 000000000000.dkr.ecr.us-east-1.amazonaws.com/iron-software/ironpdfengine:2024.1.15
docker run -d -p 33350:33350 000000000000.dkr.ecr.us-east-1.amazonaws.com/iron-software/ironpdfengine:2024.1.15
SHELL
Verificação de integridade do IronPdfEngine
Verificar a integridade do seu contêiner Docker é crucial para garantir confiabilidade e disponibilidade em um ambiente de produção. A capacidade de verificar o contêiner Docker do IronPdfEngine permite que os desenvolvedores reiniciem o serviço em caso de falha, além de dimensionar os recursos conforme a demanda aumenta, juntamente com o monitoramento contínuo da aplicação.
Para verificar o estado do seu IronPdfEngine, podemos enviar uma solicitação gRPC para a mesma porta do IronPdfEngine (por padrão, seria a 33350) para verificar se recebemos uma resposta.
Verificação de saúde com gRPC
O IronPdfEngine segue o padrão de verificação de integridade gRPC padrão, utilizando a seguinte estrutura de protocolo.
message HealthCheckRequest { string service = 1; // Name of the service to check (e.g., "IronPdfEngine")}
message HealthCheckRequest {
string service = 1; // Name of the service to check (e.g., "IronPdfEngine")
}
Text
Como estamos verificando o IronPdfEngine, substituímos o nome do serviço por IronPdfEngine.
Aqui está um exemplo usando JavaScript com o Postman para enviar uma solicitação gRPC ao serviço local IronPdfEngine com o número padrão 33350.
Como você pode ver na resposta, o status é SERVING, indicando que o serviço está ativo e funcionando. Se o contêiner não estiver íntegro, a resposta de status será NOT_SERVING.
Verificação de integridade com configuração do Kubernetes
Para configurações do Kubernetes, podemos usar o seguinte para verificar se o serviço está íntegro ou não.
Como posso converter HTML para PDF em C# usando Docker?
Você pode usar a configuração Docker do IronPDF para converter HTML em PDF em C#. Implante o IronPDFEngine em um contêiner Docker e use métodos como RenderHtmlAsPdf para realizar essa conversão.
Quais são os benefícios de usar o IronPDFEngine no Docker?
Utilizar o IronPDFEngine no Docker oferece um ambiente pré-instalado e confiável, reduzindo problemas de dependência e garantindo que todos os componentes necessários, como os binários do Chrome e do Pdfium, estejam disponíveis.
Como faço para configurar o IronPDFEngine com o Docker Compose?
Crie um arquivo docker-compose.yml e defina os serviços e redes. Certifique-se de que o IronPDFEngine seja iniciado antes da sua aplicação usando a diretiva depends_on .
Quais são os passos necessários para implantar o IronPDFEngine no AWS ECS?
Para implantar no AWS ECS, crie um cluster ECS, defina uma definição de tarefa e use o AWS Fargate para alocação de recursos. Em seguida, execute sua tarefa ou serviço para iniciar o IronPDFEngine.
Como posso obter o IronPDFEngine da Galeria Pública do AWS ECR?
Acesse a Galeria Pública do AWS ECR, encontre a imagem IronPDFEngine e siga os comandos fornecidos para baixar e executar o contêiner.
É possível usar o IronPDFEngine a partir do Azure Marketplace?
Sim, o IronPDFEngine está disponível no Azure Marketplace. Você pode seguir as instruções de configuração na página do Marketplace para implantar o contêiner Docker.
Quais são as limitações que devo ter em mente ao usar o IronPDFEngine?
O próprio contêiner Docker do IronPdfEngine não suporta escalonamento horizontal, pois foi projetado como um serviço de backend de instância única. No entanto, aplicativos que utilizam a biblioteca IronPDF (com ou sem o IronPdfEngine) ainda podem ser escalados horizontalmente implantando várias instâncias do aplicativo. Planeje sua implantação levando essa distinção em consideração.
Como posso lidar de forma eficiente com tarefas de geração e manipulação de PDFs usando o Docker?
Implante o IronPDFEngine em um contêiner Docker para gerenciar com eficiência as tarefas de geração e manipulação de PDFs, aproveitando os recursos do Docker para lidar com dependências e garantir um ambiente consistente.
Quais são os requisitos para implantar o IronPDFEngine no Azure Container Instances?
Para implantar no Azure Container Instances, certifique-se de ter uma conta do Azure e baixe a imagem Docker do IronPDFEngine para implantação.
Are there specific logging configurations available for IronPdfEngine?
Yes, IronPdfEngine supports various logging configurations, including console, file, and custom modes. This flexibility helps in monitoring and debugging, allowing developers to choose the best method for their needs.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.