<!-- review: finished -->

<a id="acme-config"></a>

# Configuração ACME

O módulo [ACME](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme) no Angie permite a aquisição automática de
certificados usando o [protocolo ACME](https://datatracker.ietf.org/doc/html/rfc8555). O protocolo ACME suporta
vários métodos de verificação de domínio (também chamados de "validação"); este
módulo implementa [validação HTTP](#acme-config-http), [validação DNS](#acme-config-dns), [validação ALPN](#acme-config-alpn) e
[validação baseada em hooks](#acme-config-hooks)
através de um serviço externo personalizado.

<a id="configuration-steps"></a>

## Etapas de Configuração

Etapas gerais para habilitar solicitações de certificado na configuração:

- **Configure um cliente ACME** no bloco `http` usando a diretiva
  [acme_client](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client), que especifica um nome único de cliente e outros
  parâmetros. Múltiplos clientes ACME podem ser configurados.
- **Especifique os domínios para os quais os certificados são solicitados**: Um
  único certificado será emitido para todos os nomes de domínio listados nas
  diretivas [server_name](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server-name) dentro de todos os blocos `server` que
  usam diretivas [acme](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1) apontando para o mesmo cliente ACME.
- **Configure o tratamento de solicitações e callbacks ACME**: Isso é necessário
  para verificar a propriedade do domínio. A configuração depende do método de
  validação de domínio escolhido:

  | Método                                   | Requisitos do Usuário                                                                                                                                                                                                                                                                                            | Multi-domínio   | Domínios Wildcard   |
  |------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------|---------------------|
  | [Validação HTTP](#acme-config-http)      | Abrir a porta 80 (ou a especificada em [acme_http_port](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-http-port))<br/>para conexões de entrada no servidor Angie.                                                                                                           | ✔               |                     |
  | [Validação DNS](#acme-config-dns)        | Abrir a porta 53 (ou a especificada em [acme_dns_port](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-dns-port))<br/>para conexões de entrada no servidor Angie.<br/><br/>Definir um registro NS para o subdomínio `_acme-challenge.`<br/>apontando para seu servidor Angie. | ✔               | ✔                   |
  | [Validação ALPN](#acme-config-alpn)      | Abrir a porta 443 (ou a porta TLS usada pelo seu servidor)<br/>para conexões de entrada no servidor Angie.                                                                                                                                                                                                       | ✔               |                     |
  | [Validação por hook](#acme-config-hooks) | Criar um serviço externo (script ou aplicação)<br/>que possa, mediante solicitação do Angie, atualizar registros DNS<br/>ou servir uma resposta especial via servidor web.                                                                                                                                       | ✔               | ✔                   |
- **Configure SSL usando o certificado e chave obtidos**: O módulo torna
  certificados e chaves disponíveis como [variáveis incorporadas](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme-variables)
  que podem ser usadas na [configuração](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) para preencher
  [ssl_certificate](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-certificate) e [ssl_certificate_key](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-certificate-key).

  Para instruções de configuração SSL, consulte [Configuração SSL](https://pt.angie.software//angie/docs/configuration/ssl.md#ssl-config).

<a id="acme-config-details"></a>

## Detalhes de Implementação

Chaves de cliente e certificados são armazenados em [codificação PEM](https://datatracker.ietf.org/doc/html/rfc7468) dentro de subdiretórios do
diretório especificado pela `--http-acme-client-path` [opção de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#configure):

```console
$ ls /var/lib/angie/acme/example/

  account.key  certificate.pem  private.key
```

O cliente ACME requer uma conta no servidor CA. Para criar e gerenciar esta
conta, o cliente usa uma chave privada (`account.key`). Se nenhuma chave
existir, ela é gerada na inicialização. O cliente então usa esta chave para
registrar a conta no servidor.

#### NOTE
Se você já possui uma chave de conta, coloque-a no subdiretório do cliente
antes de iniciar para reutilizar a conta. Alternativamente, especifique o
arquivo de chave usando o parâmetro `account_key` em [acme_client](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client).

O cliente ACME também usa uma chave separada (`private.key`) para
Solicitações de Assinatura de Certificado (CSRs). Esta chave de certificado é
automaticamente criada na inicialização se necessário.

Na inicialização, o cliente solicita um certificado se um não existir, assinando
e enviando um CSR para todos os domínios sob seu gerenciamento para o servidor
CA. O servidor verifica a propriedade do domínio usando [validação HTTP](#acme-config-http) ou [validação DNS](#acme-config-dns) e emite um
certificado, que o cliente salva localmente (`certificate.pem`).

Como mencionado anteriormente, um único certificado cobre todos os nomes de
domínio gerenciados pelo mesmo cliente ACME, potencialmente resultando em um
certificado multi-domínio. A lista de todos os nomes cobertos pelo certificado
pode ser encontrada na seção Subject Alternative Name (SAN) do certificado
obtido. Para verificar isso pela linha de comando:

```console
$ openssl x509 -in certificate.pem -noout -text | grep -A5 "Subject Alternative Name"
```

Quando um certificado está prestes a expirar ou a lista de domínios muda, o
cliente assina e envia outro CSR para o servidor CA. O servidor re-verifica a
propriedade e emite um novo certificado, que o cliente instala localmente,
substituindo o anterior.

Na [configuração](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile), o certificado obtido e sua chave
correspondente estão disponíveis através das variáveis de prefixo
[$acme_cert_<name>](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#v-acme-cert-name) e [$acme_cert_key_<name>](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#v-acme-cert-key-name). Seus valores são o
conteúdo dos respectivos arquivos, que devem ser usados com as diretivas
[ssl_certificate](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-certificate) e [ssl_certificate_key](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-certificate-key):

```nginx
server {

    listen 443 ssl;

    server_name example.com www.example.com;
    acme example;

    ssl_certificate $acme_cert_example;
    ssl_certificate_key $acme_cert_key_example;
}
```

<a id="acme-config-domain-collection"></a>

## Coleta de domínios versus uso do certificado

A diretiva [acme](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1) serve apenas para coletar nomes de domínio
para solicitações de certificado.
Ela não controla onde o certificado pode ser usado:
qualquer bloco `server` pode referenciar o certificado obtido
através da variável [$acme_cert_<name>](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#v-acme-cert-name),
independentemente de o bloco conter ou não uma diretiva `acme`.

Por exemplo, se você tem um bloco `server` com curinga
que já cobre todos os subdomínios,
blocos `server` adicionais para subdomínios específicos
não precisam da diretiva `acme`:

```nginx
http {

    resolver 127.0.0.53;

    acme_client example https://acme-v02.api.letsencrypt.org/directory
        challenge=dns;

    # This block lists the domains for the certificate request
    server {

        listen 443 ssl;

        server_name example.com *.example.com;
        acme example;

        ssl_certificate $acme_cert_example;
        ssl_certificate_key $acme_cert_key_example;
    }

    # This block uses the same certificate but does not
    # add its server_name to the certificate request
    server {

        listen 443 ssl;

        server_name app.example.com;

        ssl_certificate $acme_cert_example;
        ssl_certificate_key $acme_cert_key_example;
    }
}
```

<a id="acme-config-explicit-domains"></a>

### Lista explícita de domínios

Para controlar o conjunto exato de nomes de domínio em um certificado
sem depender da coleta automática a partir de todos os blocos `server`,
crie um bloco `server` dedicado
que contenha apenas as diretivas [server_name](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server-name) e [acme](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1).
Para evitar que esse bloco trate tráfego real,
vincule-o a um socket de domínio Unix:

```nginx
# Dedicated block that defines the certificate's domain list
server {

    listen unix:/tmp/acme_example.sock;

    server_name example.com www.example.com;
    acme example;
}
```

Outros blocos `server` podem então usar o certificado
através da variável [$acme_cert_<name>](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#v-acme-cert-name)
sem afetar quais domínios são solicitados.

<a id="acme-config-http"></a>

## Validação HTTP

A validação é tratada automaticamente. O processo envolve o servidor ACME, ao
receber uma solicitação, [recuperar um arquivo de token especial via HTTP](https://datatracker.ietf.org/doc/html/rfc8555#section-8.3) do cliente no
endereço `/.well-known/acme-challenge/<TOKEN>`. Nosso módulo ACME
rastreia e processa tais solicitações automaticamente. Quando a resposta
esperada com o conteúdo correto é recebida, o servidor ACME confirma que o
domínio pertence ao cliente.

<a id="configuration-example-1-1-1"></a>

### Exemplo de Configuração

Neste exemplo, o cliente ACME chamado `example` gerencia certificados para
`example.com` e `www.example.com` (note que certificados wildcard
não são suportados com validação HTTP):

```nginx
http {

    resolver 127.0.0.53; # Necessário para a diretiva 'acme_client'

    acme_client example https://acme-v02.api.letsencrypt.org/directory;

    server {

        listen 80; # Opcional se nenhum servidor escuta na porta de desafio HTTP
                   # (veja a diretiva 'acme_http_port')

        listen 443 ssl;

        server_name example.com www.example.com;
        acme example;

        ssl_certificate $acme_cert_example;
        ssl_certificate_key $acme_cert_key_example;
    }
}
```

Como observado anteriormente, a porta 80 deve estar aberta para tratar chamadas
HTTP ACME. Se nenhum servidor estiver configurado para escutar na porta de
desafio HTTP, o módulo cria um listener dedicado na porta 80 (ou na definida em
[acme_http_port](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-http-port)). Um bloco [server](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server) separado não é necessário.

<a id="acme-config-dns"></a>

## Validação DNS

A validação é tratada automaticamente. Ao processar uma solicitação de certificado, o
servidor ACME executa uma [consulta DNS especial](https://datatracker.ietf.org/doc/html/rfc8555#section-8.4) para o
subdomínio `_acme-challenge.` do domínio sendo verificado. Uma vez que a
resposta esperada é recebida, o servidor ACME confirma que o domínio pertence
ao cliente.

Nosso módulo ACME rastreia e processa tais solicitações automaticamente, desde que
seus registros DNS estejam configurados adequadamente para designar o servidor Angie como o
servidor de nomes autoritativo para o subdomínio `_acme-challenge.`.

#### NOTE
O servidor Angie deve estar acessível pela internet
na porta UDP 53 (ou na especificada em [acme_dns_port](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-dns-port)).
Se o servidor estiver atrás de um firewall,
certifique-se de que esta porta esteja aberta para conexões de entrada.

Por exemplo, para verificar o domínio `example.com` usando um servidor Angie no
endereço IP `93.184.215.14`, a configuração DNS do seu domínio deve incluir
os seguintes registros:

```none
_acme-challenge.example.com. 60    IN      NS       ns.example.com.
             ns.example.com. 60    IN       A       93.184.215.14
```

Esta configuração delega a resolução DNS para
`_acme-challenge.example.com` para `ns.example.com`, garantindo que
`ns.example.com` seja acessível mapeando-o para o endereço IP
(`93.184.215.14`).

#### WARNING
A propagação de registros NS pode levar de alguns minutos a 48 horas
dependendo do TTL e do provedor DNS. É recomendado verificar se a
configuração está correta antes de solicitar um certificado.

Para verificar se o DNS está configurado corretamente, você pode usar os seguintes comandos:

```console
$ dig NS _acme-challenge.example.com +short  # Verifica o registro NS para o subdomínio _acme-challenge

  ns.example.com.

$ dig A ns.example.com +short  # Verifica o registro A para o servidor de nomes

  93.184.215.14

$ nc -zv 93.184.215.14 53  # Verifica a acessibilidade do servidor DNS na porta 53
```

Este método permite solicitar certificados wildcard, por exemplo, um certificado
que inclui a entrada `*.example.com` na seção Subject Alternative Name
(SAN). Para solicitar explicitamente um certificado para um subdomínio, como
`www.example.com`, você deve verificar separadamente esse subdomínio usando o
método descrito acima.

#### WARNING
A aplicabilidade deste cenário depende amplamente das capacidades
fornecidas pelo seu provedor DNS; alguns provedores não permitem tais
configurações.

<a id="configuration-example-1-1"></a>

### Exemplo de Configuração

No geral, a configuração é similar ao exemplo da seção anterior.
Não há necessidade de configurações específicas do HTTP; em vez disso, é suficiente definir
`challenge=dns` para a diretiva [acme_client](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client).

Neste exemplo, o cliente ACME chamado `example` gerencia certificados para
`example.com` e `*.example.com`:

```nginx
http {

    resolver 127.0.0.53;

    acme_client example https://acme-v02.api.letsencrypt.org/directory
        challenge=dns;

    server {

        server_name example.com *.example.com;
        acme example;

        ssl_certificate $acme_cert_example;
        ssl_certificate_key $acme_cert_key_example;
    }
}
```

<a id="acme-config-alpn"></a>

## Validação ALPN

A validação é tratada automaticamente. O servidor ACME se conecta usando TLS e
solicita o protocolo `acme-tls/1` via ALPN. O módulo serve um certificado
temporário para a solicitação de validação.

Para habilitar este método, configure `challenge=alpn` na
diretiva [acme_client](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client) e garanta que seu listener TLS esteja acessível na
porta 443 (ou a porta usada para TLS).

<a id="acme-config-hooks"></a>

## Validação Baseada em Hooks

Diferentemente dos métodos anteriores, esta validação requer esforço adicional. O
servidor ACME executa [validação HTTP](#acme-config-http) padrão ou
[validação DNS](#acme-config-dns), mas em vez de interagir diretamente
com o servidor Angie, ele se comunica com um serviço externo gerenciado pelo
servidor Angie usando chamadas de hook ([acme_hook](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-hook)). Este serviço configura um
servidor DNS ou HTTP separado onde o servidor ACME envia suas solicitações.

Uma vez que o servidor ACME recebe a resposta esperada do servidor DNS ou
HTTP configurado, ele confirma a propriedade do domínio.

Quando a emissão ou renovação de certificado requer verificação de domínio,
o Angie gera uma solicitação interna
para o `location` nomeado que contém a diretiva [acme_hook](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-hook).
Como essa solicitação é tratada depende inteiramente das outras diretivas
configuradas no mesmo `location`.

O padrão geral é:

1. Crie um `location` nomeado com a diretiva [acme_hook](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-hook).
2. Configure um manipulador de solicitações no mesmo `location`
   usando o módulo que melhor se adequar à sua configuração:
   [fastcgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass) para FastCGI,
   [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass) para HTTP,
   `cgi` para scripts CGI, etc.
3. Passe as [variáveis](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme-variables) ACME
   para o manipulador usando o mecanismo que ele suporta,
   por exemplo `fastcgi_param` para FastCGI
   ou `cgi_set_var` para CGI.

O manipulador deve retornar um código de status `2xx`,
que pode ser enviado via o cabeçalho `Status`.
Qualquer outro código é tratado como um erro,
e a renovação do certificado é interrompida.
A saída do manipulador é ignorada.

<a id="acme-config-hooks-minimal-configuration"></a>

### Configuração mínima

Independentemente do manipulador utilizado,
o `location` do hook segue esta estrutura:

```nginx
location @acme_hook {

    acme_hook example;

    # Handler directive (fastcgi_pass, proxy_pass, cgi on, ...)
    # Pass ACME variables using the handler's mechanism:
    #   ACME_HOOK       — $acme_hook_name ("add" or "remove")
    #   ACME_CHALLENGE  — $acme_hook_challenge ("dns" or "http")
    #   ACME_DOMAIN     — $acme_hook_domain
    #   ACME_TOKEN      — $acme_hook_token
    #   ACME_KEYAUTH    — $acme_hook_keyauth
}
```

Para validação DNS, o manipulador deve usar `ACME_HOOK`
para determinar a ação:
quando ele for `add`,
crie um registro TXT para `_acme-challenge.*ACME_DOMAIN*`
com o valor de `ACME_KEYAUTH`;
quando for `remove`, exclua esse registro.

<a id="configuration-example-1"></a>

### Exemplo com FastCGI

Neste exemplo, o [cliente ACME](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client) `example` está configurado para
verificação de domínio usando callbacks DNS, indicado pelo parâmetro `challenge=dns`
na diretiva [acme_client](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client).

O bloco `server` se aplica a todos os subdomínios de `example.com` (por exemplo,
`*.example.com`) e usa o cliente ACME `example` para gerenciar
certificados, conforme especificado pela diretiva [acme](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1).

Um bloco `location` nomeado trata as chamadas de hook.
A diretiva [acme_hook](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-hook) o associa
ao cliente ACME `example`.
As solicitações de hook são enviadas para um servidor FastCGI local
na porta 9000 usando [fastcgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass).
As diretivas `fastcgi_param` passam
as variáveis ACME para o serviço externo.

```nginx
acme_client example https://acme-v02.api.letsencrypt.org/directory
    challenge=dns;

server {

    listen 80;

    server_name *.example.com;

    acme example;

    ssl_certificate $acme_cert_example;
    ssl_certificate_key $acme_cert_key_example;

    location @acme_hook_location {

        acme_hook example;

        fastcgi_pass localhost:9000;

        fastcgi_param ACME_CLIENT $acme_hook_client;
        fastcgi_param ACME_HOOK $acme_hook_name;
        fastcgi_param ACME_CHALLENGE $acme_hook_challenge;
        fastcgi_param ACME_DOMAIN $acme_hook_domain;
        fastcgi_param ACME_TOKEN $acme_hook_token;
        fastcgi_param ACME_KEYAUTH $acme_hook_keyauth;

        include fastcgi.conf;
    }
}
```

O seguinte script Perl demonstra um serviço FastCGI externo correspondente:

```perl
#!/usr/bin/perl

use strict; use warnings;

use FCGI;

my $socket = FCGI::OpenSocket(":9000", 5);
my $request = FCGI::Request(\*STDIN, \*STDOUT, \*STDERR, \%ENV, $socket);

while ($request->Accept() >= 0) {
    print "\r\n";

    my $client =    $ENV{ACME_CLIENT};
    my $hook =      $ENV{ACME_HOOK};
    my $challenge = $ENV{ACME_CHALLENGE};
    my $domain =    $ENV{ACME_DOMAIN};
    my $token =     $ENV{ACME_TOKEN};
    my $keyauth =   $ENV{ACME_KEYAUTH};

    if ($hook eq 'add') {

        DNS_set_TXT_record("_acme-challenge.$domain.", $keyauth);

    } elsif ($hook eq 'remove') {

        DNS_clear_TXT_record("_acme-challenge.$domain.");
    }
};

FCGI::CloseSocket($socket);
```

Aqui, `DNS_set_TXT_record()` e `DNS_clear_TXT_record()` são
funções assumidas para adicionar e remover registros TXT na configuração de um
servidor DNS externo que o servidor ACME consulta. Estes registros devem conter os
dados fornecidos pelo servidor Angie para permitir que o servidor DNS externo
passe com sucesso na validação, similar ao processo descrito em
[Validação DNS](#acme-config-dns). Os detalhes de implementação de tais funções estão além
do escopo deste guia; por exemplo, parâmetros também podem ser passados através da
URI da solicitação:

```nginx
# ...

location @acme_hook_location {

    acme_hook example uri=/acme_hook/$acme_hook_name?domain=$acme_hook_domain&key=$acme_hook_keyauth;

    fastcgi_pass localhost:9000;

    fastcgi_param REQUEST_URI $request_uri;
    fastcgi_param ACME_CLIENT $acme_hook_client;
    fastcgi_param ACME_CHALLENGE $acme_hook_challenge;
    fastcgi_param ACME_TOKEN $acme_hook_token;

    include fastcgi.conf;
}
```

### Exemplo com PHP-FPM

Outro exemplo, usando PHP-FPM:

```nginx
location @acme_hook_location {

    acme_hook example;
    root /var/www/dns;
    fastcgi_pass unix:/run/php-fpm/php-dns.sock;
    fastcgi_index hook.php;
    fastcgi_param SCRIPT_FILENAME /var/www/dns/hook.php;
    include fastcgi_params;

    fastcgi_param ACME_CLIENT $acme_hook_client;
    fastcgi_param ACME_HOOK $acme_hook_name;
    fastcgi_param ACME_CHALLENGE $acme_hook_challenge;
    fastcgi_param ACME_DOMAIN $acme_hook_domain;
    fastcgi_param ACME_TOKEN $acme_hook_token;
    fastcgi_param ACME_KEYAUTH $acme_hook_keyauth;
}
```

```ini
[dns]
listen = /run/php-fpm/php-dns.sock
listen.mode = 0666
user = angie
group = angie
chdir = /var/www/dns
# ...
```

Parâmetros passados podem ser acessados em PHP via `$_SERVER['...']`.

<a id="acme-config-stream"></a>

## ACME no Módulo Stream

O módulo stream [ACME](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_acme.md#stream-acme) habilita emissão automatizada
de certificados e uso para tráfego TCP.
Para que funcione corretamente, você deve primeiro configurar sua contraparte HTTP:
o cliente ACME deve ser declarado no contexto `http`,
e o próprio bloco `stream` deve ser colocado *após* o bloco `http`
na configuração.

<a id="configuration-example"></a>

### Exemplo de Configuração

Por padrão, o modo de validação HTTP é usado para obter certificados.
Como mencionado na seção [Validação HTTP](#acme-config-http),
isso requer um servidor HTTP escutando na porta 80:

```nginx
# Parte HTTP
http {

    resolver 127.0.0.53;

    # Cliente ACME para a parte stream
    acme_client example https://acme-v02.api.letsencrypt.org/directory;

    # Servidor para validação HTTP
    server {

        listen 80;
        return 444;
    }
}

# Parte Stream
stream {

    server {

        listen 12345 ssl;
        proxy_pass backend_upstream;

        ssl_certificate $acme_cert_example;
        ssl_certificate_key $acme_cert_key_example;

        server_name example.com www.example.com;
        acme example; # referência ao cliente ACME definido na parte HTTP
    }

    upstream backend_upstream {

        server 127.0.0.1:54321;
    }
}
```

Você também pode usar validação DNS
configurando `challenge=dns` na diretiva [acme_client](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client);
nesse caso, o servidor não será necessário.

<a id="acme-config-certbot"></a>

## Migrando do **certbot**

Se você usou anteriormente o [certbot](https://certbot.eff.org/)
para obter e renovar certificados SSL do Let's Encrypt
antes de [migrar do nginx para o Angie](https://pt.angie.software//angie/docs/configuration/migration.md#migration),
siga estes passos para fazer a transição para usar nosso módulo ACME.

Suponha que você configurou os certificados da seguinte forma:

```console
$ sudo certbot --nginx -d example.com -d www.example.com
```

A configuração criada automaticamente por este comando
está tipicamente localizada em `/etc/nginx/sites-available/example.conf`
e se parece com algo assim:

```nginx
server {

    listen 80;
    server_name example.com www.example.com;
    return 301 https://$host$request_uri;
}

server {

    listen 443 ssl;
    server_name example.com www.example.com;

    root /var/www/example;
    index index.html;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
}
```

No exemplo acima, as linhas destacadas precisam ser modificadas.
Dependendo das suas circunstâncias e preferências, configure
a [validação HTTP](#acme-config-http)
ou a [validação DNS](#acme-config-dns) usando o módulo ACME.

A [configuração do Angie](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) resultante
pode se parecer com isto:

```nginx
http {

    resolver 127.0.0.53;

    acme_client example https://acme-v02.api.letsencrypt.org/directory;

    server {

        listen 80;
        server_name example.com www.example.com;
        return 301 https://$host$request_uri;
    }

    server {
        listen 443 ssl;
        server_name example.com www.example.com;

        root /var/www/example;
        index index.html;

        acme                 example;

        ssl_certificate      $acme_cert_example;
        ssl_certificate_key  $acme_cert_key_example;
    }
}
```

Lembre-se de recarregar a configuração
[após fazer as alterações](https://pt.angie.software//angie/docs/configuration/runtime.md#control-config-change):

```console
$ sudo kill -HUP $(cat /run/angie.pid)
```

Uma vez que você tenha verificado que esta configuração funciona,
você pode excluir os certificados do **certbot**
e desabilitar ou remover o certbot inteiramente do servidor
se ele não for mais usado em outro lugar,
por exemplo:

```console
$ sudo rm -rf /etc/letsencrypt

$ sudo systemctl stop certbot.timer
$ sudo systemctl disable certbot.timer
$ # -- ou --
$ sudo rm /etc/cron.d/certbot

$ sudo apt remove certbot
$ # -- ou --
$ sudo dnf remove certbot
```