<!-- review: finished -->

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

# Configuración de ACME

El módulo [ACME](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme) en Angie permite la obtención automática de certificados
usando el [protocolo ACME](https://datatracker.ietf.org/doc/html/rfc8555). Este protocolo admite
varios métodos de verificación de dominio (también llamados "validación"); este módulo
implementa la [validación HTTP](#acme-config-http), la [validación DNS](#acme-config-dns), la [validación ALPN](#acme-config-alpn) y la
[validación mediante hooks](#acme-config-hooks)
a través de un servicio externo personalizado.

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

## Pasos de Configuración

Pasos generales para habilitar solicitudes de certificados en la configuración:

- **Configurar un cliente ACME** en el bloque `http` mediante la directiva
  [acme_client](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client), que especifica un nombre único de cliente y otros
  parámetros. Se pueden configurar varios clientes ACME.
- **Especificar los dominios para los que se solicitan certificados**: Se emitirá un único
  certificado para todos los nombres de dominio listados en las directivas [server_name](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server-name)
  dentro de todos los bloques `server` que usen directivas [acme](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1) que
  apunten al mismo cliente ACME.
- **Configurar el manejo de solicitudes y las devoluciones de llamada de ACME**:
  Esto es necesario para verificar la propiedad del dominio. La configuración depende
  del método de validación elegido:

  | Método                                          | Requisitos del Usuario                                                                                                                                                                                                                                                                                                 | Multidominio   | Dominios Wildcard   |
  |-------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|---------------------|
  | [Validación HTTP](#acme-config-http)            | Abrir el puerto 80 (o el especificado en [acme_http_port](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-http-port))<br/>para conexiones entrantes en el servidor Angie.                                                                                                           | ✔              |                     |
  | [Validación DNS](#acme-config-dns)              | Abrir el puerto 53 (o el especificado en [acme_dns_port](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-dns-port))<br/>para conexiones entrantes en el servidor Angie.<br/><br/>Configurar un registro NS para el subdominio `_acme-challenge.`<br/>apuntando a su servidor Angie. | ✔              | ✔                   |
  | [Validación ALPN](#acme-config-alpn)            | Abrir el puerto 443 (o el puerto TLS usado por su servidor)<br/>para conexiones entrantes en el servidor Angie.                                                                                                                                                                                                        | ✔              |                     |
  | [Validación mediante hooks](#acme-config-hooks) | Crear un servicio externo (script o aplicación)<br/>que pueda, a petición de Angie, actualizar registros DNS<br/>o servir una respuesta especial mediante el servidor web.                                                                                                                                             | ✔              | ✔                   |
- **Configurar SSL usando el certificado y la clave obtenidos**:
  El módulo pone a disposición certificados y claves como [variables integradas](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme-variables)
  que pueden usarse en la [configuración](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) para rellenar
  [ssl_certificate](https://es.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-certificate) y [ssl_certificate_key](https://es.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-certificate-key).

  Para instrucciones de configuración SSL, consulte [Configuración SSL](https://es.angie.software//angie/docs/configuration/ssl.md#ssl-config).

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

## Detalles de Implementación

Las claves y certificados de cliente se almacenan en [codificación PEM](https://datatracker.ietf.org/doc/html/rfc7468) dentro de subdirectorios del
directorio especificado por la `--http-acme-client-path` [opción de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#configure):

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

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

El cliente ACME requiere una cuenta en el servidor CA. Para crear y gestionar esta
cuenta, el cliente utiliza una clave privada (`account.key`). Si no existe clave,
se genera al inicio. Luego, el cliente usa esta clave para registrar la cuenta
con el servidor.

#### NOTE
Si ya dispone de una clave de cuenta, colóquela en el subdirectorio del cliente
antes de iniciar, para reutilizar la cuenta. Alternativamente, especifique el archivo
de clave con el parámetro `account_key` en [acme_client](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client).

El cliente ACME también utiliza una clave separada (`private.key`) para
las solicitudes de firma de certificados (CSR). Esta clave de certificado se crea automáticamente
al inicio si es necesario.

Al arrancar, el cliente solicita un certificado si no existe, firmando y enviando
un CSR para todos los dominios bajo su gestión al servidor CA. El servidor
verifica la propiedad del dominio usando [validación HTTP](#acme-config-http)
o [validación DNS](#acme-config-dns) y emite un certificado, que el cliente
guarda localmente (`certificate.pem`).

Como se mencionó anteriormente, un único certificado cubre todos los nombres de
dominio gestionados por el mismo cliente ACME, lo que puede dar lugar a un
certificado multidominio. La lista de todos los nombres cubiertos por el
certificado puede encontrarse en la sección Subject Alternative Name (SAN) del
certificado obtenido. Para comprobarlo desde la línea de comandos:

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

Cuando un certificado está a punto de expirar o la lista de dominios cambia,
el cliente firma y envía otro CSR al servidor CA. El servidor vuelve a verificar
la propiedad y emite un nuevo certificado, que el cliente instala localmente,
reemplazando el anterior.

En la [configuración](https://es.angie.software//angie/docs/configuration/configfile.md#configfile), el certificado obtenido y su clave
correspondiente están disponibles mediante las variables prefijo
[$acme_cert_<nombre>](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#v-acme-cert-name) y [$acme_cert_key_<nombre>](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#v-acme-cert-key-name). Sus valores son los
contenidos de los respectivos archivos, que deben usarse con las directivas
[ssl_certificate](https://es.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-certificate) y [ssl_certificate_key](https://es.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>

## Recopilación de dominios frente al uso del certificado

La directiva [acme](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1) sirve únicamente para recopilar nombres de dominio
para las solicitudes de certificados.
No controla dónde puede usarse el certificado:
cualquier bloque `server` puede hacer referencia al certificado obtenido
mediante la variable [$acme_cert_<name>](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#v-acme-cert-name),
independientemente de si el bloque contiene una directiva `acme`.

Por ejemplo, si tiene un bloque `server` con comodín
que ya cubre todos los subdominios,
los bloques `server` adicionales para subdominios específicos
no necesitan la directiva `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 dominios

Para controlar el conjunto exacto de nombres de dominio en un certificado
sin depender de la recopilación automática desde todos los bloques `server`,
cree un bloque `server` dedicado
que contenga únicamente las directivas [server_name](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server-name) y [acme](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1).
Para evitar que este bloque maneje tráfico real,
vincúlelo a un socket de dominio 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;
}
```

Otros bloques `server` pueden entonces usar el certificado
mediante la variable [$acme_cert_<name>](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#v-acme-cert-name)
sin afectar a qué dominios se solicitan.

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

## Validación HTTP

La validación se gestiona automáticamente. El proceso implica que el servidor
ACME, al recibir una solicitud, [recupere un archivo token especial vía HTTP](https://datatracker.ietf.org/doc/html/rfc8555#section-8.3) desde el cliente
en la dirección `/.well-known/acme-challenge/<TOKEN>`.
Nuestro módulo ACME rastrea y procesa dichas solicitudes automáticamente.
Cuando se recibe la respuesta esperada con el contenido correcto, el servidor ACME
confirma que el dominio pertenece al cliente.

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

### Ejemplo de Configuración

En este ejemplo, el cliente ACME llamado `example` gestiona certificados para
`example.com` y `www.example.com` (tenga en cuenta que los certificados
wildcard no están soportados con validación HTTP):

```nginx
http {

    resolver 127.0.0.53; # Requerido para la directiva 'acme_client'

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

    server {

        listen 80; # Opcional si ningún servidor escucha en el puerto de desafío HTTP
                   # (ver directiva '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 se mencionó anteriormente, el puerto 80 debe estar abierto para manejar las
llamadas HTTP de ACME. Si no hay ningún servidor configurado para escuchar en el
puerto de desafío HTTP, el módulo crea un listener dedicado en el puerto 80
(o el configurado en [acme_http_port](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-http-port)). No se requiere un bloque [server](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server) separado.

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

## Validación DNS

La validación se gestiona automáticamente. Al procesar una solicitud de
certificado, el servidor ACME realiza una [consulta DNS especial](https://datatracker.ietf.org/doc/html/rfc8555#section-8.4) al subdominio
`_acme-challenge.` del dominio que se está verificando. Una vez recibida la
respuesta esperada, el servidor ACME confirma que el dominio pertenece al cliente.

Nuestro módulo ACME rastrea y procesa dichas solicitudes automáticamente,
siempre que sus registros DNS estén configurados correctamente para designar
al servidor Angie como servidor de nombres autoritativo para el subdominio
`_acme-challenge.`.

#### NOTE
El servidor Angie debe ser accesible desde Internet
en el puerto UDP 53 (o el especificado en [acme_dns_port](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-dns-port)).
Si el servidor está detrás de un firewall,
asegúrese de que este puerto esté abierto para conexiones entrantes.

Por ejemplo, para verificar el dominio `example.com` usando un servidor
Angie en la dirección IP `93.184.215.14`, la configuración DNS de su
dominio debería incluir los siguientes registros:

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

Esta configuración delega la resolución DNS de
`_acme-challenge.example.com` a `ns.example.com`, asegurando
que `ns.example.com` sea accesible al asignarlo a la dirección IP
(`93.184.215.14`).

#### WARNING
La propagación de registros NS puede tardar desde unos minutos hasta 48 horas
dependiendo del TTL y del proveedor de DNS. Se recomienda verificar que la
configuración sea correcta antes de solicitar un certificado.

Para verificar que el DNS está configurado correctamente, puede usar los siguientes comandos:

```console
$ dig NS _acme-challenge.example.com +short  # Verificar registro NS para el subdominio _acme-challenge

  ns.example.com.

$ dig A ns.example.com +short  # Verificar registro A para el servidor de nombres

  93.184.215.14

$ nc -zv 93.184.215.14 53  # Verificar accesibilidad del servidor DNS en el puerto 53
```

Este método permite solicitar certificados comodín, por ejemplo, un
certificado que incluya la entrada `*.example.com` en la sección
Subject Alternative Name (SAN). Para solicitar explícitamente un certificado
para un subdominio, como `www.example.com`, debe verificar ese subdominio
por separado utilizando el método descrito anteriormente.

#### WARNING
La aplicabilidad de este escenario depende en gran medida de las capacidades
que ofrezca su proveedor de DNS; algunos proveedores no permiten este tipo de
configuraciones.

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

### Ejemplo de configuración

En general, la configuración es similar al ejemplo de la sección anterior.
No se necesitan ajustes específicos de HTTP; basta con establecer
`challenge=dns` en la directiva [acme_client](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client).

En este ejemplo, el cliente ACME llamado `example` gestiona certificados
para `example.com` y `*.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>

## Validación ALPN

La validación se gestiona automáticamente. El servidor ACME se conecta usando TLS y
solicita el protocolo `acme-tls/1` a través de ALPN. El módulo sirve un
certificado temporal para la solicitud de validación.

Para habilitar este método, configure `challenge=alpn` en la
directiva [acme_client](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client) y asegúrese de que su listener TLS sea accesible en
el puerto 443 (o el puerto usado para TLS).

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

## Validación basada en hooks

A diferencia de los métodos anteriores, esta validación requiere un esfuerzo adicional.
El servidor ACME realiza la [validación HTTP](#acme-config-http) o la
[validación DNS](#acme-config-dns) estándar, pero en lugar de interactuar
directamente con el servidor Angie, se comunica con un servicio externo
gestionado por el servidor Angie mediante llamadas hook ([acme_hook](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-hook)).
Este servicio configura un servidor DNS o HTTP separado donde el servidor ACME
envía sus solicitudes.

Una vez que el servidor ACME recibe la respuesta esperada desde el servidor DNS
o HTTP configurado, confirma la propiedad del dominio.

Cuando la emisión o renovación de un certificado requiere la verificación de dominio,
Angie genera una solicitud interna
al `location` con nombre que contiene la directiva [acme_hook](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-hook).
La forma en que se gestiona esta solicitud depende enteramente de las demás directivas
configuradas en el mismo `location`.

El patrón general es el siguiente:

1. Cree un `location` con nombre con la directiva [acme_hook](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-hook).
2. Configure un manejador de solicitudes en el mismo `location`
   utilizando el módulo que mejor se adapte a su configuración:
   [fastcgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass) para FastCGI,
   [proxy_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass) para HTTP,
   `cgi` para scripts CGI, etc.
3. Pase las [variables](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme-variables) ACME
   al manejador utilizando el mecanismo que admita,
   por ejemplo `fastcgi_param` para FastCGI
   o `cgi_set_var` para CGI.

El manejador debe devolver un código de estado `2xx`,
que puede enviarse mediante la cabecera `Status`.
Cualquier otro código se trata como un error
y se detiene la renovación del certificado.
La salida del manejador se ignora.

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

### Configuración mínima

Independientemente del manejador utilizado,
el `location` del hook sigue esta estructura:

```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 la validación DNS, el manejador debe utilizar `ACME_HOOK`
para determinar la acción:
cuando es `add`,
crear un registro TXT para `_acme-challenge.*ACME_DOMAIN*`
con el valor de `ACME_KEYAUTH`;
cuando es `remove`, eliminar dicho registro.

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

### Ejemplo con FastCGI

En este ejemplo, el [acme_client](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client) `example` está configurado para la
verificación de dominio usando callbacks DNS, indicado por el parámetro
`challenge=dns` en la directiva [acme_client](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client).

El bloque `server` se aplica a todos los subdominios de `example.com`
(p. ej., `*.example.com`) y usa el cliente ACME `example` para
gestionar certificados, tal como especifica la directiva [acme](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1).

Un bloque `location` con nombre maneja las llamadas del hook.
La directiva [acme_hook](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-hook) lo asocia
con el cliente ACME `example`.
Las solicitudes del hook se envían a un servidor FastCGI local
en el puerto 9000 mediante [fastcgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass).
Las directivas `fastcgi_param` pasan
las variables ACME al servicio 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;
    }
}
```

El siguiente script en Perl demuestra un servicio FastCGI externo correspondiente:

```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);
```

Aquí, `DNS_set_TXT_record()` y `DNS_clear_TXT_record()` son
funciones que se supone añaden y eliminan registros TXT en la configuración de
un servidor DNS externo que consulta el servidor ACME. Estos registros deben
contener los datos proporcionados por el servidor Angie para permitir que el
servidor DNS externo pase la validación con éxito, similar al proceso descrito
en [Validación DNS](#acme-config-dns). Los detalles de implementación de tales funciones
están fuera del alcance de esta guía; por ejemplo, los parámetros también
pueden pasarse a través de la URI de la solicitud:

```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;
}
```

### Ejemplo con PHP-FPM

Otro ejemplo, 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
# ...
```

Los parámetros pasados pueden accederse en PHP a través de `$_SERVER['...']`.

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

## ACME en el módulo Stream

El módulo stream [ACME](https://es.angie.software//angie/docs/configuration/modules/stream/stream_acme.md#stream-acme) permite la emisión y uso automatizado de
certificados para tráfico TCP.
Para que funcione correctamente, primero debe configurar su contraparte HTTP:
el cliente ACME debe declararse en el contexto `http`,
y el bloque `stream` en sí debe colocarse *después* del bloque `http`
en la configuración.

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

### Ejemplo de Configuración

Por defecto, se utiliza el modo de validación HTTP para obtener certificados.
Como se mencionó en la sección [Validación HTTP](#acme-config-http),
esto requiere un servidor HTTP escuchando en el puerto 80:

```nginx
# Parte HTTP
http {

    resolver 127.0.0.53;

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

    # Servidor para validación 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; # referencia al cliente ACME definido en la parte HTTP
    }

    upstream backend_upstream {

        server 127.0.0.1:54321;
    }
}
```

También puede usar la validación DNS
configurando `challenge=dns` en la directiva [acme_client](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client);
en ese caso, no se necesitará el servidor.

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

## Migración desde **certbot**

Si anteriormente usaba [certbot](https://certbot.eff.org/)
para obtener y renovar certificados SSL de Let's Encrypt
antes de [migrar de nginx a Angie](https://es.angie.software//angie/docs/configuration/migration.md#migration),
siga estos pasos para pasar a usar nuestro módulo ACME.

Supongamos que configuró certificados de la siguiente manera:

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

La configuración creada automáticamente por este comando
suele encontrarse en `/etc/nginx/sites-available/example.conf`
y se parece a lo siguiente:

```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;
}
```

En el ejemplo anterior, las líneas resaltadas deben modificarse.
Dependiendo de sus circunstancias y preferencias, configure
la [validación HTTP](#acme-config-http)
o la [validación DNS](#acme-config-dns) usando el módulo ACME.

La [configuración de Angie](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) resultante
podría verse así:

```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;
    }
}
```

Recuerde recargar la configuración
[después de hacer cambios](https://es.angie.software//angie/docs/configuration/runtime.md#control-config-change):

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

Una vez haya verificado que esta configuración funciona,
puede eliminar los certificados de **certbot**
y deshabilitar o eliminar completamente certbot del servidor
si ya no se usa en otro lugar,
por ejemplo:

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

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

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