# https://es.angie.software/angie/docs.md
# Acerca de Angie
Angie
/[andʒi](https://en.wikipedia.org/wiki/International_Phonetic_Alphabet)/
es un servidor web eficiente, potente y escalable
que fue bifurcado de nginx:
* Concebido por ex-desarrolladores del equipo original
para ir más allá de la visión anterior
y actuar como un [reemplazo directo](https://es.angie.software//angie/docs/configuration/migration.md#migration)
sin cambios importantes en la configuración de módulos o configuración.
* Incluye la mayoría de las capacidades de
[nginx 1.31.2](https://nginx.org/en/CHANGES)
y una serie de [nuevas características](#index-features-oss).
Construimos paquetes binarios para una variedad de
[sistemas y arquitecturas](https://es.angie.software//angie/docs/installation/index.md#install-packages),
así como
[imágenes Docker](https://es.angie.software//angie/docs/installation/docker.md#docker-images).
El código fuente está abierto en nuestros
[repositorios públicos](https://es.angie.software//angie/docs/development.md#development)
bajo una
[licencia tipo BSD](https://es.angie.software//angie/license-angie.md#license-angie).
Además, una versión comercial con [características adicionales](#index-features-pro)
se comercializa como Angie PRO.
Una selección de paquetes Angie prefabricados,
imágenes Docker y opciones de compilación de código fuente.
Control de inicio y tiempo de ejecución;
configuración, módulos, directivas y variables.
Resolución de problemas técnicos con Angie,
rutas de retroalimentación disponibles.
Información para desarrolladores
que quieren contribuir al proyecto.
## Versión Actual
**Angie 1.12.1** y **Angie PRO 1.12.1** fueron lanzadas el **17 de julio de 2026**.
Las nuevas versiones aparecen trimestralmente;
entre medias, publicamos correcciones urgentes y actualizaciones importantes.
Consulta también el historial completo de versiones para
[Angie](https://es.angie.software//angie/docs/oss_changes.md#oss-changes)
y
[Angie PRO](https://es.angie.software//angie/docs/pro_changes.md#pro-changes).
## Ventajas de Angie sobre nginx
Ventajas principales disponibles
en la versión gratuita de código abierto de Angie:
**Observabilidad y monitorización**
- Exposición de información básica sobre el servidor web,
su [configuración](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#a-api-config-files),
así como [métricas](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#metrics) de servidores proxy, conexiones de clientes,
zonas de memoria compartida, certificados TLS y muchas otras cosas
a través de una interfaz RESTful [API](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#a-api) en formato JSON.
- Recopilación de [métricas personalizadas](https://es.angie.software//angie/docs/configuration/custom-metrics.md#custom-metrics-config) arbitrarias
para tráfico [HTTP](https://es.angie.software//angie/docs/configuration/modules/http/http_metric.md#http-metric) y [stream](https://es.angie.software//angie/docs/configuration/modules/stream/stream_metric.md#stream-metric) en tiempo
real con el módulo Metric, utilizando métodos de agregación configurables
(contadores, histogramas, medias móviles, etc.); las métricas se agrupan por
claves arbitrarias y se exponen a través de la API de estadísticas.
- Exportación de estadísticas en formato [Prometheus](https://es.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#id1)
con [plantillas personalizables](https://es.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#prometheus-template).
- Registro de errores mejorado con la directiva [error_log](https://es.angie.software//angie/docs/configuration/modules/core.md#error-log):
filtrado de mensajes con el parámetro `filter=`, salida en JSON con el
parámetro `format=` y una tasa de registro configurable con el
parámetro `rate=`, además de etiquetas personalizadas mediante la
directiva [error_log_user_tag](https://es.angie.software//angie/docs/configuration/modules/http/index.md#error-log-user-tag).
- Monitorización del servidor a través del navegador con la
herramienta de monitorización visual [Console Light](https://es.angie.software//angie/docs/configuration/monitoring.md#monitoring).
Ver la demo en línea: [https://console.angie.software/](https://console.angie.software/)
**TLS y seguridad**
- El cliente [ACME](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1) en Angie, habilitado en nuestros paquetes
e imágenes, de modo que no hay que instalar ningún módulo aparte: emisión
y renovación automáticas de certificados TLS con validación
de dominio [por HTTP, DNS y TLS-ALPN](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client). La validación por
DNS abre la puerta a los certificados comodín (wildcard), ACME funciona
también en el módulo [stream](https://es.angie.software//angie/docs/configuration/modules/stream/stream_acme.md#stream-acme), y los métodos de validación
no estándar se conectan con la directiva [acme_hook](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-hook).
- Soporte de TLS 1.3 Early Data (0-RTT) en el módulo `stream`
mediante la directiva [ssl_early_data](https://es.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#s-ssl-early-data).
- Soporte [del lado del servidor](https://es.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-ntls) y [del lado del cliente](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-ssl-ntls)
para NTLS cuando se utiliza la
biblioteca TLS [TongSuo](https://github.com/Tongsuo-Project/Tongsuo),
habilitado [en tiempo de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#install-source-features).
**Proxy y balanceo de carga**
- Actualización dinámica de grupos upstream basada en eventos y etiquetas de
[contenedores Docker](https://es.angie.software//angie/docs/configuration/modules/http/http_docker.md#http-docker) (o herramientas similares como Podman) sin
necesidad de recargar el servidor.
- Reincorporación gradual de servidores upstream tras un fallo
utilizando la opción `slow_start` de la directiva [server](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server)
tanto en upstreams HTTP como en stream.
- [Factor de suavizado](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-response-time-factor) configurable del
balanceo por [tiempo medio de respuesta](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-least-time): determina
cuánto influyen las mediciones recientes en la media, desde un promediado
inerte hasta una reacción rápida ante los picos.
- [Vinculación de sesión](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-sticky) para los protocolos del módulo
`stream` (TCP/UDP): todas las conexiones dentro de una misma sesión
se dirigen al mismo servidor proxy.
- Retirada gradual de un servidor proxy en el módulo `stream` con la
opción `drain` de la directiva [server](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server): el servidor
deja de aceptar nuevas conexiones, pero continúa sirviendo las sesiones ya
vinculadas a él.
**Protocolos y tráfico**
- [HTTP/3](https://es.angie.software//angie/docs/configuration/modules/http/http_v3.md#http-v3) en las conexiones con [servidores proxy](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-http-version), y no solo con los clientes: la versión del protocolo
(HTTP/1.x, HTTP/2, HTTP/3) se elige de forma independiente en cada lado.
- Un [servidor DoH](https://es.angie.software//angie/docs/configuration/modules/http/http_doh.md#http-doh) integrado (DNS over HTTPS, RFC 8484):
acepta consultas DNS a través de HTTP/HTTPS y las reenvía a grupos de
servidores DNS mediante UDP o TCP.
- Ampliación de las capacidades de autorización y balanceo para el protocolo MQTT
con la directiva [mqtt_preread](https://es.angie.software//angie/docs/configuration/modules/stream/stream_mqtt_preread.md#s-mqtt-preread) bajo `stream`.
- Información para decisiones de balanceo con cookies de sesión del protocolo RDP
a través de la directiva [rdp_preread](https://es.angie.software//angie/docs/configuration/modules/stream/stream_rdp_preread.md#s-rdp-preread) bajo `stream`.
- Limitación de la [tasa de transferencia de archivos MP4](https://es.angie.software//angie/docs/configuration/modules/http/http_mp4.md#mp4-limit-rate)
proporcionalmente a su tasa de bits,
reduciendo así la carga de ancho de banda.
- Envío de PROXY Protocol v2 a los servidores proxy en el módulo `stream`,
con la posibilidad de establecer valores TLV arbitrarios mediante la
directiva [proxy_protocol_tlv](https://es.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-protocol-tlv).
- Conversión de imágenes entre formatos, incluyendo a HEIC y AVIF,
con el parámetro `convert` de la directiva [image_filter](https://es.angie.software//angie/docs/configuration/modules/http/http_image_filter.md#image-filter).
- Soporte para los [métodos de autenticación](https://es.angie.software//angie/docs/configuration/modules/mail/mail_smtp.md#m-smtp-auth) XOAUTH2 y
OAUTHBEARER en el proxy de correo.
**Configuración y operación más simples**
- Volcado de la zona de memoria compartida en [proxy_cache_path](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-path) al
disco: el contenido del índice de caché se preserva entre reinicios y
actualizaciones, lo que elimina el retraso de carga de la caché y pone
el servidor en línea aún más rápido.
- Varias expresiones coincidentes a la vez en una sola directiva
`location`: los bloques con configuraciones compartidas se pueden
[combinar](https://es.angie.software//angie/docs/configuration/modules/http/index.md#combined-locations).
- La directiva [goto](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#goto) del módulo rewrite, que realiza una
redirección interna a una ubicación con nombre sin modificar el URI,
en lugar de las soluciones alternativas basadas en `try_files` o
`error_page`.
- Configuración automática del [resolutor DNS](https://es.angie.software//angie/docs/configuration/modules/http/index.md#resolver) a partir de
`/etc/resolv.conf`: el archivo se relee ante cualquier cambio,
eliminando la necesidad de especificar manualmente las direcciones de
los servidores DNS.
- La directiva [time_format](https://es.angie.software//angie/docs/configuration/modules/http/index.md#time-format), que define una variable con
un formato de hora personalizado, admitiendo especificadores similares a
`strftime()` y `%L` para milisegundos.
- [Paquetes binarios](https://es.angie.software//angie/docs/installation/external-modules/index.md#install-thirdpartymodules) precompilados
para muchos módulos populares de terceros.
## Características de Angie PRO
Angie PRO comercial añade lo siguiente
a las características de la [versión de código abierto](#index-features-oss):
**Configuración dinámica y gestión**
- Gestión de servidores proxy a través de una [API](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#api-config) de
configuración dinámica RESTful: permite incorporar servidores al balanceo
y retirarlos de él, así como cambiar sus pesos y otros parámetros sobre la
marcha, sin recargar los procesos worker. La consola de monitorización visual
[Console Light](https://es.angie.software//angie/docs/configuration/monitoring.md#monitoring) también puede utilizarse para gestionar
el servidor desde su navegador.
- Sobrescritura de la firma del servidor en las páginas de error y en el
campo de cabecera `Server` con un valor arbitrario mediante la
directiva [server_tokens](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server-tokens).
**Balanceo avanzado y tolerancia a fallos**
- Balanceo por [retroalimentación](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-feedback): los peers se
seleccionan por el valor de una variable; se supone que proviene de los
propios peers, que informan de su carga de CPU u otras métricas.
- Cola de espera para solicitudes, configurada mediante la directiva
[queue](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-queue) en el bloque `upstream`: si no se puede elegir
un servidor para una solicitud en el primer intento, por ejemplo durante un
pico de carga, la solicitud entra en la cola en lugar de ser rechazada
de inmediato.
- Comprobación proactiva del estado de los servidores proxy mediante el envío
periódico de [solicitudes de sondeo](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe): un servidor
defectuoso sale del balanceo antes de que le llegue una solicitud de cliente,
no después.
- La directiva [no_port](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-no-port) en un bloque `upstream` del
módulo `stream`, que desvincula el puerto de los servidores del
grupo: el puerto se indica en la directiva [proxy_pass](https://es.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-pass), de modo
que un mismo grupo puede servir para proxy a distintos puertos sin
duplicar la lista de servidores.
- La directiva [backup_switch](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-backup-switch) en el bloque
`upstream`: los servidores de respaldo pueden continuar atendiendo
solicitudes cuando los servidores primarios vuelven a estar accesibles.
**Sesiones, conexiones y almacenamiento en caché**
- [Vinculación condicional de conexiones de cliente](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-bind-conn)
a la conexión del servidor proxy, que también permite el proxy de NTLM.
- La directiva [proxy_bind](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-bind), que evalúa las variables después de cada
selección de servidor proxy: la dirección de salida puede depender del
servidor seleccionado; por ejemplo, mediante la variable
[$upstream_current_addr](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#v-upstream-current-addr).
- El modo [sticky learn](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-sticky) con almacenamiento de sesiones en
un almacén externo, lo que permite unir varios balanceadores en un
clúster.
- Fragmentación de caché en el módulo de proxy, que permite distribuirla entre
[diferentes discos](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache) dependiendo de las propiedades de la respuesta.
# https://es.angie.software/angie/docs/installation.md
# Instalación
## Angie
Hay varias opciones de instalación disponibles para la versión gratuita de código abierto:
| [Paquetes binarios](https://es.angie.software//angie/docs/installation/oss_packages.md#oss-packages) | Método de instalación recomendado; construimos y publicamos paquetes para la mayoría de las distribuciones Linux y FreeBSD.
Junto con esto, también preparamos y publicamos nuestras propias compilaciones para muchos [módulos populares de terceros](https://es.angie.software//angie/docs/configuration/modules/external-modules/index.md#list-of-modules). |
|---------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [Imágenes Docker](https://es.angie.software//angie/docs/installation/docker.md#docker-images) | Para ejecutar en un contenedor, puede descargar la imagen Docker desde nuestro registro. Construimos imágenes a partir de nuestros propios paquetes basados en una amplia gama de distribuciones.
Las imágenes en el registro contienen *todos* los módulos que construimos, incluidos los de terceros; también hay una imagen mínima sin módulos adicionales. |
| [Compilación desde el código fuente](https://es.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild) | Si las opciones anteriores no le convienen por alguna razón, siempre puede crear su propia compilación desde el código fuente. |
Puede sugerir nuevos métodos de instalación, módulos y distribuciones
en el
[foro](https://forum.angie.support)
o en
[GitHub](https://github.com/webserver-llc/angie/issues).
## Angie PRO
La principal opción de instalación para la versión comercial son los
[paquetes binarios](https://es.angie.software//angie/docs/installation/pro_packages.md#pro-packages),
almacenados en un repositorio privado seguro;
para acceder a él, necesita firmar un contrato y adquirir una licencia.
Las compilaciones están disponibles para la mayoría de los sistemas compatibles con POSIX;
además, podemos crear y probar su compilación
para una distribución y método de instalación específicos.
## Módulos de Terceros y Otras Fuentes
Preparamos y publicamos compilaciones para muchos
[módulos populares de terceros](https://es.angie.software//angie/docs/configuration/modules/external-modules/index.md#list-of-modules) en nuestro repositorio.
Además, para varios sistemas operativos y distribuciones,
Angie puede instalarse desde sus
[propios repositorios](https://es.angie.software//angie/docs/installation/thirdparty.md#thirdparty).
# https://es.angie.software/angie/docs/installation/oss_packages.md
# Instalación de Angie mediante paquetes
Para instalar y actualizar Angie
utilizando el gestor de paquetes de su distribución,
añada y configure el repositorio correspondiente.
## Distribuciones
| Nombre | Versiones | Arquitecturas |
|-----------------------------------|--------------------------------|-------------------------------|
| [AlmaLinux](#install-yum-oss) | 10, 9, 8 | x86-64, arm64 |
| [Alpine](#install-alpine-oss) | 3.23, 3.22, 3.21 | x86-64, arm64 |
| [Alt](#install-alt-oss) | 11, 10 8 | x86-64, arm64 x86-64 |
| [Astra SE](#install-astrase-oss) | 4.7 1.8, 1.7 | arm64 x86-64 |
| [CentOS](#install-yum-oss) | 10, 9 | x86-64, arm64 |
| [Debian](#install-deb-oss) | 13, 12, 11 | x86-64, arm64 |
| [Fedora](#install-yum-oss) | 44, 43 | x86-64, arm64 |
| [FreeBSD](#install-freebsd-oss) | 15, 14 | x86-64, arm64 |
| [MSVSphere](#install-yum-oss) | 10, 9 8 | x86-64, arm64 x86-64 |
| [openSUSE](#install-opensuse-oss) | 16, 15 | x86-64, arm64 |
| [Oracle Linux](#install-yum-oss) | 10, 9, 8 | x86-64, arm64 |
| [OSNova](#install-osnova-oss) | 3.3.0, 2.13 | x86-64 |
| [RED OS](#install-yum-oss) | 8, 7 | x86-64, arm64 |
| [Rocky Linux](#install-yum-oss) | 10, 9, 8 | x86-64, arm64 |
| [ROSA](#install-yum-oss) | Chrome 13 Chrome 12 Fresh 12 | x86-64 x86-64, arm64 x86-64 |
| [SberLinux](#install-yum-oss) | 9 | x86-64 |
| [Ubuntu](#install-deb-oss) | 26.04, 24.04, 22.04 | x86-64, arm64 |
### Compilaciones de prueba
Probamos y compilamos código de nuestro repositorio diariamente,
y estas
[compilaciones nocturnas](https://download.angie.software/angie-nightly/)
son adecuadas para explorar nuevas funcionalidades antes de los lanzamientos oficiales.
La versión de las compilaciones nocturnas siempre corresponde al próximo lanzamiento.
El proceso de nomenclatura e instalación es generalmente similar a lo que se muestra a continuación,
pero en lugar del prefijo de ruta `https://download.angie.software/angie/*`
use `https://download.angie.software/angie-nightly/*`.
### Alma, CentOS, Fedora, MSVSphere, Oracle, RED OS, Rocky, ROSA, SberLinux
1. Para añadir el repositorio, cree un archivo llamado
`/etc/yum.repos.d/angie.repo`
con el siguiente contenido:
Alma
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/almalinux/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
CentOS
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/centos/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Fedora
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/fedora/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
MSVSphere
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/msvsphere/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Oracle
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/oracle/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
RED OS
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/redos/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Rocky
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/rocky/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
ROSA Chrome
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/rosa-chrome/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
priority=9
```
ROSA Fresh
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/rosa/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
priority=9
```
SberLinux
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/sberlinux/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
priority=9
```
2. Instale el paquete Angie:
```console
$ sudo yum install -y angie
$ # -- OR --
$ sudo dnf install -y angie
```
3. (*Opcional*) Instale cualquier paquete [adicional](#install-extras-oss)
que necesite:
```console
$ sudo yum install -y
$ # -- OR --
$ sudo dnf install -y
```
4. Inicie el servicio:
```console
$ sudo systemctl start angie
```
5. Para iniciar automáticamente Angie después del reinicio del servidor:
```console
$ sudo systemctl enable angie
```
### Alpine
1. Instale los requisitos previos
para añadir el repositorio de Angie:
```console
$ sudo apk update
$ sudo apk add curl ca-certificates
```
2. Descargue la clave pública del repositorio de Angie
para la verificación de paquetes:
```console
$ sudo curl -o /etc/apk/keys/angie-signing.rsa \
https://angie.software/keys/angie-signing.rsa
```
3. Añada el repositorio de Angie:
```console
$ echo "https://download.angie.software/angie/alpine/v$(egrep -o \
'[0-9]+\.[0-9]+' /etc/alpine-release)/main" \
| sudo tee -a /etc/apk/repositories > /dev/null
```
4. Actualice los índices del repositorio:
```console
$ sudo apk update
```
5. Instale el paquete Angie:
```console
$ sudo apk add angie
```
6. (*Opcional*) Instale cualquier paquete [adicional](#install-extras-oss)
que necesite:
```console
$ sudo apk add
```
7. Inicie el servicio:
```console
$ sudo service angie start
```
8. Para iniciar automáticamente Angie después del reinicio del servidor:
```console
$ sudo rc-update add angie
```
### Alt
1. Cree el directorio `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Instale los requisitos previos
para añadir el repositorio de Angie:
```console
$ sudo apt-get update
$ sudo apt-get install -y curl apt-https
```
3. Descargue la clave pública del repositorio de Angie
para la verificación de paquetes:
```console
$ sudo curl -o /etc/ssl/angie/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
4. Importe la clave descargada en el anillo de claves de confianza:
```console
$ sudo gpg --no-default-keyring \
--keyring /usr/lib/alt-gpgkeys/pubring.gpg --import /etc/ssl/angie/angie-signing.gpg
```
5. Guarde la firma de la clave:
```sh
$ echo 'simple-key "angie" {
Fingerprint "EB8EAF3D4EF1B1ECF34865A2617AB978CB849A76";
Name "Angie (Signing Key) ";
}' | sudo tee /etc/apt/vendors.list.d/angie.list > /dev/null
```
6. Añada el repositorio de Angie:
Alt 11
```console
$ echo "rpm [angie] https://download.angie.software/angie/altlinux/11/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt 10
```console
$ echo "rpm [angie] https://download.angie.software/angie/altlinux/10/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt SP 10
```console
$ echo "rpm [angie] https://download.angie.software/angie/altlinux-sp/10/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt SP 8
```console
$ echo "rpm [angie] https://download.angie.software/angie/altlinux-sp/8/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
7. Actualice los índices del repositorio:
```console
$ sudo apt-get update
```
8. Instale el paquete de Angie:
```console
$ sudo apt-get install -y angie
```
9. (*Opcional*) Instale cualquier paquete [extra](#install-extras-oss)
que necesite:
```console
$ sudo apt-get install -y
```
10. Inicie el servicio:
```console
$ sudo systemctl start angie
```
11. Para iniciar automáticamente Angie después de reiniciar el servidor:
```console
$ sudo systemctl enable angie
```
### Astra SE
1. Instale los requisitos previos
para añadir el repositorio de Angie:
```console
$ sudo apt-get update
$ sudo apt-get install -y ca-certificates curl lsb-release
```
2. Descargue la clave pública del repositorio de Angie
para la verificación de paquetes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
3. Añada el repositorio de Angie:
```console
$ echo "deb https://download.angie.software/angie/astra-se/$(egrep -o \
'[0-9]+.[0-9]+' /etc/astra_version) unstable main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
4. Actualice los índices del repositorio:
```console
$ sudo apt-get update
```
5. (*Opcional*) Cuando se ejecuta en un Entorno de Software Cerrado
([CSE](https://wiki.astralinux.ru/pages/viewpage.action?pageId=41190634)),
instale el paquete de clave
para la verificación binaria de Angie:
```console
$ sudo apt-get install -y angie-digsig-key
```
Actualice el CSE:
```console
$ sudo update-initramfs -uk all
```
Luego **reinicie el servidor**:
```console
$ sudo shutdown -r now
```
6. Instale el paquete de Angie:
```console
$ sudo apt-get install -y angie
```
7. (*Opcional*) Instale cualquier paquete [extra](#install-extras-oss)
que necesite:
```console
$ sudo apt-get install -y
```
### Debian, Ubuntu
1. Instale los requisitos previos
para añadir el repositorio de Angie:
```console
$ sudo apt-get update
$ sudo apt-get install -y ca-certificates curl
```
2. Descargue la clave pública del repositorio de Angie
para la verificación de paquetes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
3. Añada el repositorio de Angie:
```console
$ echo "deb https://download.angie.software/angie/$(. /etc/os-release && echo "$ID/$VERSION_ID $VERSION_CODENAME") main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
4. Actualice los índices del repositorio:
```console
$ sudo apt-get update
```
5. Instale el paquete de Angie:
```console
$ sudo apt-get install -y angie
```
6. (*Opcional*) Instale cualquier paquete [extra](#install-extras-oss)
que necesite:
```console
$ sudo apt-get install -y
```
### OSNova
1. Instale los requisitos previos
para añadir el repositorio de Angie:
```console
$ sudo apt-get update
$ sudo apt-get install -y ca-certificates curl
```
2. Descargue la clave pública del repositorio de Angie
para la verificación de paquetes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
3. Añada el repositorio de Angie:
```console
$ echo "deb https://download.angie.software/angie/osnova/$(egrep -o \
'[0-9]*' /etc/osnova_version | head -1) \
$(. /etc/os-release && echo "$VERSION_CODENAME") main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
4. Actualice los índices del repositorio:
```console
$ sudo apt-get update
```
5. Instale el paquete de Angie:
```console
$ sudo apt-get install -y angie
```
6. (*Opcional*) Instale cualquier paquete [extra](#install-extras-oss)
que necesite:
```console
$ sudo apt-get install -y
```
### FreeBSD
1. Para añadir el repositorio de Angie, cree los directorios:
```console
$ sudo mkdir -p /usr/local/etc/pkg/angie/ /usr/local/etc/pkg/repos/
```
2. Para configurar el repositorio, cree un archivo llamado
`/usr/local/etc/pkg/repos/angie.conf`
con el siguiente contenido:
```console
angie: {
url: "https://download.angie.software/angie/freebsd/${VERSION_MAJOR}/${ARCH}",
signature_type: "pubkey",
pubkey: "/usr/local/etc/pkg/angie/angie-signing.rsa",
enabled: yes
}
```
3. Descargue la clave pública del repositorio de Angie
para la verificación de paquetes:
```console
$ sudo curl -o /usr/local/etc/pkg/angie/angie-signing.rsa \
https://angie.software/keys/angie-signing.rsa
```
4. Actualice los índices del repositorio:
```console
$ sudo pkg update
```
5. Instale el paquete de Angie:
```console
$ sudo pkg install -r angie -y angie
```
6. (*Opcional*) Instale cualquier paquete [extra](#install-extras-oss)
que necesite:
```console
$ sudo pkg install -r angie -y
```
7. Inicie el servicio:
```console
$ sudo service angie start
```
8. Para iniciar automáticamente Angie después de reiniciar el servidor:
```console
$ sudo sysrc angie_enable=YES
```
#### NOTE
Dado que el gestor de paquetes de FreeBSD puede determinar incorrectamente la última versión,
utilice el siguiente enfoque para actualizar los paquetes ya instalados:
```console
$ sudo pkg upgrade `pkg search -r angie angie-[0-9] | sort -Vr | head -1 | awk {'print $1'}`
```
### openSUSE
1. Para añadir el repositorio, cree un archivo llamado
`/etc/zypp/repos.d/angie.repo`
con el siguiente contenido:
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/opensuse/$releasever_major/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
2. Actualice los índices del repositorio:
```console
$ sudo zypper refresh
```
3. Instale el paquete de Angie:
```console
$ sudo zypper install -y angie
```
4. (*Opcional*) Instale cualquier paquete [extra](#install-extras-oss)
que necesite:
```console
$ sudo zypper install -y
```
5. Inicie el servicio:
```console
$ sudo systemctl start angie
```
6. Para iniciar automáticamente Angie después de reiniciar el servidor:
```console
$ sudo systemctl enable angie
```
## Extras
Además de los paquetes que proporcionan la funcionalidad básica,
también publicamos algunos paquetes adicionales,
tanto propios como compilados a partir de fuentes de terceros seleccionadas.
### Panel web Console Light
Console Light es un panel web ligero de monitorización para Angie,
publicado como `angie-console-light` en nuestros repositorios.
Se instala de la misma manera que el paquete `angie` en los pasos anteriores;
consulte los pasos de configuración en [Panel de monitorización web Console Light](https://es.angie.software//angie/docs/configuration/monitoring.md#monitoring).
### Módulos Dinámicos
Para ampliar la funcionalidad básica de Angie,
puede añadir varios módulos dinámicos.
Los módulos pueden [compilarse desde el código fuente](https://es.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild)
para una versión correspondiente de Angie,
pero es más fácil obtenerlos como paquetes ya preparados desde nuestro repositorio:
| [angie-module-image-filter](https://es.angie.software//angie/docs/configuration/modules/http/http_image_filter.md#http-image-filter) | Añade transformaciones para imágenes JPEG, GIF, PNG y WebP. |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|
| angie-module-njs: [JS](https://es.angie.software//angie/docs/configuration/modules/external-modules/http_js.md#http-js) (HTTP), [JS](https://es.angie.software//angie/docs/configuration/modules/external-modules/stream_js.md#stream-js) (stream) | Permite usar njs (un subconjunto de JavaScript) en la configuración de Angie en los contextos `http` y `stream`, respectivamente. |
| [angie-module-perl](https://es.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl) | Permite escribir manejadores de `location` y variables en Perl, y también invocar Perl desde SSI. |
| [angie-module-wamr](https://es.angie.software//angie/docs/configuration/modules/wasm/wasm_wamr.md#wasm-wamr) | Permite la integración con [WebAssembly Micro Runtime](https://github.com/bytecodealliance/wasm-micro-runtime) para ejecutar código WASM. |
| [angie-module-wasm](https://es.angie.software//angie/docs/configuration/modules/wasm/index.md#wasm-core) | Añade soporte principal para WASM. |
| [angie-module-wasmtime](https://es.angie.software//angie/docs/configuration/modules/wasm/wasm_wasmtime.md#wasm-wasmtime) | Permite la integración con el runtime [Wasmtime](https://wasmtime.dev/) para ejecutar código WASM. |
| [angie-module-xslt](https://es.angie.software//angie/docs/configuration/modules/http/http_xslt.md#http-xslt) | Añade un filtro para transformar respuestas XML con hojas de estilo XSLT. |
Para usar un módulo instalado en una [configuración](https://es.angie.software//angie/docs/configuration/configfile.md#configfile),
cárguelo usando la directiva [load_module](https://es.angie.software//angie/docs/configuration/modules/core.md#load-module) en el contexto `main`:
```nginx
load_module modules/.so;
```
También está disponible una amplia gama de [módulos de terceros](https://es.angie.software//angie/docs/configuration/modules/external-modules/index.md#list-of-modules).
# https://es.angie.software/angie/docs/installation/docker.md
# Imágenes Docker de Angie
Para ejecutar Angie en un contenedor
[Docker](https://docs.docker.com/engine/reference/commandline/cli/)
utilice las imágenes de nuestro registro: `docker.angie.software`.
Están creadas a partir de nuestros [paquetes binarios](https://es.angie.software//angie/docs/installation/oss_packages.md#oss-packages)
y de las imágenes base oficiales de varios sistemas operativos.
#### NOTE
Estas imágenes también pueden ejecutarse con motores de
contenedores compatibles con Docker, como Podman.
La versión recomendada de Podman es 4.9.3 o superior.
#### NOTE
Tenga en cuenta también el módulo [Docker](https://es.angie.software//angie/docs/configuration/modules/http/http_docker.md#http-docker),
que implementa la actualización dinámica de grupos de servidores upstream
basándose en etiquetas de contenedores Docker.
## Imágenes mínimas
- `angie:minimal`:
versión 1.12.1 basada en Alpine 3.22.
- `angie:-minimal`:
versión especificada basada en Alpine 3.22.
Estas imágenes incluyen solo el paquete `angie`.
## Imágenes con plantillas
- `angie:templated`:
versión 1.12.1 basada en Alpine 3.22.
- `angie:-templated`:
versión especificada basada en Alpine 3.22.
Estas imágenes establecen las siguientes variables de entorno:
```docker
ENV ANGIE_BINARY="angie"
ENV ANGIE_CONFIG_TEMPLATE="/etc/angie/angie.conf.t"
ENV ANGIE_ERROR_LOG_SEVERITY="notice"
ENV ANGIE_FEATURE_RELOAD="on"
ENV ANGIE_FEATURE_TEMPLATE="on"
ENV ANGIE_LOAD_MODULES=""
ENV ANGIE_PID_FILE="/run/angie/angie.pid"
ENV ANGIE_WORKER_CONNECTIONS="65536"
ENV ANGIE_WORKER_RLIMIT_NOFILE="65536"
```
Estas variables pueden utilizarse para personalizar el funcionamiento del contenedor:
- `ANGIE_BINARY`:
Permite ejecutar la [versión de depuración](https://es.angie.software//angie/docs/troubleshooting.md#debug-logging).
- `ANGIE_ERROR_LOG_SEVERITY`:
Define el nivel de detalle de las entradas en el archivo principal del [registro de errores](https://es.angie.software//angie/docs/configuration/processing.md#logging).
- `ANGIE_LOAD_MODULES`:
Carga uno o varios módulos disponibles (todos los módulos están incluidos en la imagen).
Especifique una lista de módulos separada por comas sin espacios.
- `ANGIE_PID_FILE`:
Establece una ubicación alternativa para el archivo de identificador del proceso
(archivo PID).
- `ANGIE_FEATURE_TEMPLATE`:
Genera la [configuración de Angie](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) usando la herramienta
[gomplate](https://docs.gomplate.ca/) al iniciar el contenedor. Parámetros
usados: `--input-dir /etc/angie/templates` y
`--output-dir /etc/angie`.
- `ANGIE_FEATURE_RELOAD`:
Activa la gestión de las señales `SIGHUP`, `SIGQUIT` y `SIGTERM`.
Estas incluyen los siguientes
[paquetes](https://es.angie.software//angie/docs/installation/external-modules/index.md#install-thirdpartymodules)
(si se publicaron para la [versión de Angie](https://es.angie.software//angie/docs/oss_changes.md#oss-changes)
con la que se construyó la imagen):
### Lista de paquetes
- `angie-console-light`
- `angie-module-auth-jwt`
- `angie-module-auth-ldap`
- `angie-module-auth-pam`
- `angie-module-auth-spnego`
- `angie-module-auth-totp`
- `angie-module-brotli`
- `angie-module-cache-purge`
- `angie-module-cgi`
- `angie-module-combined-upstreams`
- `angie-module-dav-ext`
- `angie-module-dynamic-limit-req`
- `angie-module-echo`
- `angie-module-enhanced-memcached`
- `angie-module-eval`
- `angie-module-geoip2`
- `angie-module-headers-more`
- `angie-module-http-auth-radius`
- `angie-module-image-filter`
- `angie-module-keyval`
- `angie-module-lua`
- `angie-module-modsecurity`
- `angie-module-ndk`
- `angie-module-njs`
- `angie-module-opentracing`
- `angie-module-otel`
- `angie-module-perl`
- `angie-module-postgres`
- `angie-module-redis2`
- `angie-module-rtmp`
- `angie-module-set-misc`
- `angie-module-subs`
- `angie-module-testcookie`
- `angie-module-unbrotli`
- `angie-module-upload`
- `angie-module-vod`
- `angie-module-vts`
- `angie-module-wasm`
- `angie-module-wasmtime`
- `angie-module-xslt`
- `angie-module-zip`
- `angie-module-zstd`
### Ejemplos
La configuración usada en las imágenes con plantillas aplica las variables
aproximadamente de la siguiente manera:
```none
...
{{- if has $modules "zstd"}}
# package: angie-module-zstd
load_module modules/ngx_http_zstd_filter_module.so;
load_module modules/ngx_http_zstd_static_module.so;
{{end}}
user angie;
worker_processes auto;
worker_rlimit_nofile {{.Env.ANGIE_WORKER_RLIMIT_NOFILE}};
error_log /var/log/angie/error.log {{.Env.ANGIE_ERROR_LOG_SEVERITY}};
pid {{.Env.ANGIE_PID_FILE}};
events {
worker_connections {{.Env.ANGIE_WORKER_CONNECTIONS}};
}
http {
include /etc/angie/mime.types;
default_type application/octet-stream;
log_format main ...
```
Ejecutar un contenedor con acceso a la línea de comandos:
```console
$ docker run -it --pull always --rm --entrypoint=sh \
docker.angie.software/angie:templated
```
Ejecutar Angie con parámetros de conexión y módulos personalizados
(el comando **angie -T** mostrará la configuración completa):
```console
$ docker run -it --rm -e ANGIE_WORKER_CONNECTIONS=4 \
-e ANGIE_LOAD_MODULES="auth-jwt,vod" \
docker.angie.software/angie:templated angie -T
```
Ejecutar un contenedor con un nombre concreto y módulos adicionales:
```console
$ docker run -it --rm --name angie-test \
-e ANGIE_WORKER_CONNECTIONS=4 \
-e ANGIE_LOAD_MODULES="auth-jwt,vod" \
docker.angie.software/angie:templated
```
Recargar la configuración de un contenedor en ejecución:
```console
$ docker kill -s HUP angie-test
```
## Imágenes con módulos adicionales
- `angie:latest`:
versión 1.12.1 basada en Alpine 3.22.
- `angie:`,
`angie:-alpine`:
versión especificada basada en Alpine 3.22.
- `angie:-debian`:
versión especificada basada en Debian 13.
- `angie:-rocky`:
versión especificada basada en Rocky Linux 9.
- `angie:-ubuntu`:
versión especificada basada en Ubuntu 24.04 LTS.
Estas incluyen los siguientes
[paquetes](https://es.angie.software//angie/docs/installation/external-modules/index.md#install-thirdpartymodules)
(si se publicaron para la [versión de Angie](https://es.angie.software//angie/docs/oss_changes.md#oss-changes)
con la que se construyó la imagen):
### Lista de paquetes
- `angie-console-light`
- `angie-module-auth-jwt`
- `angie-module-auth-ldap`
- `angie-module-auth-pam`
- `angie-module-auth-spnego`
- `angie-module-auth-totp`
- `angie-module-brotli`
- `angie-module-cache-purge`
- `angie-module-cgi`
- `angie-module-combined-upstreams`
- `angie-module-dav-ext`
- `angie-module-dynamic-limit-req`
- `angie-module-echo`
- `angie-module-enhanced-memcached`
- `angie-module-eval`
- `angie-module-geoip2`
- `angie-module-headers-more`
- `angie-module-http-auth-radius`
- `angie-module-image-filter`
- `angie-module-keyval`
- `angie-module-lua`
- `angie-module-modsecurity`
- `angie-module-ndk`
- `angie-module-njs`
- `angie-module-opentracing`
- `angie-module-otel`
- `angie-module-perl`
- `angie-module-postgres`
- `angie-module-redis2`
- `angie-module-rtmp`
- `angie-module-set-misc`
- `angie-module-subs`
- `angie-module-testcookie`
- `angie-module-unbrotli`
- `angie-module-upload`
- `angie-module-vod`
- `angie-module-vts`
- `angie-module-wasm`
- `angie-module-wasmtime`
- `angie-module-xslt`
- `angie-module-zip`
- `angie-module-zstd`
## Ejecución
Para iniciar un contenedor con Angie en el puerto 8080,
proporcionando acceso de solo lectura al directorio de archivos estáticos `/var/www/`
y al archivo de configuración `angie.conf` ubicado en el directorio de trabajo actual:
```console
$ docker run --rm --name angie -v /var/www:/usr/share/angie/html:ro \
-v $(pwd)/angie.conf:/etc/angie/angie.conf:ro -p 8080:80 -d docker.angie.software/angie:latest
$ curl -I localhost:8080
HTTP/1.1 200 OK
Server: Angie/1.12.1
Date: Fri, 17 Jul 2026 10:42:54 GMT
Content-Type: text/html
Content-Length: 543
Last-Modified: Fri, 17 Jul 2026 09:12:23 GMT
Connection: keep-alive
ETag: "64c3ccc7-21f"
Accept-Ranges: bytes
```
Esta configuración es adecuada para desarrollo y ajustes locales.
Al usar el [módulo ACME](https://es.angie.software//angie/docs/configuration/acme.md#acme-config) para obtener certificados, monte el
directorio de almacenamiento de certificados en un volumen persistente para que
los certificados emitidos sobrevivan a la recreación del contenedor. De lo
contrario, cada contenedor recreado comienza con un almacenamiento vacío y
solicita nuevos certificados, lo que puede alcanzar los [límites de tasa](https://letsencrypt.org/docs/rate-limits/) de la CA:
```console
$ docker run --rm --name angie -v angie-acme:/var/lib/angie/acme \
-v $(pwd)/angie.conf:/etc/angie/angie.conf:ro -p 80:80 -p 443:443 -d docker.angie.software/angie:latest
```
## Construcción de imágenes personalizadas
También puede definir su propia imagen
basada en una distribución compatible,
añadiendo la capa de Angie desde [paquetes](https://es.angie.software//angie/docs/installation/oss_packages.md#oss-packages)
o [código fuente](https://es.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild).
Ejemplos de archivos `Dockerfile` correspondientes:
```dockerfile
FROM debian:13
LABEL org.opencontainers.image.authors="Release Engineering Team "
ARG DEBIAN_FRONTEND=noninteractive
RUN set -x \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y \
ca-certificates curl \
&& curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg \
&& echo "deb https://download.angie.software/angie/$(. /etc/os-release && echo \"$ID/$VERSION_ID $VERSION_CODENAME\") main" \
> /etc/apt/sources.list.d/angie.list \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y \
angie angie-module-geoip2 angie-module-njs \
&& rm -Rf /var/lib/apt/lists \
/etc/apt/sources.list.d/angie.list \
/etc/apt/trusted.gpg.d/angie-signing.gpg \
&& ln -sf /dev/stdout /var/log/angie/access.log \
&& ln -sf /dev/stderr /var/log/angie/error.log
EXPOSE 80
CMD ["angie", "-g", "daemon off;"]
```
```dockerfile
FROM alpine:3.22
LABEL org.opencontainers.image.authors="Release Engineering Team "
RUN set -x \
&& apk add --no-cache ca-certificates curl \
&& curl -o /etc/apk/keys/angie-signing.rsa https://angie.software/keys/angie-signing.rsa \
&& echo "https://download.angie.software/angie/alpine/v$(egrep -o \
'[0-9]+\.[0-9]+' /etc/alpine-release)/main" >> /etc/apk/repositories \
&& apk add --no-cache angie angie-module-geoip2 angie-module-njs \
&& rm /etc/apk/keys/angie-signing.rsa \
&& ln -sf /dev/stdout /var/log/angie/access.log \
&& ln -sf /dev/stderr /var/log/angie/error.log
EXPOSE 80
CMD ["angie", "-g", "daemon off;"]
```
Para construir la imagen `myangie` en el directorio con este `Dockerfile`
y ejecutar el contenedor como se muestra arriba:
```console
$ docker build -t myangie .
$ docker run --rm --name myangie -v /var/www:/usr/share/angie/html:ro \
-v $(pwd)/angie.conf:/etc/angie/angie.conf:ro -p 8080:80 -d myangie
```
# https://es.angie.software/angie/docs/installation/sourcebuild.md
# Compilación de Angie desde el código fuente
Recomendamos instalar Angie a partir de
[paquetes](https://es.angie.software//angie/docs/installation/oss_packages.md#oss-packages) oficiales precompilados.
No obstante, si aún necesitas tu propia compilación, asegúrate primero de
tener los requisitos previos.
#### NOTE
Compilar Angie requiere un compilador de C (**gcc** o **clang**)
y **make**, además de las bibliotecas PCRE2, zlib y OpenSSL.
Instala los paquetes de desarrollo proporcionados por tu distribución. En Debian
y Ubuntu:
```console
$ sudo apt install build-essential libpcre2-dev zlib1g-dev libssl-dev
```
En RHEL, Fedora y derivados:
```console
$ sudo dnf install gcc make pcre2-devel zlib-devel openssl-devel
```
Como alternativa, compila estas bibliotecas de forma estática junto con Angie
usando las opciones `--with-pcre=`, `--with-zlib=` y
`--with-openssl=` mostradas en los [Ejemplos](#examples-2).
Para compilar Angie desde el código fuente:
1. Descarga el archivo `.tar.gz` desde
[nuestro sitio web](https://download.angie.software/files/):
```console
$ curl -O https://download.angie.software/files/angie-1.12.1.tar.gz
```
2. Descomprime el archivo y navega al directorio de las fuentes:
```console
$ tar -xpf angie-1.12.1.tar.gz
$ cd angie-1.12.1
```
3. Para preparar la compilación, utiliza el script **./configure**,
que determina las características específicas del sistema operativo donde se compila,
en particular, los métodos que Angie puede usar para gestionar conexiones.
Tras una ejecución exitosa, el script crea un `Makefile`.
Con los requisitos previos instalados, una compilación mínima no necesita opciones:
```console
$ ./configure
```
De lo contrario, revisa y establece las [opciones de compilación](#configure) necesarias para los módulos y bibliotecas que necesites (consulta
los [Ejemplos](#examples-2)):
```console
$ ./configure
```
4. Cuando el `Makefile` esté listo, compila e instala Angie:
```console
$ make
$ make install
```
## Opciones de compilación
### General
| Opción | Descripción | Predeterminado |
|------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------|
| `--help` | Muestra un mensaje de ayuda. | |
| `--user=`name | Establece el nombre del usuario sin privilegios cuyas credenciales serán usadas por los procesos worker. Después de la instalación, el nombre siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [user](https://es.angie.software//angie/docs/configuration/modules/core.md#user). | `nobody` |
| `--group=`name | Establece el nombre del grupo cuyas credenciales serán usadas por los procesos worker. Después de la instalación, el nombre siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [user](https://es.angie.software//angie/docs/configuration/modules/core.md#user). | Ajuste de `--user` |
| `--build=`name | Establece un nombre opcional para la compilación. | |
| `--builddir=`path | Establece el directorio de compilación. | `objs` |
| `--feature-cache=`path | Especifica el directorio para cachear artefactos de compilación. | Si se establece sin ruta, se usa el ajuste `--builddir` |
### Rutas
| Opción | Descripción | Predeterminado |
|-------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------|
| `--prefix=`path | Define el directorio que almacenará los archivos del servidor. Este mismo directorio también se usará para todas las rutas relativas establecidas por **./configure** (excepto las rutas a fuentes de bibliotecas) y en el archivo de configuración `angie.conf`. | `/usr/local/angie` |
| `--sbin-path=`path | Establece el nombre del ejecutable de Angie. Este nombre solo se usa durante la instalación. | `/sbin/angie` |
| `--modules-path=`path | Define el directorio donde se instalarán los módulos dinámicos. | `/modules` |
| `--conf-path=`path | Establece el nombre del [archivo de configuración](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) `angie.conf`. Si es necesario, siempre puedes iniciar Angie con un archivo de configuración diferente usando la [opción de línea de comandos](https://es.angie.software//angie/docs/configuration/runtime.md#runtime-cli-options) `-c`. | `/conf/angie.conf` |
| `--error-log-path=`path | Establece el nombre del archivo principal de registro de errores, advertencias y diagnóstico. Después de la instalación, el nombre del archivo siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [error_log](https://es.angie.software//angie/docs/configuration/modules/core.md#error-log). | `/logs/error.log` |
| `--pid-path=`path | Establece el nombre del archivo `angie.pid` que almacenará el ID del proceso principal. Después de la instalación, el nombre del archivo siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [pid](https://es.angie.software//angie/docs/configuration/modules/core.md#pid). | `/logs/angie.pid` |
| `--lock-path=`path | Establece el prefijo para los nombres de archivos de bloqueo. Tras la instalación, el valor siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [lock_file](https://es.angie.software//angie/docs/configuration/modules/core.md#lock-file). | `/logs/angie.lock` |
| `--http-acme-client-path=`path | Establece el directorio para almacenar certificados y claves para los bloques `server` que tengan definidas directivas [acme](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1). | `/acme_client` |
| `--http-log-path=`path | Establece el nombre del archivo principal de registro de solicitudes para el servidor HTTP. Tras la instalación, el nombre del archivo siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [access_log](https://es.angie.software//angie/docs/configuration/modules/http/http_log.md#access-log). | `/logs/access.log` |
| `--http-client-body-temp-path=`path | Define el directorio para almacenar archivos temporales que contienen los cuerpos de las solicitudes del cliente. Tras la instalación, el directorio siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [client_body_temp_path](https://es.angie.software//angie/docs/configuration/modules/http/index.md#client-body-temp-path). | `/client_body_temp` |
| `--http-proxy-temp-path=`path | Define el directorio para almacenar archivos temporales con datos recibidos de servidores proxy. Tras la instalación, el directorio siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [proxy_temp_path](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-temp-path). | `/proxy_temp` |
| `--http-fastcgi-temp-path=`path | Define el directorio para almacenar archivos temporales con datos recibidos de servidores FastCGI. Tras la instalación, el directorio siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [fastcgi_temp_path](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-temp-path). | `/fastcgi_temp` |
| `--http-uwsgi-temp-path=`path | Define el directorio para almacenar archivos temporales con datos recibidos de servidores uWSGI. Tras la instalación, el directorio siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [uwsgi_temp_path](https://es.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-temp-path). | `/uwsgi_temp` |
| `--http-scgi-temp-path=`path | Define el directorio para almacenar archivos temporales con datos recibidos de servidores SCGI. Tras la instalación, el directorio siempre puede cambiarse en el archivo de configuración `angie.conf` usando la directiva [scgi_temp_path](https://es.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-temp-path). | `/scgi_temp` |
### Funciones y dependencias
| `--with-select_module`, `--without-select_module` | Activa o desactiva la compilación de un módulo que permite al servidor trabajar con el método `select()`. Este módulo se compila automáticamente si la plataforma no parece admitir métodos más adecuados como `kqueue`, `epoll` o `/dev/poll`. |
|-----------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--with-poll_module`, `--without-poll_module` | Activa o desactiva la compilación de un módulo que permite al servidor trabajar con el método `poll()`. Este módulo se compila automáticamente si la plataforma no parece admitir métodos más adecuados como `kqueue`, `epoll` o `/dev/poll`. |
| `--with-threads` | Activa el uso de [pools de hilos](https://es.angie.software//angie/docs/configuration/modules/core.md#thread-pool) (modo `aio threads`). |
| `--with-file-aio` | Activa el uso de [E/S de archivos asíncrona](https://es.angie.software//angie/docs/configuration/modules/http/index.md#aio) (AIO) en FreeBSD y Linux (modo `aio on`). |
| `--with-debug` | Activa el [registro de depuración](https://es.angie.software//angie/docs/troubleshooting.md#debug-logging). |
| `--without-http-cache` | Desactiva la caché HTTP. |
| `--with-pcre`, `--with-pcre=`path | Activa el uso de la biblioteca PCRE.
El parámetro opcional establece la ruta a las fuentes de la biblioteca PCRE. La distribución de la biblioteca debe descargarse del sitio [PCRE](http://www.pcre.org/) y extraerse. El resto lo realizan los comandos **./configure** y **make** de Angie.
La biblioteca es **necesaria** para el soporte de expresiones regulares en la directiva `location` y para el módulo [Rewrite](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#http-rewrite). |
| `--with-pcre-opt=`parameters | Establece parámetros adicionales de compilación para PCRE. |
| `--with-pcre-jit` | Compila la biblioteca PCRE con soporte de compilación JIT (la directiva [pcre_jit](https://es.angie.software//angie/docs/configuration/modules/core.md#pcre-jit)). |
| `--without-pcre` | Desactiva el uso de la biblioteca PCRE. |
| `--without-pcre2` | Desactiva el uso de la biblioteca PCRE2 en lugar de la biblioteca PCRE original. |
| `--with-libatomic`, `--with-libatomic=`path | Activa la compilación con la biblioteca **libatomic_ops**. El parámetro opcional establece la ruta a las fuentes de la biblioteca. |
| `--with-openssl=`path | Activa la compilación estática y establece la ruta a las fuentes de la biblioteca OpenSSL. AWS-LC puede usarse como biblioteca compatible con OpenSSL. |
| `--with-openssl-opt=`parameters | Establece parámetros adicionales de compilación para OpenSSL. |
| `--with-ntls` | Activa el soporte NTLS en el módulo HTTP ([lado servidor](https://es.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-ntls), [lado cliente](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-ssl-ntls)) y en el módulo stream ([lado servidor](https://es.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#s-ssl-ntls), [lado cliente](https://es.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-ssl-ntls)) al compilar con una biblioteca SSL que admita NTLS. |
| `--with-zlib=`path | Establece la ruta a las fuentes de la biblioteca zlib. La distribución de la biblioteca (versión 1.1.3 o posterior) debe descargarse del [sitio de zlib](https://zlib.net/) y extraerse; las versiones anteriores a la actual se archivan en [zlib fossils](https://zlib.net/fossils/). El resto lo realizan los comandos **./configure** y **make** de Angie.
La biblioteca es **necesaria** para el módulo [GZip](https://es.angie.software//angie/docs/configuration/modules/http/http_gzip.md#http-gzip). |
| `--with-zlib-opt=`parameters | Establece parámetros adicionales de compilación para zlib. |
| `--with-zlib-asm=`cpu | Activa el uso de optimizaciones en ensamblador para compilar zlib, optimizadas para uno de los siguientes procesadores: `pentium`, `pentiumpro`. |
### Activación y desactivación de módulos
Puedes desactivar módulos que están activados por defecto o activar
módulos que están disponibles pero desactivados por defecto.
#### HTTP
Activación de módulos adicionales:
| `--with-http_acme_module` | Activa la compilación del módulo [ACME](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme), que habilita el protocolo ACME. |
|----------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--with-http_addition_module` | Activa la compilación del módulo [Addition](https://es.angie.software//angie/docs/configuration/modules/http/http_addition.md#http-addition) que permite añadir texto antes y después de una respuesta. |
| `--with-http_auth_request_module` | Activa la compilación del módulo [Auth Request](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request) que proporciona capacidad de autorización del cliente basada en el resultado de una subsolicitud. |
| `--with-http_dav_module` | Activa la compilación del módulo [DAV](https://es.angie.software//angie/docs/configuration/modules/http/http_dav.md#http-dav) destinado a automatizar tareas de gestión de archivos en el servidor mediante el protocolo WebDAV. |
| `--with-http_degradation_module` | Activa la compilación del módulo Degradation que permite devolver los códigos de estado HTTP 204 o 444 para ciertos bloques `location`.
Este módulo solo puede usarse en los casos en que `sbrk(0)` muestra la cantidad real de memoria asignada al proceso. En otras palabras, el módulo funciona en FreeBSD hasta la versión 7.0 por defecto. A partir de la versión 7.0, solo funciona si se establece `MALLOC_OPTIONS=Dm`. En Linux no funciona. |
| `--with-http_flv_module` | Activa la compilación del módulo [FLV](https://es.angie.software//angie/docs/configuration/modules/http/http_flv.md#http-flv) que proporciona soporte de pseudo-streaming en el servidor para archivos Flash Video (FLV). |
| `--with-http_geoip_module`, `--with-http_geoip_module=dynamic` | Activa la compilación del módulo [GeoIP](https://es.angie.software//angie/docs/configuration/modules/http/http_geoip.md#http-geoip) que crea variables cuyos valores se determinan en función de la dirección IP del cliente y de las bases de datos preparadas de [MaxMind](http://www.maxmind.com/). |
| `--with-http_gunzip_module` | Activa la compilación del módulo [GunZIP](https://es.angie.software//angie/docs/configuration/modules/http/http_gunzip.md#http-gunzip) que permite descomprimir respuestas con `Content-Encoding: gzip` para clientes que no admiten el método de compresión `gzip`. |
| `--with-http_gzip_static_module` | Activa la compilación del módulo [Gzip Static](https://es.angie.software//angie/docs/configuration/modules/http/http_gzip_static.md#http-gzip-static) que permite servir un archivo precomprimido con el mismo nombre y la extensión `.gz` en lugar de un archivo normal. |
| `--with-http_image_filter_module`, `--with-http_image_filter_module=dynamic` | Activa la compilación del módulo [Image Filter](https://es.angie.software//angie/docs/configuration/modules/http/http_image_filter.md#http-image-filter) que permite transformar imágenes en formatos JPEG, GIF, PNG y WebP. |
| `--with-http_mp4_module` | Activa la compilación del módulo [MP4](https://es.angie.software//angie/docs/configuration/modules/http/http_mp4.md#http-mp4) que proporciona soporte de pseudo-streaming en el servidor para archivos en formato MP4. |
| `--with-http_perl_module`, `--with-http_perl_module=dynamic` | Activa la compilación del módulo [Perl](https://es.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl). |
| `--with-perl_modules_path=`path | Establece el directorio donde se ubicarán los archivos de módulos de Perl. |
| `--with-perl=`path | Establece el nombre del archivo ejecutable de Perl. |
| `--with-http_random_index_module` | Activa la compilación del módulo [Random Index](https://es.angie.software//angie/docs/configuration/modules/http/http_random_index.md#http-random-index) que atiende solicitudes que terminan con una barra (`/`) y devuelve un archivo aleatorio como archivo índice del directorio. |
| `--with-http_realip_module` | Activa la compilación del módulo [RealIP](https://es.angie.software//angie/docs/configuration/modules/http/http_realip.md#http-realip) que permite cambiar la dirección del cliente por la pasada en el campo de cabecera especificado. |
| `--with-http_secure_link_module` | Activa la compilación del módulo [Secure Link](https://es.angie.software//angie/docs/configuration/modules/http/http_secure_link.md#http-secure-link). |
| `--with-http_slice_module` | Activa la compilación del módulo [Slice](https://es.angie.software//angie/docs/configuration/modules/http/http_slice.md#http-slice) que permite dividir una solicitud en subsolicitudes, cada una devolviendo un rango específico de la respuesta. El módulo proporciona almacenamiento en caché eficiente de respuestas grandes. |
| `--with-http_ssl_module` | Activa el soporte [SSL](https://es.angie.software//angie/docs/configuration/modules/http/http_ssl.md#http-ssl) para el servidor HTTP.
La biblioteca OpenSSL es **necesaria** para este módulo. |
| `--with-http_stub_status_module` | Activa la compilación del módulo [Stub Status](https://es.angie.software//angie/docs/configuration/modules/http/http_stub_status.md#http-stub-status) que proporciona acceso a información básica del estado del servidor. |
| `--with-http_sub_module` | Activa la compilación del módulo [Sub](https://es.angie.software//angie/docs/configuration/modules/http/http_sub.md#http-sub) que permite modificar una cadena especificada en la respuesta por otra. |
| `--with-http_v2_module` | Activa el módulo [HTTP/2](https://es.angie.software//angie/docs/configuration/modules/http/http_v2.md#http-v2). |
| `--with-http_v3_module` | Activa el módulo [HTTP/3](https://es.angie.software//angie/docs/configuration/modules/http/http_v3.md#http-v3). |
#### NOTE
Para compilar, se **recomienda encarecidamente** usar una biblioteca SSL
que admita el protocolo [QUIC](https://www.rfc-editor.org/rfc/rfc9000.html):
BoringSSL
Compilación con [BoringSSL](https://boringssl.googlesource.com/boringssl):
```console
$ ./configure \
--with-debug \
--with-http_v3_module \
--with-cc-opt="-I../boringssl/include" \
--with-ld-opt="-L../boringssl/build/ssl -L../boringssl/build/crypto"
```
LibreSSL
Compilación con [LibreSSL](https://www.libressl.org/):
```console
$ ./configure \
--with-debug \
--with-http_v3_module \
--with-cc-opt="-I../libressl/build/include" \
--with-ld-opt="-L../libressl/build/lib"
```
QuicTLS
Compilación con [QuicTLS](https://github.com/quictls/openssl):
```console
$ ./configure \
--with-debug \
--with-http_v3_module \
--with-cc-opt="-I../quictls/build/include" \
--with-ld-opt="-L../quictls/build/lib"
```
Sin esto, la biblioteca [OpenSSL](https://openssl.org/) se usará en modo de compatibilidad, donde no se admite
el envío de [early data](https://datatracker.ietf.org/doc/html/rfc8446#section-2.3) y faltan otras
funciones, como la reutilización de sesión. Dicha compilación podrá interactuar
**solo** con clientes y servidores
que usen OpenSSL en el mismo modo.
Este respaldo es silencioso: si la biblioteca SSL configurada falta o no se
puede usar, **./configure** utiliza el OpenSSL del sistema en lugar de
informar de un error. Cuando termine, comprueba el `Configuration
summary`: una línea que indique `+ using system OpenSSL library` significa
que no se ha tomado la biblioteca compatible con QUIC prevista.
| `--with-http_xslt_module`, `--with-http_xslt_module=dynamic` | Activa la compilación del módulo [XSLT](https://es.angie.software//angie/docs/configuration/modules/http/http_xslt.md#http-xslt) que permite transformar respuestas XML usando hojas de estilo XSLT.
Las bibliotecas **libxml2** y **libxslt** son **necesarias** para este módulo. |
|----------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--with-google_perftools_module` | Activa la compilación del módulo [Google PerfTools](https://es.angie.software//angie/docs/configuration/modules/google_perftools.md#google-perftools) que proporciona soporte para perfilar los procesos worker de Angie usando [Google Performance Tools](https://github.com/gperftools/gperftools). El módulo está destinado a desarrolladores de Angie. |
Desactivación de módulos estándar:
| `--without-http` | Desactiva el servidor [HTTP](https://es.angie.software//angie/docs/configuration/modules/http/index.md#http-core). |
|---------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--without-http_access_module` | Desactiva la compilación del módulo [Access](https://es.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access) que permite limitar el acceso a ciertas direcciones de cliente. |
| `--without-http_api_module` | Desactiva la compilación del módulo [API](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#http-api) que proporciona una interfaz HTTP RESTful para acceder a información basada en JSON sobre la instancia del servidor web. |
| `--without-http_metric_module` | Desactiva la compilación del módulo [Metric](https://es.angie.software//angie/docs/configuration/modules/http/http_metric.md#http-metric). |
| `--without-http_auth_basic_module` | Desactiva la compilación del módulo [Auth Basic](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic) que permite limitar el acceso a recursos validando el nombre de usuario y la contraseña mediante el protocolo HTTP Basic Authentication. |
| `--without-http_autoindex_module` | Desactiva la compilación del módulo [AutoIndex](https://es.angie.software//angie/docs/configuration/modules/http/http_autoindex.md#http-autoindex) que procesa solicitudes que terminan con el carácter barra (`/`) y genera un listado del directorio en caso de que el módulo [Index](https://es.angie.software//angie/docs/configuration/modules/http/http_index.md#http-index) no pueda encontrar un archivo índice. |
| `--without-http_browser_module` | Desactiva la compilación del módulo [Browser](https://es.angie.software//angie/docs/configuration/modules/http/http_browser.md#http-browser) que crea variables cuyos valores dependen del valor del campo de cabecera `User-Agent` de la solicitud. |
| `--without-http_charset_module` | Desactiva la compilación del módulo [Charset](https://es.angie.software//angie/docs/configuration/modules/http/http_charset.md#http-charset) que añade el charset especificado al campo de cabecera de respuesta `Content-Type` y, adicionalmente, puede convertir datos de un charset a otro. |
| `--without-http_empty_gif_module` | Desactiva la compilación del [módulo](https://es.angie.software//angie/docs/configuration/modules/http/http_empty_gif.md#http-empty-gif) que emite un GIF transparente de un píxel. |
| `--without-http_fastcgi_module` | Desactiva la compilación del módulo [FastCGI](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#http-fastcgi) que envía solicitudes a un servidor FastCGI. |
| `--without-http_geo_module` | Desactiva la compilación del módulo [Geo](https://es.angie.software//angie/docs/configuration/modules/http/http_geo.md#http-geo) que crea variables con valores que dependen de la dirección IP del cliente. |
| `--without-http_gzip_module` | Desactiva la compilación del [módulo](https://es.angie.software//angie/docs/configuration/modules/http/http_gzip.md#http-gzip) que comprime las respuestas del servidor HTTP.
La biblioteca zlib es **necesaria** para este módulo. |
| `--without-http_grpc_module` | Desactiva la compilación del módulo [gRPC](https://es.angie.software//angie/docs/configuration/modules/http/http_grpc.md#http-grpc) que envía solicitudes a un servidor gRPC. |
| `--without-http_limit_conn_module` | Desactiva la compilación del módulo [Limit Conn](https://es.angie.software//angie/docs/configuration/modules/http/http_limit_conn.md#http-limit-conn) que limita el número de conexiones por clave, por ejemplo, el número de conexiones desde una única dirección IP. |
| `--without-http_limit_req_module` | Desactiva la compilación del módulo [Limit Req](https://es.angie.software//angie/docs/configuration/modules/http/http_limit_req.md#http-limit-req) que limita la velocidad de procesamiento de solicitudes por clave, por ejemplo, la velocidad de procesamiento de solicitudes provenientes de una única dirección IP. |
| `--without-http_map_module` | Desactiva la compilación del módulo [Map](https://es.angie.software//angie/docs/configuration/modules/http/http_map.md#http-map) que crea variables con valores que dependen de los valores de otras variables. |
| `--without-http_memcached_module` | Desactiva la compilación del módulo [Memcached](https://es.angie.software//angie/docs/configuration/modules/http/http_memcached.md#http-memcached) que obtiene respuestas de un servidor memcached. |
| `--without-http_mirror_module` | Desactiva la compilación del módulo [Mirror](https://es.angie.software//angie/docs/configuration/modules/http/http_mirror.md#http-mirror) que implementa el mirroring de una solicitud original creando subsolicitudes espejo en segundo plano. |
| `--without-http_prometheus_module` | Desactiva la compilación del módulo [Prometheus](https://es.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#http-prometheus) para el servidor HTTP. |
| `--without-http_proxy_module` | Desactiva la compilación del módulo [Proxy](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy) para el servidor HTTP. |
| `--without-http_referer_module` | Desactiva la compilación del módulo [Referer](https://es.angie.software//angie/docs/configuration/modules/http/http_referer.md#http-referer) que puede bloquear el acceso a un sitio para solicitudes con valores no válidos en el campo de cabecera `Referer`. |
| `--without-http_rewrite_module` | Desactiva la compilación del módulo [Rewrite](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#http-rewrite) que permite al servidor HTTP redirigir solicitudes y cambiar sus URIs.
La biblioteca PCRE es **necesaria** para este módulo. |
| `--without-http_scgi_module` | Desactiva la compilación del módulo [SCGI](https://es.angie.software//angie/docs/configuration/modules/http/http_scgi.md#http-scgi) que envía solicitudes a un servidor SCGI. |
| `--without-http_split_clients_module` | Desactiva la compilación del módulo [Split Clients](https://es.angie.software//angie/docs/configuration/modules/http/http_split_clients.md#http-split-clients) que crea variables para pruebas A/B. |
| `--without-http_ssi_module` | Desactiva la compilación del módulo [SSI](https://es.angie.software//angie/docs/configuration/modules/http/http_ssi.md#http-ssi) que procesa comandos SSI (Server Side Includes) en respuestas que pasan a través de él. |
| `--without-http_upstream_hash_module` | Desactiva la compilación del módulo que implementa el método de balanceo de carga [hash](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-hash). |
| `--without-http_upstream_ip_hash_module` | Desactiva la compilación del módulo que implementa el método de balanceo de carga [ip_hash](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-ip-hash). |
| `--without-http_upstream_keepalive_module` | Desactiva la compilación del módulo que proporciona [caché de conexiones](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-keepalive) hacia servidores upstream. |
| `--without-http_upstream_least_conn_module` | Desactiva la compilación del módulo que implementa el método de balanceo de carga [least_conn](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-least-conn). |
| `--without-http_upstream_random_module` | Desactiva la compilación del módulo que implementa el método de balanceo de carga [random](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-random). |
| `--without-http_upstream_sticky_module` | Desactiva la compilación del módulo que implementa la [persistencia de sesión](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-sticky), garantizando que todas las solicitudes en la sesión del cliente se envíen al mismo servidor en el upstream. |
| `--without-http_upstream_zone_module` | Desactiva la compilación del módulo que permite almacenar el estado en tiempo de ejecución de un upstream en una [zona de memoria compartida](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone). |
| `--without-http_userid_module` | Desactiva la compilación del módulo [UserID](https://es.angie.software//angie/docs/configuration/modules/http/http_userid.md#http-userid) que establece cookies adecuadas para la identificación del cliente. |
| `--without-http_uwsgi_module` | Desactiva la compilación del módulo [uWSGI](https://es.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#http-uwsgi) que envía solicitudes a un servidor uWSGI. |
#### Módulos Stream
Activación de módulos adicionales:
#### \* - `--with-stream`, `--with-stream=dynamic` - Activa el módulo principal [Stream](https://es.angie.software//angie/docs/configuration/modules/stream/index.md#stream-core) para proxying genérico TCP/UDP y balanceo de carga.
| `--with-stream_acme_module` | Activa la compilación del módulo [ACME](https://es.angie.software//angie/docs/configuration/modules/stream/stream_acme.md#stream-acme), que habilita el protocolo ACME. |
|--------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--with-stream_geoip_module`, `--with-stream_geoip_module=dynamic` | Activa el módulo [GeoIP](https://es.angie.software//angie/docs/configuration/modules/stream/stream_geoip.md#stream-geoip) que crea variables en función de la dirección IP del cliente y de las bases de datos precompiladas [MaxMind](http://www.maxmind.com/). |
| `--with-stream_mqtt_preread_module` | Activa el módulo [MQTT Preread](https://es.angie.software//angie/docs/configuration/modules/stream/stream_mqtt_preread.md#stream-mqtt-preread) que permite extraer IDs de cliente y nombres de usuario de paquetes `CONNECT` en las versiones MQTT [3.1.1](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718028) y [5.0](https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901033). |
| `--with-stream_rdp_preread_module` | Activa el módulo [RDP Preread](https://es.angie.software//angie/docs/configuration/modules/stream/stream_rdp_preread.md#stream-rdp-preread) que permite extraer cookies de sesiones RDP. |
| `--with-stream_realip_module` | Activa el módulo [RealIP](https://es.angie.software//angie/docs/configuration/modules/stream/stream_realip.md#stream-realip) que cambia la dirección del cliente por la dirección enviada en la cabecera del protocolo PROXY. |
| `--with-stream_ssl_module` | Activa el soporte [SSL](https://es.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#stream-ssl) para el servidor Stream.
La biblioteca OpenSSL es **necesaria** para compilar y ejecutar este módulo. |
| `--with-stream_ssl_preread_module` | Activa el módulo [SSL Preread](https://es.angie.software//angie/docs/configuration/modules/stream/stream_ssl_preread.md#stream-ssl-preread) que permite extraer información de los mensajes [ClientHello](https://datatracker.ietf.org/doc/html/rfc5246#section-7.4.1.2) sin terminar SSL/TLS. |
| `--with-stream_upstream_probe_icmp` (PRO) | Activa las sondas de eco ICMP para la directiva [upstream_probe (PRO)](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#s-u-upstream-probe). Requiere soporte ICMP del sistema operativo. |
Desactivación de módulos estándar:
#### \* - `--without-stream_access_module` - Desactiva el módulo [Access](https://es.angie.software//angie/docs/configuration/modules/stream/stream_access.md#stream-access) que permite limitar el acceso a ciertas direcciones de cliente.
| `--without-stream_geo_module` | Desactiva el módulo [Geo](https://es.angie.software//angie/docs/configuration/modules/stream/stream_geo.md#stream-geo) que crea variables con valores que dependen de la dirección IP del cliente. |
|-----------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--without-stream_limit_conn_module` | Desactiva el módulo [Limit Conn](https://es.angie.software//angie/docs/configuration/modules/stream/stream_limit_conn.md#stream-limit-conn) que limita el número de conexiones por clave, por ejemplo, el número de conexiones desde una única dirección IP. |
| `--without-stream_map_module` | Desactiva el módulo [Map](https://es.angie.software//angie/docs/configuration/modules/stream/stream_map.md#stream-map) que crea variables con valores que dependen de los valores de otras variables. |
| `--without-stream_return_module` | Desactiva el módulo [Return](https://es.angie.software//angie/docs/configuration/modules/stream/stream_return.md#stream-return) que envía el valor especificado al cliente y luego cierra la conexión. |
| `--without-stream_set_module` | Desactiva el módulo [Set](https://es.angie.software//angie/docs/configuration/modules/stream/stream_set.md#stream-set) que establece un valor para una variable. |
| `--without-stream_split_clients_module` | Desactiva el módulo [Split Clients](https://es.angie.software//angie/docs/configuration/modules/stream/stream_split_clients.md#stream-split-clients) que crea variables para pruebas A/B. |
| `--without-stream_upstream_hash_module` | Desactiva el módulo que implementa el método de balanceo de carga [hash](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-hash). |
| `--without-stream_upstream_least_conn_module` | Desactiva el módulo que implementa el método de balanceo de carga [least_conn](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-least-conn). |
| `--without-stream_upstream_random_module` | Desactiva el módulo que implementa el método de balanceo de carga [random](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-random). |
| `--without-stream_upstream_zone_module` | Desactiva el módulo que permite almacenar el estado en tiempo de ejecución de un upstream en una [zona de memoria compartida](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-zone). |
#### Mail
Activación de módulos adicionales:
#### \* - `--with-mail`, `--with-mail=dynamic` - Activa el módulo principal [Mail](https://es.angie.software//angie/docs/configuration/modules/mail/index.md#mail-core) que admite POP3, IMAP4 y SMTP.
| `--with-mail_ssl_module` | Activa el soporte [SSL](https://es.angie.software//angie/docs/configuration/modules/mail/mail_ssl.md#mail-ssl) para el servidor Mail.
La biblioteca OpenSSL es **necesaria** para compilar y ejecutar este módulo. |
|----------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
Desactivación de módulos estándar:
#### \* - `--without-mail_imap_module` - Desactiva el protocolo [IMAP](https://es.angie.software//angie/docs/configuration/modules/mail/mail_imap.md#mail-imap) en el servidor Mail.
| `--without-mail_pop3_module` | Desactiva el protocolo [POP3](https://es.angie.software//angie/docs/configuration/modules/mail/mail_pop3.md#mail-pop3) en el servidor Mail. |
|--------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------|
| `--without-mail_smtp_module` | Desactiva el protocolo [SMTP](https://es.angie.software//angie/docs/configuration/modules/mail/mail_smtp.md#mail-smtp) en el servidor Mail. |
#### Otras opciones
#### \* - `--with-cpp_test_module` - Activa el módulo de pruebas CPP. Se utiliza principalmente para desarrollo y pruebas y no está destinado a uso en producción.
| `--add-module=`path | Activa la compilación de un módulo externo en la ruta especificada. |
|-----------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--add-dynamic-module=`path | Activa la compilación de un módulo dinámico externo en la ruta especificada. |
| `--with-compat` | Activa el modo de compatibilidad de módulos dinámicos. Cuando está habilitado, Angie puede cargar y usar módulos dinámicos que se hayan compilado para la misma versión de Angie, incluso si dichos módulos se compilaron con opciones diferentes. Angie PRO solo puede cargar módulos compilados para Angie PRO; los módulos de Angie (OSS) se rechazan debido a una firma de módulo diferente. |
| `--with-cc=`path | Establece el compilador que se usará durante la compilación. |
| `--with-cpp=`path | Establece el preprocesador que se usará durante la compilación. |
| `--with-cc-opt=`parameters | Establece parámetros adicionales que se añadirán a la variable `CFLAGS`. Al usar la biblioteca PCRE del sistema en FreeBSD, se debe especificar `--with-cc-opt="-I /usr/local/include"`. Si es necesario aumentar el número de archivos admitidos por `select()`, también puede especificarse aquí, por ejemplo `--with-cc-opt="-D FD_SETSIZE=2048"`. |
| `--with-ld-opt=`parameters | Establece parámetros adicionales que se usarán durante el enlace. Al usar la biblioteca PCRE del sistema en FreeBSD, se debe especificar `--with-ld-opt="-L /usr/local/lib"`. |
| `--with-cpu-opt=`cpu | Activa compilaciones optimizadas para uno de los siguientes procesadores: `pentium`, `pentiumpro`, `pentium3`, `pentium4`, `athlon`, `opteron`, `sparc32`, `sparc64`, `ppc64`. |
### Ejemplos
**Compilación simple con HTTPS habilitado**. Esta configuración básica habilita el soporte HTTPS
usando SSL/TLS, con las dependencias necesarias (PCRE para expresiones regulares,
zlib para compresión y OpenSSL para SSL/TLS):
```console
$ ./configure \
--sbin-path=/usr/sbin/angie \
--conf-path=/etc/angie/angie.conf \
--pid-path=/run/angie.pid \
--with-http_ssl_module \
--with-pcre=../pcre2-10.40 \
--with-zlib=../zlib-1.3 \
--with-openssl=../openssl-3.0.8
```
**Compilación optimizada para rendimiento**. Esta configuración está optimizada para el rendimiento,
incluye soporte HTTP/2, compresión estática **gzip**, JIT para PCRE y
E/S asíncrona; también se habilitan pools de hilos para el manejo eficiente de cargas altas:
```console
$ ./configure \
--sbin-path=/usr/sbin/angie \
--conf-path=/etc/angie/angie.conf \
--pid-path=/run/angie.pid \
--with-http_ssl_module \
--with-http_v2_module \
--with-http_gzip_static_module \
--with-pcre=../pcre2-10.40 \
--with-pcre-jit \
--with-zlib=../zlib-1.3 \
--with-threads \
--with-file-aio
```
**Balanceador de carga con proxying TCP/UDP**. Esta configuración configura un balanceador
de carga para servicios HTTP y no HTTP:
```console
$ ./configure \
--sbin-path=/usr/sbin/angie \
--conf-path=/etc/angie/angie.conf \
--pid-path=/run/angie.pid \
--with-stream \
--with-stream_ssl_module \
--with-pcre=../pcre2-10.40 \
--with-zlib=../zlib-1.3
```
**Compilación especializada**. Esta configuración incluye HTTPS, HTTP/2, compresión,
seguridad y rendimiento mejorados, junto con módulos adicionales para compresión Brotli
y gestión de caché, optimizada tanto para proxying HTTP como TCP/UDP:
```console
$ ./configure \
--prefix=/usr/local/angie \
--sbin-path=/usr/sbin/angie \
--conf-path=/etc/angie/angie.conf \
--pid-path=/run/angie.pid \
--lock-path=/var/lock/angie.lock \
--error-log-path=/var/log/angie/error.log \
--http-log-path=/var/log/angie/access.log \
--with-http_ssl_module \
--with-http_v2_module \
--with-http_realip_module \
--with-http_gzip_static_module \
--with-http_stub_status_module \
--with-threads \
--with-file-aio \
--with-stream \
--with-stream_ssl_module \
--with-pcre=../pcre2-10.40 \
--with-pcre-jit \
--with-zlib=../zlib-1.3 \
--with-openssl=../openssl-3.0.8 \
--with-openssl-opt="enable-ec_nistp_64_gcc_128" \
--add-module=../ngx_brotli \
--add-dynamic-module=../ngx_cache_purge
```
Las opciones `--add-module` y `--add-dynamic-module` anteriores
hacen referencia a fuentes de módulos de terceros que descargas por separado. Por
ejemplo, clónalas junto al árbol de fuentes de Angie:
```console
$ git clone --recurse-submodules https://github.com/google/ngx_brotli
$ git clone https://github.com/nginx-modules/ngx_cache_purge
```
Consulta [Módulos de terceros](https://es.angie.software//angie/docs/installation/external-modules/index.md#install-thirdpartymodules) para conocer los
módulos que Angie empaqueta y sus fuentes.
# https://es.angie.software/angie/docs/installation/pro_packages.md
# Instalación de Angie PRO mediante paquetes
Para acceder al repositorio de paquetes, debe firmar un contrato y adquirir una licencia. Para preguntas sobre licencias, contratos y compilaciones personalizadas, póngase en contacto con:
- [info@wbsrv.ru](mailto:info@wbsrv.ru)
- [https://angie.software/](https://angie.software/)
- +7 (495) 120 50 33
Luego, configure el repositorio para el gestor de paquetes de su distribución para instalar y actualizar Angie PRO y los [módulos dinámicos](#install-dynamicmodules-pro) que necesite. Finalmente, instale el [archivo de licencia](#install-license) y elimine las restricciones.
## Distribuciones
| Nombre | Versiones | Arquitecturas |
|-----------------------------------|--------------------------------|-------------------------------|
| [AlmaLinux](#install-yum-pro) | 10, 9, 8 | x86-64, arm64 |
| [Alpine](#install-alpine-pro) | 3.23, 3.22, 3.21 | x86-64, arm64 |
| [Alt](#install-alt-pro) | 11, 10 8 | x86-64, arm64 x86-64 |
| [Astra SE](#install-astrase-pro) | 4.7 1.8, 1.7 | arm64 x86-64 |
| [CentOS](#install-yum-pro) | 10, 9 | x86-64, arm64 |
| [Debian](#install-deb-pro) | 13, 12, 11 | x86-64, arm64 |
| [Fedora](#install-yum-pro) | 44, 43 | x86-64, arm64 |
| [FreeBSD](#install-freebsd-pro) | 15, 14 | x86-64, arm64 |
| [MSVSphere](#install-yum-pro) | 10, 9 8 | x86-64, arm64 x86-64 |
| [openSUSE](#install-opensuse-pro) | 16, 15 | x86-64, arm64 |
| [Oracle Linux](#install-yum-pro) | 10, 9, 8 | x86-64, arm64 |
| [OSNova](#install-osnova-pro) | 3.3.0, 2.13 | x86-64 |
| [RED OS](#install-yum-pro) | 8, 7 | x86-64, arm64 |
| [Rocky Linux](#install-yum-pro) | 10, 9, 8 | x86-64, arm64 |
| [ROSA](#install-yum-pro) | Chrome 13 Chrome 12 Fresh 12 | x86-64 x86-64, arm64 x86-64 |
| [SberLinux](#install-yum-pro) | 9 | x86-64 |
| [Ubuntu](#install-deb-pro) | 26.04, 24.04, 22.04 | x86-64, arm64 |
### Alma, CentOS, Fedora, MSVSphere, Oracle, RED OS, Rocky, ROSA, SberLinux
1. Cree el directorio `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Transfiera los archivos que recibió con su licencia:
| Tipo de archivo | Nombre original | Dónde colocarlo |
|-------------------|-------------------|---------------------------------|
| Certificado | `angie-repo.crt` | `/etc/ssl/angie/angie-repo.crt` |
| Clave privada | `angie-repo.key` | `/etc/ssl/angie/angie-repo.key` |
3. Para añadir el repositorio,
cree el archivo
`/etc/yum.repos.d/angie.repo`
con el siguiente contenido:
Alma
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/almalinux/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
CentOS
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/centos/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Fedora
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/fedora/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
MSVSphere
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/msvsphere/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Oracle
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/oracle/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
RED OS
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/redos/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Rocky
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/rocky/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
ROSA Chrome
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/rosa-chrome/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
ROSA Fresh
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/rosa/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
SberLinux
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/sberlinux/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
4. Instale el paquete Angie PRO:
```console
$ sudo yum install -y angie-pro
$ # -- OR --
$ sudo dnf install -y angie-pro
```
5. (*Opcional*) Instale cualquier paquete [adicional](#install-extras-pro)
que necesite:
```console
$ sudo yum install -y
$ # -- OR --
$ sudo dnf install -y
```
6. Inicie el servicio:
```console
$ sudo systemctl start angie
```
7. Para iniciar automáticamente Angie PRO después del reinicio del servidor:
```console
$ sudo systemctl enable angie
```
### Alpine
1. Transfiera los archivos que recibió con su licencia:
| Tipo de archivo | Nombre original | Dónde colocar |
|-------------------|-------------------|---------------------|
| Certificado | `angie-repo.crt` | `/etc/apk/cert.pem` |
| Clave privada | `angie-repo.key` | `/etc/apk/cert.key` |
2. Instale los paquetes auxiliares
para añadir el repositorio de Angie PRO:
```console
$ sudo apk update
$ sudo apk add curl ca-certificates
```
3. Descargue la clave pública del repositorio de Angie PRO
para la verificación de paquetes:
```console
$ sudo curl -o /etc/apk/keys/angie-signing.rsa \
https://angie.software/keys/angie-signing.rsa
```
4. Añada el repositorio de Angie PRO:
```console
$ echo "https://download.angie.software/angie-pro/alpine/v$(egrep -o \
'[0-9]+\.[0-9]+' /etc/alpine-release)/main" \
| sudo tee -a /etc/apk/repositories > /dev/null
```
5. Actualice los índices del repositorio:
```console
$ sudo apk update
```
6. Instale el paquete Angie PRO:
```console
$ sudo apk add angie-pro
```
7. (*Opcional*) Instale cualquier paquete [adicional](#install-extras-pro)
que necesite:
```console
$ sudo apk add
```
8. Inicie el servicio:
```console
$ sudo service angie start
```
9. Para iniciar automáticamente Angie PRO después del reinicio del servidor:
```console
$ sudo rc-update add angie
```
### Alt
1. Cree el directorio `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Transfiera los archivos que recibió con su licencia:
| Tipo de archivo | Nombre original | Dónde colocar |
|-------------------|-------------------|---------------------------------|
| Certificado | `angie-repo.crt` | `/etc/ssl/angie/angie-repo.crt` |
| Clave privada | `angie-repo.key` | `/etc/ssl/angie/angie-repo.key` |
3. Descargue la clave pública del repositorio de Angie PRO
para la verificación de paquetes:
```console
$ curl -o ~/angie-signing.gpg https://angie.software/keys/angie-signing.gpg && \
sudo gpg --no-default-keyring --keyring /usr/lib/alt-gpgkeys/pubring.gpg --import ~/angie-signing.gpg
```
4. Guarde la firma de la clave:
```sh
$ echo 'simple-key "angie-pro" {
Fingerprint "EB8EAF3D4EF1B1ECF34865A2617AB978CB849A76";
Name "Angie PRO (Signing Key) ";
}' | sudo tee /etc/apt/vendors.list.d/angie.list > /dev/null
```
5. Añada el repositorio de Angie PRO:
Alt 11
```console
$ echo "rpm [angie-pro] https://download.angie.software/angie-pro/altlinux/11/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt 10
```console
$ echo "rpm [angie-pro] https://download.angie.software/angie-pro/altlinux/10/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt SP 10
```console
$ echo "rpm [angie-pro] https://download.angie.software/angie-pro/altlinux-sp/10/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt SP 8
```console
$ echo "rpm [angie-pro] https://download.angie.software/angie-pro/altlinux-sp/8/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
6. Cree el archivo de configuración `apt` del repositorio de Angie PRO
en `/etc/apt/apt.conf.d`:
```console
$ ( echo 'Acquire::https::Verify-Peer "true";';
echo 'Acquire::https::Verify-Host "true";';
echo 'Acquire::https::SslCert "/etc/ssl/angie/angie-repo.crt";';
echo 'Acquire::https::SslKey "/etc/ssl/angie/angie-repo.key";';
) | sudo tee -a /etc/apt/apt.conf >/dev/null
```
7. Actualice los índices del repositorio:
```console
$ sudo apt-get update
```
8. Instale el paquete Angie PRO:
```console
$ sudo apt-get install -y angie-pro
```
9. (*Opcional*) Instale cualquier paquete [adicional](#install-extras-pro)
que necesite:
```console
$ sudo apt-get install -y
```
10. Inicie el servicio:
```console
$ sudo systemctl start angie
```
11. Para iniciar automáticamente Angie PRO después del reinicio del servidor:
```console
$ sudo systemctl enable angie
```
### Astra SE
1. Cree el directorio `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Transfiera los archivos que recibió con su licencia:
| Tipo de archivo | Nombre original | Dónde colocar |
|-------------------|-------------------|---------------------------------|
| Certificado | `angie-repo.crt` | `/etc/ssl/angie/angie-repo.crt` |
| Clave privada | `angie-repo.key` | `/etc/ssl/angie/angie-repo.key` |
Restrinja el acceso al directorio y archivos:
```console
$ sudo chown -R _apt:nogroup /etc/ssl/angie/
```
3. Instale los paquetes auxiliares
para añadir el repositorio de Angie PRO:
```console
$ sudo apt-get update
$ sudo apt-get install -y apt-transport-https lsb-release \
ca-certificates curl gnupg2
```
4. Descargue la clave pública del repositorio de Angie PRO
para la verificación de paquetes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
5. Añada el repositorio de Angie PRO:
```console
$ echo "deb https://download.angie.software/angie-pro/astra-se/$(egrep -o \
'[0-9]+\.[0-9]+' /etc/astra_version) unstable main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
6. Para configurar el repositorio, cree un archivo
`/etc/apt/apt.conf.d/90download-angie`
con el siguiente contenido:
```console
Acquire::https::download.angie.software::Verify-Peer "true";
Acquire::https::download.angie.software::Verify-Host "true";
Acquire::https::download.angie.software::SslCert "/etc/ssl/angie/angie-repo.crt";
Acquire::https::download.angie.software::SslKey "/etc/ssl/angie/angie-repo.key";
```
7. Actualice los índices del repositorio:
```console
$ sudo apt-get update
```
8. (*Opcional*) Cuando se ejecuta en modo Entorno de Software Cerrado
([CSE](https://wiki.astralinux.ru/pages/viewpage.action?pageId=41190634)),
instale el paquete de clave para verificar la autenticidad de
los archivos ejecutables de Angie PRO:
```console
$ sudo apt-get install -y angie-digsig-key
```
Actualice el CSE:
```console
$ sudo update-initramfs -uk all
```
Luego **reinicie el servidor**:
```console
$ sudo shutdown -r now
```
9. Instale el paquete Angie PRO:
```console
$ sudo apt-get install -y angie-pro
```
10. (*Opcional*) Instale cualquier paquete [adicional](#install-extras-pro)
que necesite:
```console
$ sudo apt-get install -y
```
### Debian, Ubuntu
1. Cree el directorio `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Transfiera los archivos que recibió con su licencia:
| Tipo de Archivo | Nombre Original | Dónde |
|-------------------|-------------------|---------------------------------|
| Certificado | `angie-repo.crt` | `/etc/ssl/angie/angie-repo.crt` |
| Clave Privada | `angie-repo.key` | `/etc/ssl/angie/angie-repo.key` |
Restrinja el acceso al directorio y a los archivos:
```console
$ sudo chown -R _apt:nogroup /etc/ssl/angie/
```
3. Instale los requisitos previos
para añadir el repositorio Angie PRO:
```console
$ sudo apt-get update
$ sudo apt-get install -y apt-transport-https lsb-release \
ca-certificates curl gnupg2
```
4. Descargue la clave pública del repositorio Angie PRO
para la verificación de paquetes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
5. Añada el repositorio Angie PRO:
```console
$ echo "deb https://download.angie.software/angie-pro/$(. /etc/os-release && echo "$ID/$VERSION_ID $VERSION_CODENAME") main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
6. Para configurar el repositorio, cree un archivo llamado
`/etc/apt/apt.conf.d/90download-angie`
con el siguiente contenido:
```console
Acquire::https::download.angie.software::Verify-Peer "true";
Acquire::https::download.angie.software::Verify-Host "true";
Acquire::https::download.angie.software::SslCert "/etc/ssl/angie/angie-repo.crt";
Acquire::https::download.angie.software::SslKey "/etc/ssl/angie/angie-repo.key";
```
7. Actualice los índices del repositorio:
```console
$ sudo apt-get update
```
8. Instale el paquete Angie PRO:
```console
$ sudo apt-get install -y angie-pro
```
9. (*Opcional*) Instale cualquier paquete [extra](#install-extras-pro)
que necesite:
```console
$ sudo apt-get install -y
```
### OSNova
1. Instale los requisitos previos
para añadir el repositorio Angie PRO:
```console
$ sudo apt-get update
$ sudo apt-get install -y ca-certificates curl
```
2. Descargue la clave pública del repositorio Angie PRO
para la verificación de paquetes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
3. Añada el repositorio Angie PRO:
```console
$ echo "deb https://download.angie.software/angie-pro/osnova/$(egrep -o \
'[0-9]*' /etc/osnova_version | head -1) \
$(. /etc/os-release && echo "$VERSION_CODENAME") main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
4. Actualice los índices del repositorio:
```console
$ sudo apt-get update
```
5. Instale el paquete Angie PRO:
```console
$ sudo apt-get install -y angie
```
6. (*Opcional*) Instale cualquier paquete [extra](#install-extras-pro)
que necesite:
```console
$ sudo apt-get install -y
```
### FreeBSD
1. Para añadir el repositorio Angie PRO, cree estos directorios:
```console
$ sudo mkdir -p /usr/local/etc/pkg/angie/ /usr/local/etc/pkg/repos/
```
2. Para configurar el repositorio, cree un archivo llamado
`/usr/local/etc/pkg/repos/angie.conf`
con el siguiente contenido:
```pkgconfig
angie: {
url: "https://download.angie.software/angie-pro/freebsd/${VERSION_MAJOR}/${ARCH}",
signature_type: "pubkey",
pubkey: "/usr/local/etc/pkg/angie/angie-signing.rsa",
enabled: yes
}
```
3. Descargue la clave pública del repositorio Angie PRO
para la verificación de paquetes:
```console
$ sudo curl -o /usr/local/etc/pkg/angie/angie-signing.rsa \
https://angie.software/keys/angie-signing.rsa
```
4. Transfiera los archivos que recibió con su licencia:
| Tipo de Archivo | Nombre Original | Dónde |
|-------------------|-------------------|-------------------------------------------|
| Certificado | `angie-repo.crt` | `/usr/local/etc/pkg/angie/angie-repo.crt` |
| Clave Privada | `angie-repo.key` | `/usr/local/etc/pkg/angie/angie-repo.key` |
5. Añada el certificado y la clave a la configuración del gestor de paquetes:
```sh
$ echo '
PKG_ENV: {
SSL_CLIENT_CERT_FILE: "/usr/local/etc/pkg/angie/angie-repo.crt",
SSL_CLIENT_KEY_FILE: "/usr/local/etc/pkg/angie/angie-repo.key"
}' | sudo tee -a /usr/local/etc/pkg.conf > /dev/null
```
6. Actualice los índices del repositorio:
```console
$ sudo pkg update
```
7. Instale el paquete Angie PRO:
```console
$ sudo pkg install -r angie -y angie-pro
```
8. (*Opcional*) Instale cualquier paquete [extra](#install-extras-pro)
que necesite:
```console
$ sudo pkg install -r angie -y
```
9. Inicie el servicio:
```console
$ sudo service angie start
```
10. Para iniciar automáticamente Angie PRO después del reinicio del servidor:
```console
$ sudo sysrc angie_enable=YES
```
#### NOTE
Dado que el gestor de paquetes de FreeBSD puede determinar incorrectamente la última versión,
utilice el siguiente enfoque para actualizar los paquetes ya instalados:
```console
$ sudo pkg upgrade `pkg search -r angie angie-pro-[0-9] | sort -Vr | head -1 | awk {'print $1'}`
```
### openSUSE
1. Cree el directorio `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Transfiera los archivos que recibió con su licencia:
| Tipo de Archivo | Nombre Original | Dónde |
|-------------------|-------------------|---------------------------------|
| Certificado | `angie-repo.crt` | `/etc/ssl/angie/angie-repo.crt` |
| Clave Privada | `angie-repo.key` | `/etc/ssl/angie/angie-repo.key` |
Luego combínelos en un paquete `/etc/ssl/angie/angie-repo-bundle.crt`:
```console
$ cat /etc/ssl/angie/angie-repo.crt /etc/ssl/angie/angie-repo.key | \
sudo tee -a /etc/ssl/angie/angie-repo-bundle.crt > /dev/null
```
3. Para añadir el repositorio, cree un archivo llamado
`/etc/zypp/repos.d/angie.repo`
con el siguiente contenido:
```ini
[angie-pro]
enabled=1
autorefresh=1
baseurl=https://download.angie.software/angie-pro/opensuse/$releasever_major?ssl_clientcert=/etc/ssl/angie/angie-repo-bundle.crt&ssl_verify=peer
gpgcheck=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
4. Actualice los índices del repositorio:
```console
$ sudo zypper refresh
```
5. Instale el paquete Angie PRO:
```console
$ sudo zypper install -y angie-pro
```
6. (*Opcional*) Instale cualquier paquete [extra](#install-extras-pro)
que necesite:
```console
$ sudo zypper install -y
```
7. Inicie el servicio:
```console
$ sudo systemctl start angie
```
8. Para iniciar automáticamente Angie PRO después del reinicio del servidor:
```console
$ sudo systemctl enable angie
```
## Extras
Además de los paquetes que proporcionan funcionalidad básica,
también publicamos varios paquetes adicionales,
tanto propios como de fuentes de terceros seleccionadas.
### Panel Web Console Light
Console Light es un [panel web de monitorización](https://es.angie.software//angie/docs/configuration/monitoring.md#monitoring) ligero para Angie PRO,
publicado en nuestros repositorios como el paquete `angie-pro-console-light`.
Se instala de la misma manera que el paquete `angie` en las instrucciones anteriores;
para instrucciones de configuración, consulte la sección [Panel de monitorización web Console Light](https://es.angie.software//angie/docs/configuration/monitoring.md#monitoring).
### Módulos Dinámicos
Para ampliar la funcionalidad básica de Angie PRO,
puede añadir varios módulos dinámicos.
Puede obtenerlos como paquetes listos para usar desde nuestro repositorio:
| [angie-pro-module-image-filter](https://es.angie.software//angie/docs/configuration/modules/http/http_image_filter.md#http-image-filter) | Añade transformaciones de imágenes para formatos JPEG, GIF, PNG y WebP. |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------|
| angie-pro-module-njs: [JS](https://es.angie.software//angie/docs/configuration/modules/external-modules/http_js.md#http-js) (HTTP), [JS](https://es.angie.software//angie/docs/configuration/modules/external-modules/stream_js.md#stream-js) (stream) | Permite usar el lenguaje njs (un subconjunto de JavaScript) en la configuración de Angie PRO en los contextos `http` y `stream` respectivamente. |
| [angie-pro-module-perl](https://es.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl) | Permite escribir manejadores de `location` y variables en Perl, así como llamar a Perl desde SSI. |
| [angie-pro-module-xslt](https://es.angie.software//angie/docs/configuration/modules/http/http_xslt.md#http-xslt) | Añade un filtro que transforma respuestas XML usando plantillas XSLT. |
Para aplicar un módulo instalado en su [configuración](https://es.angie.software//angie/docs/configuration/configfile.md#configfile),
cárguelo usando la directiva [load_module](https://es.angie.software//angie/docs/configuration/modules/core.md#load-module) en el contexto `main`:
```nginx
load_module modules/.so;
```
También está disponible una amplia gama de [módulos de terceros](https://es.angie.software//angie/docs/configuration/modules/external-modules/index.md#list-of-modules).
## Archivo de Licencia
Para configurar la licencia de Angie PRO:
1. Guarda el archivo de licencia como `/etc/angie/license.pem`,
estableciendo los mismos permisos que usas para tus
[certificados de cliente](https://es.angie.software//angie/docs/configuration/ssl.md#ssl-config).
2. Verifica que la licencia sea válida;
de lo contrario, comprueba los detalles:
```console
$ sudo angie -t
angie: Valid license found:
angie: - owner: CN=Angie Client License
angie: - period: Jul 8 21:00:00 2024 GMT .. Jul 17 20:59:59 2024 GMT
angie:
angie: Limitations:
angie: - worker_processes_limit: 8
angie: - worker_connections_limit: 0
```
3. Monitoriza la consola y los registros para detectar cualquier problema de licencia.
Si la licencia expira durante la operación,
Angie PRO emite periódicamente las advertencias correspondientes.
Además, al recargar, aparecerán mensajes de error de configuración
si, por ejemplo, se excede el número de procesos de trabajo
especificado en los términos de la licencia.
4. Modifica el archivo `/etc/angie/angie.conf`;
después de la instalación, dos parámetros en él limitan la operación:
```nginx
worker_processes 1;
worker_connections 256;
```
Después de guardar el archivo de licencia,
cámbialos según los términos de tu licencia, por ejemplo:
```nginx
worker_processes 8;
worker_connections 65535;
```
# https://es.angie.software/angie/docs/installation/external-modules.md
# Módulos de Terceros
Además de nuestros propios módulos dinámicos para
[Angie](https://es.angie.software//angie/docs/installation/oss_packages.md#install-dynamicmodules-oss) y [Angie PRO](https://es.angie.software//angie/docs/installation/pro_packages.md#install-dynamicmodules-pro),
recopilamos y publicamos paquetes para varios módulos populares de terceros compatibles con nginx,
desarrollados fuera de nuestra empresa, en nuestro repositorio.
## Instalación y Configuración
Los paquetes de módulos de terceros se instalan desde nuestro repositorio igual que nuestros propios paquetes:
- [Angie](https://es.angie.software//angie/docs/installation/oss_packages.md#oss-packages)
- [Angie PRO](https://es.angie.software//angie/docs/installation/pro_packages.md#pro-packages)
Para usar el módulo instalado en la [configuración](https://es.angie.software//angie/docs/configuration/configfile.md#configfile),
cárgalo usando la directiva [load_module](https://es.angie.software//angie/docs/configuration/modules/core.md#load-module) en el contexto `main`:
```nginx
load_module modules/.so;
```
#### NOTE
No revisamos el código fuente de estos módulos
y no somos responsables de las consecuencias de su instalación;
los paquetes se compilan basándose en numerosas solicitudes
*exclusivamente* para la comodidad del usuario.
## Lista de Módulos
| Módulo | Versión | Paquetes |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------|
| [Auth JWT](https://es.angie.software//angie/docs/configuration/modules/external-modules/auth-jwt.md#external-auth-jwt) | [0.14.2](https://github.com/kjdev/nginx-auth-jwt) | `angie-module-auth-jwt` `angie-pro-module-auth-jwt` |
| [Auth LDAP](https://es.angie.software//angie/docs/configuration/modules/external-modules/auth-ldap.md#external-ldap) | [241200e](https://github.com/kvspb/nginx-auth-ldap) | `angie-module-auth-ldap` `angie-pro-module-auth-ldap` |
| [Auth PAM](https://es.angie.software//angie/docs/configuration/modules/external-modules/auth-pam.md#external-auth-pam) | [v1.5.5](https://github.com/sto/ngx_http_auth_pam_module) | `angie-module-auth-pam` `angie-pro-module-auth-pam` |
| [Auth SPNEGO](https://es.angie.software//angie/docs/configuration/modules/external-modules/auth-spnego.md#external-auth-spnego) | [v1.1.3](https://github.com/stnoonan/spnego-http-auth-nginx-module) | `angie-module-auth-spnego` `angie-pro-module-auth-spnego` |
| [Auth TOTP](https://es.angie.software//angie/docs/configuration/modules/external-modules/auth-totp.md#external-auth-totp) | [1.2.0](https://github.com/61131/nginx-http-auth-totp) | `angie-module-auth-totp` `angie-pro-module-auth-totp` |
| [Brotli](https://es.angie.software//angie/docs/configuration/modules/external-modules/brotli.md#external-brotli) | [v1.0.0rc](https://github.com/google/ngx_brotli) | `angie-module-brotli` `angie-pro-module-brotli` |
| [Cache Purge](https://es.angie.software//angie/docs/configuration/modules/external-modules/cache-purge.md#external-cache-purge) | [3.0.2](https://github.com/nginx-modules/ngx_cache_purge) | `angie-module-cache-purge` `angie-pro-module-cache-purge` |
| [CGI](https://es.angie.software//angie/docs/configuration/modules/external-modules/cgi.md#external-cgi) | [v0.15](https://github.com/pjincz/nginx-cgi) | `angie-module-cgi` `angie-pro-module-cgi` |
| [Combined Upstreams](https://es.angie.software//angie/docs/configuration/modules/external-modules/combined-upstreams.md#external-combined-upstreams) | [2.3.1](https://github.com/lyokha/nginx-combined-upstreams-module) | `angie-module-combined-upstreams` `angie-pro-module-combined-upstreams` |
| [DAV Ext](https://es.angie.software//angie/docs/configuration/modules/external-modules/dav-ext.md#external-dav-ext) | [v4.0.1](https://github.com/arut/nginx-dav-ext-module) | `angie-module-dav-ext` `angie-pro-module-dav-ext` |
| [Dynamic Limit Req](https://es.angie.software//angie/docs/configuration/modules/external-modules/dynamic-limit-req.md#external-dynamic-limit-req) | [1.9.3](https://github.com/limithit/ngx_dynamic_limit_req_module) | `angie-module-dynamic-limit-req` `angie-pro-module-dynamic-limit-req` |
| [Echo](https://es.angie.software//angie/docs/configuration/modules/external-modules/echo.md#external-echo) | [v0.64](https://github.com/openresty/echo-nginx-module) | `angie-module-echo` `angie-pro-module-echo` |
| [Enhanced Memcached](https://es.angie.software//angie/docs/configuration/modules/external-modules/enhanced-memcached.md#external-enhanced-memcached) | [v0.3](https://github.com/bpaquet/ngx_http_enhanced_memcached_module) | `angie-module-enhanced-memcached` `angie-pro-module-enhanced-memcached` |
| [Eval](https://es.angie.software//angie/docs/configuration/modules/external-modules/eval.md#external-eval) | [2016.06.10](https://github.com/openresty/nginx-eval-module) | `angie-module-eval` `angie-pro-module-eval` |
| [GeoIP2](https://es.angie.software//angie/docs/configuration/modules/external-modules/geoip2.md#external-geoip2) | [3.4](https://github.com/leev/ngx_http_geoip2_module) | `angie-module-geoip2` `angie-pro-module-geoip2` |
| [Headers More](https://es.angie.software//angie/docs/configuration/modules/external-modules/headers-more.md#external-headers-more) | [v0.39](https://github.com/openresty/headers-more-nginx-module) | `angie-module-headers-more` `angie-pro-module-headers-more` |
| [HTTP Auth Radius](https://es.angie.software//angie/docs/configuration/modules/external-modules/http-auth-radius.md#external-http-auth-radius) | [458af16](https://github.com/ten0s/ngx_http_auth_radius_module) | `angie-module-http-auth-radius` `angie-pro-module-http-auth-radius` |
| [JWT](https://es.angie.software//angie/docs/configuration/modules/external-modules/jwt.md#external-jwt) | [v3.4.4](https://github.com/max-lt/nginx-jwt-module) | `angie-module-jwt` `angie-pro-module-jwt` |
| [Keyval](https://es.angie.software//angie/docs/configuration/modules/external-modules/keyval.md#external-keyval) | [0.5.0](https://github.com/kjdev/nginx-keyval) | `angie-module-keyval` `angie-pro-module-keyval` |
| [Lua](https://es.angie.software//angie/docs/configuration/modules/external-modules/lua.md#external-lua): [http_lua_module](https://github.com/openresty/lua-nginx-module), [stream_lua_module](https://github.com/openresty/stream-lua-nginx-module) | [0.10.31](https://github.com/openresty/lua-nginx-module) / [v0.0.17](https://github.com/openresty/stream-lua-nginx-module) | `angie-module-lua` `angie-pro-module-lua` |
| [ModSecurity](https://es.angie.software//angie/docs/configuration/modules/external-modules/modsecurity.md#external-modsec) | [v1.0.4](https://github.com/owasp-modsecurity/ModSecurity-nginx) | `angie-module-modsecurity` `angie-pro-module-modsecurity` |
| [NJS](https://es.angie.software//angie/docs/configuration/modules/external-modules/njs.md#external-njs): [http_js](https://es.angie.software//angie/docs/configuration/modules/external-modules/http_js.md#http-js), [stream_js](https://es.angie.software//angie/docs/configuration/modules/external-modules/stream_js.md#stream-js) | [1.0.0](https://nginx.org/en/docs/njs/) | `angie-module-njs` `angie-pro-module-njs` |
| [NDK](https://es.angie.software//angie/docs/configuration/modules/external-modules/ndk.md#external-ndk) | [v0.3.4](https://github.com/vision5/ngx_devel_kit) | `angie-module-ndk` `angie-pro-module-ndk` |
| [OpenTracing](https://es.angie.software//angie/docs/configuration/modules/external-modules/opentracing.md#external-opentracing) | [0.48.0](https://github.com/opentracing-contrib/nginx-opentracing) | `angie-module-opentracing` `angie-pro-module-opentracing` |
| [OpenTelemetry](https://es.angie.software//angie/docs/configuration/modules/external-modules/otel.md#external-otel) | [v0.1.2](https://github.com/nginxinc/nginx-otel) | `angie-module-otel` `angie-pro-module-otel` |
| [PostgreSQL](https://es.angie.software//angie/docs/configuration/modules/external-modules/postgres.md#external-postgres) | [1.0rc7](https://github.com/FRiCKLE/ngx_postgres) | `angie-module-postgres` `angie-pro-module-postgres` |
| [Redis2](https://es.angie.software//angie/docs/configuration/modules/external-modules/redis2.md#external-redis2) | [v0.15](https://github.com/openresty/redis2-nginx-module) | `angie-module-redis2` `angie-pro-module-redis2` |
| [RTMP](https://es.angie.software//angie/docs/configuration/modules/external-modules/rtmp.md#external-rtmp) | [v1.2.2](https://github.com/arut/nginx-rtmp-module) | `angie-module-rtmp` `angie-pro-module-rtmp` |
| [Set Misc](https://es.angie.software//angie/docs/configuration/modules/external-modules/set-misc.md#external-set-misc) | [v0.33](https://github.com/openresty/set-misc-nginx-module) | `angie-module-set-misc` `angie-pro-module-set-misc` |
| [Subs](https://es.angie.software//angie/docs/configuration/modules/external-modules/subs.md#external-subs) | [e12e965](https://github.com/yaoweibin/ngx_http_substitutions_filter_module) | `angie-module-subs` `angie-pro-module-subs` |
| [TestCookie](https://es.angie.software//angie/docs/configuration/modules/external-modules/testcookie.md#external-testcookie) | [7d263d4](https://github.com/kyprizel/testcookie-nginx-module) | `angie-module-testcookie` `angie-pro-module-testcookie` |
| [UnBrotli](https://es.angie.software//angie/docs/configuration/modules/external-modules/unbrotli.md#external-unbrotli) | [60bed63](https://github.com/clyfish/ngx_unbrotli) | `angie-module-unbrotli` `angie-pro-module-unbrotli` |
| [Upload](https://es.angie.software//angie/docs/configuration/modules/external-modules/upload.md#external-upload) | [2.3.0](https://github.com/fdintino/nginx-upload-module) | `angie-module-upload` `angie-pro-module-upload` |
| [VOD](https://es.angie.software//angie/docs/configuration/modules/external-modules/vod.md#external-vod) | [1.9.0](https://github.com/kaltura/nginx-vod-module) | `angie-module-vod` `angie-pro-module-vod` |
| [VTS](https://es.angie.software//angie/docs/configuration/modules/external-modules/vts.md#external-vts): [module-vts](https://github.com/vozlt/nginx-module-vts), [module-sts](https://github.com/vozlt/nginx-module-sts), [module-stream-sts](https://github.com/vozlt/nginx-module-stream-sts) | [v0.2.5](https://github.com/vozlt/nginx-module-vts) / [v0.1.1](https://github.com/vozlt/nginx-module-sts) / [v0.1.1](https://github.com/vozlt/nginx-module-stream-sts) | `angie-module-vts` `angie-pro-module-vts` |
| [ZIP](https://es.angie.software//angie/docs/configuration/modules/external-modules/zip.md#external-zip) | [1.3.0](https://github.com/evanmiller/mod_zip) | `angie-module-zip` `angie-pro-module-zip` |
| [Zstd](https://es.angie.software//angie/docs/configuration/modules/external-modules/zstd.md#external-zstd) | [f4ba115](https://github.com/tokers/zstd-nginx-module) | `angie-module-zstd` `angie-pro-module-zstd` |
# https://es.angie.software/angie/docs/installation/thirdparty.md
# Repositorios de Terceros para Angie
Recomendamos utilizar nuestros paquetes oficiales para instalar Angie:
- [Angie](https://es.angie.software//angie/docs/installation/oss_packages.md#oss-packages)
- [Angie PRO](https://es.angie.software//angie/docs/installation/pro_packages.md#pro-packages)
Si desea utilizar repositorios de terceros
específicos para su sistema o distribución,
las siguientes opciones están actualmente disponibles.
Repositorios oficiales de varias distribuciones Linux:
- [Alt Linux](https://packages.altlinux.org/ru/sisyphus/srpms/angie/)
- [Arch User Repository](https://aur.archlinux.org/packages/angie)
- [FreeBSD FreshPorts](https://www.freshports.org/www/angie/)
- [nixpkgs](https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/servers/http/angie/default.nix)
- [ROSA Linux ABF](https://abf.io/import/angie/)
Gestores de paquetes para macOS:
- [Homebrew](https://github.com/stychos/homebrew-angie):
```console
$ brew tap stychos/angie
$ brew install stychos/angie/angie
```
- [MacPorts](https://github.com/macports/macports-ports/tree/master/www/angie):
```console
$ sudo port install angie
```
Para una lista adicional de fuentes de terceros, consulte [aquí](https://repology.org/project/angie/versions).
#### NOTE
No publicamos nada en estos repositorios
y no nos hacemos responsables de las consecuencias de instalar software desde ellos.
# https://es.angie.software/angie/docs/configuration.md
# Configuración
Esta página contiene artículos, referencias, índices e instrucciones
para configurar Angie.
## Información general
Estos artículos cubren la instalación y configuración de Angie,
iniciar y detener el servidor web, gestionarlo,
así como varios aspectos del procesamiento de solicitudes
y la interacción con otros servidores.
* [Configuración](https://es.angie.software//angie/docs/configuration/configfile.md)
* [Gestión](https://es.angie.software//angie/docs/configuration/runtime.md)
* [Conexiones, Sesiones, Solicitudes, Registros](https://es.angie.software//angie/docs/configuration/processing.md)
## Referencias e índices
Estas secciones de resumen proporcionan información de referencia sobre módulos integrados,
ejemplos de su configuración, así como directivas y variables compatibles.
* [Módulos](https://es.angie.software//angie/docs/configuration/modules/index.md)
* [Variables](https://es.angie.software//angie/docs/configuration/varindex.md)
* [Referencia de la API de NJS](https://es.angie.software//angie/docs/configuration/njs-reference.md)
También puede utilizar el servicio de enlaces cortos en [https://angie.ws/](https://angie.ws/)
para encontrar rápidamente directivas y variables individuales:
* [Acceso rápido](https://es.angie.software//angie/docs/configuration/quickaccess.md)
## Instrucciones
Aquí se proporcionan instrucciones paso a paso para aspectos específicos de la configuración de Angie.
* [Configuración de ACME](https://es.angie.software//angie/docs/configuration/acme.md)
* [Configuración de clústeres](https://es.angie.software//angie/docs/configuration/cluster.md)
* [Configuración de OIDC](https://es.angie.software//angie/docs/configuration/oidc.md)
* [Configuración de SSL](https://es.angie.software//angie/docs/configuration/ssl.md)
* [Directivas de nginx no admitidas](https://es.angie.software//angie/docs/configuration/nginx-unsupported-directives.md)
* [Migración desde nginx](https://es.angie.software//angie/docs/configuration/migration.md)
* [Métricas personalizadas](https://es.angie.software//angie/docs/configuration/custom-metrics.md)
* [Panel Console Light](https://es.angie.software//angie/docs/configuration/monitoring.md)
* [Panel de Grafana](https://es.angie.software//angie/docs/configuration/grafana.md)
## Materiales de la comunidad
Hemos recopilado recursos de la comunidad que le ayudarán a comprender mejor
la configuración y el uso de Angie.
### Artículos
- [Angie: A New NGINX Fork Developed by Some of Its Former Devs](https://linuxiac.com/angie-web-server-is-a-new-nginx-fork/)
en Linuxiac
- [What's New in the Angie 1.9 Web Server (an nginx fork) and What to Expect from 1.10?](https://habr.com/en/articles/911444/)
en Habr
### Cursos
Actualmente no hay cursos sobre Angie disponibles en español.
Consulte la documentación oficial de Angie y las guías prácticas a continuación.
### Guías prácticas
- [Migrating from Nginx to Angie: A Real-World Journey from Certbot to Built-in ACME](https://dev.to/stan-breaks/migrating-from-nginx-to-angie-a-real-world-journey-from-certbot-to-built-in-acme-7a3)
en DEV Community
### Entrevistas y podcasts
- "NGINX is Dead? // Angie Web Server Migration Guide" por DevOps Toolbox
([YouTube](https://www.youtube.com/watch?v=HFCtaiJMDGg), 27.03.2026)
- "Nginx Has a BIG Problem..." por DevOps Toolbox ([YouTube](https://www.youtube.com/watch?v=acJBNVTW42I), 30.01.2026)
## Documentación para asistentes de IA
El sitio publica copias legibles por máquina de cada página de la
documentación para que las herramientas basadas en LLM — Claude Code,
Cursor, ChatGPT y otros asistentes agénticos — puedan ingerir el
contenido directamente en lugar de extraer HTML renderizado.
### llms.txt y llms-full.txt
Cada subdominio de idioma sirve un sitemap
[llms.txt](https://llmstxt.org/) con una breve descripción del
proyecto y una lista de todas las páginas (título, URL absoluta,
anotación). Su archivo complementario `llms-full.txt` concatena el
contenido Markdown completo de cada página en un único archivo
adecuado para ingesta de una sola vez:
- [https://es.angie.software/llms.txt](https://es.angie.software/llms.txt)
- [https://es.angie.software/llms-full.txt](https://es.angie.software/llms-full.txt)
Estas URL también se anuncian en
[robots.txt](https://es.angie.software/robots.txt) mediante la
directiva `Llms:`, por lo que los rastreadores LLM las descubren
automáticamente.
### Versiones Markdown de las páginas
Cada página HTML tiene su equivalente en Markdown. Para obtener la
versión Markdown de cualquier URL de la documentación, reemplace la
barra final por `.md`:
- HTML: [https://es.angie.software/angie/docs/configuration/](https://es.angie.software/angie/docs/configuration/)
- Markdown: [https://es.angie.software/angie/docs/configuration.md](https://es.angie.software/angie/docs/configuration.md)
El Markdown se genera a partir del mismo código fuente
reStructuredText que el HTML, por lo que el contenido siempre
permanece sincronizado.
### Context7
La documentación de Angie está indexada en
[Context7](https://context7.com/), un registro que entrega
documentación actualizada de bibliotecas a editores de código de IA a
través de su servidor MCP. La ficha en español de Angie está en
[https://context7.com/websites/es_angie_software_angie](https://context7.com/websites/es_angie_software_angie).
# https://es.angie.software/angie/docs/configuration/configfile.md
# Archivos de Configuración
Angie utiliza un archivo de configuración basado en texto. Por defecto, este archivo se llama
`angie.conf` y se ubica según el parámetro de compilación [--conf-path](https://es.angie.software//angie/docs/installation/sourcebuild.md#paths),
típicamente en el directorio `/etc/angie`.
Un archivo de configuración generalmente consiste en los siguientes contextos:
- [events](https://es.angie.software//angie/docs/configuration/modules/core.md#events) – Procesamiento general de conexiones
- [http](https://es.angie.software//angie/docs/configuration/modules/http/index.md#d-http) – Tráfico HTTP
- [mail](https://es.angie.software//angie/docs/configuration/modules/mail/index.md#m-mail) – Tráfico de correo
- [stream](https://es.angie.software//angie/docs/configuration/modules/stream/index.md#s-stream) – Tráfico TCP y UDP
- [wasm_modules](https://es.angie.software//angie/docs/configuration/modules/wasm/index.md#wasm-modules) – Entorno de ejecución WASM
Las directivas que se colocan fuera de estos contextos se consideran dentro del
contexto `main`:
```nginx
user angie; # directiva en el contexto 'main'
events {
# configuración del procesamiento de conexiones
}
http {
# Configuración específica de HTTP que afecta a todos los servidores virtuales
server {
# configuración del servidor virtual HTTP 1
location /one {
# configuración para procesar URIs que comienzan con '/one'
}
location /two {
# configuración para procesar URIs que comienzan con '/two'
}
}
server {
# configuración del servidor virtual HTTP 2
}
}
stream {
# Configuración específica de TCP/UDP que afecta a todos los servidores virtuales
server {
# configuración del servidor virtual TCP 1
}
}
```
Para simplificar la gestión de la configuración, se recomienda usar la directiva
[include](https://es.angie.software//angie/docs/configuration/modules/core.md#include) en el archivo principal `angie.conf` para referenciar el contenido de
archivos específicos por funcionalidad:
```nginx
include /etc/angie/http.d/*.conf;
include /etc/angie/stream.d/*.conf;
```
## Herencia
En general, un contexto hijo (uno que está contenido dentro de otro contexto, que
se considera su padre) hereda las configuraciones de las directivas definidas en el
nivel padre. Algunas directivas pueden aparecer en múltiples contextos; en tales casos,
puede sobrescribirse la configuración heredada del padre incluyendo la directiva en el contexto hijo.
## Sintaxis
### Unidades de Medida
Puede especificar tamaños utilizando las siguientes unidades:
| Sin sufijo | Bytes |
|--------------|-----------|
| `k`, `K` | Kilobytes |
| `m`, `M` | Megabytes |
| `g`, `G` | Gigabytes |
Por ejemplo: `1024`, `8k`, `1m`, `16g`.
Los intervalos de tiempo pueden especificarse en milisegundos, segundos, minutos, horas, días,
y así sucesivamente, usando los siguientes sufijos:
| `ms` | Milisegundos |
|--------|----------------------------------|
| `s` | Segundos |
| `m` | Minutos |
| `h` | Horas |
| `d` | Días |
| `w` | Semanas |
| `M` | Meses (se asume igual a 30 días) |
| `y` | Años (se asume igual a 365 días) |
Se pueden combinar varias unidades en un solo valor especificándolas en orden,
de la más significativa a la menos significativa, opcionalmente separadas por
espacios. Por ejemplo, `"1h 30m"` especifica la misma duración que
`"90m"` o `"5400s"`. Un valor sin sufijo se interpreta como
segundos. Se recomienda siempre especificar un sufijo.
Algunos intervalos de tiempo solo pueden especificarse con resolución en segundos.
### Directivas
Cada directiva consiste en un nombre y un conjunto de parámetros.
Si alguna parte de una directiva necesita contener espacios,
debe colocarse entre comillas o escapar los espacios:
```nginx
add_header X-MyHeader "foo bar";
add_header X-MyHeader foo\ bar;
```
Si un parámetro con nombre necesita espacios y se usan comillas,
su nombre también debe colocarse entre comillas:
```nginx
server example.com "sid=server 1";
```
### Cadenas con variables
Muchas directivas aceptan una *cadena con variables* (también llamada *valor
complejo*): un valor de parámetro que combina texto literal con referencias a
variables como `$name`, `${name}` y las variables de captura de expresiones
regulares de `$1` a `$9`. Dicho valor se compila una sola vez al cargar la
configuración y se evalúa de nuevo en cada petición o conexión, por lo que la
cadena resultante puede variar de una petición a otra. Un valor que no contiene
`$` se comporta como un literal simple y no añade sobrecarga por petición.
Use la forma con llaves `${name}` para separar el nombre de una variable del
texto que la sigue inmediatamente, como en `${name}_suffix`. Las variables de
captura de `$1` a `$9` solo están disponibles donde ha coincidido una
expresión regular con los grupos correspondientes, y requieren una compilación
con PCRE.
No existe escape de `$` mediante barra invertida. Para incluir un `$`
literal, defina una variable que lo contenga, por ejemplo con [map](https://es.angie.software//angie/docs/configuration/modules/http/http_map.md#id1) o
[set](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#set), y referencie esa variable en el valor.
El conjunto de variables disponibles depende del contexto: las del subsistema
[http](https://es.angie.software//angie/docs/configuration/modules/http/index.md#d-http) difieren de las del subsistema [stream](https://es.angie.software//angie/docs/configuration/modules/stream/index.md#s-stream);
consulte el [índice de variables](https://es.angie.software//angie/docs/configuration/varindex.md#varindex) para ver la lista completa.
Las variables las generan tanto los módulos integrados como directivas como
[map](https://es.angie.software//angie/docs/configuration/modules/http/http_map.md#id1), [geo](https://es.angie.software//angie/docs/configuration/modules/http/http_geo.md#id1) y [split_clients](https://es.angie.software//angie/docs/configuration/modules/http/http_split_clients.md#id1).
Para algunas directivas la presencia de una variable cambia el comportamiento en
tiempo de ejecución: el valor se resuelve entonces dinámicamente en cada petición
en lugar de fijarse al cargar la configuración, lo que puede requerir un
[resolver](https://es.angie.software//angie/docs/configuration/modules/http/index.md#resolver). La directiva [proxy_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass) es uno de esos casos.
## Configuración de Hashes
Para procesar de manera eficiente conjuntos estáticos de datos, como nombres de servidores, valores de la directiva [map](https://es.angie.software//angie/docs/configuration/modules/http/http_map.md#id1), tipos MIME y nombres de cabeceras de solicitudes, Angie utiliza tablas hash. Durante el arranque y en cada reconfiguración, Angie determina el tamaño óptimo de estas tablas hash para asegurar que el tamaño del bucket, que almacena claves con valores hash idénticos, no exceda el parámetro configurado (hash bucket size). El tamaño de la tabla se mide en buckets y se ajusta hasta que supera el parámetro hash max size. La mayoría de las tablas hash tienen directivas correspondientes para ajustar estos parámetros, como [server_names_hash_max_size](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server-names-hash-max-size) y [server_names_hash_bucket_size](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server-names-hash-bucket-size) para nombres de servidores.
El parámetro hash bucket size se alinea a un múltiplo del tamaño de la línea de caché del procesador. Esta alineación mejora la eficiencia de la búsqueda de claves en procesadores modernos al reducir el número de accesos a memoria. Si el hash bucket size es igual al tamaño de una línea de caché, el número máximo de accesos a memoria durante la búsqueda de una clave será dos: uno para calcular la dirección del bucket y otro para buscar dentro del bucket. Por lo tanto, si Angie indica que se debe aumentar el hash max size o el hash bucket size, se recomienda comenzar aumentando el hash max size.
### Recarga de Configuración
Para aplicar cambios al archivo de configuración, este debe recargarse. Puede reiniciar el proceso de Angie con una verificación previa de la sintaxis de la configuración:
```console
$ sudo angie -t && sudo service angie restart
```
Alternativamente, puede recargar el servicio para aplicar la nueva configuración sin
interrumpir el procesamiento de solicitudes actuales:
```console
$ sudo angie -t && sudo service angie reload
```
# https://es.angie.software/angie/docs/configuration/runtime.md
# Control en Tiempo de Ejecución
Para iniciar Angie, utilice **systemd** con el siguiente comando:
```console
$ sudo service angie start
```
Se recomienda comprobar antes la sintaxis de la configuración. He aquí cómo hacerlo:
```console
$ sudo angie -t && sudo service angie start
```
Para recargar la configuración:
```console
$ sudo angie -t && sudo service angie reload
```
Para detener Angie:
```console
$ sudo service angie stop
```
Después de la instalación, ejecute el siguiente comando para asegurarse de que Angie está funcionando:
```console
$ curl localhost:80
```
#### NOTE
Los métodos para ejecutar la versión de código abierto de Angie pueden variar en función
del método de instalación.
Angie tiene un proceso maestro y varios procesos de trabajo. El proceso maestro se encarga de
leer y evaluar la configuración y de mantener los procesos de trabajo. Los procesos de trabajo
gestionan el procesamiento real de las peticiones. Angie utiliza un modelo basado en eventos y
mecanismos dependientes del sistema operativo para distribuir eficazmente las peticiones entre
los procesos de trabajo. El número de procesos de trabajo se define en el archivo de configuración
y puede ser fijo para una configuración dada o ajustarse automáticamente en función del número de
núcleos de CPU disponibles (consulte [worker_processes](https://es.angie.software//angie/docs/configuration/modules/core.md#worker-processes)).
Cuando está configurado, Angie también vaciará ciertas zonas de memoria compartida
(actualmente, `keys_zone` en [proxy_cache_path](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-path))
al disco antes de salir,
de modo que el nuevo proceso maestro pueda restaurarlas
y así mejorar el rendimiento.
Si la restauración falla debido a un cambio en el tamaño de la zona,
incompatibilidad de versión binaria u otras razones,
Angie registrará una alerta (`failed to restore zone at address`)
y no utilizará el mecanismo de restauración de zonas.
## Uso de Señales
Angie también puede controlarse mediante señales. Por defecto, el ID de proceso del
proceso maestro se escribe en el archivo `/run/angie.pid`. Este
nombre de archivo puede cambiarse en tiempo de configuración o en `angie.conf` mediante la
directiva [pid](https://es.angie.software//angie/docs/configuration/modules/core.md#pid). El proceso maestro admite las siguientes señales:
| `TERM`, `INT` | Apagado rápido |
|-----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `QUIT` | Apagado [elegante](https://es.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout) |
| `HUP` | Recargar configuración, actualizar zona horaria (solo para FreeBSD y Linux), iniciar nuevos procesos de trabajo con la configuración actualizada, apagar [elegantemente](https://es.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout) los antiguos procesos de trabajo |
| `USR1` | Reabrir archivos de registro |
| `USR2` | Actualizar el archivo ejecutable |
| `WINCH` | Apagado [elegante](https://es.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout) de procesos de trabajo |
Puede enviar señales usando **kill**:
```console
$ sudo kill -QUIT $(cat /run/angie.pid)
```
También se pueden controlar procesos de trabajo individuales usando señales, aunque esto
es opcional. Las señales admitidas son:
| `TERM`, `INT` | Apagado rápido |
|-----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `QUIT` | Apagado [elegante](https://es.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout) |
| `USR1` | Reabrir archivos de registro |
| `WINCH` | Terminación anómala para depuración (requiere que [debug_points](https://es.angie.software//angie/docs/configuration/modules/core.md#debug-points) esté habilitado) |
## Cambiar la Configuración
Para que Angie vuelva a leer el archivo de configuración, debe enviarse una señal `HUP`
al proceso maestro. El proceso maestro primero comprueba la validez de la sintaxis y luego intenta
aplicar la nueva configuración, lo que incluye abrir nuevos archivos de registro y sockets de
escucha. Si aplicar la nueva configuración falla, el proceso maestro revierte los cambios y
continúa operando con la configuración anterior. Si la aplicación tiene éxito, el proceso maestro
inicia nuevos procesos de trabajo y envía mensajes a los antiguos solicitando que se apaguen
[elegantemente](https://es.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout). Los antiguos procesos de trabajo cierran sus
sockets de escucha y continúan atendiendo a los clientes existentes.
Una vez servidos todos los clientes, los antiguos procesos de trabajo se apagan.
Angie rastrea los cambios de configuración para cada proceso. Los números de generación
comienzan en 1 cuando el servidor se inicia por primera vez. Estos números se incrementan con
cada recarga de configuración y son visibles en los títulos de procesos:
```console
$ sudo angie
$ ps aux | grep angie
angie: master process v1.12.1 #1 [angie]
angie: worker process #1
```
Tras una recarga de configuración exitosa (independientemente de que haya cambios reales),
Angie incrementa el número de generación para los procesos que recibieron la nueva configuración:
```console
$ sudo kill -HUP $(cat /run/angie.pid)
$ ps aux | grep angie
angie: master process v1.12.1 #2 [angie]
angie: worker process #2
```
Si continúan operando procesos de trabajo de generaciones anteriores,
serán visibles de inmediato:
```console
$ ps aux | grep angie
angie: worker process #1
angie: worker process #2
```
#### NOTE
No confunda el número de generación de la configuración con un "número de proceso";
Angie no utiliza numeración continua de procesos por motivos prácticos.
## Rotación de Archivos de Registro
Para rotar archivos de registro, primero renómbrelos. Luego, envíe una señal `USR1` al
proceso maestro. Este reabrirá todos los archivos de registro abiertos y los asignará al
usuario sin privilegios bajo el cual se ejecutan los procesos de trabajo. Tras reabrir los
archivos correctamente, el proceso maestro cierra todos los archivos abiertos y notifica a
los procesos de trabajo que reabran sus archivos de registro. Estos abrirán los nuevos
archivos y cerrarán los antiguos inmediatamente. Como resultado, los archivos antiguos quedan
disponibles casi de inmediato para el posprocesamiento, como la compresión.
## Actualización del Ejecutable en Vivo
Para actualizar el ejecutable del servidor, primero sustituya el archivo antiguo por el
nuevo. Luego, envíe una señal `USR2` al proceso maestro. Este renombrará su archivo
actual con el ID de proceso añadiéndole el sufijo `.oldbin`,
por ejemplo `/usr/local/angie/logs/angie.pid.oldbin`,
y luego iniciará el nuevo ejecutable, que a su vez iniciará nuevos procesos de trabajo.
Tenga en cuenta que el antiguo proceso maestro no cierra sus sockets de escucha y puede
gestionarse para reiniciar sus procesos de trabajo si es necesario. Si el nuevo ejecutable no
funciona como se espera, puede tomar una de las siguientes acciones:
* Enviar la señal `HUP` al antiguo proceso maestro. Esto iniciará nuevos procesos de
trabajo sin volver a leer la configuración. Puede apagar todos los nuevos procesos
[elegantemente](https://es.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout) enviando la señal `QUIT` al nuevo
proceso maestro.
* Enviar la señal `TERM` al nuevo proceso maestro. Este enviará un mensaje a sus
procesos de trabajo solicitando que salgan inmediatamente. Si alguno no sale, envíe la
señal `KILL` para forzarlo. Cuando el nuevo proceso maestro salga, el antiguo iniciará
automáticamente nuevos procesos de trabajo.
Si el nuevo proceso maestro sale, el antiguo eliminará el sufijo `.oldbin` del nombre de
archivo con el ID de proceso.
Si la actualización es exitosa, envíe la señal `QUIT` al antiguo proceso maestro, y solo
quedarán los nuevos procesos.
Cuando está configurado, Angie también vaciará ciertas zonas de memoria compartida
(actualmente, `keys_zone` en [proxy_cache_path](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-path))
al disco antes de actualizar,
de modo que el nuevo proceso maestro pueda restaurarlas
y así mejorar el rendimiento.
Si la restauración falla debido a un cambio en el tamaño de la zona,
incompatibilidad de versión binaria u otras razones,
Angie registrará una alerta (`failed to restore zone at address`)
y no utilizará el mecanismo de restauración de zonas.
## Opciones de Línea de Comandos
| `-?`, `-h` | Mostrar ayuda para los parámetros de línea de comandos y salir. |
|-----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--build-env` | Mostrar información auxiliar sobre el entorno de compilación y salir. |
| `-c` file | Usar file como archivo de configuración en lugar del [archivo predeterminado](https://es.angie.software//angie/docs/configuration/configfile.md#configfile). |
| `-e` file | Usar file como archivo de registro de errores en lugar del [archivo predeterminado](https://es.angie.software//angie/docs/configuration/processing.md#logging). El valor especial `stderr` especifica la salida de error estándar. |
| `-g` directives | Establecer [directivas de configuración globales](https://es.angie.software//angie/docs/configuration/modules/core.md#core), por ejemplo: `angie -g "pid /var/run/angie.pid; worker_processes `sysctl -n hw.ncpu`;"`. |
| `-m`, `-M` | Mostrar una lista de módulos incorporados (`-m`) o incorporados y cargados (`-M`), y luego salir. |
| `-p` prefix | Usar la ruta prefix especificada para `angie` (el directorio donde se encuentran los archivos del servidor; el valor predeterminado es `/usr/local/angie/`). |
| `-q` | Mostrar solo mensajes de error si se establece `-t` o `-T`; de lo contrario, no tiene efecto. |
| `-s` signal | Enviar una [señal](#control-signals) al proceso maestro: `stop`, `quit`, `reopen`, `reload`, etc. |
| `-t` | Probar el archivo de configuración y salir. Angie comprueba la sintaxis de la configuración, incluyendo de forma recursiva los archivos mencionados en ella. |
| `-T` | Igual que `-t`, pero además muestra el resumen de configuración en la salida estándar tras incluir recursivamente todos los archivos mencionados en la configuración. |
| `-v` | Mostrar la versión de Angie y salir. |
| `-V` | Mostrar la versión de Angie, la versión del compilador, el tiempo de compilación y los [parámetros de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#configure) utilizados, y salir. |
# https://es.angie.software/angie/docs/configuration/processing.md
# Conexiones, Sesiones, Solicitudes, Registros
## Mecanismos de procesamiento de conexiones
Angie admite varios métodos de procesamiento de conexiones. La disponibilidad de un método específico depende de la plataforma que se esté utilizando. En plataformas que admiten múltiples métodos, Angie suele seleccionar automáticamente el método más eficiente. No obstante, si es necesario, se puede elegir explícitamente un método de procesamiento de conexiones usando la directiva [use](https://es.angie.software//angie/docs/configuration/modules/core.md#use).
Los siguientes métodos de procesamiento de conexiones están disponibles:
| Método | Descripción |
|-------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `select` | Un método estándar. El módulo de soporte se crea automáticamente en plataformas que no disponen de métodos más eficientes. Las opciones de compilación `--with-select_module` y `--without-select_module` pueden usarse para habilitar o deshabilitar la construcción de este módulo de forma forzada. |
| `poll` | Un método estándar. El módulo de soporte se crea automáticamente en plataformas que no disponen de métodos más eficientes. Las opciones de compilación `--with-poll_module` y `--without-poll_module` pueden usarse para habilitar o deshabilitar la construcción de este módulo de forma forzada. |
| `kqueue` | Un método eficiente disponible en FreeBSD 4.1+, OpenBSD 2.9+, NetBSD 2.0 y macOS. |
| `epoll` | Un método eficiente disponible en Linux 2.6+. |
| `/dev/poll` | Un método eficiente disponible en Solaris 7 11/99+, HP/UX 11.22+ (eventport), IRIX 6.5.15+ y Tru64 UNIX 5.1A+. |
| `eventport` | El método `event ports` está disponible en Solaris 10+. (Debido a problemas conocidos, se recomienda utilizar el método `/dev/poll` en su lugar.) |
## Procesamiento de solicitudes HTTP
Una solicitud HTTP atraviesa una serie de fases, durante las cuales se realiza un tipo específico de procesamiento en cada fase.
| `Post-read` | La fase inicial. En esta fase se invoca el módulo [RealIP](https://es.angie.software//angie/docs/configuration/modules/http/http_realip.md#http-realip). |
|------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `Server-rewrite` | La fase en la que se procesan las directivas del módulo [Rewrite](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#http-rewrite), definidas dentro de un bloque `server` (pero fuera de un bloque `location`). |
| `Find-config` | Una fase especial en la que se selecciona una [location](https://es.angie.software//angie/docs/configuration/modules/http/index.md#location) basada en la URI de la solicitud. |
| `Rewrite` | Similar a la fase `Server-rewrite`, pero se aplica a las reglas [rewrite](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#id5) definidas dentro del bloque de location seleccionado en la fase anterior. |
| `Post-rewrite` | Una fase especial en la que la solicitud se redirige a una nueva ubicación, como en la fase `Find-config`, si su URI fue modificada durante la fase `Rewrite`. |
| `Preaccess` | Durante esta fase, módulos estándar de Angie como [Limit Req](https://es.angie.software//angie/docs/configuration/modules/http/http_limit_req.md#http-limit-req) registran sus manejadores. |
| `Access` | La fase en la que se verifica la autorización del cliente para realizar la solicitud, normalmente invocando módulos estándar de Angie como [Auth Basic](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic). |
| `Post-access` | Una fase especial en la que se procesa la directiva [satisfy any](https://es.angie.software//angie/docs/configuration/modules/http/index.md#satisfy). |
| `Precontent` | Las directivas de módulos estándar, como [try_files](https://es.angie.software//angie/docs/configuration/modules/http/index.md#try-files) y [mirror](https://es.angie.software//angie/docs/configuration/modules/http/http_mirror.md#id1), registran sus manejadores durante esta fase. |
| `Content` | La fase en la que normalmente se genera la respuesta. Varios módulos estándar de Angie registran sus manejadores en esta etapa, incluyendo [Index](https://es.angie.software//angie/docs/configuration/modules/http/http_index.md#http-index). Las directivas [proxy_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass), [fastcgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass), [uwsgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-pass), [scgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-pass) y [grpc_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_grpc.md#grpc-pass) también se gestionan aquí.
Los manejadores se invocan de forma secuencial hasta que uno de ellos genera la salida. |
| `Log` | La fase final, en la que se registra la solicitud. Actualmente, solo el módulo [Log](https://es.angie.software//angie/docs/configuration/modules/http/http_log.md#http-log) registra su manejador en esta etapa para el registro de acceso. |
## Procesamiento de sesiones TCP/UDP
Una sesión TCP/UDP de un cliente atraviesa una serie de fases, durante las cuales se realiza un tipo específico de procesamiento en cada fase:
| `Post-accept` | La fase inicial tras aceptar una conexión del cliente. En esta fase se invoca el módulo [RealIP](https://es.angie.software//angie/docs/configuration/modules/stream/stream_realip.md#stream-realip). |
|-----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `Pre-access` | Una fase preliminar para comprobar el acceso. Los módulos [Set](https://es.angie.software//angie/docs/configuration/modules/stream/stream_set.md#stream-set) se invocan durante esta fase. |
| `Access` | La fase en la que se limita el acceso del cliente antes del procesamiento real de datos. El módulo [Access](https://es.angie.software//angie/docs/configuration/modules/stream/stream_access.md#stream-access) se invoca en esta etapa. |
| `SSL` | La fase en la que tiene lugar la terminación TLS/SSL. El módulo [SSL](https://es.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#stream-ssl) se invoca durante esta fase. |
| `Preread` | La fase para leer los bytes iniciales de datos en el [búfer de prelectura](https://es.angie.software//angie/docs/configuration/modules/stream/index.md#s-preread-buffer-size) para permitir que módulos como [SSL Preread](https://es.angie.software//angie/docs/configuration/modules/stream/stream_ssl_preread.md#stream-ssl-preread) analicen los datos antes del procesamiento. |
| `Content` | Una fase obligatoria en la que realmente se procesan los datos, normalmente involucrando el módulo [Return](https://es.angie.software//angie/docs/configuration/modules/stream/stream_return.md#stream-return) para enviar una respuesta al cliente. La directiva [proxy_pass](https://es.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-pass) también se maneja aquí. |
| `Log` | La fase final en la que se registra el resultado del procesamiento de la sesión del cliente. El módulo [Log](https://es.angie.software//angie/docs/configuration/modules/stream/stream_log.md#stream-log) se invoca en esta fase. |
## Procesamiento de solicitudes
### Selección de servidor virtual
Inicialmente, se crea una conexión dentro del contexto de un servidor predeterminado. El nombre del servidor puede determinarse en las siguientes etapas del procesamiento de la solicitud, cada una de las cuales está involucrada en la selección de la configuración del servidor:
- Durante el protocolo de enlace SSL, de antemano, según el SNI.
- Después de procesar la línea de solicitud.
- Después de procesar el campo de cabecera `Host`.
Si el nombre del servidor no se determina después de procesar la línea de solicitud o el campo de cabecera `Host`, Angie utilizará un nombre vacío como nombre de servidor.
En cada una de estas etapas, se pueden aplicar diferentes configuraciones de servidor. Por lo tanto, ciertas directivas deben especificarse con precaución:
- En el caso de la directiva [ssl_protocols](https://es.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-protocols), la lista de protocolos es establecida por la biblioteca OpenSSL antes de que se aplique la configuración del servidor según el nombre solicitado a través de SNI. Como resultado, los protocolos solo deben especificarse para el servidor predeterminado.
- Las directivas [client_header_buffer_size](https://es.angie.software//angie/docs/configuration/modules/http/index.md#client-header-buffer-size) y [merge_slashes](https://es.angie.software//angie/docs/configuration/modules/http/index.md#merge-slashes) se aplican antes de leer la línea de solicitud. Por lo tanto, estas directivas utilizan la configuración del servidor predeterminado o la configuración del servidor elegida por SNI.
- En el caso de las directivas [ignore_invalid_headers](https://es.angie.software//angie/docs/configuration/modules/http/index.md#ignore-invalid-headers), [large_client_header_buffers](https://es.angie.software//angie/docs/configuration/modules/http/index.md#large-client-header-buffers) y [underscores_in_headers](https://es.angie.software//angie/docs/configuration/modules/http/index.md#underscores-in-headers), que están involucradas en el procesamiento de los campos de cabecera de solicitud, la configuración del servidor depende adicionalmente de si se actualizó según la línea de solicitud o el campo de cabecera `Host`.
- Una respuesta de error se gestiona mediante la directiva [error_page](https://es.angie.software//angie/docs/configuration/modules/http/index.md#error-page) en el servidor que está procesando actualmente la solicitud.
### Servidores virtuales basados en nombres
Angie determina primero qué servidor debe manejar la solicitud. Considere una configuración simple donde los tres servidores virtuales escuchan en el puerto 80:
```nginx
server {
listen 80;
server_name example.org www.example.org;
# ...
}
server {
listen 80;
server_name example.net www.example.net;
# ...
}
server {
listen 80;
server_name example.com www.example.com;
# ...
}
```
En esta configuración, Angie determina qué servidor debe manejar la solicitud basándose únicamente en el campo de cabecera `Host`. Si el valor de esta cabecera no coincide con ningún nombre de servidor o si la solicitud no contiene este campo de cabecera, Angie enviará la solicitud al servidor predeterminado para este puerto. En la configuración anterior, el servidor predeterminado es el primero, que es el comportamiento predeterminado estándar de Angie. También se puede especificar explícitamente qué servidor debe ser el predeterminado utilizando el parámetro `default_server` en la directiva [listen](https://es.angie.software//angie/docs/configuration/modules/http/index.md#listen):
```nginx
server {
listen 80 default_server;
server_name example.net www.example.net;
# ...
}
```
#### NOTE
Tenga en cuenta que el servidor predeterminado es una propiedad del socket de escucha, no del nombre del servidor.
### Nombres internacionalizados
Los [nombres de dominio internacionalizados (IDN)](https://en.wikipedia.org/wiki/Internationalized_domain_name)
deberían especificarse utilizando una representación ASCII (Punycode) en la directiva
[server_name](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server-name) (nombre del servidor):
```nginx
server {
listen 80;
server_name xn--e1afmkfd.xn--80akhbyknj4f; # пример.испытание
# ...
}
```
### Prevención de solicitudes con nombres de servidor indefinidos
Si no se deben permitir solicitudes sin el campo de cabecera `Host`, se puede definir un
servidor que simplemente descarte esas solicitudes:
```nginx
server {
listen 80;
server_name "";
return 444;
}
```
En esta configuración, el nombre del servidor se establece como una cadena vacía, que coincide
con las solicitudes sin el campo de cabecera `Host`. A continuación se devuelve un código especial no estándar 444,
que cierra la conexión.
### Combinación de servidores virtuales basados en nombre y en IP
Examinemos una configuración más compleja en la que algunos servidores virtuales escuchan en
diferentes direcciones:
```nginx
server {
listen 192.168.1.1:80;
server_name example.org www.example.org;
# ...
}
server {
listen 192.168.1.1:80;
server_name example.net www.example.net;
# ...
}
server {
listen 192.168.1.2:80;
server_name example.com www.example.com;
# ...
}
```
En esta configuración, Angie primero verifica la dirección IP y el puerto de la solicitud contra las directivas [listen](https://es.angie.software//angie/docs/configuration/modules/http/index.md#listen) de los bloques [server](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server). Luego verifica el campo de cabecera `Host` de la solicitud frente a las entradas [server_name](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server-name) de los bloques [server](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server) que coincidieron con la dirección IP y el puerto. Si no se encuentra el nombre del servidor, la solicitud será procesada por el servidor predeterminado. Por ejemplo, una solicitud para `www.example.com` recibida en el puerto 192.168.1.1:80 será manejada por el servidor predeterminado para ese puerto — es decir, por el primer servidor — ya que `www.example.com` no está definido para este puerto.
Como se mencionó anteriormente, un servidor predeterminado es una propiedad del puerto de escucha, y se pueden definir diferentes servidores predeterminados para distintos puertos:
```nginx
server {
listen 192.168.1.1:80;
server_name example.org www.example.org;
# ...
}
server {
listen 192.168.1.1:80 default_server;
server_name example.net www.example.net;
# ...
}
server {
listen 192.168.1.2:80 default_server;
server_name example.com www.example.com;
# ...
}
```
### Elección de ubicaciones
Consideremos una configuración simple de un sitio web PHP:
```nginx
server {
listen 80;
server_name example.org www.example.org;
root /data/www;
location / {
index index.html index.php;
}
location ~* \.(gif|jpg|png)$ {
expires 30d;
}
location ~ \.php$ {
fastcgi_pass localhost:9000;
fastcgi_param SCRIPT_FILENAME
$document_root$fastcgi_script_name;
include fastcgi_params;
}
}
```
Angie primero busca la `location` de prefijo más específica dada por cadenas literales, independientemente del orden en que estén listadas. En la configuración anterior, la única ubicación de prefijo es `location /`, que coincide con cualquier solicitud y se utilizará como último recurso. Luego, Angie comprueba las ubicaciones definidas por expresiones regulares en el orden en que aparecen en el archivo de configuración. La primera expresión coincidente detiene la búsqueda, y Angie utilizará esa `location`. Si ninguna expresión regular coincide con una solicitud, Angie utilizará la `location` de prefijo más específica encontrada anteriormente.
#### NOTE
Las ubicaciones de todos los tipos solo prueban la parte URI de la línea de solicitud, excluyendo los argumentos. Esto se debe a que los argumentos en la cadena de consulta pueden especificarse de varias maneras, por ejemplo:
- `/index.php?user=john&page=1`
- `/index.php?page=1&user=john`
Además, las cadenas de consulta pueden contener cualquier número de parámetros:
- `/index.php?page=1&something+else&user=john`
Ahora veamos cómo se procesarían las solicitudes en la configuración anterior:
- La solicitud `/logo.gif` primero coincide con el prefijo `location /` y luego con la expresión regular `.(gif|jpg|png)$`. Por lo tanto, es manejada por la última ubicación. Usando la directiva `root /data/www`, la solicitud se asigna al archivo `/data/www/logo.gif`, y el archivo se envía al cliente.
- La solicitud `/index.php` también coincide inicialmente con el prefijo
`location /` y luego con la expresión regular `.(php)$`. En consecuencia, es manejada por esta última ubicación, y la solicitud se pasa a un servidor FastCGI que escucha en `localhost:9000`. La directiva [fastcgi_param](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-param) establece el parámetro FastCGI `SCRIPT_FILENAME` a `/data/www/index.php`, y el servidor FastCGI ejecuta el archivo. La variable [$document_root](https://es.angie.software//angie/docs/configuration/modules/http/index.md#v-document-root) se establece con el valor de la directiva `root`, y la variable [$fastcgi_script_name](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#v-fastcgi-script-name) se establece con el URI de la solicitud, es decir, `/index.php`.
- La solicitud `/about.html` solo coincide con el prefijo `location /`, por lo que se maneja en esta ubicación. Usando la directiva `root /data/www`, la solicitud se asigna al archivo `/data/www/about.html`, y el archivo se envía al cliente.
El manejo de la solicitud `/` es más complejo. Solo coincide con el prefijo
`location /`, por lo que se maneja en esta ubicación. La directiva [index](https://es.angie.software//angie/docs/configuration/modules/http/http_index.md#id1) entonces
comprueba la existencia de archivos de índice según sus parámetros y la
directiva `root /data/www`. Si el archivo `/data/www/index.html` no existe pero el archivo `/data/www/index.php` sí, la directiva realiza
una redirección interna a `/index.php`, y Angie busca las ubicaciones nuevamente como si la solicitud hubiera sido enviada por un cliente. Como se mencionó anteriormente, la solicitud redirigida finalmente será manejada por el servidor FastCGI.
Los ejemplos anteriores asignan una solicitud a un archivo a través de la directiva
[root](https://es.angie.software//angie/docs/configuration/modules/http/index.md#root), pero la correspondencia completa implica varias directivas que actúan
conjuntamente. Una vez seleccionado el [location](https://es.angie.software//angie/docs/configuration/modules/http/index.md#location) coincidente, Angie asigna el
[$uri](https://es.angie.software//angie/docs/configuration/modules/http/index.md#v-uri) normalizado de la solicitud a una ruta del sistema de archivos:
la directiva [root](https://es.angie.software//angie/docs/configuration/modules/http/index.md#root) añade el URI completo a su valor, mientras que la directiva
[alias](https://es.angie.software//angie/docs/configuration/modules/http/index.md#alias) reemplaza el prefijo de la ubicación coincidente. La directiva
[try_files](https://es.angie.software//angie/docs/configuration/modules/http/index.md#try-files) comprueba entonces la existencia de archivos candidatos en esa ruta;
si no existe ninguno, su último parámetro desencadena una redirección interna, y Angie
vuelve a buscar en las ubicaciones con el nuevo [$uri](https://es.angie.software//angie/docs/configuration/modules/http/index.md#v-uri), igual que en la
redirección al archivo índice mencionada anteriormente.
Para la misma solicitud `/images/top.gif`, las dos ubicaciones siguientes la
resuelven al mismo archivo, `/data/w3/images/top.gif`:
```nginx
location /images/ {
root /data/w3; # añade: /data/w3 + /images/top.gif
}
location /images/ {
alias /data/w3/images/; # reemplaza: /images/ -> /data/w3/images/, luego top.gif
}
```
Con [alias](https://es.angie.software//angie/docs/configuration/modules/http/index.md#alias), el prefijo coincidente se elimina por su longitud, por lo que las
barras finales de la ubicación y del valor de alias deben ser consistentes. Si se
eliminara la barra final de la ruta del alias anterior, el resultado sería
`/data/w3/imagestop.gif`.
## Proxy y balanceo de carga
Uno de los usos más comunes de Angie es configurarlo como servidor proxy. En este rol,
Angie recibe solicitudes, las reenvía a los servidores proxied, obtiene
las respuestas de esos servidores y las envía de vuelta a los clientes.
Un servidor proxy simple:
```nginx
server {
location / {
proxy_pass http://backend:8080;
}
```
La directiva [proxy_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass) indica a Angie que pase las solicitudes del cliente al
backend `backend:8080` (el servidor proxied). Hay muchas [directivas](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy) adicionales disponibles para configurar aún más una conexión proxy.
### Proxy FastCGI
Angie puede usarse para enrutar solicitudes a servidores FastCGI que ejecutan aplicaciones
desarrolladas con varios marcos y lenguajes de programación, como PHP.
La configuración más básica de Angie para trabajar con un servidor FastCGI
involucra usar la directiva [fastcgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass) en lugar de la
directiva [proxy_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass), junto con directivas [fastcgi_param](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-param) para establecer
parámetros pasados al servidor FastCGI. Supongamos que el servidor FastCGI es
accesible en `localhost:9000`. En PHP, el parámetro `SCRIPT_FILENAME`
se utiliza para determinar el nombre del script, y el parámetro `QUERY_STRING`
se utiliza para pasar los parámetros de la solicitud. La configuración resultante sería:
```nginx
server {
location / {
fastcgi_pass localhost:9000;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param QUERY_STRING $query_string;
}
location ~ \.(gif|jpg|png)$ {
root /data/images;
}
}
```
Esta configuración establece un servidor que enruta todas las solicitudes, excepto aquellas para
imágenes estáticas, al servidor proxied que opera en `localhost:9000` a través del
protocolo FastCGI.
### Proxy de WebSocket
Para actualizar una conexión de HTTP/1.1 a WebSocket, se utiliza el mecanismo de [cambio de protocolo](https://datatracker.ietf.org/doc/html/rfc2616#section-14.42) disponible en HTTP/1.1.
Sin embargo, existe una sutileza: dado que la cabecera `Upgrade` es una [cabecera salto a salto](https://datatracker.ietf.org/doc/html/rfc2616#section-13.5.1), no se
pasa del cliente al servidor proxy. Con el proxy directo, los clientes
pueden usar el método CONNECT para evitar este problema. Este enfoque no funciona
con el proxy inverso, ya que los clientes no son conscientes de ningún servidor proxy, y se requiere
un procesamiento especial en el servidor proxy.
Angie implementa un modo especial de operación que permite establecer un túnel
entre un cliente y un servidor proxy si el servidor proxy devuelve una respuesta
con código 101 (Switching Protocols), y el cliente solicita un cambio de protocolo
mediante la cabecera `Upgrade` en la petición.
Como se mencionó, las cabeceras salto a salto, incluyendo `Upgrade` y
`Connection`, no se pasan del cliente al servidor proxy.
Por lo tanto, para que el servidor proxy sea consciente de la intención del cliente de
cambiar al protocolo WebSocket, estas cabeceras deben pasarse explícitamente:
```nginx
location /chat/ {
proxy_pass http://backend;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
```
Un ejemplo más sofisticado demuestra cómo el valor del
campo de cabecera `Connection` en una petición al servidor proxy depende de
la presencia del campo `Upgrade` en la cabecera de petición del cliente:
```nginx
http {
map $http_upgrade $connection_upgrade {
default upgrade;
'' close;
}
server {
...
location /chat/ {
proxy_pass http://backend;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $connection_upgrade;
}
}
}
```
Por defecto, la conexión se cerrará si el servidor proxy no
transmite ningún dato en 60 segundos. Este tiempo de espera puede aumentarse usando la
directiva [proxy_read_timeout](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-read-timeout). Alternativamente, el servidor proxy puede
configurarse para enviar periódicamente tramas de ping de WebSocket para restablecer el tiempo de espera y
comprobar si la conexión sigue activa.
### Balanceo de Carga
El balanceo de carga entre múltiples instancias de la aplicación es una técnica ampliamente utilizada
para optimizar la utilización de recursos, maximizar el rendimiento, reducir la latencia y
garantizar configuraciones tolerantes a fallos.
Angie puede emplearse como un balanceador de carga HTTP altamente eficiente para distribuir
el tráfico entre varios servidores de aplicaciones, mejorando así el rendimiento,
la escalabilidad y la fiabilidad de las aplicaciones web.
La configuración más simple para el balanceo de carga con Angie podría verse así:
```nginx
http {
upstream myapp1 {
server srv1.example.com;
server srv2.example.com;
server srv3.example.com;
}
server {
listen 80;
location / {
proxy_pass http://myapp1;
}
}
}
```
En el ejemplo anterior, tres instancias de la misma aplicación se ejecutan en
`srv1` a `srv3`. Cuando no se configura explícitamente un método de balanceo de carga,
el método predeterminado es round-robin. Otros mecanismos de balanceo de carga compatibles
incluyen: [weight](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server), [least_conn](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-least-conn) y [ip_hash](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-ip-hash). La implementación del proxy inverso en Angie también admite
sondeos de estado del servidor en banda (o pasivos). Estos se configuran mediante las directivas [max_fails](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#max-fails) y [fail_timeout](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#fail-timeout)
dentro del bloque [server](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server) en el contexto [upstream](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream).
## Registro
#### NOTE
Además de las opciones enumeradas aquí,
también puede habilitar el [registro de depuración](https://es.angie.software//angie/docs/troubleshooting.md#debug-logging).
### Syslog
Las directivas [error_log](https://es.angie.software//angie/docs/configuration/modules/core.md#error-log) y [access_log](https://es.angie.software//angie/docs/configuration/modules/http/http_log.md#access-log) admiten el registro en
`syslog`. Los siguientes parámetros se utilizan para configurar el registro en
`syslog`:
| `server=`address | Especifica la dirección de un servidor `syslog`. La dirección puede ser un nombre de dominio o una dirección IP, con un puerto opcional, o una ruta de socket de dominio UNIX especificada después del prefijo `"unix:"`. Si no se especifica el puerto, se utiliza el puerto UDP 514. Si un nombre de dominio se resuelve a múltiples direcciones IP, se utiliza la primera dirección resuelta. |
|--------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `facility=`string | Establece la facilidad para los mensajes de `syslog`, como se define en [RFC 3164](https://datatracker.ietf.org/doc/html/rfc3164.html). Las posibles facilidades incluyen: `"kern"`, `"user"`, `"mail"`, `"daemon"`, `"auth"`, `"intern"`, `"lpr"`, `"news"`, `"uucp"`, `"clock"`, `"authpriv"`, `"ftp"`, `"ntp"`, `"audit"`, `"alert"`, `"cron"`, `"local0".."local7"`. El valor predeterminado es `"local7"`. |
| `severity=`string | Define el nivel de severidad de los mensajes de `syslog` para [access_log](https://es.angie.software//angie/docs/configuration/modules/http/http_log.md#access-log), como se especifica en [RFC 3164](https://datatracker.ietf.org/doc/html/rfc3164.html). Los valores posibles son los mismos que los del segundo parámetro (nivel) de la directiva [error_log](https://es.angie.software//angie/docs/configuration/modules/core.md#error-log). El valor predeterminado es `"info"`. La severidad de los mensajes de error es determinada por Angie, por lo que este parámetro se ignora en la directiva [error_log](https://es.angie.software//angie/docs/configuration/modules/core.md#error-log). |
| `tag=`string | Establece la etiqueta para los mensajes de `syslog`. La etiqueta predeterminada es `"angie"`. |
| `nohostname` | Desactiva la adición del campo `hostname` en la cabecera del mensaje `syslog`. |
Ejemplo de configuración syslog:
```nginx
error_log syslog:server=192.168.1.1 debug;
access_log syslog:server=unix:/var/log/angie.sock,nohostname;
access_log syslog:server=[2001:db8::1]:12345,facility=local7,tag=angie,severity=info combined;
```
# https://es.angie.software/angie/docs/configuration/modules.md
# Módulos
Esta guía describe los módulos de Angie, tanto nativos como de terceros,
proporciona ejemplos de configuración, enumera sus directivas y parámetros,
así como variables integradas.
## Módulo Core
| [Core](https://es.angie.software//angie/docs/configuration/modules/core.md#core) | Gestión de archivos de servicio, procesos y otros módulos de Angie. |
|------------------------------------------------------------------------------------|-----------------------------------------------------------------------|
## Módulos HTTP
| [HTTP](https://es.angie.software//angie/docs/configuration/modules/http/index.md#http-core) | Funcionalidad principal para procesar solicitudes y respuestas HTTP, gestionar el servidor HTTP, conexiones y archivos estáticos. |
|----------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [Access](https://es.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access) | Control de acceso basado en direcciones IP y rangos CIDR. |
| [ACME](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme) | Obtención y renovación automática de certificados SSL utilizando el protocolo ACME para servidores HTTP. |
| [Docker](https://es.angie.software//angie/docs/configuration/modules/http/http_docker.md#http-docker) | Actualización dinámica de grupos de servidores proxy basada en etiquetas de contenedores Docker. |
| [Addition](https://es.angie.software//angie/docs/configuration/modules/http/http_addition.md#http-addition) | Inserción de un fragmento específico antes o después del cuerpo de la respuesta. |
| [API](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#http-api) | Interfaz HTTP RESTful para obtener información básica del servidor web y estadísticas en formato JSON, así como para gestionar grupos de servidores proxy. |
| [Auth Basic](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic) | Autenticación HTTP básica para control de acceso basada en nombre de usuario y contraseña. |
| [Auth Request](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request) | Autorización mediante una subpetición a un servicio HTTP externo. |
| [AutoIndex](https://es.angie.software//angie/docs/configuration/modules/http/http_autoindex.md#http-autoindex) | Listado automático de directorios sin un archivo índice. |
| [Browser](https://es.angie.software//angie/docs/configuration/modules/http/http_browser.md#http-browser) (obsoleto) | Identificación del navegador basada en la cabecera `User-Agent`. |
| [Charset](https://es.angie.software//angie/docs/configuration/modules/http/http_charset.md#http-charset) | Configuración y conversión de la codificación de respuesta. |
| [DAV](https://es.angie.software//angie/docs/configuration/modules/http/http_dav.md#http-dav) | Gestión de archivos en el servidor mediante el protocolo WebDAV. |
| [DoH](https://es.angie.software//angie/docs/configuration/modules/http/http_doh.md#http-doh) | Servidor DNS over HTTPS (RFC 8484) que hace de proxy de las consultas DNS a un grupo de servidores DNS mediante UDP o TCP. |
| [Empty GIF](https://es.angie.software//angie/docs/configuration/modules/http/http_empty_gif.md#http-empty-gif) | Servir un GIF transparente de un píxel. |
| [FastCGI](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#http-fastcgi) | Proxy de peticiones a un servidor FastCGI. |
| [FLV](https://es.angie.software//angie/docs/configuration/modules/http/http_flv.md#http-flv) | Pseudo-streaming de archivos Flash Video (FLV). |
| [Geo](https://es.angie.software//angie/docs/configuration/modules/http/http_geo.md#http-geo) | Conversión de direcciones IP en valores de variables específicas. |
| [GeoIP](https://es.angie.software//angie/docs/configuration/modules/http/http_geoip.md#http-geoip) | Obtención de datos de direcciones IP basados en geolocalización utilizando bases de datos MaxMind GeoIP. |
| [gRPC](https://es.angie.software//angie/docs/configuration/modules/http/http_grpc.md#http-grpc) | Proxy de peticiones a un servidor gRPC. |
| [GunZIP](https://es.angie.software//angie/docs/configuration/modules/http/http_gunzip.md#http-gunzip) | Descompresión de respuestas comprimidas con GZip para su modificación y en casos donde el cliente no soporta compresión. |
| [GZip](https://es.angie.software//angie/docs/configuration/modules/http/http_gzip.md#http-gzip) | Compresión de respuestas utilizando el método GZip para ahorrar tráfico. |
| [GZip Static](https://es.angie.software//angie/docs/configuration/modules/http/http_gzip_static.md#http-gzip-static) | Servir archivos estáticos precomprimidos utilizando el método GZip. |
| [Headers](https://es.angie.software//angie/docs/configuration/modules/http/http_headers.md#http-headers) | Modificación de campos de cabecera de respuesta. |
| [HTTP2](https://es.angie.software//angie/docs/configuration/modules/http/http_v2.md#http-v2) | Procesamiento de peticiones utilizando el protocolo HTTP/2. |
| [HTTP3](https://es.angie.software//angie/docs/configuration/modules/http/http_v3.md#http-v3) | Procesamiento de peticiones utilizando el protocolo HTTP/3. |
| [Image Filter](https://es.angie.software//angie/docs/configuration/modules/http/http_image_filter.md#http-image-filter) [1](#id5) | Transformación de imágenes. |
| [Index](https://es.angie.software//angie/docs/configuration/modules/http/http_index.md#http-index) | Configuración de archivos índice que atienden peticiones que terminan con una barra (`/`). |
| [Limit Conn](https://es.angie.software//angie/docs/configuration/modules/http/http_limit_conn.md#http-limit-conn) | Limitación del número de peticiones concurrentes (conexiones activas) para protección contra sobrecargas. |
| [Limit Req](https://es.angie.software//angie/docs/configuration/modules/http/http_limit_req.md#http-limit-req) | Limitación de la frecuencia de peticiones para protección contra sobrecargas y adivinación de contraseñas. |
| [Log](https://es.angie.software//angie/docs/configuration/modules/http/http_log.md#http-log) | Configuración de registros de peticiones para seguimiento del acceso a recursos con fines de monitorización y análisis. |
| [Map](https://es.angie.software//angie/docs/configuration/modules/http/http_map.md#http-map) | Conversión de variables basada en pares clave-valor predefinidos. |
| [Metric](https://es.angie.software//angie/docs/configuration/modules/http/http_metric.md#http-metric) | Métricas numéricas personalizadas en la API de estadísticas en tiempo real. |
| [Memcached](https://es.angie.software//angie/docs/configuration/modules/http/http_memcached.md#http-memcached) | Recuperación de respuestas desde un servidor Memcached. |
| [Mirror](https://es.angie.software//angie/docs/configuration/modules/http/http_mirror.md#http-mirror) | Duplicación de peticiones a otros servidores. |
| [MP4](https://es.angie.software//angie/docs/configuration/modules/http/http_mp4.md#http-mp4) | Pseudo-streaming de archivos MP4. |
| [Perl](https://es.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl) [1](#id5) | Manejadores para extender la funcionalidad especificando lógica adicional en el lenguaje Perl. |
| [Prometheus](https://es.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#http-prometheus) | Métricas del servidor en formato compatible con Prometheus para monitorización y recopilación de estadísticas. |
| [Proxy](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy) | Proxy inverso de peticiones a otros servidores HTTP. |
| [Random Index](https://es.angie.software//angie/docs/configuration/modules/http/http_random_index.md#http-random-index) | Selección aleatoria de un archivo índice para peticiones que terminan con una barra (`/`). |
| [RealIP](https://es.angie.software//angie/docs/configuration/modules/http/http_realip.md#http-realip) | Determinación de la dirección y puerto del cliente cuando se opera detrás de otro servidor proxy. |
| [Referer](https://es.angie.software//angie/docs/configuration/modules/http/http_referer.md#http-referer) | Validación de valores de la cabecera `Referer`. |
| [Rewrite](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#http-rewrite) | Modificación del URI de la petición, redirecciones, establecimiento de variables y selección condicional de configuración. |
| [SCGI](https://es.angie.software//angie/docs/configuration/modules/http/http_scgi.md#http-scgi) | Proxy de peticiones a un servidor SCGI. |
| [Secure Link](https://es.angie.software//angie/docs/configuration/modules/http/http_secure_link.md#http-secure-link) | Creación de enlaces seguros con capacidad para limitar el tiempo de acceso. |
| [Slice](https://es.angie.software//angie/docs/configuration/modules/http/http_slice.md#http-slice) | División de peticiones en múltiples subpeticiones para fragmentos individuales para mejorar el almacenamiento en caché de respuestas grandes. |
| [Split Clients](https://es.angie.software//angie/docs/configuration/modules/http/http_split_clients.md#http-split-clients) | Creación de variables para pruebas A/B, despliegues canary, fragmentación, y otros escenarios que requieren división proporcional de grupos. |
| [SSI](https://es.angie.software//angie/docs/configuration/modules/http/http_ssi.md#http-ssi) | Procesamiento de comandos SSI (Server Side Includes) en respuestas. |
| [SSL](https://es.angie.software//angie/docs/configuration/modules/http/http_ssl.md#http-ssl) | Configuración SSL/TLS para procesar peticiones HTTPS. |
| [Stub Status](https://es.angie.software//angie/docs/configuration/modules/http/http_stub_status.md#http-stub-status) (obsoleto) | Contadores globales de conexiones y peticiones en formato texto. |
| [Sub](https://es.angie.software//angie/docs/configuration/modules/http/http_sub.md#http-sub) | Búsqueda y reemplazo de fragmentos en el cuerpo de la respuesta. |
| [Tunnel](https://es.angie.software//angie/docs/configuration/modules/http/http_tunnel.md#http-tunnel) | Gestión de solicitudes HTTP/1.1 CONNECT y establecimiento de túneles de extremo a extremo. |
| [Upstream](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#http-upstream) | Configuración de grupos de servidores proxy para balanceo de carga. |
| [Upstream Probe](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#http-upstream-probe) | Configuración de comprobaciones de salud activas para grupos de servidores proxy. |
| [UserID](https://es.angie.software//angie/docs/configuration/modules/http/http_userid.md#http-userid) | Emisión y procesamiento de cookies con identificadores únicos de cliente para seguimiento de sesiones y análisis. |
| [uWSGI](https://es.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#http-uwsgi) | Proxy de peticiones a un servidor uWSGI. |
| [XSLT](https://es.angie.software//angie/docs/configuration/modules/http/http_xslt.md#http-xslt) [1](#id5) | Transformación de documentos XML utilizando el lenguaje XSLT. |
## Módulos Stream
| [Stream](https://es.angie.software//angie/docs/configuration/modules/stream/index.md#stream-core) | Funcionalidad principal del servidor stream para balanceo de protocolos TCP y UDP a nivel L4. |
|-------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
| [Access](https://es.angie.software//angie/docs/configuration/modules/stream/stream_access.md#stream-access) | Control de acceso basado en direcciones IP y rangos CIDR. |
| [ACME](https://es.angie.software//angie/docs/configuration/modules/stream/stream_acme.md#stream-acme) | Obtención y renovación automática de certificados SSL utilizando el protocolo ACME para servidores stream. |
| [Geo](https://es.angie.software//angie/docs/configuration/modules/stream/stream_geo.md#stream-geo) | Conversión de direcciones IP en valores de variables específicas. |
| [GeoIP](https://es.angie.software//angie/docs/configuration/modules/stream/stream_geoip.md#stream-geoip) | Obtención de datos de direcciones IP basados en geolocalización utilizando bases de datos MaxMind GeoIP. |
| [Limit Conn](https://es.angie.software//angie/docs/configuration/modules/stream/stream_limit_conn.md#stream-limit-conn) | Limitación del número de conexiones concurrentes para protección contra sobrecargas. |
| [Log](https://es.angie.software//angie/docs/configuration/modules/stream/stream_log.md#stream-log) | Configuración de registros de sesiones para seguimiento del acceso a recursos con fines de monitorización y análisis. |
| [Map](https://es.angie.software//angie/docs/configuration/modules/stream/stream_map.md#stream-map) | Conversión de variables basada en pares clave-valor predefinidos. |
| [Metric](https://es.angie.software//angie/docs/configuration/modules/stream/stream_metric.md#stream-metric) | Métricas numéricas personalizadas en la API de estadísticas en tiempo real. |
| [MQTT Preread](https://es.angie.software//angie/docs/configuration/modules/stream/stream_mqtt_preread.md#stream-mqtt-preread) | Lectura del identificador de cliente y nombre de usuario de conexiones MQTT antes de tomar decisiones de balanceo de carga. |
| [Pass](https://es.angie.software//angie/docs/configuration/modules/stream/stream_pass.md#stream-pass) | Paso de conexiones aceptadas directamente a un socket de escucha configurado. |
| [Proxy](https://es.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#stream-proxy) | Configuración de proxy a otros servidores. |
| [RDP Preread](https://es.angie.software//angie/docs/configuration/modules/stream/stream_rdp_preread.md#stream-rdp-preread) | Lectura de cookies de conexiones RDP antes de tomar decisiones de balanceo de carga. |
| [RealIP](https://es.angie.software//angie/docs/configuration/modules/stream/stream_realip.md#stream-realip) | Determinación de la dirección y puerto del cliente cuando se opera detrás de otro servidor proxy. |
| [Return](https://es.angie.software//angie/docs/configuration/modules/stream/stream_return.md#stream-return) | Envío de un valor específico al cliente al conectarse sin proxy adicional. |
| [Set](https://es.angie.software//angie/docs/configuration/modules/stream/stream_set.md#stream-set) | Establecimiento de valores de variables específicas. |
| [Split Clients](https://es.angie.software//angie/docs/configuration/modules/stream/stream_split_clients.md#stream-split-clients) | Creación de variables para pruebas A/B, despliegues canary, fragmentación, y otros escenarios que requieren división proporcional de grupos. |
| [SSL](https://es.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#stream-ssl) | Terminación de protocolos SSL/TLS y DTLS. |
| [SSL Preread](https://es.angie.software//angie/docs/configuration/modules/stream/stream_ssl_preread.md#stream-ssl-preread) | Extracción de información de mensajes `ClientHello` sin terminación SSL/TLS y antes de tomar decisiones de balanceo de carga. |
| [Upstream](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#stream-upstream) | Configuración de grupos de servidores proxy para balanceo de carga. |
| [Upstream Probe](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#stream-upstream-probe) | Configuración de comprobaciones de salud activas para grupos de servidores proxy. |
## Módulos de Correo
| [Mail](https://es.angie.software//angie/docs/configuration/modules/mail/index.md#mail-core) | Funcionalidad básica del servidor proxy de correo. |
|----------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
| [Auth HTTP](https://es.angie.software//angie/docs/configuration/modules/mail/mail_auth_http.md#mail-auth-http) | Autenticación de usuarios y selección de servidor para proxying posterior mediante peticiones HTTP a un servidor externo. |
| [IMAP](https://es.angie.software//angie/docs/configuration/modules/mail/mail_imap.md#mail-imap) | Soporte para el protocolo IMAP. |
| [POP3](https://es.angie.software//angie/docs/configuration/modules/mail/mail_pop3.md#mail-pop3) | Soporte para el protocolo POP3. |
| [Proxy](https://es.angie.software//angie/docs/configuration/modules/mail/mail_proxy.md#mail-proxy) | Configuración de proxying hacia otros servidores. |
| [RealIP](https://es.angie.software//angie/docs/configuration/modules/mail/mail_realip.md#mail-realip) | Determinación de la dirección y puerto del cliente cuando se opera detrás de otro servidor proxy. |
| [SMTP](https://es.angie.software//angie/docs/configuration/modules/mail/mail_smtp.md#mail-smtp) | Soporte para el protocolo SMTP. |
| [SSL](https://es.angie.software//angie/docs/configuration/modules/mail/mail_ssl.md#mail-ssl) | Soporte para protocolos SSL/TLS y StartTLS. |
## Módulo Google PerfTools
| [Google PerfTools](https://es.angie.software//angie/docs/configuration/modules/google_perftools.md#google-perftools) | Responsable de la integración con la biblioteca Google Performance Tools para perfilado de aplicaciones y análisis de rendimiento. |
|------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|
## Módulos WASM
| [WASM](https://es.angie.software//angie/docs/configuration/modules/wasm/index.md#wasm-core) [1](#id5) | Funcionalidad básica de WASM que permite la ejecución de código WASM en Angie. |
|--------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
| [WAMR](https://es.angie.software//angie/docs/configuration/modules/wasm/wasm_wamr.md#wasm-wamr) | Integración con [WebAssembly Micro Runtime](https://github.com/bytecodealliance/wasm-micro-runtime). |
| [Wasmtime](https://es.angie.software//angie/docs/configuration/modules/wasm/wasm_wasmtime.md#wasm-wasmtime) | Integración con el entorno de ejecución [Wasmtime](https://wasmtime.dev/). |
## Módulos de terceros
Módulos de terceros compatibles con nginx para los que creamos paquetes.
Su instalación se describe en la sección [Módulos de Terceros](https://es.angie.software//angie/docs/installation/external-modules/index.md#install-thirdpartymodules),
y la lista completa con descripciones está en la sección [Módulos de Terceros](https://es.angie.software//angie/docs/configuration/modules/external-modules/index.md#list-of-modules).
### Notas al pie
* **[1]** En nuestras compilaciones, estos módulos se compilan dinámicamente e instalan como [paquetes separados](https://es.angie.software//angie/docs/installation/index.md#install-packages); para más detalles, consulte la descripción de cada módulo.
# https://es.angie.software/angie/docs/configuration/modules/core.md
# Módulo Core
El módulo proporciona la funcionalidad esencial y las directivas de configuración
necesarias para la operación básica del servidor, y gestiona tareas críticas
como la gestión de procesos de trabajo, la configuración de modelos orientados
a eventos y el procesamiento de conexiones y solicitudes entrantes.
Incluye directivas clave para configurar el proceso principal, el registro de errores
y el control del comportamiento del servidor a bajo nivel.
## Ejemplo de configuración
```nginx
user www www;
worker_processes 2;
error_log /var/log/error.log info;
events {
use kqueue; worker_connections 2048;
}
```
## Directivas
### accept_mutex
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `accept_mutex` `on` | `off`; |
|--------------------------------------------------------------------------------------------|--------------------------------|
| Predeterminado | `accept_mutex off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Cuando `accept_mutex` está habilitado,
los procesos de trabajo aceptarán nuevas conexiones por turno.
Sin esta configuración, todos los procesos de trabajo son notificados de nuevas conexiones,
lo que puede conducir a un uso ineficiente de los recursos del sistema
si el volumen de nuevas conexiones es bajo.
#### NOTE
No es necesario habilitar `accept_mutex` en sistemas
que admiten la bandera `EPOLLEXCLUSIVE`
o cuando se utiliza la directiva [reuseport](https://es.angie.software//angie/docs/configuration/modules/http/index.md#listen).
### accept_mutex_delay
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `accept_mutex_delay` tiempo; |
|--------------------------------------------------------------------------------------------|--------------------------------|
| Predeterminado | `accept_mutex_delay 500ms;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Si [accept_mutex](#accept-mutex) está habilitado,
esta directiva especifica el tiempo máximo
que un proceso de trabajo esperará
para continuar aceptando nuevas conexiones
mientras otro proceso de trabajo ya está manejando nuevas conexiones.
### daemon
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `daemon` `on` | `off`; |
|--------------------------------------------------------------------------------------------|--------------------------|
| Predeterminado | `daemon on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Determina si Angie debe ejecutarse como un demonio.
Esto se utiliza principalmente durante el desarrollo.
### debug_connection
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `debug_connection` dirección | CIDR | `unix:`; |
|--------------------------------------------------------------------------------------------|--------------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Habilita los registros de depuración para conexiones de clientes específicas.
Otras conexiones utilizarán el nivel de registro
establecido por la directiva [error_log](#error-log).
Puede especificar conexiones por dirección IPv4 o IPv6, red o nombre de host.
Para conexiones que utilicen sockets de dominio UNIX,
utilice el parámetro `unix:` para habilitar los registros de depuración.
```nginx
events {
debug_connection 127.0.0.1;
debug_connection localhost;
debug_connection 192.0.2.0/24;
debug_connection ::1;
debug_connection 2001:0db8::/32;
debug_connection unix:;
# ...
}
```
#### NOTE
Para que esta directiva funcione,
Angie debe estar compilada con el [registro de depuración](https://es.angie.software//angie/docs/troubleshooting.md#debug-logging) habilitado.
### debug_points
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `debug_points` `abort` | `stop`; |
|--------------------------------------------------------------------------------------------|------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Esta directiva se utiliza para depuración.
Cuando ocurre un error interno,
como una fuga de socket durante los reinicios del proceso de trabajo,
habilitar `debug_points` creará un archivo core (`abort`)
o detendrá el proceso (`stop`) para un análisis posterior con un depurador del sistema.
### env
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `env` variable[=valor]; |
|--------------------------------------------------------------------------------------------|---------------------------|
| Predeterminado | `env TZ;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Por defecto,
Angie elimina todas las variables de entorno heredadas de su proceso padre
excepto la variable `TZ`.
Esta directiva le permite conservar algunas variables heredadas,
modificar sus valores o crear nuevas variables de entorno.
Estas variables son entonces:
- heredadas durante una
[actualización en vivo de un archivo ejecutable](https://es.angie.software//angie/docs/configuration/runtime.md#service-upgrade)
- utilizadas por el módulo [Perl](https://es.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl)
- disponibles para los procesos de trabajo
Tenga en cuenta que controlar las bibliotecas del sistema de esta manera puede no ser siempre efectivo,
ya que las bibliotecas a menudo verifican las variables solo durante la inicialización,
que ocurre antes de que esta directiva surta efecto.
La variable `TZ` siempre se hereda
y es accesible para el módulo [Perl](https://es.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl)
a menos que se configure explícitamente lo contrario.
Ejemplo:
```nginx
env MALLOC_OPTIONS;
env PERL5LIB=/data/site/modules;
env OPENSSL_ALLOW_PROXY_CERTS=1;
```
#### NOTE
La variable de entorno `ANGIE` se utiliza internamente por Angie
y no debe ser establecida directamente por el usuario.
### error_log
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `error_log` archivo [nivel]; |
|--------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Predeterminado | `error_log logs/error.log error;` (la ruta depende de la opción de compilación `--error-log-path` [build option](https://es.angie.software//angie/docs/installation/sourcebuild.md#paths)) |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main, http, mail, stream, server, location |
Configura el registro,
permitiendo especificar múltiples logs en el mismo nivel de configuración.
Si no se define explícitamente un archivo de log en el nivel de configuración `main`,
se utilizará el archivo predeterminado.
El primer parámetro especifica el archivo donde almacenar el log.
El valor especial `stderr` selecciona la salida de error estándar.
Para configurar el registro en [syslog](https://es.angie.software//angie/docs/configuration/processing.md#syslog-logging),
utilice el prefijo `"syslog:"`.
Para registrar en un [buffer cíclico de memoria](https://es.angie.software//angie/docs/troubleshooting.md#cyclic-memory-buffer),
utilice el prefijo `"memory:"` seguido del tamaño del buffer;
esto se utiliza típicamente para depuración.
El segundo parámetro establece el nivel de registro, que puede ser uno de los siguientes:
`debug`, `info`, `notice`, `warn`, `error`,
`crit`, `alert`, o `emerg`.
Estos niveles están listados en orden de gravedad creciente.
Establecer un nivel de log capturará mensajes de igual y mayor gravedad:
| Configuración | Niveles Capturados |
|-----------------|--------------------------------------------------------------------------|
| `debug` | `debug`, `info`, `notice`, `warn`, `error`, `crit`, `alert`, `emerg` |
| `info` | `info`, `notice`, `warn`, `error`, `crit`, `alert`, `emerg` |
| `notice` | `notice`, `warn`, `error`, `crit`, `alert`, `emerg` |
| `warn` | `warn`, `error`, `crit`, `alert`, `emerg` |
| `error` | `error`, `crit`, `alert`, `emerg` |
| `crit` | `crit`, `alert`, `emerg` |
| `alert` | `alert`, `emerg` |
| `emerg` | `emerg` |
Si este parámetro se omite,
se usa `error` como nivel de registro predeterminado.
#### NOTE
Para que el nivel de registro `debug` funcione,
Angie debe estar compilada con el [registro de depuración](https://es.angie.software//angie/docs/troubleshooting.md#debug-logging) habilitado.
Cada entrada en el log de errores tiene el siguiente formato:
```text
timestamp [level] PID#TID: *connection_id message
```
Donde:
- `timestamp` — fecha y hora del evento
- `level` — nivel de registro del evento
- `PID#TID` — identificadores de proceso e hilo
- `*connection_id` — número de serie de la conexión, compartido por todas las solicitudes de la misma conexión (si aplica)
- `message` — texto del mensaje de error o evento
### events
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `events` { ... }; |
|--------------------------------------------------------------------------------------------|---------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Proporciona el contexto del archivo de configuración para directivas
que afectan al procesamiento de conexiones.
### include
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `include` archivo | máscara; |
|--------------------------------------------------------------------------------------------|--------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | any |
Incluye otro archivo, o archivos que coincidan con la máscara especificada,
en la configuración.
Los archivos incluidos deben contener directivas y bloques sintácticamente correctos.
Ejemplo:
```nginx
include mime.types;
include vhosts/*.conf;
```
### load_module
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `load_module` file; |
|--------------------------------------------------------------------------------------------|-----------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Carga un módulo dinámico desde el archivo especificado.
Si se proporciona una ruta relativa, se interpreta en función de la
opción de compilación `--prefix` [build option](https://es.angie.software//angie/docs/installation/sourcebuild.md#configure). Para verificar la ruta:
```console
$ sudo angie -V
```
Ejemplo:
```nginx
load_module modules/ngx_mail_module.so;
```
Si un módulo dinámico se compiló para una compilación de Angie diferente, la carga falla con un
error como: "module "..." was built for "..." but you are running "Angie"".
### lock_file
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `lock_file` file; |
|--------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Predeterminado | `lock_file logs/angie.lock;` (la ruta depende de la [opción de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#paths) `--lock-path`) |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Angie utiliza un mecanismo de bloqueo para implementar [accept_mutex](#accept-mutex)
y serializar el acceso a la memoria compartida.
En la mayoría de los sistemas, los bloqueos se gestionan mediante operaciones atómicas,
lo que hace innecesaria esta directiva.
En ciertos sistemas, sin embargo, se utiliza un mecanismo alternativo de archivo de bloqueo.
Esta directiva establece un prefijo para los nombres de archivos de bloqueo.
### master_process
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `master_process` `on` | `off`; |
|--------------------------------------------------------------------------------------------|----------------------------------|
| Predeterminado | `master_process on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Determina si se inician procesos de trabajo.
Esta directiva está destinada para desarrolladores de Angie.
### multi_accept
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `multi_accept` `on` | `off`; |
|--------------------------------------------------------------------------------------------|--------------------------------|
| Predeterminado | `multi_accept off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
| `on` | Un proceso de trabajo aceptará todas las nuevas conexiones simultáneamente. |
|--------|-------------------------------------------------------------------------------|
| `off` | Un proceso de trabajo aceptará una nueva conexión a la vez. |
#### NOTE
Esta directiva se ignora
si se utiliza el método de procesamiento de conexiones [kqueue](https://es.angie.software//angie/docs/configuration/processing.md#kqueue),
ya que proporciona el número de nuevas conexiones listas para ser aceptadas.
### pcre_jit
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `pcre_jit` `on` | `off`; |
|--------------------------------------------------------------------------------------------|----------------------------|
| Predeterminado | `pcre_jit off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Habilita o deshabilita la "compilación just-in-time" (PCRE JIT)
para expresiones regulares conocidas en el momento del análisis de la configuración.
La PCRE JIT puede acelerar significativamente el procesamiento de expresiones regulares.
#### NOTE
JIT está disponible en las bibliotecas PCRE desde la versión 8.20,
siempre que se hayan compilado con la opción de configuración `--enable-jit`.
Cuando Angie se compila con la biblioteca PCRE (`--with-pcre=`),
el soporte JIT se habilita mediante la opción `--with-pcre-jit`.
### pid
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `pid` file | `off`; |
|--------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Predeterminado | `pid logs/angie.pid;` (la ruta depende de la [opción de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#paths) `--pid-path`) |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Especifica el archivo que almacenará el ID del proceso principal de Angie.
El archivo se crea atómicamente, lo que garantiza que su contenido siempre sea correcto.
La opción `off` desactiva la creación de este archivo.
#### NOTE
Si se modifica el valor de file durante la reconfiguración
pero apunta a un enlace simbólico del archivo PID anterior,
el archivo no se volverá a crear.
### ssl_engine
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `ssl_engine` device; |
|--------------------------------------------------------------------------------------------|------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Especifica el nombre del acelerador de hardware SSL.
### ssl_object_cache_inheritable
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `ssl_object_cache_inheritable` `on` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------------------------------|
| Predeterminado | `ssl_object_cache_inheritable on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Si está habilitado, los objetos SSL (certificados SSL, claves secretas, certificados CA de confianza,
listas CRL) se heredan a través de las recargas de configuración.
Los objetos SSL cargados desde archivos se heredan si su tiempo de modificación e índice
de archivo no han cambiado desde la carga de configuración anterior. Las claves secretas
especificadas como `engine:name:id` nunca se heredan, mientras que las claves secretas
especificadas como `data:value` siempre se heredan.
Los objetos SSL cargados desde variables no pueden heredarse.
Ejemplo:
```nginx
ssl_object_cache_inheritable on;
http {
server {
ssl_certificate example.com.crt;
ssl_certificate_key example.com.key;
}
}
```
### thread_pool
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `thread_pool` name `threads=`number [`max_queue=`number]; |
|--------------------------------------------------------------------------------------------|-------------------------------------------------------------|
| Predeterminado | `thread_pool default threads=32 max_queue=65536;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Define el nombre y los parámetros de un grupo de hilos
utilizado para la lectura y envío de archivos multihilo
[sin bloqueo](https://es.angie.software//angie/docs/configuration/modules/http/index.md#aio) de procesos de trabajo.
El parámetro `threads` define el número de hilos en el grupo.
Si todos los hilos del grupo están ocupados ejecutando tareas, las nuevas tareas esperan en una cola.
El parámetro `max_queue` limita el número de tareas
permitidas para esperar en la cola.
Por defecto, hasta 65536 tareas pueden estar en la cola.
Cuando la cola se desborda, la tarea se completa con un error.
### timer_resolution
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `timer_resolution` interval; |
|--------------------------------------------------------------------------------------------|--------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Reduce la resolución del temporizador en los procesos de trabajo,
reduciendo así el número de llamadas al sistema `gettimeofday()`.
Por defecto, `gettimeofday()` se llama cada vez que se recibe un evento del kernel.
Con resolución reducida, `gettimeofday()` solo se llama una vez por intervalo especificado.
Ejemplo:
```nginx
timer_resolution 100ms;
```
La implementación interna del intervalo depende del método utilizado:
- el filtro `EVFILT_TIMER` si se usa [kqueue](https://es.angie.software//angie/docs/configuration/processing.md#kqueue);
- `timer_create()` si se usa [eventport](https://es.angie.software//angie/docs/configuration/processing.md#eventport);
- `setitimer()` en otros casos.
### use
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `use` method; |
|--------------------------------------------------------------------------------------------|-----------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Especifica el método a utilizar para el [procesamiento de conexiones](https://es.angie.software//angie/docs/configuration/processing.md#methods-use).
Normalmente no hay necesidad de especificarlo explícitamente,
porque Angie utilizará por defecto el método más eficiente.
### user
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `user` user [group]; |
|--------------------------------------------------------------------------------------------|------------------------------------------------------------|
| Predeterminado | `user ;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Define las credenciales de user y group utilizadas por los procesos de trabajo
(ver también [parámetros de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#configure)).
Si se omite group, se utiliza un grupo cuyo nombre es igual al de user.
### worker_aio_requests
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_aio_requests` number; |
|--------------------------------------------------------------------------------------------|---------------------------------|
| Predeterminado | `worker_aio_requests 32;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Al usar [aio](https://es.angie.software//angie/docs/configuration/modules/http/index.md#aio) con el método de procesamiento de conexiones [epoll](https://es.angie.software//angie/docs/configuration/processing.md#epoll),
establece el número máximo de operaciones de E/S asíncronas pendientes
para un único proceso de trabajo.
### worker_connections
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_connections` number; |
|--------------------------------------------------------------------------------------------|--------------------------------|
| Predeterminado | `worker_connections 512;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Establece el número máximo de conexiones simultáneas que puede abrir un proceso de trabajo.
Debe tenerse en cuenta que este número incluye todas las conexiones
(por ejemplo, conexiones con servidores proxy, entre otras),
no solo conexiones con clientes.
Otra consideración es que el número real de conexiones simultáneas
no puede exceder el límite actual del número máximo de archivos abiertos,
que puede cambiarse mediante [worker_rlimit_nofile](#worker-rlimit-nofile).
### worker_cpu_affinity
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_cpu_affinity` cpumask ...;
`worker_cpu_affinity` auto [cpumask]; |
|--------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Vincula los procesos de trabajo a conjuntos de CPUs.
Cada conjunto de CPU está representado por una máscara de bits de CPUs permitidas.
Debe definirse un conjunto separado para cada uno de los procesos de trabajo.
Por defecto, los procesos de trabajo no están vinculados a ninguna CPU específica.
Por ejemplo:
```nginx
worker_processes 4;
worker_cpu_affinity 0001 0010 0100 1000;
```
Esta configuración vincula cada proceso de trabajo a una CPU separada.
Alternativamente:
```nginx
worker_processes 2;
worker_cpu_affinity 0101 1010;
```
Esto vincula el primer proceso de trabajo a CPU0 y CPU2,
y el segundo proceso de trabajo a CPU1 y CPU3.
Esta configuración es adecuada para hyper-threading.
El valor especial `auto`
permite vincular automáticamente los procesos de trabajo a las CPUs disponibles:
```nginx
worker_processes auto;
worker_cpu_affinity auto;
```
El parámetro opcional de máscara puede utilizarse para limitar las CPUs
disponibles para la vinculación automática:
```nginx
worker_cpu_affinity auto 01010101;
```
#### NOTE
La directiva solo está disponible en FreeBSD y Linux.
### worker_priority
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_priority` number; |
|--------------------------------------------------------------------------------------------|-----------------------------|
| Predeterminado | `worker_priority 0;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Define la prioridad de planificación para los procesos de trabajo, tal como lo hace
el comando **nice**: un number negativo
significa mayor prioridad.
El rango permitido normalmente varía de -20 a 20.
Ejemplo:
```nginx
worker_priority -10;
```
### worker_processes
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_processes` number | `auto`; |
|--------------------------------------------------------------------------------------------|---------------------------------------|
| Predeterminado | `worker_processes 1;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Define el número de procesos de trabajo.
El valor óptimo depende de muchos factores, incluyendo (pero no limitado a)
el número de núcleos de CPU, el número de discos duros que almacenan datos,
y el patrón de carga.
En caso de duda, establecerlo al número de núcleos de CPU disponibles
sería un buen inicio (el valor "`auto`" intentará detectarlo automáticamente).
### worker_rlimit_core
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_rlimit_core` size; |
|--------------------------------------------------------------------------------------------|------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Cambia el límite del tamaño máximo de un archivo core (`RLIMIT_CORE`)
para los procesos de trabajo.
Se utiliza para aumentar el límite sin reiniciar el proceso principal.
### worker_rlimit_nofile
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_rlimit_nofile` number; |
|--------------------------------------------------------------------------------------------|----------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Cambia el límite del número máximo de archivos abiertos (`RLIMIT_NOFILE`)
para los procesos de trabajo.
Se utiliza para aumentar el límite sin reiniciar el proceso principal.
### worker_shutdown_timeout
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_shutdown_timeout` time; |
|--------------------------------------------------------------------------------------------|-----------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Configura un tiempo de espera en segundos para un apagado ordenado de los procesos de trabajo.
Cuando el tiempo especificado expira,
Angie intentará cerrar todas las conexiones actualmente abiertas
para facilitar el apagado.
El apagado ordenado se inicia enviando una [señal QUIT](https://es.angie.software//angie/docs/configuration/runtime.md#control-signals) al proceso principal, que indica a los procesos de trabajo
que dejen de aceptar nuevas conexiones y permite que las conexiones existentes se completen.
Los procesos de trabajo continúan manejando las solicitudes activas hasta que finalicen,
y luego se apagan de manera ordenada. Si las conexiones permanecen abiertas
más tiempo que `worker_shutdown_timeout`, Angie cerrará forzosamente estas
conexiones para completar el apagado.
Además, las conexiones keep-alive del cliente se cierran solo si han estado
inactivas durante al menos el tiempo especificado por [lingering_timeout](https://es.angie.software//angie/docs/configuration/modules/http/index.md#lingering-timeout).
### working_directory
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `working_directory` directory; |
|--------------------------------------------------------------------------------------------|----------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Define el directorio de trabajo actual para un proceso de trabajo.
Se utiliza principalmente al escribir un archivo core,
en cuyo caso un proceso de trabajo debe tener permiso de escritura para el
directorio especificado.
# https://es.angie.software/angie/docs/configuration/modules/http.md
# Módulo HTTP
El módulo HTTP principal implementa la funcionalidad básica de un servidor HTTP:
esto incluye la definición de bloques de servidor, la configuración de
ubicaciones para el enrutamiento de peticiones, la entrega de archivos estáticos
y el control de acceso, la configuración de redirecciones, el soporte de
conexiones keep-alive y la gestión de cabeceras de petición y respuesta.
Los demás módulos de esta sección amplían esta funcionalidad, permitiendo
configurar y optimizar de forma flexible el servidor HTTP para distintos
escenarios y requisitos.
## Directivas
### absolute_redirect
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `absolute_redirect` `on` | `off`; |
|--------------------------------------------------------------------------------------------|-------------------------------------|
| Predeterminado | `absolute_redirect on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Si está deshabilitada, las redirecciones emitidas por Angie serán relativas.
Véase también las directivas [server_name_in_redirect](#server-name-in-redirect) y [port_in_redirect](#port-in-redirect).
### aio
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `aio` `on` | `off` | `threads` [=pool]; |
|--------------------------------------------------------------------------------------------|-------------------------------------------|
| Predeterminado | `aio off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva el uso de operaciones de E/S de archivos asíncronas (AIO) en FreeBSD y Linux:
```nginx
location /video/ {
aio on;
output_buffers 1 64k;
}
```
En FreeBSD, AIO puede usarse a partir de FreeBSD 4.3. Antes de FreeBSD 11.0,
AIO podía enlazarse estáticamente en el núcleo:
```nginx
options VFS_AIO
```
o cargarse dinámicamente como un módulo del núcleo:
```nginx
kldload aio
```
En Linux, AIO puede usarse desde la versión 2.6.22 del núcleo. Además, es necesario habilitar [directio](#directio), de lo contrario la lectura será bloqueante:
```nginx
location /video/ {
aio on;
directio 512;
output_buffers 1 128k;
}
```
En Linux, [directio](#directio) solo puede usarse para leer bloques alineados en
fronteras de 512 bytes (o 4K en XFS). El final de un archivo no alineado se lee
en modo bloqueante. Lo mismo se aplica a las solicitudes de rango de bytes y a
las solicitudes FLV que no empiezan desde el inicio del archivo: la lectura de
datos no alineados al principio y al final de un archivo será bloqueante.
Cuando AIO y [sendfile](#sendfile) están habilitados simultáneamente en Linux, AIO se
usa para los archivos cuyo tamaño es mayor o igual al especificado en la
directiva [directio](#directio), mientras que [sendfile](#sendfile) se usa para archivos más
pequeños o cuando [directio](#directio) está deshabilitado:
```nginx
location /video/ {
sendfile on;
aio on;
directio 8m;
}
```
Finalmente, los archivos pueden leerse y [enviarse](#sendfile) usando
multihilo, sin bloquear un proceso worker:
```nginx
location /video/ {
sendfile on;
aio threads;
}
```
Las operaciones de lectura y envío de archivos se delegan a los hilos del
[pool](https://es.angie.software//angie/docs/configuration/modules/core.md#thread-pool) especificado. Si se omite el nombre del pool, se usa
el pool llamado "default". El nombre del pool también puede definirse mediante
variables:
```nginx
aio threads=pool$disk;
```
Usar `aio on` requiere compilar con el parámetro de configuración
`--with-file-aio`. Usar `aio threads` requiere compilar con el
parámetro `--with-threads`.
Actualmente, el multihilo solo es compatible con los métodos [epoll](https://es.angie.software//angie/docs/configuration/processing.md#epoll), [kqueue](https://es.angie.software//angie/docs/configuration/processing.md#kqueue) y [eventport](https://es.angie.software//angie/docs/configuration/processing.md#eventport). El envío
multihilo de archivos solo está soportado en Linux.
Véase también la directiva [sendfile](#sendfile).
### aio_write
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `aio_write` `on` | `off`; |
|--------------------------------------------------------------------------------------------|-----------------------------|
| Predeterminado | `aio_write off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Si [aio](#aio) está habilitado, especifica si se utiliza para la escritura de archivos. Actualmente, esto solo funciona cuando se usa `aio threads` y está limitado a la escritura de archivos temporales con datos recibidos de servidores proxificados.
### alias
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `alias` path; |
|--------------------------------------------------------------------------------------------|-----------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Define un reemplazo para la ubicación especificada. Por ejemplo, con la siguiente configuración:
```nginx
location /i/ {
alias /data/w3/images/;
}
```
al solicitar `/i/top.gif`, se enviará el archivo /data/w3/images/top.gif.
El valor path puede contener [variables](https://es.angie.software//angie/docs/configuration/configfile.md#string-variables), excepto [$document_root](#v-document-root) y [$realpath_root](#v-realpath-root).
Si `alias` se usa dentro de una ubicación definida con una expresión regular, dicha expresión debe contener capturas y `alias` debe referirse a esas capturas, por ejemplo:
```nginx
location ~ ^/users/(.+\.(?:gif|jpe?g|png))$ {
alias /data/w3/images/$1;
}
```
Cuando la ubicación coincide con la última parte del valor de la directiva:
```nginx
location /images/ {
alias /data/w3/images/;
}
```
es mejor usar la directiva [root](#root) en su lugar:
```nginx
location /images/ {
root /data/w3;
}
```
### auth_delay
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `auth_delay` time; |
|--------------------------------------------------------------------------------------------|------------------------|
| Predeterminado | `auth_delay 0s;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Retrasa el procesamiento de las solicitudes no autorizadas con el código de respuesta 401 para prevenir ataques de temporización cuando el acceso está limitado por [contraseña](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic) o por el [resultado de una subsolicitud](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request).
### auto_redirect
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `auto_redirect` [`on` | `off` | `default`]; |
|--------------------------------------------------------------------------------------------|-----------------------------------------------|
| Predeterminado | `auto_redirect default;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Controla el comportamiento de la [redirección](#location-redirect) cuando
una ubicación con prefijo termina en una barra inclinada:
```nginx
location /prefix/ {
auto_redirect on;
}
```
Aquí, una solicitud a `/prefix` provoca una redirección a `/prefix/`.
El valor `on` habilita explícitamente la redirección, mientras que
`off` la desactiva. Cuando se establece en `default`, la redirección
solo se habilita si la ubicación procesa solicitudes con [api](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#a-api),
[proxy_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass), [fastcgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass), [uwsgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-pass), [scgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-pass),
[memcached_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_memcached.md#memcached-pass) o [grpc_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_grpc.md#grpc-pass).
### chunked_transfer_encoding
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `chunked_transfer_encoding` `on` | `off`; |
|--------------------------------------------------------------------------------------------|---------------------------------------------|
| Predeterminado | `chunked_transfer_encoding on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite desactivar la codificación de transferencia fragmentada (chunked) en HTTP/1.1. Puede resultar útil cuando se utiliza software que no admite esta codificación a pesar de ser un requisito del estándar.
### client
#### Versionadded
Added in version 1.10.0.
#### Versionchanged
Distinto en la versión 1.10.1.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `client` { ... } |
|--------------------------------------------------------------------------------------------|--------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Crea un contexto especial `client` para procesar solicitudes HTTP internas
que Angie realiza por sí mismo sin la participación de clientes externos.
El contexto `client` aísla el tráfico de servicio de varios módulos de
Angie del tráfico de usuario, permitiendo un control adicional sobre él. Dentro
de este contexto, solo pueden definirse ubicaciones con nombre (con el prefijo
`@`); estas no son accesibles para solicitudes HTTP externas y solo pueden
invocarse programáticamente a través de mecanismos internos del servidor.
El contexto `client` se utiliza para:
- enviar solicitudes a la autoridad de certificación en el módulo [ACME](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme)
mediante la ubicación predefinida `location @acme`, que puede
configurarse adicionalmente usando directivas del módulo [Proxy](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy);
- solicitudes a la API de Docker en el módulo [Docker](https://es.angie.software//angie/docs/configuration/modules/http/http_docker.md#http-docker) mediante las
ubicaciones predefinidas `location @docker_events` y
`@docker_containers`, que pueden configurarse adicionalmente usando
directivas del módulo [Proxy](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy);
- sondas de salud de servidores proxificados mediante [upstream_probe (PRO)](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe);
- modo [sticky learn](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-sticky) con `remote_action` en el módulo
[Upstream](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#stream-upstream) de stream.
El soporte para múltiples bloques `client` permite agrupar configuraciones
comunes para múltiples bloques `location` dentro de cada bloque, lo que
ayuda a evitar la duplicación de configuración.
Las directivas especificadas en cada bloque `client` solo son heredadas
por los bloques `location` declarados explícitamente dentro de él. En
particular, por eso no afectan a la configuración de otros módulos que usan
implícitamente el bloque `client` para solicitudes salientes (por ejemplo,
[ACME](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme) o [Docker](https://es.angie.software//angie/docs/configuration/modules/http/http_docker.md#http-docker)).
Ejemplo de uso de múltiples bloques `client` con herencia de
configuración:
```nginx
client {
proxy_set_header Host docker.example.com;
proxy_set_header Authorization "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==";
location @docker_events {
}
location @docker_containers {
}
}
client {
proxy_method GET;
proxy_set_header Host backend.example.com;
proxy_set_header X-Real-IP $remote_addr;
location @health_check {
proxy_pass http://upstream-server/health;
}
}
```
#### NOTE
Aquí se permiten las mismas directivas que en bloques `location` normales,
pero solo funcionan los manejadores de contenido
(como [js_content](https://es.angie.software//angie/docs/configuration/modules/external-modules/http_js.md#js-content) o [autoindex](https://es.angie.software//angie/docs/configuration/modules/http/http_autoindex.md#id1))
y los manejadores de variables (como [map](https://es.angie.software//angie/docs/configuration/modules/http/http_map.md#id1)),
así como las directivas que generan peticiones por sí mismas,
como `upstream_probe`.
Las directivas que operan en otras
[etapas de procesamiento de la petición](https://es.angie.software//angie/docs/configuration/processing.md#http-sessions)
(como [limit_req](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#limit-req), [auth_request](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#id1),
[try_files](#try-files), filtros de imagen, XSLT, etc.)
no funcionan aquí.
### client_body_buffer_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_body_buffer_size` size; |
|--------------------------------------------------------------------------------------------|-----------------------------------|
| Predeterminado | `client_body_buffer_size 8k|16k;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define el tamaño del búfer para leer el cuerpo de la petición del cliente. Si el cuerpo de la petición es mayor que el búfer, el cuerpo completo o solo una parte se escribe en un [archivo temporal](#client-body-temp-path). Por defecto, el tamaño del búfer equivale a dos páginas de memoria. En x86, otras plataformas de 32 bits y x86-64, esto es 8K. En otras plataformas de 64 bits, normalmente es 16K.
### client_body_in_file_only
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_body_in_file_only` `on` | `clean` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------------------------------------|
| Predeterminado | `client_body_in_file_only off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Determina si se guarda el cuerpo completo de la petición del cliente en un archivo. Esta directiva puede usarse durante la depuración, o cuando se utiliza la variable [$request_body_file](#v-request-body-file) o el método [$r->request_body_file](https://es.angie.software//angie/docs/configuration/modules/http/http_perl.md#p-r-request-body-file) del módulo [Perl](https://es.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl).
| `on` | los archivos temporales no se eliminan después de procesar la petición |
|---------|--------------------------------------------------------------------------|
| `clean` | permite eliminar los archivos temporales tras procesar la petición |
### client_body_in_single_buffer
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_body_in_single_buffer` `on` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------------------------------|
| Predeterminado | `client_body_in_single_buffer off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Determina si se guarda el cuerpo completo de la petición del cliente en un solo búfer. La directiva se recomienda cuando se usa la variable [$request_body](#v-request-body) para reducir el número de operaciones de copia implicadas.
### client_body_temp_path
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_body_temp_path` path [level1 [level2 [level3]]]; |
|--------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Predeterminado | `client_body_temp_path client_body_temp;` (la ruta depende de la [opción de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#paths) `--http-client-body-temp-path`) |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define un directorio para almacenar archivos temporales con cuerpos de peticiones de clientes. Se puede usar hasta una jerarquía de subdirectorios de tres niveles bajo el directorio especificado. Por ejemplo, en la siguiente configuración
```nginx
client_body_temp_path /spool/angie/client_temp 1 2;
```
la ruta de un archivo temporal podría ser:
```nginx
/spool/angie/client_temp/7/45/00000123457
```
### client_body_timeout
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_body_timeout` time; |
|--------------------------------------------------------------------------------------------|-------------------------------|
| Predeterminado | `client_body_timeout 60s;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define un tiempo de espera para leer el cuerpo de la petición del cliente. El tiempo de espera se establece solo entre dos operaciones de lectura sucesivas, no para la transmisión completa del cuerpo de la petición. Si un cliente no transmite nada dentro de este tiempo, la petición finaliza con el error 408 (Request Time-out).
### client_header_buffer_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_header_buffer_size` size; |
|--------------------------------------------------------------------------------------------|-------------------------------------|
| Predeterminado | `client_header_buffer_size 1k;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Define el tamaño del búfer para leer la cabecera de la petición del cliente. Para la mayoría de las peticiones, un búfer de 1K es suficiente. Sin embargo, si la petición incluye cookies largas o proviene de un cliente WAP, podría no caber en 1K. Si la línea de petición o un campo de cabecera no caben en este búfer, se asignan búferes más grandes, configurados mediante la directiva [large_client_header_buffers](#large-client-header-buffers).
Si la directiva se especifica en el nivel [server](#server), puede usarse el valor del servidor por defecto. Véase la sección [Selección de servidor virtual](https://es.angie.software//angie/docs/configuration/processing.md#request-processing) para más detalles.
### client_header_timeout
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_header_timeout` time; |
|--------------------------------------------------------------------------------------------|---------------------------------|
| Predeterminado | `client_header_timeout 60s;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Define un tiempo de espera para leer la cabecera de la petición del cliente. Si un cliente no transmite la cabecera completa dentro de este tiempo, la petición finaliza con el error 408 (Request Time-out).
### client_max_body_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_max_body_size` size; |
|--------------------------------------------------------------------------------------------|--------------------------------|
| Predeterminado | `client_max_body_size 1m;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define el tamaño máximo permitido para el cuerpo de la petición del cliente. Si el tamaño en una petición excede el valor configurado, se devuelve al cliente el error 413 (Request Entity Too Large). Ten en cuenta que los navegadores no pueden mostrar correctamente este error.
| `0` | desactiva la comprobación del tamaño del cuerpo de la petición del cliente |
|-------|------------------------------------------------------------------------------|
### connection_pool_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `connection_pool_size` size; |
|--------------------------------------------------------------------------------------------|-------------------------------------|
| Predeterminado | `connection_pool_size 256` | `512;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite ajustar con precisión las asignaciones de memoria por conexión. Esta directiva tiene un impacto mínimo en el rendimiento y generalmente no debería usarse. Por defecto:
| `256` (bytes) | en plataformas de 32 bits |
|-----------------|-----------------------------|
| `512` (bytes) | en plataformas de 64 bits |
### default_type
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `default_type` mime-type; |
|--------------------------------------------------------------------------------------------|-----------------------------|
| Predeterminado | `default_type text/plain;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define el tipo MIME predeterminado de una respuesta. El mapeo de extensiones de nombre de archivo a tipos MIME puede establecerse con la directiva [types](#types).
### directio
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `directio` size | `off`; |
|--------------------------------------------------------------------------------------------|----------------------------|
| Predeterminado | `directio off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita el uso de la bandera `O_DIRECT` (FreeBSD, Linux), la bandera `F_NOCACHE` (macOS) o la función `directio()` (Solaris) al leer archivos que son mayores o iguales al tamaño especificado. La directiva desactiva automáticamente el uso de [sendfile](#sendfile) para una petición dada. Se recomienda para servir archivos grandes:
```nginx
directio 4m;
```
o cuando se usa [aio](#aio) en Linux.
### directio_alignment
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `directio_alignment` size; |
|--------------------------------------------------------------------------------------------|------------------------------|
| Predeterminado | `directio_alignment 512;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define la alineación para [directio](#directio). En la mayoría de los casos, una alineación de 512 bytes es suficiente. Sin embargo, al usar XFS en Linux, debe aumentarse a 4K.
### disable_symlinks
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `disable_symlinks` `off`;
`disable_symlinks` `on` | `if_not_owner` [`from=`part]; |
|--------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------|
| Predeterminado | `disable_symlinks off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Determina cómo deben tratarse los enlaces simbólicos al abrir archivos:
| `off` | Se permiten enlaces simbólicos en la ruta y no se comprueban. Este es el comportamiento predeterminado. |
|----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `on` | Si algún componente de la ruta es un enlace simbólico, se deniega el acceso al archivo. |
| `if_not_owner` | Se deniega el acceso al archivo si algún componente de la ruta es un enlace simbólico y el enlace y el objeto al que apunta tienen propietarios diferentes. |
| `from=`part | Al comprobar enlaces simbólicos (parámetros `on` y `if_not_owner`), normalmente se comprueban todos los componentes de la ruta. Es posible omitir la comprobación de enlaces simbólicos en la parte inicial de la ruta indicando adicionalmente el parámetro `from=part`. En este caso, los enlaces simbólicos se comprueban solo a partir del componente de ruta que sigue a la parte inicial especificada. Si el valor no es una parte inicial de la ruta comprobada, la ruta se comprueba por completo, como si no se hubiera especificado este parámetro. Si el valor coincide exactamente con el nombre del archivo, no se comprueban los enlaces simbólicos. Se pueden usar variables en el valor del parámetro. |
Ejemplo:
```nginx
disable_symlinks on from=$document_root;
```
Esta directiva solo está disponible en sistemas que tengan las interfaces `openat()` y `fstatat()`. Dichos sistemas incluyen versiones modernas de FreeBSD, Linux y Solaris.
#### WARNING
Los parámetros `on` y `if_not_owner` añaden sobrecarga de procesamiento.
En los sistemas que no admiten abrir directorios solo para búsqueda, el uso de estos parámetros requiere que los procesos worker tengan permisos de lectura en todos los directorios que se verifiquen.
#### NOTE
Los módulos [AutoIndex](https://es.angie.software//angie/docs/configuration/modules/http/http_autoindex.md#http-autoindex), [Random Index](https://es.angie.software//angie/docs/configuration/modules/http/http_random_index.md#http-random-index) y [DAV](https://es.angie.software//angie/docs/configuration/modules/http/http_dav.md#http-dav) actualmente ignoran esta directiva.
### early_hints
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `early_hints` string ...; |
|--------------------------------------------------------------------------------------------|-----------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define las condiciones bajo las cuales se pasará al cliente la respuesta "103 Early Hints". La respuesta puede ser devuelta por backends proxificados y gRPC. Si al menos un valor de los parámetros string no está vacío y no es igual a `0`, se pasará la respuesta:
```nginx
map $http_sec_fetch_mode $early_hints {
navigate $http2$http3;
}
server {
...
location / {
early_hints $early_hints;
proxy_pass http://example.com;
}
}
```
Los valores de los parámetros pueden contener variables.
### error_log_user_tag
#### Versionadded
Added in version 1.12.0.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `error_log_user_tag` value; |
|--------------------------------------------------------------------------------------------|--------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, limit_except |
Añade una etiqueta específica de la solicitud a los registros de [error_log](https://es.angie.software//angie/docs/configuration/modules/core.md#error-log). value puede
[contener variables](https://es.angie.software//angie/docs/configuration/configfile.md#string-variables). La directiva puede especificarse
varias veces para añadir varias etiquetas. Las etiquetas pueden coincidir con
`filter=tag:` en [error_log](https://es.angie.software//angie/docs/configuration/modules/core.md#error-log).
### error_page
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `error_page` code ... [=[response]] uri; |
|--------------------------------------------------------------------------------------------|--------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Define el URI que se mostrará para los errores especificados. El valor uri puede usar variables.
Ejemplo:
```nginx
error_page 404 /404.html;
error_page 500 502 503 504 /50x.html;
```
Esto provoca una redirección interna al uri especificado, cambiando el método de la petición del cliente a "GET" (para todos los métodos distintos de "GET" y "HEAD").
Además, es posible cambiar el código de respuesta a otro usando la sintaxis `=response`, por ejemplo:
```nginx
error_page 404 =200 /empty.gif;
```
Si una respuesta de error es procesada por un servidor proxificado o un servidor FastCGI/uwsgi/SCGI/gRPC, y el servidor puede devolver distintos códigos de respuesta (p. ej., 200, 302, 401 o 404), es posible pasar el código que devuelva:
```nginx
error_page 404 = /404.php;
```
Si no es necesario cambiar el URI y el método durante la redirección interna, es posible delegar el procesamiento del error a un `location` con nombre:
```nginx
location / {
error_page 404 = @fallback;
}
location @fallback {
proxy_pass http://backend;
}
```
#### NOTE
Si ocurre un error durante el procesamiento del uri, se devuelve al cliente la respuesta con el código del último error ocurrido.
También es posible usar redirecciones URL para el manejo de errores:
```nginx
error_page 403 http://example.com/forbidden.html;
error_page 404 =301 http://example.com/notfound.html;
```
En este caso, por defecto, se devuelve al cliente el código de respuesta 302. Solo puede cambiarse a uno de los códigos de redirección (301, 302, 303, 307 y 308).
### etag
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `etag` `on` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------|
| Predeterminado | `etag on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva la generación automática del campo de cabecera de respuesta `ETag` para recursos estáticos.
### http
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `http` { ... } |
|--------------------------------------------------------------------------------------------|------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Proporciona el contexto de archivo de configuración en el que se especifican las directivas del servidor HTTP.
### if_modified_since
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `if_modified_since` `off` | `exact` | `before`; |
|--------------------------------------------------------------------------------------------|---------------------------------------------------|
| Predeterminado | `if_modified_since exact;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Especifica cómo comparar la fecha de modificación de una respuesta con la fecha del campo de cabecera `If-Modified-Since` en la petición:
| `off` | la respuesta siempre se considera modificada |
|----------|-----------------------------------------------------------------------------------------------------------------------------------|
| `exact` | coincidencia exacta |
| `before` | la fecha de modificación de la respuesta es menor o igual que la fecha en el campo de cabecera `If-Modified-Since` de la petición |
### ignore_invalid_headers
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `ignore_invalid_headers` `on` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------------------------|
| Predeterminado | `ignore_invalid_headers on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Controla si Angie ignora los campos de cabecera con nombres no válidos. Los nombres válidos están compuestos por letras en inglés, dígitos, guiones y, posiblemente, guiones bajos (según lo controle la directiva [underscores_in_headers](#underscores-in-headers)).
Si la directiva se especifica en el nivel [server](#server), puede usarse el valor del servidor predeterminado.
### internal
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `internal;` |
|--------------------------------------------------------------------------------------------|---------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Especifica que un `location` dado solo puede usarse para peticiones internas. Para peticiones externas, se devuelve el error de cliente 404 (Not Found). Las peticiones internas son las siguientes:
* peticiones redirigidas por las directivas [error_page](#error-page), [index](https://es.angie.software//angie/docs/configuration/modules/http/http_index.md#id1), [random_index](https://es.angie.software//angie/docs/configuration/modules/http/http_random_index.md#random-index) y [try_files](#try-files);
* peticiones redirigidas por el campo de cabecera de respuesta `X-Accel-Redirect` de un servidor upstream;
* subpeticiones formadas por el comando `include virtual` del módulo [SSI](https://es.angie.software//angie/docs/configuration/modules/http/http_ssi.md#http-ssi), por las directivas del módulo [Addition](https://es.angie.software//angie/docs/configuration/modules/http/http_addition.md#http-addition), y por las directivas [auth_request](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#id1) y [mirror](https://es.angie.software//angie/docs/configuration/modules/http/http_mirror.md#id1);
* peticiones modificadas por la directiva [rewrite](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#id5);
* peticiones redirigidas por la directiva [goto](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#goto).
Ejemplo:
```nginx
error_page 404 /404.html;
location = /404.html {
internal;
}
```
Dado que el error 404 se devuelve en el contexto de un `location` con la directiva `internal`, las peticiones externas pueden redirigirse a un location diferente. Esto permite usar el mismo prefijo tanto para peticiones externas como internas, pero con procesamientos distintos, por ejemplo:
```nginx
location /path {
internal;
error_page 404 =@external;
proxy_pass https://internal;
}
location @external {
proxy_pass https://external;
}
```
Aquí, una petición externa `GET /path` se enviará por proxy a
`https://external/path`, mientras que la misma petición interna se enviará por proxy a
`https://internal/path`.
#### NOTE
Hay un límite de 10 redirecciones internas por petición para prevenir ciclos de procesamiento de peticiones que pueden ocurrir en configuraciones incorrectas. Si se alcanza este límite, se devuelve el error 500 (Internal Server Error). En tales casos, puede verse el mensaje `rewrite or internal redirection cycle` en el registro de errores.
### keepalive_disable
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `keepalive_disable` `none` | browser ...; |
|--------------------------------------------------------------------------------------------|---------------------------------------------|
| Predeterminado | `keepalive_disable msie6;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Desactiva las conexiones keep-alive con navegadores que se comportan mal. Los parámetros browser especifican qué navegadores se verán afectados.
| `none` | activa las conexiones keep-alive con todos los navegadores |
|----------|----------------------------------------------------------------------------------------------------------------------------------|
| `msie6` | desactiva las conexiones keep-alive con versiones antiguas de MSIE, una vez que se recibe una petición POST |
| `safari` | desactiva las conexiones keep-alive con Safari y navegadores similares a Safari en macOS y sistemas operativos similares a macOS |
### keepalive_requests
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `keepalive_requests` number; |
|--------------------------------------------------------------------------------------------|--------------------------------|
| Predeterminado | `keepalive_requests 1000;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define el número máximo de peticiones que pueden servirse a través de una sola conexión keep-alive. Una vez alcanzado el número máximo de peticiones, la conexión se cierra.
El cierre periódico de conexiones es necesario para liberar asignaciones de memoria por conexión. Por lo tanto, usar un número máximo demasiado alto de peticiones puede provocar un uso excesivo de memoria y no se recomienda.
### keepalive_time
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `keepalive_time` time; |
|--------------------------------------------------------------------------------------------|--------------------------|
| Predeterminado | `keepalive_time 1h;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Limita el tiempo máximo durante el cual pueden procesarse peticiones a través de una misma conexión keep-alive. Una vez alcanzado este tiempo, la conexión se cierra tras procesar la petición siguiente.
### keepalive_timeout
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `keepalive_timeout` timeout [header_timeout]; |
|--------------------------------------------------------------------------------------------|-------------------------------------------------|
| Predeterminado | `keepalive_timeout 75s;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
| timeout | define un tiempo de espera durante el cual una conexión keep-alive del cliente permanecerá abierta en el lado del servidor |
|-----------|------------------------------------------------------------------------------------------------------------------------------|
| `0` | desactiva las conexiones keep-alive de clientes |
El segundo parámetro, *opcional*, establece un valor en el campo de cabecera de respuesta `Keep-Alive: timeout=time`. Los dos parámetros pueden diferir.
El campo de cabecera `Keep-Alive: timeout=time` es reconocido por Mozilla y Konqueror. MSIE cierra las conexiones keep-alive por sí mismo en aproximadamente 60 segundos.
### large_client_header_buffers
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `large_client_header_buffers` number size; |
|--------------------------------------------------------------------------------------------|----------------------------------------------|
| Predeterminado | `large_client_header_buffers 4 8k;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Define el número máximo y el tamaño de los búferes usados para leer cabeceras grandes de peticiones de clientes. Una línea de petición no puede exceder el tamaño de un búfer, o se devuelve al cliente el error 414 (Request-URI Too Large). Un campo de cabecera tampoco puede exceder el tamaño de un búfer, o se devuelve el error 400 (Bad Request). Los búferes se asignan solo bajo demanda. Por defecto, el tamaño del búfer es de 8K bytes. Si, tras finalizar el procesamiento de la petición, una conexión pasa al estado keep-alive, estos búferes se liberan.
Si la directiva se especifica en el nivel [server](#server), puede usarse el valor del servidor por defecto.
### limit_except
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `limit_except` method1 [method2...] { ... }; |
|--------------------------------------------------------------------------------------------|------------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Limita los métodos HTTP permitidos dentro de una ubicación. El parámetro method puede ser uno de los
siguientes: `GET`, `HEAD`, `POST`, `PUT`, `DELETE`,
`MKCOL`, `COPY`, `MOVE`, `OPTIONS`, `PROPFIND`,
`PROPPATCH`, `LOCK`, `UNLOCK` o `PATCH`. Permitir el
método `GET` hace que el método `HEAD` también esté permitido. El acceso a otros métodos
puede limitarse usando las directivas de los módulos [Access](https://es.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access) y
[Auth Basic](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic):
```nginx
limit_except GET {
allow 192.168.1.0/32;
deny all;
}
```
#### NOTE
La restricción en este ejemplo se aplica a todos los métodos
**excepto** `GET` y `HEAD`.
### limit_rate
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `limit_rate` rate; |
|--------------------------------------------------------------------------------------------|----------------------------------------|
| Predeterminado | `limit_rate 0;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Limita la velocidad de transmisión de la respuesta hacia un cliente. La velocidad se especifica en bytes por segundo. El valor cero desactiva la limitación de velocidad. El límite se aplica por petición; por lo tanto, si un cliente abre dos conexiones simultáneamente, la velocidad total será el doble del límite especificado.
El valor del parámetro puede contener variables. Esto puede ser útil en casos donde la velocidad deba limitarse en función de una condición determinada:
```nginx
map $slow $rate {
1 4k;
2 8k;
}
limit_rate $rate;
```
El límite de velocidad también puede establecerse en la variable [$limit_rate](#v-limit-rate), aunque este método no se recomienda:
```nginx
server {
if ($slow) {
set $limit_rate 4k;
}
}
```
El límite de velocidad también puede establecerse en el campo de cabecera `X-Accel-Limit-Rate` de la respuesta de un servidor proxificado. Esta capacidad puede desactivarse mediante las directivas [proxy_ignore_headers](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-ignore-headers), [fastcgi_ignore_headers](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-ignore-headers), [uwsgi_ignore_headers](https://es.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-ignore-headers) y [scgi_ignore_headers](https://es.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-ignore-headers).
### limit_rate_after
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `limit_rate_after` size; |
|--------------------------------------------------------------------------------------------|----------------------------------------|
| Predeterminado | `limit_rate_after 0;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Define la cantidad inicial después de la cual la transmisión de una respuesta al cliente será limitada en velocidad. El valor del parámetro puede contener variables.
Ejemplo:
```nginx
location /flv/ {
flv;
limit_rate_after 500k;
limit_rate 50k;
}
```
### lingering_close
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `lingering_close` `on` | `always` | `off`; |
|--------------------------------------------------------------------------------------------|----------------------------------------------|
| Predeterminado | `lingering_close on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Controla cómo Angie cierra las conexiones de clientes.
| `on` | instruye a Angie a [esperar](#lingering-timeout) y [procesar](#lingering-time) datos adicionales de un cliente antes de cerrar completamente una conexión, pero solo si la heurística sugiere que un cliente puede estar enviando más datos. |
|----------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `always` | Angie siempre esperará y procesará datos adicionales del cliente. |
| `off` | Angie no esperará más datos y cerrará la conexión inmediatamente. Este comportamiento rompe el protocolo y no debe usarse en circunstancias normales. |
Para controlar el cierre de conexiones HTTP/2, la directiva debe especificarse en el nivel [server](#server).
### lingering_time
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `lingering_time` time; |
|--------------------------------------------------------------------------------------------|--------------------------|
| Predeterminado | `lingering_time 30s;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Cuando [lingering_close](#lingering-close) está activo, esta directiva especifica el tiempo máximo durante el cual Angie procesará (leerá e ignorará) datos adicionales provenientes de un cliente. Después de eso, la conexión se cerrará, incluso si hay más datos.
### lingering_timeout
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `lingering_timeout` time; |
|--------------------------------------------------------------------------------------------|-----------------------------|
| Predeterminado | `lingering_timeout 5s;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Cuando [lingering_close](#lingering-close) está activo, esta directiva especifica el tiempo máximo
de espera para que lleguen más datos del cliente. Si no se reciben datos durante
este tiempo, la conexión se cierra. De lo contrario, los datos se leen e ignoran,
y Angie comienza a esperar más datos nuevamente. El ciclo "esperar-leer-ignorar" se
repite, pero no más tiempo del especificado por la directiva [lingering_time](#lingering-time).
Durante el apagado gradual, las conexiones keepalive de clientes se cierran solo cuando
han estado inactivas durante al menos el tiempo especificado en `lingering_timeout`.
#### NOTE
En nginx, la directiva análoga se llama [keepalive_min_timeout](https://nginx.org/en/docs/http/ngx_http_core_module.html#keepalive_min_timeout).
### listen
#### Versionchanged
Distinto en la versión 1.10.0.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `listen` address[:port] [`default_server`] [`ssl`] [http2 | `quic`] [`proxy_protocol`] [`setfib=`number] [`fastopen=`number] [`backlog=`number] [`rcvbuf=`size] [`sndbuf=`size] [`accept_filter=`filter] [`deferred`] [`bind`] [`ipv6only=``on` | `off`] [`reuseport`] [`so_keepalive=`on|off|[`keepidle`]:[`keepintvl`]:[`keepcnt`]];
`listen` unix:path [`default_server`] [`ssl`] [http2 | `quic`] [`proxy_protocol`] [`backlog=`number] [`rcvbuf=`size] [`sndbuf=`size] [`accept_filter=`filter] [`deferred`] [`bind`] [`so_keepalive=`on|off|[`keepidle`]:[`keepintvl`]:[`keepcnt`]]; |
|--------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Predeterminado | `listen *:80` | `*:8000;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | server |
Define la address y el port para el socket de escucha, o la ruta de un socket de dominio UNIX donde el servidor aceptará peticiones. Una address también puede ser un nombre de host, por ejemplo:
```nginx
listen 127.0.0.1:8000;
listen 127.0.0.1;
listen 8000;
listen *:8000;
listen localhost:8000;
```
Las direcciones IPv6 se especifican entre corchetes:
```nginx
listen [::]:8000;
listen [::1];
```
Los rangos de puertos se indican con el primer y último puerto separados por un guion:
```nginx
listen 127.0.0.1:8000-8009;
listen 8000-8009;
```
Los sockets de dominio UNIX se especifican con el prefijo `unix:`:
```nginx
listen unix:/var/run/angie.sock;
```
Pueden especificarse tanto address como port, o solo address o solo port.
Cuando se omiten algunas partes, se aplican las siguientes reglas:
- Si solo se da la address, se usa el puerto 80.
- Si solo se da el port,
Angie escucha en todas las interfaces IPv4 disponibles (y también IPv6, si está habilitado).
El primer bloque `server` para ese puerto
se convierte en el servidor por defecto para peticiones con una cabecera `Host` no coincidente.
- Si la directiva se omite por completo, Angie usa `*:80`
cuando se ejecuta con privilegios de superusuario, o `*:8000` en caso contrario.
| `default_server` | El servidor con este parámetro especificado será el servidor por defecto para el par address:port dado (juntos forman un *socket de escucha*).
Si no hay directivas con el parámetro `default_server`, el servidor por defecto para el socket de escucha será el primer servidor en la configuración que atienda ese socket. |
|--------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `ssl` | indica que todas las conexiones aceptadas en este socket de escucha deben funcionar en modo SSL. Esto permite una [configuración más compacta](https://es.angie.software//angie/docs/configuration/ssl.md#compact-server) para el servidor que maneja tanto peticiones HTTP como HTTPS. |
| `http2` | configura el puerto para aceptar conexiones HTTP/2. Normalmente, para que esto funcione debe especificarse también el parámetro `ssl`, aunque Angie también puede configurarse para aceptar conexiones HTTP/2 sin SSL.
#### Deprecated Obsoleto desde la versión 1.2.0: Usa en su lugar la directiva [http2](https://es.angie.software//angie/docs/configuration/modules/http/http_v2.md#http2). |
| `quic` | configura el puerto para aceptar conexiones QUIC. Para usar esta opción, Angie debe tener el [módulo HTTP/3](https://es.angie.software//angie/docs/configuration/modules/http/http_v3.md#http-v3) habilitado y configurado. Con `quic` activado, también se puede especificar `reuseport` para que puedan usarse múltiples procesos worker. |
| `proxy_protocol` | indica que todas las conexiones aceptadas en este socket de escucha deben usar el protocolo PROXY. |
La directiva `listen` también puede especificar varios parámetros adicionales específicos de llamadas al sistema relacionadas con sockets. Estos parámetros pueden especificarse en cualquier directiva `listen`, pero solo una vez para un socket de escucha determinado:
| `setfib=`number | establece la tabla de enrutamiento, FIB (la opción `SO_SETFIB`) para el socket de escucha. Actualmente solo funciona en FreeBSD. |
|--------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `fastopen=`number | habilita "TCP Fast Open" para el socket de escucha y limita la longitud máxima de la cola de conexiones que aún no han completado el protocolo de enlace de tres vías.
#### WARNING No habilites "TCP Fast Open" a menos que el servidor pueda manejar la recepción del mismo paquete SYN con datos más de una vez. |
| `backlog=`number | establece el parámetro `backlog` en la llamada `listen()` que limita la longitud máxima de la cola de conexiones pendientes. Por defecto, backlog se establece en -1 en FreeBSD, DragonFly BSD y macOS, y en 511 en otras plataformas. |
| `rcvbuf=`size | establece el tamaño del búfer de recepción (la opción `SO_RCVBUF`) para el socket de escucha. |
| `sndbuf=`size | establece el tamaño del búfer de envío (la opción `SO_SNDBUF`) para el socket de escucha. |
| `accept_filter=`filter | establece el nombre del filtro de aceptación (la opción `SO_ACCEPTFILTER`) para el socket de escucha que filtra las conexiones entrantes antes de pasarlas a `accept()`. Esto solo funciona en FreeBSD y NetBSD 5.0+. Los valores posibles son `dataready` y `httpready`. |
| `deferred` | indica que se use un `accept()` diferido (la opción de socket `TCP_DEFER_ACCEPT`) en Linux. |
| `bind` | indica que se haga una llamada `bind()` separada para un par address:port dado. Esto es útil porque si hay varias directivas `listen` con el mismo puerto pero diferentes direcciones, y una de las directivas `listen` escucha en todas las direcciones para el `port` dado (`*:port`), Angie hará `bind()` solo a `*:port`. Debe tenerse en cuenta que en este caso se hará la llamada al sistema `getsockname()` para determinar la dirección que aceptó la conexión. Si se usan los parámetros `setfib`, `fastopen`, `backlog`, `rcvbuf`, `sndbuf`, `accept_filter`, `deferred`, `ipv6only`, `reuseport` o `so_keepalive`, siempre se hará una llamada `bind()` separada para un par `address:port` dado. |
| `ipv6only=on` | `off` | determina (mediante la opción de socket `IPV6_V6ONLY`) si un socket IPv6 que escucha en una dirección comodín [::] aceptará solo conexiones IPv6 o tanto conexiones IPv6 como IPv4. Este parámetro está activado por defecto. Solo puede establecerse una vez al inicio. |
| `reuseport` | indica que se cree un socket de escucha individual para cada proceso worker (usando la opción de socket `SO_REUSEPORT` en Linux 3.9+ y DragonFly BSD, o `SO_REUSEPORT_LB` en FreeBSD 12+), permitiendo que el kernel distribuya las conexiones entrantes entre los procesos worker. Actualmente solo funciona en Linux 3.9+, DragonFly BSD y FreeBSD 12+.
#### WARNING El uso inapropiado del parámetro `reuseport` puede tener implicaciones de seguridad. |
| `multipath` | habilita la aceptación de conexiones mediante [Multipath TCP](https://en.wikipedia.org/wiki/Multipath_TCP) (MPTCP), soportado en el kernel de Linux desde la versión 5.6. Este parámetro es **incompatible** con `quic`. |
| `so_keepalive=on` | `off` | [`keepidle`]:[`keepintvl`]:[`keepcnt`] | configura el comportamiento de "TCP keepalive" para el socket de escucha.
| `''` | si se omite este parámetro, la configuración del sistema operativo estará en efecto para el socket | |--------|------------------------------------------------------------------------------------------------------| | `on` | la opción `SO_KEEPALIVE` se activa para el socket | | `off` | la opción `SO_KEEPALIVE` se desactiva para el socket | |
Algunos sistemas operativos soportan el establecimiento de parámetros TCP keepalive por
socket usando las opciones de socket `TCP_KEEPIDLE`, `TCP_KEEPINTVL` y
`TCP_KEEPCNT`. En tales sistemas (actualmente, Linux, NetBSD,
Dragonfly, FreeBSD y macOS), pueden configurarse usando los
parámetros `keepidle`, `keepintvl` y `keepcnt`. Uno o dos
parámetros pueden omitirse, en cuyo caso la configuración predeterminada del sistema para la
opción de socket correspondiente estará en efecto. Por ejemplo,
```nginx
so_keepalive=30m::10
```
establecerá el tiempo de espera de inactividad (`TCP_KEEPIDLE`) en 30 minutos, dejará el intervalo de sondeo (`TCP_KEEPINTVL`) en su valor predeterminado del sistema, y establecerá el número de sondeos (`TCP_KEEPCNT`) en 10 sondeos.
Ejemplo:
```nginx
listen 127.0.0.1 default_server accept_filter=dataready backlog=1024;
```
### location
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `location` ([ = | ~ | ~\* | ^~ ] uri | `@name`)+ { ... } |
|--------------------------------------------------------------------------------------------|------------------------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | server, location |
Establece la configuración en función de si el URI de la solicitud coincide
con alguna de las expresiones de coincidencia.
La coincidencia se realiza contra un URI normalizado (el valor de [$uri](#v-uri)), después de decodificar
el texto codificado en formato "%XX", resolver las referencias a componentes de ruta
relativa "." y "..", y la posible [compresión](#merge-slashes) de dos o más
barras adyacentes en una sola barra.
Un `location` puede definirse mediante una cadena de prefijo o mediante
una expresión regular.
Las expresiones regulares se especifican con el modificador precedente:
| `~*` | Coincidencia sin distinción de mayúsculas y minúsculas |
|--------|----------------------------------------------------------|
| `~` | Coincidencia con distinción de mayúsculas y minúsculas |
Para encontrar una ubicación que coincida con una solicitud, Angie primero comprueba las
ubicaciones definidas con cadenas de prefijo (ubicaciones de prefijo). Entre ellas, se selecciona
y recuerda la ubicación con el prefijo de coincidencia más largo.
#### NOTE
Para sistemas operativos sin distinción de mayúsculas y minúsculas como macOS, la coincidencia de cadenas de prefijo
es insensible a mayúsculas y minúsculas.
Sin embargo, la coincidencia se limita a locales de un solo byte.
Después se comprueban las expresiones regulares en el orden en que aparecen en el
archivo de configuración. La búsqueda se detiene tras la primera coincidencia, y se utiliza la
configuración correspondiente. Si no se encuentra coincidencia con una expresión regular, entonces se
usa la configuración de la ubicación de prefijo recordada anteriormente.
Con algunas excepciones mencionadas más abajo,
los bloques `location` pueden anidarse.
Las expresiones regulares pueden crear grupos de captura
que pueden usarse posteriormente con otras directivas.
Si la ubicación de prefijo de coincidencia más larga tiene el modificador `^~`,
entonces no se comprueban las expresiones regulares.
También, usando el modificador `=`, es posible definir una coincidencia exacta de URI y
ubicación. Si se encuentra una coincidencia exacta, la búsqueda termina. Por ejemplo, si una
solicitud `/` ocurre con frecuencia, definir `location =/` acelerará
el procesamiento de estas solicitudes, ya que la búsqueda termina tras la primera comparación.
Tal ubicación no puede contener ubicaciones anidadas, ya que define una coincidencia exacta.
Una vez seleccionado el `location` coincidente, la solicitud se asigna a un archivo
a través de la directiva [root](#root) o [alias](#alias), y [try_files](#try-files) puede comprobar
la existencia de archivos dentro de él; véase [Elección de ubicaciones](https://es.angie.software//angie/docs/configuration/processing.md#pick-location) para una descripción
general.
Ejemplo:
```nginx
location =/ {
#configuration A
}
location / {
#configuration B
}
location /documents/ {
#configuration C
}
location ^~/images/ {
#configuration D
}
location ~*\.(gif|jpg|jpeg)$ {
#configuration E
}
```
- Una solicitud `/` coincidirá con la configuración A,
- una solicitud `/index.html` coincidirá con la configuración B,
- una solicitud `/documents/document.html` coincidirá con la configuración C,
- una solicitud `/images/1.gif` coincidirá con la configuración D,
- y una solicitud `/documents/1.jpg` coincidirá con la configuración E.
#### NOTE
Si un `location` prefijo termina con una barra y
[auto_redirect](#auto-redirect) está habilitado, ocurre lo siguiente:
Cuando llega una petición con un URI que no tiene la barra final
pero coincide exactamente con el prefijo, se devuelve una redirección
permanente con código 301, apuntando al URI solicitado con la barra añadida.
Con un `location` de coincidencia exacta de URI, no se aplica redirección:
```nginx
location /user/ {
proxy_pass http://user.example.com;
}
location =/user {
proxy_pass http://login.example.com;
}
```
El prefijo `@` define un `location` *nombrado*. Estos locations no se usan para el procesamiento normal de peticiones,
sino que están destinados únicamente a la redirección de peticiones.
No pueden anidarse ni contener locations anidados.
#### Ubicaciones combinadas
Varios contextos `location` que definan bloques de configuración idénticos
pueden compactarse listando todas sus expresiones de coincidencia en un único
`location` con un único bloque de configuración.
A esto se le llama un `location` *combinado*.
Supongamos que las configuraciones A, D y E del ejemplo anterior
definen configuraciones idénticas; puedes combinarlas en un único `location`:
```nginx
location =/
^~/images/
~*\.(gif|jpg|jpeg)$ {
# configuración general
}
```
Un `location` nombrado también puede formar parte de la combinación:
```nginx
location =/
@named_combined {
#...
}
```
#### WARNING
Un `location` combinado no puede tener un espacio entre el modificador
de la expresión de coincidencia y la expresión en sí.
Forma correcta: `location ~*/match(ing|es|er)$ *...*`.
#### NOTE
Actualmente, un `location` combinado no puede contener **inmediatamente**
directivas `proxy_pass` con URI establecido, ni `api` o `alias`.
Sin embargo, estas directivas pueden usarse en ubicaciones anidadas
dentro de una ubicación combinada.
### log_not_found
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `log_not_found` `on` | `off`; |
|--------------------------------------------------------------------------------------------|---------------------------------|
| Predeterminado | `log_not_found on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva el registro de errores sobre archivos no encontrados en [error_log](https://es.angie.software//angie/docs/configuration/modules/core.md#error-log).
### log_subrequest
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `log_subrequest` `on` | `off`; |
|--------------------------------------------------------------------------------------------|----------------------------------|
| Predeterminado | `log_subrequest off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva el registro de subpeticiones en [access_log](https://es.angie.software//angie/docs/configuration/modules/http/http_log.md#access-log).
### max_headers
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `max_headers` number; |
|--------------------------------------------------------------------------------------------|-------------------------|
| Predeterminado | `max_headers 1000;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Define el número máximo de campos de cabecera de petición del cliente permitidos.
Si se excede este límite, se devuelve un error `400 (Bad Request)`.
Cuando esta directiva se establece en el nivel [server](#server),
puede aplicarse el valor del servidor por defecto.
Para más información, consulta la sección [Selección de servidor virtual](https://es.angie.software//angie/docs/configuration/processing.md#virtual-server-selection).
### max_ranges
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `max_ranges` number; |
|--------------------------------------------------------------------------------------------|------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Limita el número máximo permitido de rangos en peticiones con byte-range. Las peticiones que exceden el límite se procesan como si no hubieran especificado rangos de bytes. Por defecto, el número de rangos no está limitado.
| `0` | desactiva completamente el soporte de byte-range |
|-------|----------------------------------------------------|
### merge_slashes
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `merge_slashes` `on` | `off`; |
|--------------------------------------------------------------------------------------------|---------------------------------|
| Predeterminado | `merge_slashes on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Activa o desactiva la compresión de dos o más barras consecutivas en un URI en una sola barra.
Ten en cuenta que la compresión es esencial para la coincidencia correcta de ubicaciones de cadena de prefijo y expresiones regulares. Sin ella, la petición `//scripts/one.php` no coincidiría con
```nginx
location /scripts/ { }
```
y podría procesarse como un archivo estático. Así se convierte en `/scripts/one.php`.
Desactivar la compresión puede ser necesario si un URI contiene nombres codificados en base64, ya que base64 utiliza el carácter "/" internamente. Sin embargo, por motivos de seguridad, es mejor evitar desactivar la compresión.
Si la directiva se especifica en el nivel [server](#server), puede usarse el valor del servidor por defecto.
### msie_padding
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `msie_padding` `on` | `off`; |
|--------------------------------------------------------------------------------------------|--------------------------------|
| Predeterminado | `msie_padding on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva la adición de comentarios a respuestas para clientes MSIE con estado superior a 400 para aumentar el tamaño de la respuesta a 512 bytes.
### msie_refresh
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `msie_refresh` `on` | `off`; |
|--------------------------------------------------------------------------------------------|--------------------------------|
| Predeterminado | `msie_refresh off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva la emisión de actualizaciones en lugar de redirecciones para clientes MSIE.
### open_file_cache
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `open_file_cache` `off`;
`open_file_cache` `max=`N [`inactive=`time]; |
|--------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------|
| Predeterminado | `open_file_cache off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Configura una caché que puede almacenar:
* descriptores de archivos abiertos, sus tamaños y tiempos de modificación;
* información sobre existencia de directorios;
* errores de búsqueda de archivos, como "archivo no encontrado", "sin permiso de lectura", etc.
El almacenamiento en caché de errores debe activarse por separado mediante la directiva [open_file_cache_errors](#open-file-cache-errors).
| `max` | define el número máximo de elementos en la caché; en caso de desbordamiento de la caché se eliminan los elementos menos utilizados recientemente (LRU) |
|------------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
| `inactive` | define un tiempo tras el cual un elemento se elimina de la caché si no ha sido accedido durante este tiempo;
por defecto, 60 segundos |
| `off` | desactiva la caché |
Ejemplo:
```nginx
open_file_cache max=1000 inactive=20s;
open_file_cache_valid 30s;
open_file_cache_min_uses 2;
open_file_cache_errors on;
```
### open_file_cache_errors
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `open_file_cache_errors` `on` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------------------------|
| Predeterminado | `open_file_cache_errors off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva el almacenamiento en caché de errores de búsqueda de archivos mediante [open_file_cache](#open-file-cache).
### open_file_cache_events
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `open_file_cache_events` `on` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------------------------|
| Predeterminado | `open_file_cache_events off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa el uso de eventos del kernel para validar los elementos de [open_file_cache](#open-file-cache). Esta directiva solo funciona con el método [kqueue](https://es.angie.software//angie/docs/configuration/processing.md#kqueue). Ten en cuenta que solo NetBSD 2.0+ y FreeBSD 6.0+ admiten eventos para tipos de sistemas de archivos arbitrarios; otros sistemas operativos solo admiten eventos para sistemas de archivos esenciales como UFS o FFS.
### open_file_cache_min_uses
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `open_file_cache_min_uses` number; |
|--------------------------------------------------------------------------------------------|--------------------------------------|
| Predeterminado | `open_file_cache_min_uses 1;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define el número mínimo de accesos a archivos durante el período configurado por el parámetro `inactive` de la directiva [open_file_cache](#open-file-cache), requeridos para que un descriptor de archivo permanezca abierto en la caché.
### open_file_cache_valid
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `open_file_cache_valid` time; |
|--------------------------------------------------------------------------------------------|---------------------------------|
| Predeterminado | `open_file_cache_valid 60s;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define un tiempo tras el cual los elementos de [open_file_cache](#open-file-cache) deben ser validados.
### output_buffers
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `output_buffers` number size; |
|--------------------------------------------------------------------------------------------|---------------------------------|
| Predeterminado | `output_buffers 2 32k;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define el número y tamaño de los búferes usados para leer una respuesta desde disco.
### port_in_redirect
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `port_in_redirect` `on` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------------------|
| Predeterminado | `port_in_redirect on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva la especificación del puerto en redirecciones [absolutas](#absolute-redirect) emitidas por Angie.
El uso del nombre de servidor principal en redirecciones se controla mediante la directiva [server_name_in_redirect](#server-name-in-redirect).
### postpone_output
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `postpone_output` size; |
|--------------------------------------------------------------------------------------------|---------------------------|
| Predeterminado | `postpone_output 1460;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Si es posible, la transmisión de datos del cliente se pospondrá hasta que Angie tenga al menos el número especificado de bytes para enviar.
| `0` | desactiva el aplazamiento de transmisión de datos |
|-------|-----------------------------------------------------|
### read_ahead
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `read_ahead` size; |
|--------------------------------------------------------------------------------------------|------------------------|
| Predeterminado | `read_ahead 0;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define la cantidad de lectura anticipada para el kernel al trabajar con archivos.
En Linux se utiliza la llamada al sistema `posix_fadvise(0, 0, 0, POSIX_FADV_SEQUENTIAL)`, por lo que el parámetro size se ignora.
En FreeBSD se utiliza la llamada al sistema `fcntl(O_READAHEAD,` size ), soportada desde FreeBSD 9.0-CURRENT.
### recursive_error_pages
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `recursive_error_pages` `on` | `off`; |
|--------------------------------------------------------------------------------------------|-----------------------------------------|
| Predeterminado | `recursive_error_pages off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva la realización de varias redirecciones usando la directiva [error_page](#error-page). El número de estas redirecciones está [limitado](#internal).
### request_pool_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `request_pool_size` size; |
|--------------------------------------------------------------------------------------------|-----------------------------|
| Predeterminado | `request_pool_size 4k;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Permite ajustar con precisión las asignaciones de memoria por petición. Esta directiva tiene un impacto mínimo en el rendimiento y generalmente no debería usarse.
### reset_timedout_connection
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `reset_timedout_connection` `on` | `off`; |
|--------------------------------------------------------------------------------------------|---------------------------------------------|
| Predeterminado | `reset_timedout_connection off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva el reseteo de conexiones que expiran por timeout y de conexiones cerradas con el código no estándar 444. El reseteo se realiza de la siguiente manera. Antes de cerrar un socket, se establece la opción `SO_LINGER` con un valor de timeout de 0. Cuando se cierra el socket, se envía un TCP RST al cliente y se libera toda la memoria asociada a ese socket. Esto ayuda a evitar mantener un socket ya cerrado en estado FIN_WAIT1 con los búferes llenos durante largo tiempo.
#### NOTE
Las conexiones keep-alive se cierran normalmente cuando expiran.
### resolver
#### Versionchanged
Distinto en la versión 1.12.0.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `resolver` [address ...] [`conf` [`=`file]] [`valid=`time] [`ipv4=``on` | `off`] [`ipv6=``on` | `off`] [`status_zone=`zone];
`resolver` `off`; |
|--------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|
| Predeterminado | `resolver conf;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, upstream |
Configura los servidores de nombres usados para resolver los nombres de servidores upstream en direcciones, por ejemplo:
```nginx
resolver 127.0.0.53 [::1]:5353;
```
La dirección puede especificarse como nombre de dominio o dirección IP, con un puerto opcional. Si no se especifica el puerto, se utiliza el puerto 53. Los servidores de nombres se consultan en modo round-robin.
Debe especificarse al menos una dirección de servidor DNS o el parámetro
`conf`, excepto en la forma `resolver off;`.
#### NOTE
Se recomienda usar un resolver local de confianza, como `127.0.0.53`
(systemd-resolved), en lugar de uno público (p.ej., `8.8.8.8`). Los
resolvers públicos exponen las consultas DNS a terceros y aumentan el
riesgo de ataques de envenenamiento de caché.
#### NOTE
El valor de la directiva se hereda en bloques anidados
y puede sobrescribirse en ellos si es necesario.
Dentro de un mismo bloque, la directiva solo puede especificarse una vez;
repetirla constituye un error de configuración.
Esta directiva activa la resolución de nombres DNS. Se usa para servidores upstream referenciados mediante variables o configurados con el parámetro [resolve](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#reresolve), así como por el cliente ACME y el grapado OCSP.
Además de direcciones de servidor explícitas, la directiva reconoce:
| `off` | desactiva explícitamente la resolución de nombres DNS |
|------------------|----------------------------------------------------------------------------------------------------------------------------------|
| `conf` [`=`file] | lee direcciones de servidor DNS desde el archivo especificado, o desde `/etc/resolv.conf` si no se especifica ningún archivo |
El archivo puede contener líneas `nameserver` con el mismo formato usado por el resolver del sistema:
```text
nameserver 127.0.1.4
nameserver 127.0.1.5
```
Las direcciones leídas del archivo se añaden a cualquier dirección especificada explícitamente en la directiva, y todas ellas se consultan después conjuntamente en modo round-robin. Si el archivo no existe, no puede leerse o no enumera ninguna dirección, y no hay ninguna configurada explícitamente, Angie recurre al servidor predeterminado `127.0.0.1:53`.
Angie vuelve a leer el archivo automáticamente cuando cambia, actualizando en consecuencia el conjunto activo de servidores.
Por defecto, Angie almacena en caché cada respuesta durante el período de vigencia del valor TTL en la respuesta DNS. El parámetro opcional `valid` permite sobrescribir esto:
| `valid` | parámetro *opcional* que permite sobrescribir el período de validez de la caché de respuestas |
|-----------|-------------------------------------------------------------------------------------------------|
```nginx
resolver 127.0.0.53 [::1]:5353 valid=30s;
```
Por defecto, Angie buscará tanto direcciones IPv4 como IPv6 al resolver.
| `ipv4=off` | desactiva la búsqueda de direcciones IPv4 |
|--------------|---------------------------------------------|
| `ipv6=off` | desactiva la búsqueda de direcciones IPv6 |
| `status_zone` | parámetro *opcional*; activa la recopilación de métricas de peticiones y respuestas de los servidores DNS en la zona especificada, exponiéndolas en [/status/resolvers/](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-resolvers), la pestaña [«DNS Resolvers»](https://es.angie.software//angie/docs/configuration/monitoring.md#samp-dns-resolvers-tab) y la salida de [Prometheus](https://es.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#http-prometheus). Sin él, estas métricas no se recopilan y no se registra ninguna advertencia |
|-----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
### resolver_timeout
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `resolver_timeout` time; |
|--------------------------------------------------------------------------------------------|----------------------------------|
| Predeterminado | `resolver_timeout 30s;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, upstream |
Define un tiempo de espera para la resolución de nombres, por ejemplo:
```nginx
resolver_timeout 5s;
```
### root
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `root` path; |
|--------------------------------------------------------------------------------------------|----------------------------------------|
| Predeterminado | `root html;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Define el directorio raíz para las peticiones. Por ejemplo, con la siguiente configuración:
```nginx
location /i/ {
root /data/w3;
}
```
El archivo `/data/w3/i/top.gif` se enviará en respuesta a la petición `/i/top.gif`.
El valor path puede contener variables, excepto [$document_root](#v-document-root) y [$realpath_root](#v-realpath-root).
La ruta al archivo se construye simplemente añadiendo el URI al valor de la directiva root. Si el URI debe modificarse, debe usarse la directiva [alias](#alias). La barra final del valor path se elimina, ya que el URI se añade con su propia barra inicial.
### satisfy
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `satisfy` `all` | `any`; |
|--------------------------------------------------------------------------------------------|----------------------------|
| Predeterminado | `satisfy all;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite el acceso si todos (`all`) o al menos uno (`any`) de los módulos [Access](https://es.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access), [Auth Basic](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic) o [Auth Request](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request) permiten el acceso.
```nginx
location / {
satisfy any;
allow 192.168.1.0/32;
deny all;
auth_basic "closed site";
auth_basic_user_file conf/htpasswd;
}
```
### send_lowat
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `send_lowat` size; |
|--------------------------------------------------------------------------------------------|------------------------|
| Predeterminado | `send_lowat 0;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Si la directiva se define con un valor distinto de cero, Angie intentará minimizar el número de operaciones de envío en los sockets de cliente, usando bien la bandera `NOTE_LOWAT` del método [kqueue](https://es.angie.software//angie/docs/configuration/processing.md#kqueue), o bien la opción de socket `SO_SNDLOWAT`. En ambos casos se usa el tamaño especificado.
### send_timeout
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `send_timeout` time; |
|--------------------------------------------------------------------------------------------|------------------------|
| Predeterminado | `send_timeout 60s;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define un tiempo de espera para la transmisión de una respuesta al cliente. El tiempo se aplica únicamente entre dos operaciones de escritura consecutivas, no a la transmisión completa de la respuesta. Si el cliente no recibe nada en este intervalo, la conexión se cierra.
### sendfile
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `sendfile` `on` | `off`; |
|--------------------------------------------------------------------------------------------|----------------------------------------|
| Predeterminado | `sendfile off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Activa o desactiva el uso de `sendfile()`.
[aio](#aio) puede usarse para precargar datos para `sendfile()`:
```nginx
location /video/ {
sendfile on;
tcp_nopush on;
aio on;
}
```
En esta configuración, `sendfile()` se invoca con la bandera `SF_NODISKIO`, lo que evita que bloquee en operaciones de E/S de disco, informando en su lugar de que los datos no están en memoria. Angie entonces inicia una carga de datos asíncrona leyendo un byte. En la primera lectura, el kernel de FreeBSD carga en memoria los primeros 128K de un archivo, mientras que las lecturas posteriores solo cargan bloques de 16K. Esto puede modificarse mediante la directiva [read_ahead](#read-ahead).
### sendfile_max_chunk
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `sendfile_max_chunk` size; |
|--------------------------------------------------------------------------------------------|------------------------------|
| Predeterminado | `sendfile_max_chunk 2m;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Limita la cantidad de datos que pueden transferirse en una sola llamada a `sendfile()`. Sin este límite, una conexión rápida podría monopolizar completamente el proceso de trabajo.
### server
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `server` { ... } |
|--------------------------------------------------------------------------------------------|--------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define la configuración para un servidor virtual. No hay una separación estricta entre servidores virtuales basados en IP (basados en la dirección IP) y basados en nombre (basados en la cabecera de petición "Host"). En su lugar, las directivas [listen](#listen) describen todas las direcciones y puertos que deben aceptar conexiones para el servidor, y la directiva [server_name](#server-name) lista todos los nombres de servidor.
Se pueden encontrar ejemplos de configuración en el documento [Cómo procesa Angie una petición](https://es.angie.software//angie/docs/configuration/processing.md#request-processing).
### server_name
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `server_name` name ...; |
|--------------------------------------------------------------------------------------------|---------------------------|
| Predeterminado | `server_name ""`; |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | server |
Define los nombres de un servidor virtual, por ejemplo:
```nginx
server {
server_name example.com www.example.com;
}
```
El primer nombre se convierte en el nombre principal del servidor.
Los nombres de servidor pueden incluir un asterisco ("\*") sustituyendo la primera o última parte de un nombre:
```nginx
server {
server_name example.com *.example.com www.example.*;
}
```
Tales nombres se denominan nombres comodín.
Los dos primeros nombres del ejemplo anterior pueden combinarse en uno:
```nginx
server {
server_name .example.com;
}
```
También es posible usar expresiones regulares en los nombres de servidor, precediendo el nombre con una virgulilla ("~"):
```nginx
server {
server_name ~^www\d+\.example\.com$ www.example.com;
}
```
Las expresiones regulares pueden contener capturas que luego pueden usarse en otras directivas:
```nginx
server {
server_name ~^(www\.)?(.+)$;
location / {
root /sites/$2;
}
}
server {
server_name _;
location / {
root /sites/default;
}
}
```
Los grupos de captura con nombre en expresiones regulares crean variables que luego pueden usarse en otras directivas:
```nginx
server {
server_name ~^(www\.)?(?.+)$;
location / {
root /sites/$domain;
}
}
server {
server_name _;
location / {
root /sites/default;
}
}
```
#### NOTE
Si el parámetro de la directiva se define como [$hostname](#v-hostname),
se utiliza el nombre de la máquina.
También puede especificarse un nombre de servidor vacío:
```nginx
server {
server_name www.example.com "";
}
```
Al buscar un servidor virtual por nombre,
si el nombre coincide con más de una de las variantes especificadas
(por ejemplo, tanto un nombre comodín como una expresión regular coinciden),
se elegirá la primera variante coincidente, en el siguiente orden de prioridad:
- nombre exacto;
- nombre comodín más largo que comience con un asterisco, p. ej. `*.example.com`;
- nombre comodín más largo que termine con un asterisco, p. ej. `mail.*`;
- primera expresión regular coincidente (en orden de aparición en el archivo de configuración),
incluyendo un nombre vacío.
#### WARNING
Para usar `server_name` con TLS,
se requiere la terminación de la conexión TLS.
Esta directiva coincide con el `Host` en la petición HTTP,
por lo que el handshake debe completarse y la conexión estar descifrada.
### server_name_in_redirect
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `server_name_in_redirect` `on` | `off`; |
|--------------------------------------------------------------------------------------------|-------------------------------------------|
| Predeterminado | `server_name_in_redirect off`; |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva el uso del nombre de servidor principal, especificado por la directiva [server_name](#server-name), en redirecciones [absolutas](#absolute-redirect) emitidas por Angie.
| `on` | se usa el nombre de servidor principal definido por la directiva [server_name](#server-name) |
|--------|---------------------------------------------------------------------------------------------------------------------------------|
| `off` | se usa el nombre del campo de cabecera de petición "Host". Si este campo no está presente, se usa la dirección IP del servidor. |
El uso del puerto en las redirecciones se controla mediante la directiva [port_in_redirect](#port-in-redirect).
### server_names_hash_bucket_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `server_names_hash_bucket_size` size; |
|--------------------------------------------------------------------------------------------|----------------------------------------------------|
| Predeterminado | `server_names_hash_bucket_size 32` | `64` | `128;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define el tamaño de bloque (*bucket size*) para las tablas hash de nombres de servidor. El valor por defecto depende del tamaño de la línea de caché del procesador. Los detalles sobre la configuración de tablas hash se describen en un [documento separado](https://es.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
### server_names_hash_max_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `server_names_hash_max_size` size; |
|--------------------------------------------------------------------------------------------|--------------------------------------|
| Predeterminado | `server_names_hash_max_size 512`; |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define el tamaño máximo de las tablas hash de nombres de servidor. Los detalles sobre la configuración de tablas hash se describen en un [documento separado](https://es.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
### server_tokens
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `server_tokens` `on` | `off` | `build` | string; |
|--------------------------------------------------------------------------------------------|----------------------------------------------------|
| Predeterminado | `server_tokens on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva la inclusión de la versión de Angie
en las páginas de error y en el campo de cabecera de respuesta `Server`.
El parámetro `build` activa la inclusión del nombre de compilación,
definido mediante el parámetro correspondiente de [configure](https://es.angie.software//angie/docs/installation/sourcebuild.md#configure),
junto con la versión.
En Angie PRO, si la directiva define una string, que también puede contener variables,
las páginas de error y el campo de cabecera de respuesta `Server`
utilizarán el valor de la cadena interpolada con variables
en lugar del nombre del servidor, versión y nombre de compilación.
Una string vacía desactiva la emisión del campo `Server`.
### status_zone
#### Versionchanged
Distinto en la versión 1.12.0.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `status_zone` `off` | zone | key `zone=`zone[:number]; |
|--------------------------------------------------------------------------------------------|----------------------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | server, location, if in location |
Reserva una zona de memoria compartida para recopilar
las métricas de [/status/http/location_zones/](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-http-location-zones) y [/status/http/server_zones/](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-http-server-zones).
Varios contextos `server`
pueden compartir la misma zona para la recogida de datos;
el valor especial `off`
desactiva la recogida de datos en bloques `location` anidados.
La sintaxis con un único valor zone
combina todas las métricas del contexto actual en una sola zona de memoria compartida:
```nginx
server {
listen 80;
server_name *.example.com;
status_zone single;
# ...
}
```
La sintaxis alternativa permite definir los siguientes parámetros:
| key | Una cadena con variables, cuyo valor determina la agrupación de las peticiones en la zona. Todas las peticiones que produzcan valores idénticos tras la sustitución se agrupan juntas. Si la sustitución produce un valor vacío, las métricas no se actualizan. |
|-------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| zone | El nombre de la zona de memoria compartida. |
| number (opcional) | El número máximo de grupos separados para recopilar métricas. Si nuevos valores de key superan este límite, se agrupan bajo `zone`.
El valor por defecto es 1. |
En el siguiente ejemplo,
todas las peticiones que compartan el mismo valor de `$host`
se agrupan en la zona `host_zone`.
Las métricas se rastrean por separado para cada `$host` único
hasta un máximo de 10 grupos de métricas.
Una vez alcanzado este límite,
cualquier valor adicional de `$host` se incluye bajo `host_zone`:
```nginx
server {
listen 80;
server_name *.example.com;
status_zone $host zone=host_zone:10;
location / {
proxy_pass http://example.com;
}
}
```
De este modo, las métricas resultantes se dividen entre hosts individuales en la salida de la API.
#### NOTE
Estas métricas solo se recopilan cuando `status_zone` está configurado. Sin él,
el servidor o la location no aparece en [/status/http/server_zones/](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-http-server-zones),
[/status/http/location_zones/](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-http-location-zones), el widget [«HTTP Zones»](https://es.angie.software//angie/docs/configuration/monitoring.md#http-zones-widget),
ni en la salida de [Prometheus](https://es.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#http-prometheus), y no se registra ninguna advertencia.
Consulte [ejemplo de configuración](https://es.angie.software//angie/docs/configuration/modules/http/http_api.md#example-configuration).
### subrequest_output_buffer_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `subrequest_output_buffer_size` size; |
|--------------------------------------------------------------------------------------------|--------------------------------------------|
| Predeterminado | `subrequest_output_buffer_size 4k` | `8k;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define el tamaño del búfer usado para almacenar el cuerpo de la respuesta de una subpetición.
Por defecto, el tamaño del búfer es igual a una página de memoria. Esto corresponde a
`4K` o `8K`, dependiendo de la plataforma. Puede configurarse más pequeño
si es necesario.
#### NOTE
La directiva es aplicable solo a subpeticiones cuyos cuerpos de respuesta se guardan en memoria. Por ejemplo, tales subpeticiones son creadas por [SSI](https://es.angie.software//angie/docs/configuration/modules/http/http_ssi.md#ssi-include-set).
### tcp_nodelay
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `tcp_nodelay` `on` | `off`; |
|--------------------------------------------------------------------------------------------|-------------------------------|
| Predeterminado | `tcp_nodelay on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva el uso de la opción `TCP_NODELAY`. La opción se activa cuando una conexión pasa al estado keep-alive. Además, se activa en conexiones SSL, para el proxying sin búfer y para [proxying de WebSocket](https://es.angie.software//angie/docs/configuration/processing.md#websocket-proxy).
### tcp_nopush
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `tcp_nopush` `on` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------------|
| Predeterminado | `tcp_nopush off`; |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Activa o desactiva el uso de la opción de socket `TCP_NOPUSH` en FreeBSD o la opción de socket `TCP_CORK` en Linux. Las opciones se activan solo cuando se usa [sendfile](#sendfile). Al activarse, permiten
* enviar la cabecera de respuesta y el inicio de un archivo en un único paquete, en Linux y FreeBSD 4.\*;
* enviar un archivo en paquetes completos.
### time_format
#### Versionadded
Added in version 1.12.0.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `time_format` $variable format; |
|--------------------------------------------------------------------------------------------|-----------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define una $variable para contener la hora local actual, renderizada con una
cadena format personalizada compuesta por especificadores de tipo
`strftime` más `%L` para milisegundos. La directiva es útil cuando
[$time_local](#v-time-local) y [$time_iso8601](#v-time-iso8601) se
quedan cortos, por ejemplo porque no ofrecen precisión de subsegundo:
```nginx
time_format $time_ms "%Y-%m-%dT%H:%M:%S.%L%Z";
log_format tf '$time_ms $remote_addr "$request" $status';
```
Con el formato anterior, `$time_ms` se expande a un valor como
`2024-01-15T14:34:56.789+03:00`.
Redefinir una variable integrada, como [$time_local](#v-time-local), o
repetir `time_format` para el mismo nombre hace que falle la carga de
la configuración con un error del tipo: "the duplicate "..." variable".
La cadena format acepta los siguientes especificadores, evaluados en la
misma zona horaria local que [$time_local](#v-time-local):
| `%Y` | año de 4 dígitos |
|------------|-----------------------------------------------------------|
| `%y` | año de 2 dígitos |
| `%m` | mes, `01-12` |
| `%d` | día del mes, `01-31` |
| `%e` | día del mes, rellenado con espacios, `1-31` |
| `%H` | hora, `00-23` |
| `%I` | hora, `01-12` |
| `%M` | minuto, `00-59` |
| `%S` | segundo, `00-59` |
| `%L` | milisegundos, `000-999` |
| `%p` | `AM` / `PM` en mayúsculas |
| `%P` | `am` / `pm` en minúsculas |
| `%a` | nombre abreviado del día de la semana, `Sun-Sat` |
| `%A` | nombre completo del día de la semana, `Sunday-Saturday` |
| `%b`, `%h` | nombre abreviado del mes, `Jan-Dec` |
| `%B` | nombre completo del mes, `January-December` |
| `%z` | desplazamiento de zona horaria, `+0300` |
| `%Z` | desplazamiento de zona horaria, estilo ISO 8601, `+03:00` |
| `%n` | salto de línea |
| `%t` | tabulación |
| `%%` | `%` literal |
#### NOTE
Un especificador no reconocido se copia tal cual en la salida, incluido el
`%` inicial; un `%` aislado al final de la cadena format
se descarta.
### try_files
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `try_files` file ... uri;
`try_files` file ... =code; |
|--------------------------------------------------------------------------------------------|------------------------------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | server, location |
Verifica la existencia de archivos en el orden especificado y utiliza el primer archivo encontrado para procesar la petición; el procesamiento se realiza en el contexto del [location](#location) actual. La ruta a un archivo se construye a partir del parámetro file según las directivas [root](#root) y [alias](#alias). Es posible verificar la existencia de un directorio añadiendo una barra al final del nombre, por ejemplo `$uri/`. Si no se encuentra ningún archivo, se realiza una redirección interna al uri especificado en el último parámetro.
Los parámetros file y uri pueden contener variables.
Por ejemplo:
```nginx
location /images/ {
try_files $uri /images/default.gif;
}
location = /images/default.gif {
expires 30s;
}
```
El último parámetro puede ser un URI para una redirección interna,
una referencia a un `location` con nombre (por ejemplo, `@drupal`),
o un código de respuesta en la forma `=code` (por ejemplo, `=404`):
```nginx
location / {
try_files $uri $uri/index.html $uri.html =404;
}
```
Debe tenerse en cuenta que el uso excesivo de la directiva `try_files`
incrementa el número de llamadas al sistema,
lo que puede afectar negativamente al rendimiento.
Por tanto, `try_files` no debe usarse para replicar un comportamiento
que es efectivamente el comportamiento por defecto, por ejemplo:
```nginx
location /bad_pattern {
# try_files $uri $uri/ =404; # ¡no recomendado!
}
```
Además, `try_files` no debe usarse
únicamente para redirigir cuando un archivo está ausente.
La razón es que la directiva `try_files` tiene dos peculiaridades:
- Primero, verifica la existencia de cada archivo,
lo que incrementa la carga del sistema.
- Segundo, cualquier error al abrir archivos (por ejemplo, `too many open files`,
errores de permisos) también se trata como ausencia de archivo y activa el mecanismo de respaldo
al manejador alternativo, lo que puede enmascarar errores 5xx con respuestas exitosas
y llevar a un cacheo incorrecto.
Así, en la práctica, puede encontrarse la siguiente construcción problemática:
```nginx
location / {
try_files $uri $uri/ @drupal; # ¡no recomendado!
}
```
El problema aquí es que el único propósito es la redirección.
Usar `try_files` conlleva las desventajas listadas anteriormente,
pero no proporciona beneficios,
ya que no se necesita verificar la existencia del archivo.
La solución correcta es usar la directiva [error_page](#error-page),
que no tiene estas desventajas:
```nginx
error_page 404 = @drupal;
log_not_found off;
```
En contraste, en el siguiente ejemplo:
```nginx
location ~ \.php$ {
try_files $uri @drupal;
fastcgi_pass ...;
fastcgi_param SCRIPT_FILENAME /path/to$fastcgi_script_name;
# ...
}
```
La directiva `try_files` verifica la existencia del archivo PHP
antes de pasar la petición al servidor FastCGI configurado en el mismo bloque;
aquí el uso de `try_files` está justificado.
### Ejemplo de uso al hacer proxy a Mongrel:
```nginx
location / {
try_files /system/maintenance.html
$uri $uri/index.html $uri.html
@mongrel;
}
location @mongrel {
proxy_pass http://mongrel;
}
```
### Ejemplo de uso con Drupal/FastCGI:
```nginx
location / {
error_page 404 = @drupal;
}
location ~ \.php$ {
try_files $uri @drupal;
fastcgi_pass ...;
fastcgi_param SCRIPT_FILENAME /path/to$fastcgi_script_name;
fastcgi_param SCRIPT_NAME $fastcgi_script_name;
fastcgi_param QUERY_STRING $args;
# ... other fastcgi_param
}
location @drupal {
fastcgi_pass ...;
fastcgi_param SCRIPT_FILENAME /path/to/index.php;
fastcgi_param SCRIPT_NAME /index.php;
fastcgi_param QUERY_STRING q=$uri&$args;
# ... other fastcgi_param
}
```
### Ejemplo de uso con Wordpress y Joomla:
```nginx
location / {
error_page 404 = @wordpress;
}
location ~ \.php$ {
try_files $uri @wordpress;
fastcgi_pass ...;
fastcgi_param SCRIPT_FILENAME /path/to$fastcgi_script_name;
# ... other fastcgi_param
}
location @wordpress {
fastcgi_pass ...;
fastcgi_param SCRIPT_FILENAME /path/to/index.php;
# ... other fastcgi_param
}
```
### types
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `types` { ... } |
|--------------------------------------------------------------------------------------------|------------------------------------------------------------|
| Predeterminado | `types *text/html html; image/gif gif; image/jpeg jpg;* ` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Asocia extensiones de nombre de archivo con tipos MIME de las respuestas. Las extensiones no distinguen entre mayúsculas y minúsculas. Varias extensiones pueden asignarse a un mismo tipo, por ejemplo:
```nginx
types {
application/octet-stream bin exe dll;
application/octet-stream deb;
application/octet-stream dmg;
}
```
Una tabla de asignación suficientemente completa se distribuye con Angie y se encuentra en el archivo `conf/mime.types`.
Para hacer que un `location` concreto devuelva el tipo MIME "application/octet-stream" en todas las respuestas, se puede usar la siguiente configuración:
```nginx
location /download/ {
types { }
default_type application/octet-stream;
}
```
### types_hash_bucket_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `types_hash_bucket_size` size; |
|--------------------------------------------------------------------------------------------|----------------------------------|
| Predeterminado | `types_hash_bucket_size 64;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define el tamaño de bloque para las tablas hash de tipos. Los detalles de la configuración de tablas hash se tratan [por separado](https://es.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
### types_hash_max_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `types_hash_max_size` size; |
|--------------------------------------------------------------------------------------------|-------------------------------|
| Predeterminado | `types_hash_max_size 1024;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define el tamaño máximo de las tablas hash de tipos. Los detalles de la configuración de tablas hash se tratan [por separado](https://es.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
### underscores_in_headers
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `underscores_in_headers` `on` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------------------------|
| Predeterminado | `underscores_in_headers off`; |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Activa o desactiva el uso de guiones bajos en los campos de cabecera de las peticiones de cliente. Cuando el uso de guiones bajos está desactivado, los campos de cabecera de petición cuyos nombres contengan guiones bajos se marcan como inválidos y quedan sujetos a la directiva [ignore_invalid_headers](#ignore-invalid-headers).
Si la directiva se especifica en el nivel [server](#server), puede usarse el valor del servidor por defecto.
### variables_hash_bucket_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `variables_hash_bucket_size` size; |
|--------------------------------------------------------------------------------------------|--------------------------------------|
| Predeterminado | `variables_hash_bucket_size 64;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define el tamaño de bloque para la tabla hash de variables. Los detalles de la configuración de tablas hash se tratan [por separado](https://es.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
### variables_hash_max_size
#### Versionchanged
Distinto en la versión 1.11.0.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `variables_hash_max_size` size; |
|--------------------------------------------------------------------------------------------|-----------------------------------|
| Predeterminado | `variables_hash_max_size 2048;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define el tamaño máximo de la tabla hash de variables. Los detalles de la configuración de tablas hash se tratan [por separado](https://es.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
## Variables integradas
El módulo `http_core` admite variables integradas con nombres que coinciden con las
variables de Apache Server. En primer lugar, se trata de variables que representan campos de cabecera
de las peticiones del cliente, como `$http_user_agent`, `$http_cookie`,
etc. Además, existen otras variables:
### `$angie_version`
Versión de Angie
### `$arg_`
argumento name en la línea de petición
### `$args`
argumentos en la línea de petición
### `$binary_remote_addr`
dirección del cliente en forma binaria; la longitud del valor es siempre de 4 bytes para direcciones IPv4 o 16 bytes para direcciones IPv6
### `$body_bytes_sent`
número de bytes enviados al cliente, sin contar la cabecera de la respuesta; esta variable es compatible con el parámetro "%B" del módulo Apache `mod_log_config`
### `$bytes_sent`
número de bytes enviados a un cliente
### `$connection`
número de serie de la conexión
### `$connection_requests`
número actual de peticiones realizadas a través de una conexión
### `$connection_time`
tiempo de la conexión en segundos con resolución en milisegundos
### `$content_length`
campo de cabecera `Content-Length` de la petición
### `$content_type`
campo de cabecera `Content-Type` de la petición
### `$cookie_`
cookie con el name especificado
### `$document_root`
valor de las directivas [root](#root) o [alias](#alias) para la petición actual
### `$document_uri`
igual que [$uri](#v-uri)
### `$host`
en este orden de precedencia: nombre de host de la línea de petición, o nombre de host del campo de cabecera "Host", o el nombre de servidor que coincide con la petición
### `$hostname`
nombre del host
### `$http_`
#### Versionchanged
Distinto en la versión 1.11.0: En las solicitudes HTTP/3, `$http_host` se inicializa a partir de la
pseudocabecera `:authority` si la cabecera `Host` no fue
enviada por el cliente.
campo de cabecera arbitrario de la petición; la última parte del nombre de la variable corresponde al nombre del campo convertido a minúsculas con guiones sustituidos por guiones bajos
### `$https`
`on` si la conexión funciona en modo SSL, o una cadena vacía en caso contrario
### `$is_args`
`?` si la línea de petición contiene argumentos, o una cadena vacía en caso contrario
### `$is_request_port`
`:` si el valor de [$request_port](#v-request-port) no está vacío, o una cadena vacía en caso contrario
### `$limit_rate`
configurar esta variable habilita la limitación de la velocidad de respuesta; véase [limit_rate](#limit-rate)
### `$msec`
hora actual en segundos con resolución en milisegundos
### `$nginx_version`
versión de nginx
### `$pid`
PID del proceso trabajador
### `$pipe`
`p` si la petición fue *pipelined*, `.` en caso contrario
### `$proxy_protocol_addr`
dirección del cliente desde la cabecera del protocolo PROXY
El protocolo PROXY debe habilitarse previamente configurando el parámetro `proxy_protocol` en la directiva [listen](#listen).
### `$proxy_protocol_port`
puerto del cliente desde la cabecera del protocolo PROXY
El protocolo PROXY debe habilitarse previamente configurando el parámetro `proxy_protocol` en la directiva [listen](#listen).
### `$proxy_protocol_server_addr`
dirección del servidor desde la cabecera del protocolo PROXY
El protocolo PROXY debe habilitarse previamente configurando el parámetro `proxy_protocol` en la directiva [listen](#listen).
### `$proxy_protocol_server_port`
puerto del servidor desde la cabecera del protocolo PROXY
El protocolo PROXY debe habilitarse previamente configurando el parámetro `proxy_protocol` en la directiva [listen](#listen).
### `$proxy_protocol_tlv_`
TLV desde la cabecera del protocolo PROXY. El name puede ser un nombre de tipo TLV o su valor numérico. En este último caso, el valor es hexadecimal y debe ir precedido de `0x`:
```none
$proxy_protocol_tlv_alpn
$proxy_protocol_tlv_0x01
```
Los TLV SSL también pueden accederse mediante el nombre del tipo TLV o su valor numérico, ambos precedidos por `ssl_`:
```none
$proxy_protocol_tlv_ssl_version
$proxy_protocol_tlv_ssl_0x21
```
Se admiten los siguientes nombres de tipo TLV:
* `alpn (0x01)` - protocolo de capa superior usado en la conexión
* `authority (0x02)` - valor del nombre de host enviado por el cliente
* `unique_id (0x05)` - identificador único de la conexión
* `netns (0x30)` - nombre del *namespace*
* `ssl (0x20)` - estructura binaria SSL TLV
Se admiten los siguientes nombres de tipo TLV SSL:
* `ssl_version (0x21)` - versión de SSL usada en la conexión del cliente
* `ssl_cn (0x22)` - *Common Name* del certificado SSL
* `ssl_cipher (0x23)` - nombre del cifrado utilizado
* `ssl_sig_alg (0x24)` - algoritmo usado para firmar el certificado
* `ssl_key_alg (0x25)` - algoritmo de clave pública
Además, se admite el siguiente nombre especial de tipo TLV SSL:
* `ssl_verify` - resultado de la verificación del certificado SSL del cliente: `0` si el cliente presentó un certificado y se verificó correctamente, distinto de cero en caso contrario
El protocolo PROXY debe habilitarse previamente configurando el parámetro `proxy_protocol` en la directiva [listen](#listen).
### `$query_string`
igual que [$args](#v-args)
### `$realpath_root`
ruta absoluta correspondiente al valor de las directivas [root](#root) o [alias](#alias) para la petición actual, con todos los enlaces simbólicos resueltos a rutas reales
### `$remote_addr`
dirección del cliente
### `$remote_port`
puerto del cliente
### `$remote_user`
nombre de usuario suministrado mediante autenticación básica
### `$request`
línea de petición original completa
### `$request_body`
cuerpo de la petición
El valor de la variable está *disponible* en las ubicaciones procesadas por las directivas [proxy_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass), [fastcgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass), [uwsgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-pass) y [scgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-pass) cuando el cuerpo de la petición se ha leído en un [búfer de memoria](#client-body-buffer-size).
### `$request_body_file`
nombre de un archivo temporal con el cuerpo de la petición
Al final del procesamiento, el archivo debe eliminarse. Para escribir siempre el cuerpo de la petición en un archivo, habilita [client_body_in_file_only](#client-body-in-file-only). Cuando se pasa el nombre de un archivo temporal en una petición proxy o en una petición a un servidor FastCGI/uwsgi/SCGI, el envío del cuerpo de la petición debe deshabilitarse con las directivas [proxy_pass_request_body off](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass-request-body), [fastcgi_pass_request_body off](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass-request-body), [uwsgi_pass_request_body off](https://es.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-pass-request-body) o [scgi_pass_request_body off](https://es.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-pass-request-body) respectivamente.
### `$request_completion`
`OK` si la petición se ha completado, o una cadena vacía en caso contrario
### `$request_filename`
ruta del archivo para la petición actual, basada en las directivas [root](#root) o [alias](#alias) y en el URI de la petición
### `$request_id`
identificador único de la petición generado a partir de 16 bytes aleatorios, en hexadecimal
### `$request_length`
longitud de la petición (incluyendo línea de petición, cabeceras y cuerpo de la petición)
### `$request_method`
método de la petición, normalmente `GET` o `POST`
### `$request_port`
en este orden de precedencia: número de puerto del componente de autoridad del URI de la petición, o número de puerto del campo de cabecera "Host"
### `$request_time`
tiempo de procesamiento de la petición en segundos con resolución en milisegundos; tiempo transcurrido desde que se leyeron los primeros bytes del cliente
### `$request_uri`
URI original completo de la petición (con argumentos), nunca modificado durante el procesamiento de la petición; véase [$uri](#v-uri) para el URI actual (potencialmente reescrito)
### `$scheme`
esquema de la petición, "http" o "https"
### `$sent_body`
#### Versionadded
Added in version 1.11.0.
cuerpo de la respuesta de una subpetición o petición externa cuando se almacena en memoria;
en caso contrario, una cadena vacía
### `$sent_http_`
campo de cabecera arbitrario de la respuesta; la última parte del nombre de la variable corresponde al nombre del campo convertido a minúsculas con guiones sustituidos por guiones bajos
### `$sent_trailer_`
campo arbitrario enviado al final de la respuesta; la última parte del nombre de la variable corresponde al nombre del campo convertido a minúsculas con guiones sustituidos por guiones bajos
### `$server_addr`
Dirección del servidor que aceptó la petición.
El cálculo del valor de la variable normalmente requiere una llamada al sistema. Para evitar una llamada al sistema, las directivas [listen](#listen) deben especificar direcciones y usar el parámetro `bind`.
### `$server_name`
nombre del servidor que aceptó una petición
### `$server_port`
puerto del servidor que aceptó una petición
### `$server_protocol`
protocolo de la petición, normalmente "HTTP/1.0", "HTTP/1.1" o "HTTP/2.0"
### `$status`
estado de la respuesta
### `$tcpinfo_rtt, $tcpinfo_rttvar, $tcpinfo_snd_cwnd, $tcpinfo_rcv_space`
información sobre la conexión TCP del cliente; disponible en sistemas que admiten la opción de socket `TCP_INFO`
### `$time_iso8601`
hora local en formato estándar ISO 8601
### `$time_local`
hora local en formato Common Log Format
### `$uri`
URI actual en la petición, [normalizado](#location)
El valor de `$uri` puede cambiar durante el procesamiento de la petición, por ejemplo, al reescribir con [rewrite](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#id5), al realizar redirecciones internas o al usar archivos índice. Véase [Elección de ubicaciones](https://es.angie.software//angie/docs/configuration/processing.md#pick-location) para conocer cómo este valor se corresponde con una ruta del sistema de archivos.
# https://es.angie.software/angie/docs/configuration/modules/http/http_access.md
# Access
El módulo controla el acceso a los recursos del servidor basándose en las direcciones IP o redes de los clientes. Permite autorizar o bloquear el acceso para direcciones IP específicas, rangos de IP o sockets de dominio UNIX para mejorar la seguridad restringiendo el acceso a áreas sensibles de un sitio web o aplicación.
El acceso también puede restringirse mediante el uso de una contraseña con el módulo [Auth Basic](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic) o basándose en el resultado de una subsolicitud con el módulo [Auth Request](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request). Para aplicar restricciones tanto de direcciones como de contraseñas al mismo tiempo, utilice la directiva [satisfy](https://es.angie.software//angie/docs/configuration/modules/http/index.md#satisfy).
## Ejemplo de configuración
```nginx
location / {
deny 192.168.1.1;
allow 192.168.1.0/24;
allow 10.1.1.0/16;
allow 2001:0db8::/32;
deny all;
}
```
Las reglas se evalúan secuencialmente hasta encontrar una coincidencia. En este ejemplo, el acceso se permite solo para las redes IPv4 `10.1.1.0/16` y `192.168.1.0/24`, excluyendo la dirección específica `192.168.1.1`, y para la red IPv6 `2001:0db8::/32`. Cuando hay muchas reglas, es preferible utilizar variables del módulo [Geo](https://es.angie.software//angie/docs/configuration/modules/http/http_geo.md#http-geo).
## Directivas
### allow
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `allow` address | CIDR | `unix:` | `all`; |
|--------------------------------------------------------------------------------------------|---------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, limit_except |
Permite el acceso para una red o dirección especificada.
El valor especial `all` significa todas las direcciones IP de los clientes.
El valor especial `unix:` permite el acceso para cualquier socket de dominio UNIX.
### deny
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `deny` address | CIDR | `unix:` | `all`; |
|--------------------------------------------------------------------------------------------|--------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, limit_except |
Deniega el acceso para una red o dirección especificada.
El valor especial `all` significa todas las direcciones IP de los clientes.
El valor especial `unix:` deniega el acceso para cualquier socket de dominio UNIX.
# https://es.angie.software/angie/docs/configuration/modules/http/http_acme.md
# ACME
Proporciona obtención automática de certificados utilizando el [protocolo ACME](https://datatracker.ietf.org/doc/html/rfc8555).
Cuando [compila desde el código fuente](https://es.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild), el módulo no se compila por defecto;
debe habilitarse con la [opción de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#configure)
`--with-http_acme_module`.
En paquetes e imágenes de
[nuestros repositorios](https://es.angie.software//angie/docs/installation/index.md#install-packages),
el módulo está incluido en la compilación.
## Ejemplo de configuración
En este ejemplo, un cliente ACME llamado `example` obtiene y renueva automáticamente un certificado para `example.com` y `www.example.com` mediante la validación HTTP predeterminada:
```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;
}
}
```
Para otros métodos de validación (DNS, ALPN, basada en hooks) e instrucciones de configuración detalladas, consulte la sección [Configuración de ACME](https://es.angie.software//angie/docs/configuration/acme.md#acme-config).
## Directivas
### acme
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme` nombre; |
|--------------------------------------------------------------------------------------------|------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | server |
Especifica el [cliente ACME](#acme-client) que obtiene un certificado
para los identificadores de certificado válidos de este bloque [server](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server).
Un único certificado cubre todos los nombres de dominio válidos y las direcciones IP
especificados en las directivas [server_name](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server-name)
de todos los bloques [server](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server)
que hacen referencia al cliente con el nombre dado;
si la configuración `server_name` cambia,
el certificado se renueva para reflejar los cambios.
Cada vez que Angie se inicia, se solicitan nuevos certificados para todos los identificadores
que carecen de un certificado válido.
Las posibles razones incluyen la caducidad del certificado,
archivos faltantes o ilegibles,
y cambios en la configuración del certificado.
#### NOTE
Esta directiva solo controla qué identificadores de certificado válidos
se incluyen en las solicitudes de certificados;
no afecta a dónde puede usarse el certificado.
Cualquier bloque `server` puede hacer referencia al certificado
mediante la variable [$acme_cert_](#v-acme-cert-name),
independientemente de si el bloque contiene una directiva `acme`.
Eliminar `acme` de un bloque `server`
simplemente excluye los valores de [server_name](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server-name) de ese bloque
de futuras solicitudes de certificados,
pero no impide que el bloque utilice el certificado.
#### NOTE
Actualmente, los dominios especificados con expresiones regulares
no son compatibles y serán omitidos.
Los dominios comodín solo son compatibles con `challenge=dns`
en `acme_client`.
Las direcciones IPv4 e IPv6 son compatibles a menos que el cliente use
`challenge=dns`. Con la validación DNS habilitada, las direcciones IP se omiten.
Esta directiva puede especificarse varias veces
para cargar certificados de diferentes tipos, por ejemplo RSA y ECDSA:
```nginx
server {
listen 443 ssl;
server_name example.com www.example.com;
ssl_certificate $acme_cert_rsa;
ssl_certificate_key $acme_cert_key_rsa;
ssl_certificate $acme_cert_ecdsa;
ssl_certificate_key $acme_cert_key_ecdsa;
acme rsa;
acme ecdsa;
}
```
### acme_client
#### Versionchanged
Distinto en la versión 1.11.0.
#### Versionchanged
Distinto en la versión 1.12.0.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_client` nombre uri [`enabled=``on` | `off`] [`key_type=`tipo] [`key_bits=`número] [`email=`email] [`max_cert_size=`número] [`max_key_auth_size=`tamaño] [`renew_before_expiry=`tiempo] [`renew_on_load`] [`retry_after_error=`off|tiempo] [`challenge=``dns` | `http` | `alpn`] [`profile=`name] [`account_key=`archivo] [`eab=`id[:alg]:key]; |
|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define un cliente ACME con un nombre único a nivel global.
Debe ser válido para un directorio,
es una [cadena con variables](https://es.angie.software//angie/docs/configuration/configfile.md#string-variables),
y se utilizará sin distinción entre mayúsculas y minúsculas.
Cada cliente gestiona un único certificado; para obtener certificados
independientes, configure múltiples bloques `acme_client`
(consulte [Certificados Independientes para Diferentes Dominios](https://es.angie.software//angie/docs/configuration/acme.md#acme-config-multiple-clients)).
El segundo parámetro obligatorio es la uri del directorio ACME.
Por ejemplo, la URI del directorio ACME de Let's Encrypt está [especificada](https://letsencrypt.org/getting-started/)
como
[https://acme-v02.api.letsencrypt.org/directory](https://acme-v02.api.letsencrypt.org/directory).
#### NOTE
El módulo ACME añade una `location @acme` con nombre
al contexto [client](https://es.angie.software//angie/docs/configuration/modules/http/index.md#client),
que puede utilizarse para configurar solicitudes al directorio ACME;
por defecto, esta `location`
contiene una directiva [proxy_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass) con la uri del directorio,
a la que se pueden añadir otros ajustes del módulo [Proxy](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy).
Para que esta directiva funcione,
debe configurarse un [resolver](https://es.angie.software//angie/docs/configuration/modules/http/index.md#resolver) en el mismo contexto.
#### NOTE
Para fines de prueba,
las autoridades de certificación suelen proporcionar entornos de staging separados.
Por ejemplo, el [entorno de staging de Let's Encrypt](https://letsencrypt.org/docs/staging-environment/)
es
[https://acme-staging-v02.api.letsencrypt.org/directory](https://acme-staging-v02.api.letsencrypt.org/directory).
| `enabled` | Habilita o deshabilita la renovación de certificados para el cliente; esto es útil, por ejemplo, para suspender temporalmente sin eliminar el cliente de la configuración.
Predeterminado: `on`. |
|-----------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `key_type` | El tipo de algoritmo de clave privada para el certificado. Valores válidos: `rsa`, `ecdsa`.
Predeterminado: `ecdsa`. |
| `key_bits` | Número de bits en la clave del certificado. Predeterminado: 256 para `ecdsa`, 2048 para `rsa`. |
| `email` | Dirección de correo electrónico opcional para retroalimentación; se utiliza al crear una cuenta en el servidor CA. |
| `max_cert_size` | Especifica el tamaño máximo permitido de un nuevo archivo de certificado en bytes para reservar espacio para el nuevo certificado en memoria compartida; cuantos más dominios se soliciten para el certificado, más espacio se requiere. Este parámetro no limita el tamaño de las respuestas del servidor ACME; utilice [acme_max_response_size](#acme-max-response-size) para eso.
Si el parámetro no está establecido, Angie calcula un tamaño aproximado basándose en la lista de dominios configurada y lo utiliza para la asignación de memoria compartida.
Si un certificado ya existe al inicio pero su tamaño excede el valor de `max_cert_size`, el valor de `max_cert_size` se incrementa dinámicamente para coincidir con el tamaño del archivo de certificado existente.
Si el tamaño de un certificado obtenido durante la renovación excede `max_cert_size`, el proceso de renovación fallará con un error.
Predeterminado: calculado automáticamente. |
| `max_key_auth_size` | Limita el tamaño de la cadena de autorización de clave que Angie almacena en memoria compartida para un desafío ACME. Si el servidor ACME devuelve una cadena de autorización de clave mayor que este valor, la solicitud falla con un error que aconseja aumentar `max_key_auth_size`.
Aunque se especifica en la línea `acme_client`, es un ajuste único compartido por todos los clientes del bloque `http`.
Predeterminado: `2k`. |
| `renew_before_expiry` | [Tiempo](https://es.angie.software//angie/docs/configuration/configfile.md#syntax) antes de la expiración del certificado cuando debe comenzar la renovación.
Predeterminado: `30d`. |
| `renew_on_load` | Especifica que el certificado debe renovarse forzosamente cada vez que se carga la configuración. |
| `retry_after_error` | [Tiempo](https://es.angie.software//angie/docs/configuration/configfile.md#syntax) de espera antes de reintentar si la obtención del certificado falló. Si se establece en `off`, el cliente no reintentará obtener el certificado después de un error.
Predeterminado: `2h`. |
| `challenge` | Especifica el tipo de verificación para el cliente ACME. Valores válidos: `dns`, `http`, `alpn`.
El valor `alpn` habilita la validación [TLS-ALPN-01](https://datatracker.ietf.org/doc/rfc8737/) y requiere que Angie esté compilado con OpenSSL que soporte ALPN (no compatible con compilaciones de BoringSSL o AWS-LC).
Predeterminado: `http`. |
| `profile` | Solicita un perfil ACME específico a la autoridad de certificación. Un perfil es una variante, definida por la CA, de los ajustes de certificado y validación, por ejemplo la vigencia del certificado o qué tipos de identificadores pueden solicitarse.
Por ejemplo, Let's Encrypt describe sus perfiles disponibles en la [documentación de perfiles](https://letsencrypt.org/docs/profiles/).
El servidor ACME debe anunciar este perfil en los metadatos de su directorio; de lo contrario, el cliente no podrá obtener un certificado. |
| `account_key` | Especifica la ruta completa a un archivo que contiene una clave en formato PEM. Esto es útil si desea utilizar una clave de cuenta existente en lugar de la generación automática, o si necesita utilizar una clave para múltiples clientes ACME.
Tipos de claves soportados:
- Claves RSA con longitudes que son múltiplos de 8, desde 2048 hasta 8192 bits. - Claves ECDSA con longitudes de 256, 384 o 521 bits.
Al especificar el parámetro `account_key`, asegúrese de que el archivo de clave realmente exista. Si el archivo no existe, Angie intentará crearlo en la ruta especificada.
Tenga en cuenta que las claves para los clientes ACME se crean en el orden en que se mencionan los clientes correspondientes en la configuración en las directivas [acme_client](#acme-client), [acme](#id1) o [acme_hook](#acme-hook). Por lo tanto, si un cliente debe usar una clave creada para otro, ese otro cliente debe aparecer antes en la configuración.
Además, las claves solo se crean para clientes que tienen el parámetro `enabled=on` establecido. |
| `eab` | Configura [External Account Binding](https://datatracker.ietf.org/doc/html/rfc8555#section-7.3.4) (EAB), que vincula la cuenta ACME a una cuenta ya registrada en la autoridad de certificación (CA).
El valor tiene la forma `eab=`id[:alg]:key:
- id — el identificador de clave emitido por la CA. - alg — el algoritmo de firma HMAC utilizado para calcular la firma de vinculación: `HS256` (predeterminado), `HS384` o `HS512`. - key — la clave MAC codificada en Base64URL asociada con id en el lado de la CA.
Si la CA requiere External Account Binding pero el parámetro no está establecido, el cliente informa un error sin crear una cuenta ACME. Las credenciales EAB solo se envían al registrar una nueva cuenta ACME; una cuenta ACME existente se reutiliza tal cual. |
### acme_client_path
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_client_path` ruta; |
|--------------------------------------------------------------------------------------------|----------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Anula la ruta al directorio para almacenar certificados y claves,
establecida durante la compilación usando el [parámetro de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#configure)
`--http-acme-client-path`.
### acme_dns_port
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_dns_port` puerto | ip[:puerto] | [ip6][:puerto]; |
|--------------------------------------------------------------------------------------------|----------------------------------------------------------|
| Predeterminado | `acme_dns_port 53;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Especifica el puerto
que el módulo utiliza para manejar consultas DNS desde el servidor ACME a través de UDP.
El número de puerto debe estar en el rango de 1 a 65535.
También se admite especificar una dirección IP junto con un puerto opcional.
Se pueden utilizar tanto direcciones IPv4 en la forma `ip:puerto`
como direcciones IPv6 en la forma `[ip6]:puerto`:
```nginx
acme_dns_port 8053;
acme_dns_port 127.0.0.1;
acme_dns_port [::1];
```
Para usar un número de puerto 1024 o inferior,
el proceso maestro de Angie debe ejecutarse con privilegios de superusuario.
### acme_dns_ttl
#### Versionadded
Added in version 1.12.0.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_dns_ttl` number; |
|--------------------------------------------------------------------------------------------|--------------------------|
| Predeterminado | `acme_dns_ttl 1;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Establece el TTL, en segundos, de los registros TXT que el módulo devuelve
en las respuestas a las consultas de [validación DNS](https://es.angie.software//angie/docs/configuration/acme.md#acme-config-dns)
de los servidores ACME. Acepta valores de 0 a 2147483647, según la
[RFC 2181](https://datatracker.ietf.org/doc/html/rfc2181#section-8).
### acme_hook
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_hook` nombre [uri]; |
|--------------------------------------------------------------------------------------------|-----------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Habilita la validación de dominio basada en hooks
para el [cliente ACME](#acme-client) especificado por nombre.
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 donde se encuentra esta directiva.
La forma en que se gestiona la solicitud depende enteramente
de las demás directivas configuradas en el mismo `location`,
como [fastcgi_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass), [proxy_pass](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass),
o cualquier otro manejador de solicitudes.
| nombre | El nombre del [cliente ACME](#acme-client) para el que este hook gestiona la verificación de dominio. |
|----------|-----------------------------------------------------------------------------------------------------------------------|
| uri | Una cadena con variables; especifica la URI de solicitud para las llamadas al hook.
Predeterminado: `/`. |
Por ejemplo, la siguiente configuración pasa los valores de las [variables de hook](#http-acme-variables)
a una aplicación FastCGI a través de la URI de solicitud:
```nginx
acme_hook example uri=/acme_hook/$acme_hook_name?domain=$acme_hook_domain&key=$acme_hook_keyauth;
fastcgi_param REQUEST_URI $request_uri;
fastcgi_pass ...;
```
### acme_http_port
#### Versionadded
Added in version 1.11.0.
#### Versionchanged
Distinto en la versión 1.11.1.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_http_port` puerto | ip[:puerto] | [ip6][:puerto]; |
|--------------------------------------------------------------------------------------------|-----------------------------------------------------------|
| Predeterminado | `acme_http_port 80;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Especifica el puerto
que el módulo utiliza para manejar solicitudes de desafío ACME HTTP.
El número de puerto debe estar en el rango de 1 a 65535.
También se admite especificar una dirección IP junto con un puerto opcional.
Se pueden utilizar tanto direcciones IPv4 en la forma `ip:puerto`
como direcciones IPv6 en la forma `[ip6]:puerto`:
```nginx
acme_http_port 8080;
acme_http_port 127.0.0.1;
acme_http_port [::1];
```
Si no hay ningún servidor configurado para escuchar en la dirección y puerto especificados,
el módulo crea un listener dedicado para desafíos HTTP.
Para usar un número de puerto 1024 o inferior,
el proceso maestro de Angie debe ejecutarse con privilegios de superusuario.
### acme_max_response_size
#### Versionadded
Added in version 1.11.0.
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_max_response_size` tamaño; |
|--------------------------------------------------------------------------------------------|------------------------------------|
| Predeterminado | `acme_max_response_size 32k;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Limita el tamaño máximo del cuerpo de una respuesta del servidor ACME. Si una respuesta excede
este límite, la solicitud falla con un error. Aumente el valor si ve
errores como `too big subrequest response while sending to client`.
## Variables integradas
### `$acme_cert_`
Contenido del último archivo de certificado (si existe)
obtenido por el cliente con este nombre.
### `$acme_cert_key_`
Contenido del archivo de clave del certificado
utilizado por el cliente con este nombre.
#### NOTE
El archivo de certificado está disponible
solo si el cliente ACME ha obtenido al menos un certificado,
pero el archivo de clave está disponible inmediatamente después del inicio.
### `$acme_hook_challenge`
El tipo de desafío. Valores posibles: `dns`, `http`, `alpn`.
### `$acme_hook_client`
El nombre del cliente ACME que inicia la solicitud.
### `$acme_hook_domain`
El dominio que se está verificando.
Si es un dominio comodín, se pasará sin el prefijo `*.`.
### `$acme_hook_keyauth`
La cadena de autorización:
- Para el desafío DNS, se utiliza como el valor del registro TXT,
cuyo nombre se forma como
`_acme-challenge. + $acme_hook_domain + .`.
- Para el desafío HTTP, esta cadena debe utilizarse
como el contenido de la respuesta solicitada por el servidor ACME.
### `$acme_hook_name`
El nombre del hook. Para diferentes tipos de desafío, puede tener diferentes valores y significados:
| Valor | Significado para desafío DNS | Significado para desafío HTTP |
|--------------------------------|-----------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------|
| `add` (hook de adición) | El registro TXT correspondiente debe añadirse a la configuración DNS. | Se debe preparar una respuesta a la solicitud HTTP correspondiente. |
| `remove` (hook de eliminación) | El registro TXT puede eliminarse de la configuración DNS. | Esta solicitud HTTP ya no es relevante; el archivo creado previamente con la cadena de autorización puede eliminarse. |
### `$acme_hook_token`
El token de verificación.
Para el desafío HTTP, se utiliza como el nombre del archivo solicitado:
`/.well-known/acme-challenge/` + `$acme_hook_token`.
# https://es.angie.software/angie/docs/configuration/modules/http/http_addition.md
# Addition
Este módulo es un filtro que añade texto antes y después de una respuesta.
Al [compilar desde el código fuente](https://es.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild),
este módulo no se compila por defecto;
debe habilitarse con la
[opción de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#configure) `‑‑with‑http_addition_module`.
En paquetes e imágenes de [nuestros repositorios](https://es.angie.software//angie/docs/installation/index.md#install-packages),
el módulo está incluido en la compilación.
## Ejemplo de configuración
```nginx
location / {
add_before_body /before_action;
add_after_body /after_action;
}
```
## Directivas
### add_after_body
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `add_after_body` uri; |
|--------------------------------------------------------------------------------------------|-------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Añade el texto devuelto como resultado del procesamiento de una subpetición dada después del cuerpo de la respuesta. Una cadena vacía (`""`) como parámetro cancela la adición heredada del nivel de configuración anterior.
### add_before_body
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `add_before_body` uri; |
|--------------------------------------------------------------------------------------------|--------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Añade el texto devuelto como resultado del procesamiento de una subpetición dada antes del cuerpo de la respuesta. Una cadena vacía (`""`) como parámetro cancela la adición heredada del nivel de configuración anterior.
### addition_types
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `addition_types` mime-type ...; |
|--------------------------------------------------------------------------------------------|-----------------------------------|
| Predeterminado | `addition_types text/html;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite añadir texto en respuestas con los tipos MIME especificados, además de "text/html". El valor especial "\*" coincide con cualquier tipo MIME.
# https://es.angie.software/angie/docs/configuration/modules/http/http_api.md
# API
El módulo `API` implementa una interfaz RESTful HTTP para obtener información básica sobre el servidor web en formato JSON, así como [estadísticas](#metrics) sobre conexiones de clientes, zonas de memoria compartida, consultas DNS, peticiones HTTP, caché de respuestas HTTP, sesiones del módulo [stream](https://es.angie.software//angie/docs/configuration/modules/stream/index.md#stream-core) y zonas de los módulos [limit_conn http](https://es.angie.software//angie/docs/configuration/modules/http/http_limit_conn.md#http-limit-conn), [limit_conn stream](https://es.angie.software//angie/docs/configuration/modules/stream/stream_limit_conn.md#stream-limit-conn), [limit_req](https://es.angie.software//angie/docs/configuration/modules/http/http_limit_req.md#http-limit-req) y [http upstream](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#http-upstream), así como información sobre los certificados especificados en la configuración y obtenidos por clientes ACME.
#### NOTE
Explore un ejemplo en vivo de la salida de la API en
[https://console.angie.software/api/](https://console.angie.software/api/).
La interfaz admite métodos HTTP `GET` y `HEAD`; una petición con otro método provocará un error:
```json
{
"error": "MethodNotAllowed",
"description": "The POST method is not allowed for the requested API element \"/\"."
}
```
En Angie PRO, esta interfaz incluye una sección de [configuración dinámica](#api-config) que permite cambiar ajustes sin recargar la configuración ni reiniciar; actualmente, la configuración de servidores individuales dentro de [upstream](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream) está disponible.
## Directivas
### api
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `api` path; |
|--------------------------------------------------------------------------------------------|---------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Habilita la interfaz RESTful HTTP en `location`.
El parámetro path es obligatorio. Similar a la directiva [alias](https://es.angie.software//angie/docs/configuration/modules/http/index.md#alias), establece la ruta para reemplazar la que se especifica en `location`, pero sobre el árbol de la API en lugar del sistema de archivos.
Si se especifica en un prefijo `location`:
```nginx
location /stats/ {
api /status/http/server_zones/;
}
```
la parte del URI de la petición que coincide con el prefijo /stats/ será reemplazada con la ruta especificada en el parámetro path: /status/http/server_zones/. Por ejemplo, una petición a /stats/foo/ accederá al elemento de la API `/status/http/server_zones/foo/`.
Se permiten [variables](https://es.angie.software//angie/docs/configuration/configfile.md#string-variables): api /status/$module/server_zones/$name/ y uso dentro de location con expresiones regulares:
```nginx
location ~^/api/([^/]+)/(.*)$ {
api /status/http/$1_zones/$2;
}
```
Aquí el parámetro path define la ruta completa al elemento de la API; así, de una petición a `/api/location/data/` se extraerán las siguientes variables:
```console
$1 = "location"
$2 = "data/"
```
Y la petición final será `/status/http/location_zones/data/`.
#### NOTE
En Angie PRO, puede separar la [API de configuración dinámica](#api-config) y la [API de estado](#metrics) inmutable que refleja el estado actual:
```nginx
location /config/ {
api /config/;
}
location /status/ {
api /status/;
}
```
El parámetro path también permite controlar el acceso a la API:
```nginx
location /status/ {
api /status/;
allow 127.0.0.1;
deny all;
}
```
O:
```nginx
location /blog/requests/ {
api /status/http/server_zones/blog/requests/;
auth_basic "blog";
auth_basic_user_file conf/htpasswd;
}
```
#### NOTE
Si `api` se coloca en un `location` con una barra final en el prefijo (por ejemplo, `location /name/`), y la directiva [auto_redirect](https://es.angie.software//angie/docs/configuration/modules/http/index.md#auto-redirect) está establecida en `default`, las peticiones sin barra final serán redirigidas (`/name -> /name/`).
### api_config_files
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `api_config_files` `on` | `off`; |
|--------------------------------------------------------------------------------------------|------------------------------------|
| Predeterminado | off |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Habilita o deshabilita la adición del objeto `config_files`, que lista el contenido de todos los archivos de configuración de Angie actualmente cargados por la instancia del servidor, a la sección de la API [/status/angie/](#status-angie). Por ejemplo, con esta configuración:
```nginx
location /status/ {
api /status/;
api_config_files on;
}
```
Una petición a `/status/angie/` devuelve aproximadamente lo siguiente:
```json
{
"version":"1.12.1",
"address":"192.168.16.5",
"generation":1,
"load_time":"2026-07-17T12:58:39.789Z",
"config_files": {
"/etc/angie/angie.conf": "...",
"/etc/angie/mime.types": "..."
}
}
```
Por defecto, la salida está deshabilitada porque los archivos de configuración pueden contener información particularmente sensible y confidencial.
## Métricas
Angie publica estadísticas de uso en la sección de API `/status/`; puedes abrir el acceso a ella configurando la `location` adecuada. Acceso completo:
```nginx
location /status/ {
api /status/;
}
```
Ejemplo de acceso parcial, ya mostrado anteriormente:
```nginx
location /stats/ {
api /status/http/server_zones/;
}
```
### Ejemplo de configuración
Con una configuración que incluye `location /status/`, `resolver`, `http` en
`upstream`, `http server`, `location`, `cache`, `limit_conn` en
`http` y zonas `limit_req`:
```nginx
http {
resolver 127.0.0.53 status_zone=resolver_zone;
proxy_cache_path /var/cache/angie/cache keys_zone=cache_zone:2m;
limit_conn_zone $binary_remote_addr zone=limit_conn_zone:10m;
limit_req_zone $binary_remote_addr zone=limit_req_zone:10m rate=1r/s;
upstream upstream {
zone upstream 256k;
server backend.example.com service=_example._tcp resolve max_conns=5;
keepalive 4;
}
server {
server_name www.example.com;
listen 443 ssl;
status_zone http_server_zone;
proxy_cache cache_zone;
proxy_cache_valid 200 10m;
access_log /var/log/access.log main;
location / {
root /usr/share/angie/html;
status_zone location_zone;
limit_conn limit_conn_zone 1;
limit_req zone=limit_req_zone burst=5;
}
location /status/ {
api /status/;
allow 127.0.0.1;
deny all;
}
}
}
```
En respuesta a la solicitud `curl https://www.example.com/status/`, Angie devuelve:
### JSON tree
```json
{
"angie": {
"version":"1.12.1",
"address":"192.168.16.5",
"generation":1,
"load_time":"2026-07-17T12:58:39.789Z"
},
"connections": {
"accepted":2257,
"dropped":0,
"active":3,
"idle":1
},
"slabs": {
"cache_zone": {
"pages": {
"used":2,
"free":506
},
"slots": {
"64": {
"used":1,
"free":63,
"reqs":1,
"fails":0
},
"512": {
"used":1,
"free":7,
"reqs":1,
"fails":0
}
}
},
"limit_conn_zone": {
"pages": {
"used":2,
"free":2542
},
"slots": {
"64": {
"used":1,
"free":63,
"reqs":74,
"fails":0
},
"128": {
"used":1,
"free":31,
"reqs":1,
"fails":0
}
}
},
"limit_req_zone": {
"pages": {
"used":2,
"free":2542
},
"slots": {
"64": {
"used":1,
"free":63,
"reqs":1,
"fails":0
},
"128": {
"used":2,
"free":30,
"reqs":3,
"fails":0
}
}
}
},
"http": {
"server_zones": {
"http_server_zone": {
"ssl": {
"handshaked":4174,
"reuses":0,
"timedout":0,
"failed":0
},
"requests": {
"total":4327,
"processing":0,
"discarded":8
},
"responses": {
"200":4305,
"302":12,
"404":4
},
"data": {
"received":733955,
"sent":59207757
}
}
},
"location_zones": {
"location_zone": {
"requests": {
"total":4158,
"discarded":0
},
"responses": {
"200":4157,
"304":1
},
"data": {
"received":538200,
"sent":177606236
}
}
},
"caches": {
"cache_zone": {
"size":0,
"cold":false,
"hit": {
"responses":0,
"bytes":0
},
"stale": {
"responses":0,
"bytes":0
},
"updating": {
"responses":0,
"bytes":0
},
"revalidated": {
"responses":0,
"bytes":0
},
"miss": {
"responses":0,
"bytes":0,
"responses_written":0,
"bytes_written":0
},
"expired": {
"responses":0,
"bytes":0,
"responses_written":0,
"bytes_written":0
},
"bypass": {
"responses":0,
"bytes":0,
"responses_written":0,
"bytes_written":0
}
}
},
"limit_conns": {
"limit_conn_zone": {
"passed":73,
"skipped":0,
"rejected":0,
"exhausted":0
}
},
"limit_reqs": {
"limit_req_zone": {
"passed":54816,
"skipped":0,
"delayed":65,
"rejected":26,
"exhausted":0
}
},
"upstreams": {
"upstream": {
"peers": {
"192.168.16.4:80": {
"server":"backend.example.com",
"service":"_example._tcp",
"backup":false,
"weight":5,
"state":"up",
"selected": {
"current":2,
"total":232
},
"max_conns":5,
"responses": {
"200":222,
"302":12
},
"data": {
"sent":543866,
"received":27349934
},
"health": {
"fails":0,
"unavailable":0,
"downtime":0
},
"sid":""
}
},
"keepalive":2
}
}
},
"resolvers": {
"resolver_zone": {
"queries": {
"name":442,
"srv":2,
"addr":0
},
"responses": {
"success":440,
"timedout":1,
"format_error":0,
"server_failure":1,
"not_found":1,
"unimplemented":0,
"refused":1,
"other":0
}
}
}
}
```
Se puede solicitar un conjunto de métricas por rama JSON individual construyendo la solicitud adecuada. Por ejemplo:
```console
$ curl https://www.example.com/status/angie
$ curl https://www.example.com/status/connections
$ curl https://www.example.com/status/slabs
$ curl https://www.example.com/status/slabs//slots
$ curl https://www.example.com/status/slabs//slots/64
$ curl https://www.example.com/status/http/
$ curl https://www.example.com/status/http/acme_clients
$ curl https://www.example.com/status/http/acme_clients/
$ curl https://www.example.com/status/http/metric_zones
$ curl https://www.example.com/status/http/metric_zones//metrics
$ curl https://www.example.com/status/http/server_zones
$ curl https://www.example.com/status/http/server_zones/
$ curl https://www.example.com/status/http/server_zones//ssl
```
### Argumentos de consulta
Los siguientes argumentos de la cadena de consulta modifican las respuestas JSON de la API:
`pretty`
: De forma predeterminada, la API formatea las respuestas JSON con sangría y
saltos de línea. Para obtener una salida compacta de una sola línea, añada
`pretty=off` a la cadena de consulta:
```console
$ curl https://www.example.com/status/connections?pretty=off
{"accepted":2257,"dropped":0,"active":3,"idle":1}
```
`date`
: Por defecto, el módulo utiliza cadenas de formato ISO 8601 para las fechas;
para usar en su lugar el formato entero de época UNIX, añada el parámetro
`date=epoch` a la cadena de consulta:
```console
$ curl https://www.example.com/status/angie/load_time
"2024-04-01T00:59:59+01:00"
$ curl https://www.example.com/status/angie/load_time?date=epoch
1711929599
```
`defaults` (PRO)
: Puede obtener valores de parámetros predeterminados con el argumento `defaults=on`:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers?defaults=on
```
```json
{
"backend.example.com": {
"weight": 1,
"max_conns": 5,
"max_fails": 1,
"fail_timeout": 10,
"slow_start": 0,
"backup": false,
"down": false,
"sid": ""
}
}
```
### Estado del servidor
#### `/status/angie`
```json
{
"version": "1.12.1",
"build_time": "2026-07-17T16:05:43.805Z",
"address": "192.168.16.5",
"generation": 1,
"load_time": "2026-07-17T16:15:43.805Z"
"config_files": {
"/etc/angie/angie.conf": "...",
"/etc/angie/mime.types": "..."
}
}
```
| `version` | Cadena; versión del servidor web Angie en ejecución |
|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `build` | Cadena; nombre de compilación particular si se especifica durante la compilación |
| `build_time` | Cadena; tiempo de compilación del ejecutable Angie en el formato [date](#api-date-format) |
| `address` | Cadena; la dirección del servidor que aceptó la petición API |
| `generation` | Número; número total de recargas de configuración desde el último inicio |
| `load_time` | Cadena; tiempo de la última recarga de configuración en el formato [date](#api-date-format); los valores de cadena tienen resolución en milisegundos |
| `config_files` | Objeto; sus miembros son rutas absolutas de todos los archivos de configuración de Angie que están actualmente cargados por la instancia del servidor, y sus valores son representaciones en cadena del contenido de los archivos, por ejemplo:
#### WARNING El objeto `config_files` está disponible en `/status/angie/` solo si la directiva [api_config_files](#a-api-config-files) está habilitada. |
#### `/status/angie/license` (PRO)
#### Versionadded
Added in version 1.11.0: PRO
```json
{
"path": "/etc/angie/license.pem",
"status": "valid",
"owner": "Example Corp",
"days_left": 30,
"since": "2026-01-01",
"until": "2027-01-01",
"limits": {
"worker_processes": 16,
"worker_connections": 65535
}
}
```
| `path` | Cadena; ruta completa al archivo de licencia |
|-------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `status` | Cadena; estado de la licencia: `missing`, `invalid`, `valid`, `grace`, `expired`, o `pending` |
| `owner` | Cadena; propietario de la licencia del sujeto del certificado |
| `days_left` | Número; días hasta que la licencia cambie de estado. Un valor negativo significa que la licencia ha expirado, y el valor es el número de días desde la expiración |
| `since` | Cadena; fecha de inicio de validez de la licencia |
| `until` | Cadena; fecha de fin de validez de la licencia |
| `limits` | Objeto; límites licenciados para la instancia actual |
### Conexiones
#### `/status/connections`
```json
{
"accepted": 2257,
"dropped": 0,
"active": 3,
"idle": 1
}
```
| `accepted` | Número; el número total de conexiones de clientes aceptadas |
|--------------|---------------------------------------------------------------|
| `dropped` | Número; el número total de conexiones de clientes descartadas |
| `active` | Número; el número actual de conexiones de clientes activas |
| `idle` | Número; el número actual de conexiones de clientes ociosas |
### Zonas de memoria compartida con asignación slab
#### `/status/slabs/`
Estadísticas de uso de zonas de memoria compartida que utilizan [asignación slab](https://en.wikipedia.org/wiki/Slab_allocation). Se informa cualquier zona que
utilice asignación slab, incluidas las de [limit_conn](#limit-conn),
[limit_req](#limit-req) y [caché HTTP](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache), así como la zona
de memoria compartida de un upstream [HTTP](#a-upstream) o
[stream](#a-s-upstream):
```nginx
limit_conn_zone $binary_remote_addr zone=limit_conn_zone:10m;
limit_req_zone $binary_remote_addr zone=limit_req_zone:10m rate=1r/s;
proxy_cache cache_zone;
proxy_cache_valid 200 10m;
```
La zona de memoria compartida especificada recogerá las siguientes estadísticas:
| `pages` | Objeto; estadísticas de páginas de memoria |
|-----------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `used` | Número; el número de páginas de memoria actualmente utilizadas |
| `free` | Número; el número de páginas de memoria actualmente libres |
| `slots` | Objeto; estadísticas de slots de memoria para cada tamaño de slot. El objeto `slots` contiene datos para tamaños de slots de memoria (`8`, `16`, `32`, etc., hasta la mitad del tamaño de la página en bytes) |
| `used` | Número; el número de slots de memoria actualmente utilizados del tamaño especificado |
| `free` | Número; el número de slots de memoria actualmente libres del tamaño especificado |
| `reqs` | Número; el número total de intentos de asignar memoria del tamaño especificado |
| `fails` | Número; el número de intentos fallidos de asignar memoria del tamaño especificado |
Ejemplo:
```json
{
"pages": {
"used": 2,
"free": 506
},
"slots": {
"64": {
"used": 1,
"free": 63,
"reqs": 1,
"fails": 0
}
}
```
### Consultas DNS al resolvedor
#### `/status/resolvers/`
Para recopilar estadísticas del resolvedor,
la directiva [resolver](https://es.angie.software//angie/docs/configuration/modules/http/index.md#resolver) debe establecer el parámetro `status_zone`
([HTTP](https://es.angie.software//angie/docs/configuration/modules/http/index.md#resolver-status) o [Stream](https://es.angie.software//angie/docs/configuration/modules/stream/index.md#s-resolver-status)):
```nginx
resolver 127.0.0.53 status_zone=resolver_zone;
```
La zona de memoria compartida especificada recopilará las siguientes estadísticas:
| `queries` | Objeto; estadísticas de consultas |
|------------------|---------------------------------------------------------------------------------------------|
| `name` | Número; el número de consultas para resolver nombres a direcciones (consultas A y AAAA) |
| `srv` | Número; el número de consultas para resolver servicios a direcciones (consultas SRV) |
| `addr` | Número; el número de consultas para resolver direcciones a nombres (consultas PTR) |
| `responses` | Objeto; estadísticas de respuestas |
| `success` | Número; el número de respuestas exitosas |
| `timedout` | Número; el número de consultas agotadas por tiempo |
| `format_error` | Número; el número de respuestas con código 1 (Format Error) |
| `server_failure` | Número; el número de respuestas con código 2 (Server Failure) |
| `not_found` | Número; el número de respuestas con código 3 (Name Error) |
| `unimplemented` | Número; el número de respuestas con código 4 (Not Implemented) |
| `refused` | Número; el número de respuestas con código 5 (Refused) |
| `other` | Número; el número de consultas completadas con otro código distinto de cero |
| `sent` | Objeto; estadísticas de consultas DNS enviadas |
| `a` | Número; el número de consultas de tipo A |
| `aaaa` | Número; el número de consultas de tipo AAAA |
| `ptr` | Número; el número de consultas de tipo PTR |
| `srv` | Número; el número de consultas de tipo SRV |
#### NOTE
`queries` y `responses` cuentan cada solicitud de resolución
que Angie realiza internamente, incluidas las servidas desde la caché TTL.
`sent` cuenta los paquetes realmente enviados al servidor de nombres;
la diferencia entre ambos refleja los aciertos de caché.
Los códigos de respuesta se describen en [RFC 1035](https://datatracker.ietf.org/doc/html/rfc1035.html), sección [4.1.1](https://datatracker.ietf.org/doc/html/rfc1035.html#section-4.1.1).
Los diversos tipos de registros DNS se detallan en [RFC 1035](https://datatracker.ietf.org/doc/html/rfc1035.html),
[RFC 2782](https://datatracker.ietf.org/doc/html/rfc2782.html), y
[RFC 3596](https://datatracker.ietf.org/doc/html/rfc3596.html).
Ejemplo:
```json
{
"queries": {
"name": 442,
"srv": 2,
"addr": 0
},
"responses": {
"success": 440,
"timedout": 1,
"format_error": 0,
"server_failure": 1,
"not_found": 1,
"unimplemented": 0,
"refused": 1,
"other": 0
},
"sent": {
"a": 185,
"aaaa": 245,
"srv": 2,
"ptr": 12
}
}
```
### Servidor HTTP y ubicación
#### `/status/http/server_zones/`
Para recopilar las métricas de `server`,
establezca la directiva [status_zone](https://es.angie.software//angie/docs/configuration/modules/http/index.md#status-zone) en el contexto [server](https://es.angie.software//angie/docs/configuration/modules/http/index.md#server):
```nginx
server {
...
status_zone server_zone;
}
```
Para agrupar las métricas por un valor personalizado, utilice la sintaxis alternativa.
Aquí, las métricas se agregan por [$host](https://es.angie.software//angie/docs/configuration/modules/http/index.md#v-host),
con cada grupo reportado como una zona independiente:
```nginx
status_zone $host zone=server_zone:5;
```
La zona de memoria compartida especificada recopilará las siguientes estadísticas:
| `ssl` | Objeto; estadísticas SSL. Presente si `server` establece `listen ssl;` |
|--------------|-----------------------------------------------------------------------------------------|
| `handshaked` | Número; el número total de handshakes SSL exitosos |
| `reuses` | Número; el número total de reutilizaciones de sesión durante el handshake SSL |
| `timedout` | Número; el número total de handshakes SSL que agotaron el tiempo de espera |
| `failed` | Número; el número total de handshakes SSL fallidos |
| `requests` | Objeto; estadísticas de solicitudes |
| `total` | Número; el número total de solicitudes de clientes |
| `processing` | Número; el número de solicitudes de clientes que se están procesando actualmente |
| `discarded` | Número; el número total de solicitudes de clientes completadas sin enviar una respuesta |
| `responses` | Objeto; estadísticas de respuestas |
| `` | Número; un número distinto de cero de respuestas con estado (100-599) |
| `xxx` | Número; un número distinto de cero de respuestas con otros códigos de estado |
| `data` | Objeto; estadísticas de datos |
| `received` | Número; el número total de bytes recibidos de los clientes |
| `sent` | Número; el número total de bytes enviados a los clientes |
#### NOTE
Los contadores `responses` solo registran respuestas reales, es
decir, las que se enviaron efectivamente al cliente. Una solicitud cuyo
procesamiento finalizó sin enviar una respuesta se contabiliza en
`discarded` y no incrementa los contadores `responses`. En
particular, `499` no es una respuesta, sino un código de servicio
interno, registrado únicamente en el registro de acceso, que marca una
solicitud cuyo procesamiento terminó sin que se enviara una respuesta;
tales solicitudes se reflejan en `discarded`, nunca en
`responses`.
Ejemplo:
```json
{
"ssl":{
"handshaked":4174,
"reuses":0,
"timedout":0,
"failed":0
},
"requests":{
"total":4327,
"processing":0,
"discarded":0
},
"responses":{
"200":4305,
"302":6,
"304":12,
"404":4
},
"data":{
"received":733955,
"sent":59207757
}
}
```
#### `/status/http/location_zones/`
Para recopilar las métricas de `location`, establezca la directiva [status_zone](https://es.angie.software//angie/docs/configuration/modules/http/index.md#status-zone)
en el contexto de [location](https://es.angie.software//angie/docs/configuration/modules/http/index.md#location) o [if in location](https://es.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#if):
```nginx
location / {
root /usr/share/angie/html;
status_zone location_zone;
if ($request_uri ~* "^/condition") {
# ...
status_zone if_location_zone;
}
}
```
Para agrupar las métricas por un valor personalizado, utilice la sintaxis alternativa.
Aquí, las métricas se agregan por [$host](https://es.angie.software//angie/docs/configuration/modules/http/index.md#v-host),
con cada grupo reportado como una zona independiente:
```nginx
status_zone $host zone=server_zone:5;
```
La zona de memoria compartida especificada recopilará las siguientes estadísticas:
| `requests` | Objeto; estadísticas de solicitudes |
|--------------|-----------------------------------------------------------------------------------------|
| `total` | Número; el número total de solicitudes de clientes |
| `discarded` | Número; el número total de solicitudes de clientes completadas sin enviar una respuesta |
| `responses` | Objeto; estadísticas de respuestas |
| `` | Número; un número distinto de cero de respuestas con estado (100-599) |
| `xxx` | Número; un número distinto de cero de respuestas con otros códigos de estado |
| `data` | Objeto; estadísticas de datos |
| `received` | Número; el número total de bytes recibidos de los clientes |
| `sent` | Número; el número total de bytes enviados a los clientes |
#### NOTE
Los contadores `responses` solo registran respuestas reales, es
decir, las que se enviaron efectivamente al cliente. Una solicitud cuyo
procesamiento finalizó sin enviar una respuesta se contabiliza en
`discarded` y no incrementa los contadores `responses`. En
particular, `499` no es una respuesta, sino un código de servicio
interno, registrado únicamente en el registro de acceso, que marca una
solicitud cuyo procesamiento terminó sin que se enviara una respuesta;
tales solicitudes se reflejan en `discarded`, nunca en
`responses`.
Ejemplo:
```json
{
"requests": {
"total": 4158,
"discarded": 0
},
"responses": {
"200": 4157,
"304": 1
},
"data": {
"received": 538200,
"sent": 177606236
}
}
```
#### `/status/http/metric_zones/`
Métricas personalizadas definidas por [metric_zone](https://es.angie.software//angie/docs/configuration/modules/http/http_metric.md#metric-zone) o [metric_complex_zone](https://es.angie.software//angie/docs/configuration/modules/http/http_metric.md#metric-complex-zone)
en el contexto `http`. Las métricas se actualizan con la directiva [metric](https://es.angie.software//angie/docs/configuration/modules/http/http_metric.md#id1)
o las variables del módulo.
| `discarded` | Número; el número de entradas de métricas descartadas porque la zona se quedó sin memoria. |
|---------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `metrics` | Objeto; métricas por clave. Para zonas de métrica única, los valores son números. Para zonas complejas, los valores son objetos con nombres de métricas. Para el modo histograma, los valores son objetos con nombres de buckets. |
Si `discard_key` está configurado y algunas entradas han expirado,
sus métricas agregadas se exponen bajo esta clave.
Ejemplo:
```json
{
"discarded": 3,
"metrics": {
"example.com": {
"count": 42,
"max": 8
}
"expired": {
"count": 10,
"max": 3.2
}
}
}
```
### Servidor Stream
#### `/status/stream/server_zones/`
Para recopilar las métricas de `server`,
establezca la directiva [status_zone](https://es.angie.software//angie/docs/configuration/modules/stream/index.md#s-status-zone) en el contexto [server](https://es.angie.software//angie/docs/configuration/modules/stream/index.md#s-server):
```nginx
server {
...
status_zone server_zone;
}
```
Para agrupar las métricas por un valor personalizado, utilice la sintaxis alternativa.
Aquí, las métricas se agregan por [$server_addr](https://es.angie.software//angie/docs/configuration/modules/stream/index.md#v-s-server-addr),
con cada grupo reportado como una zona independiente:
```nginx
status_zone $server_addr zone=server_zone:5;
```
La zona de memoria compartida especificada recopilará las siguientes estadísticas:
| `ssl` | Objeto; estadísticas SSL. Presente si `server` establece `listen ssl;` |
|-----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `handshaked` | Número; el número total de handshakes SSL exitosos |
| `reuses` | Número; el número total de reutilizaciones de sesión durante el handshake SSL |
| `timedout` | Número; el número total de handshakes SSL que agotaron el tiempo de espera |
| `failed` | Número; el número total de handshakes SSL fallidos |
| `connections` | Objeto; estadísticas de conexiones |
| `total` | Número; el número total de conexiones de clientes |
| `processing` | Número; el número de conexiones de clientes que se están procesando actualmente |
| `discarded` | Número; el número total de conexiones de clientes completadas sin crear una sesión |
| `passed` | Número; el número total de conexiones de clientes redirigidas a otro puerto de escucha con directivas `pass` |
| `sessions` | Objeto; estadísticas de sesiones |
| `success` | Número; el número de sesiones completadas con código 200, lo que significa finalización exitosa |
| `invalid` | Número; el número de sesiones completadas con código 400, lo que ocurre cuando los datos del cliente no pudieron analizarse, por ejemplo, la cabecera del protocolo PROXY |
| `forbidden` | Número; el número de sesiones completadas con código 403, cuando se prohibió el acceso, por ejemplo, cuando el acceso está limitado para ciertas direcciones de clientes |
| `internal_error` | Número; el número de sesiones completadas con código 500, error interno del servidor |
| `bad_gateway` | Número; el número de sesiones completadas con código 502, bad gateway, por ejemplo, si no se pudo seleccionar o alcanzar un servidor upstream |
| `service_unavailable` | Número; el número de sesiones completadas con código 503, servicio no disponible, por ejemplo, cuando el acceso está limitado por el número de conexiones |
| `data` | Objeto; estadísticas de datos |
| `received` | Número; el número total de bytes recibidos de los clientes |
| `sent` | Número; el número total de bytes enviados a los clientes |
Ejemplo:
```json
{
"ssl": {
"handshaked": 24,
"reuses": 0,
"timedout": 0,
"failed": 0
},
"connections": {
"total": 24,
"processing": 1,
"discarded": 0,
"passed": 2
},
"sessions": {
"success": 24,
"invalid": 0,
"forbidden": 0,
"internal_error": 0,
"bad_gateway": 0,
"service_unavailable": 0
},
"data": {
"received": 2762947,
"sent": 53495723
}
}
```
#### `/status/stream/metric_zones/`
Métricas personalizadas definidas por [metric_zone](https://es.angie.software//angie/docs/configuration/modules/stream/stream_metric.md#s-metric-zone) o
[metric_complex_zone](https://es.angie.software//angie/docs/configuration/modules/stream/stream_metric.md#s-metric-complex-zone) en el contexto `stream`.
Las métricas se actualizan con la directiva [metric](https://es.angie.software//angie/docs/configuration/modules/stream/stream_metric.md#s-metric) o
con las variables del módulo.
| `discarded` | Número; el número de entradas de métricas descartadas porque la zona se quedó sin memoria. |
|---------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `metrics` | Objeto; métricas por clave. Para zonas de métrica única, los valores son números. Para zonas complejas, los valores son objetos con nombres de métricas. Para el modo histograma, los valores son objetos con nombres de bucket. |
Si `discard_key` está configurado y algunas entradas han expirado,
sus métricas agregadas se exponen bajo esta clave.
Ejemplo:
```json
{
"discarded": 3,
"metrics": {
"127.0.0.1": {
"count": 42,
"max": 8
},
"expired": {
"count": 10,
"max": 3.2
}
}
}
```
### Cachés HTTP
```nginx
proxy_cache cache_zone;
proxy_cache_valid 200 10m;
```
#### `/status/http/caches/`
Para cada zona configurada con [proxy_cache](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache), se almacenan los siguientes datos:
```json
{
"name_zone": {
"size": 0,
"cold": false,
"hit": {
"responses": 0,
"bytes": 0
},
"stale": {
"responses": 0,
"bytes": 0
},
"updating": {
"responses": 0,
"bytes": 0
},
"revalidated": {
"responses": 0,
"bytes": 0
},
"miss": {
"responses": 0,
"bytes": 0,
"responses_written": 0,
"bytes_written": 0
},
"expired": {
"responses": 0,
"bytes": 0,
"responses_written": 0,
"bytes_written": 0
},
"bypass": {
"responses": 0,
"bytes": 0,
"responses_written": 0,
"bytes_written": 0
}
}
}
```
| `size` | Número; el tamaño actual de la caché |
|---------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `max_size` | Número; límite configurado para el tamaño máximo de la caché |
| `cold` | Booleano; `true` mientras el cache loader carga datos desde el disco |
| `hit` | Objeto; estadísticas de respuestas válidas en caché ([proxy_cache_valid](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-valid)) |
| `responses` | Número; el número total de respuestas leídas desde la caché |
| `bytes` | Número; el número total de bytes leídos desde la caché |
| `stale` | Objeto; estadísticas de respuestas obsoletas tomadas de la caché ([proxy_cache_use_stale](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-use-stale)) |
| `responses` | Número; el número total de respuestas leídas desde la caché |
| `bytes` | Número; el número total de bytes leídos desde la caché |
| `updating` | Objeto; estadísticas de respuestas obsoletas tomadas de la caché mientras se actualizaban las respuestas ([proxy_cache_use_stale](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-use-stale) updating) |
| `responses` | Número; el número total de respuestas leídas desde la caché |
| `bytes` | Número; el número total de bytes leídos desde la caché |
| `revalidated` | Objeto; estadísticas de respuestas expiradas y revalidadas tomadas de la caché ([proxy_cache_revalidate](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-revalidate)) |
| `responses` | Número; el número total de respuestas leídas desde la caché |
| `bytes` | Número; el número total de bytes leídos desde la caché |
| `miss` | Objeto; estadísticas de respuestas no encontradas en la caché |
| `responses` | Número; el número total de respuestas correspondientes |
| `bytes` | Número; el número total de bytes leídos desde el servidor proxy |
| `responses_written` | Número; el número total de respuestas escritas en la caché |
| `bytes_written` | Número; el número total de bytes escritos en la caché |
| `expired` | Objeto; estadísticas de respuestas expiradas no tomadas de la caché |
| `responses` | Número; el número total de respuestas correspondientes |
| `bytes` | Número; el número total de bytes leídos desde el servidor proxy |
| `responses_written` | Número; el número total de respuestas escritas en la caché |
| `bytes_written` | Número; el número total de bytes escritos en la caché |
| `bypass` | Objeto; estadísticas de respuestas no buscadas en la caché ([proxy_cache_bypass](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-bypass)) |
| `responses` | Número; el número total de respuestas correspondientes |
| `bytes` | Número; el número total de bytes leídos desde el servidor proxy |
| `responses_written` | Número; el número total de respuestas escritas en la caché |
| `bytes_written` | Número; el número total de bytes escritos en la caché |
En Angie PRO, si el cache sharding está habilitado con directivas [proxy_cache_path](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-path),
los fragmentos individuales se exponen como miembros de objeto de un objeto `shards`:
| `shards` | Objeto; enumera fragmentos individuales como miembros |
|------------|-----------------------------------------------------------------------------|
| `` | Objeto; representa un fragmento individual con su ruta de caché como nombre |
| `size` | Número; el tamaño actual del fragmento |
| `max_size` | Número; tamaño máximo del fragmento, si está configurado |
| `cold` | Booleano; `true` mientras el cache loader carga datos desde el disco |
```json
{
"name_zone": {
"shards": {
"/path/to/shard1": {
"size": 0,
"cold": false
},
"/path/to/shard2": {
"size": 0,
"cold": false
}
}
}
```
### Clientes ACME
#### `/status/http/acme_clients/`
Para cada [acme_client](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client) configurado en el bloque `http`, devuelve el
estado actual del cliente y del certificado:
```json
{
"state": "ready",
"certificate": "valid",
"details": "The client is ready to request a certificate.",
"next_run": "2026-07-17T16:15:43.805Z"
}
```
| `state` | Cadena; estado del cliente ACME. Valores posibles: `ready`, `requesting`, `disabled`, `failed`. |
|---------------|------------------------------------------------------------------------------------------------------------------------------------------------|
| `certificate` | Cadena; estado del certificado. Valores posibles: `valid`, `expired`, `missing`, `mismatch`, `error`. |
| `details` | Cadena; detalles breves del estado de la última operación ACME. |
| `next_run` | Fecha; próximo intento programado para solicitar o renovar el certificado. No se devuelve cuando `state` es `disabled` o `requesting`. |
### limit_conn
```nginx
limit_conn_zone $binary_remote_addr zone=limit_conn_zone:10m;
```
#### `/status/http/limit_conns/`, `/status/stream/limit_conns/`
Objetos para cada [limit_conn en http](#limit-conn) o [limit_conn en stream](https://es.angie.software//angie/docs/configuration/modules/stream/stream_limit_conn.md#s-limit-conn) configurados con los siguientes campos:
```json
{
"passed": 73,
"skipped": 0,
"rejected": 0,
"exhausted": 0
}
```
| `passed` | Número; el número total de conexiones aceptadas |
|-------------|----------------------------------------------------------------------------------------------------------|
| `skipped` | Número; el número total de conexiones aceptadas con clave de longitud cero, o clave que excede 255 bytes |
| `rejected` | Número; el número total de conexiones que exceden el límite configurado |
| `exhausted` | Número; el número total de conexiones rechazadas por agotamiento del almacenamiento de la zona |
### limit_req
```nginx
limit_req_zone $binary_remote_addr zone=limit_req_zone:10m rate=1r/s;
```
#### `/status/http/limit_reqs/`
Objetos para cada [limit_req](#limit-req) configurado con los siguientes campos:
```json
{
"passed": 54816,
"skipped": 0,
"delayed": 65,
"rejected": 26,
"exhausted": 0
}
```
| `passed` | Número; el número total de solicitudes aceptadas |
|-------------|-----------------------------------------------------------------------------------------------------------|
| `skipped` | Número; el número total de solicitudes aceptadas con clave de longitud cero, o clave que excede 255 bytes |
| `delayed` | Número; el número total de solicitudes retrasadas |
| `rejected` | Número; el número total de solicitudes rechazadas |
| `exhausted` | Número; el número total de solicitudes rechazadas por agotamiento del almacenamiento de la zona |
### HTTP upstream
Para habilitar la recopilación de las siguientes métricas,
establezca la directiva [zone](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone) en el contexto [upstream](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream),
por ejemplo:
```nginx
upstream upstream {
zone upstream 256k;
server backend.example.com service=_example._tcp resolve max_conns=5;
keepalive 4;
}
```
El uso de memoria de esta zona de memoria compartida se informa en la sección
de la API [/status/slabs/](#samp-status-slabs-zone), indexado por el nombre
de la zona.
#### `/status/http/upstreams/`
donde es el nombre de cualquier [upstream](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream) especificado con la directiva [zone](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone)
```json
{
"peers": {
"192.168.16.4:80": {
"server": "backend.example.com",
"service": "_example._tcp",
"backup": false,
"weight": 5,
"state": "up",
"selected": {
"current": 2,
"total": 232
},
"max_conns": 5,
"responses": {
"200": 222,
"302": 12
},
"data": {
"sent": 543866,
"received": 27349934
},
"health": {
"fails": 0,
"unavailable": 0,
"downtime": 0
},
"sid": ""
}
},
"keepalive": 2
}
```
| `peers` | Objeto; contiene las métricas de los peers del upstream como subobjetos cuyos nombres son representaciones canónicas de las direcciones de los peers. Miembros de cada subobjeto: |
|----------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `server` | Cadena; el parámetro de la directiva [server](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server) |
| `service` | Cadena; nombre del servicio tal como se especifica en la directiva [server](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server), si está configurado |
| `backup` | Booleano; `true` para servidores de respaldo |
| `weight` | Número; [peso](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server) configurado |
| `state` | Cadena; el estado actual del peer y qué solicitudes se le envían:
- `busy`: indica que el número de solicitudes al servidor ha alcanzado el límite establecido por [max_conns](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server), y no se envían nuevas solicitudes; - `down`: deshabilitado manualmente, no se envían solicitudes; - `draining`: similar a `down`, pero las solicitudes de sesiones previamente enlazadas (vía [sticky](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-sticky)) siguen enviándose; - `recovering`: recuperándose tras un fallo según [slow_start](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#slow-start), cada vez se envían más solicitudes; - `unavailable`: alcanzó el límite [max_fails](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#max-fails), solo se envían solicitudes de prueba del cliente en intervalos definidos por [fail_timeout](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#fail-timeout); - `up`: operativo, las solicitudes se envían como de costumbre;
Estados adicionales en Angie PRO:
- `checking`: configurado como `essential` y siendo verificado, solo se envían [solicitudes de sonda](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe); - `unhealthy`: no operativo, solo se envían [solicitudes de sonda](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe). |
| `selected` | Objeto; estadísticas de selección del peer |
| `current` | Número; el número actual de conexiones al peer |
| `total` | Número; número total de solicitudes reenviadas al peer |
| `last` | Cadena o número; momento en que el peer fue seleccionado por última vez, formateado como una [fecha](#api-date-format) |
| `max_conns` | Número; el número [máximo](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server) configurado de conexiones activas simultáneas al peer, si está especificado |
| `responses` | Objeto; estadísticas de respuestas |
| `` | Número; un número no cero de respuestas con estado (100-599) |
| `xxx` | Número; un número no cero de respuestas con otros códigos de estado |
| `data` | Objeto; estadísticas de datos |
| `received` | Número; el número total de bytes recibidos del peer |
| `sent` | Número; el número total de bytes enviados al peer |
| `health` | Objeto; estadísticas de salud |
| `fails` | Número; el número total de intentos fallidos de comunicarse con el peer |
| `unavailable` | Número; cuántas veces el peer se volvió `unavailable` por alcanzar el límite [max_fails](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#max-fails) |
| `downtime` | Número; el tiempo total (en milisegundos) que el peer estuvo `unavailable` para selección |
| `downstart` | Cadena o número; momento en que el peer se volvió `unavailable`, formateado como una [fecha](#api-date-format). El campo solo está presente mientras el peer está en estado `unavailable`; de lo contrario, está ausente |
| `header_time` | Número; tiempo promedio (en milisegundos) para recibir las cabeceras de respuesta del servidor; ver [response_time_factor](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-response-time-factor) |
| `response_time` | Número; tiempo promedio (en milisegundos) para recibir la respuesta completa del servidor; ver [response_time_factor](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-response-time-factor) |
| `sid` | Cadena; [id configurado](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#reresolve) del servidor en el grupo upstream |
| `feedback` (PRO) | Número; el valor de feedback promedio actual utilizado por el método de balanceo de carga [feedback](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-feedback), presente solo cuando se usa este método |
| `keepalive` | Número; el número actual de conexiones en caché |
| `backup_switch` | Objeto; contiene el estado actual de la lógica de respaldo activa, presente si [backup_switch (PRO)](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-backup-switch) está configurado para el upstream |
| `active` | Número; el nivel del grupo activo que se utiliza actualmente para el balanceo de carga de solicitudes. Si el grupo activo es el primario, el valor es 0 |
| `timeout` | Número; tiempo de espera restante en milisegundos, después del cual el balanceador volverá a verificar nodos sanos en grupos con niveles inferiores, comenzando por el grupo primario, mientras que los grupos con niveles superiores no se verifican; no se muestra para el grupo primario (nivel 0) |
##### `health/probes` (PRO)
Si el upstream tiene sondas [upstream_probe (PRO)](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe) configuradas,
el objeto `health` también tiene un subobjeto `probes`
que almacena los contadores de sondas de salud del servidor,
mientras que `state`, además de los valores listados en la tabla anterior,
también puede ser `checking` y `unhealthy`:
```json
{
"192.168.16.4:80": {
"state": "unhealthy",
"...": "...",
"health": {
"...": "...",
"probes": {
"count": 10,
"fails": 10,
"last": "2026-07-17T09:56:07Z"
}
}
}
}
```
El valor `checking` de `state` no se cuenta como `downtime`
y significa que el servidor, que tiene una sonda configurada como `essential`,
aún no ha sido verificado;
el valor `unhealthy` significa que el servidor está funcionando incorrectamente.
Ambos estados también implican que el servidor no está incluido en el balanceo de carga.
Para detalles sobre sondas de salud, ver [upstream_probe](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe).
Contadores en `probes`:
| `count` | Número; sondas totales para este servidor |
|-----------|---------------------------------------------------------------------------------------------|
| `fails` | Número; sondas fallidas totales |
| `last` | Cadena o número; hora de la última sonda, formateada como una [fecha](#api-date-format) |
##### `queue` (PRO)
Si se configura una [cola de solicitudes](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-queue) para el upstream,
el objeto upstream también contiene un objeto anidado `queue`
con contadores de la cola de solicitudes:
```json
{
"queue": {
"queued": 20112,
"waiting": 1011,
"dropped": 6031,
"timedout": 560,
"overflows": 13
}
}
```
Los valores de los contadores se suman en todos los procesos de trabajo:
| `queued` | Número; número total de solicitudes que entraron en la cola |
|-------------|------------------------------------------------------------------------------------------------------------------|
| `waiting` | Número; número actual de solicitudes en la cola |
| `dropped` | Número; número total de solicitudes eliminadas de la cola porque el cliente cerró la conexión prematuramente |
| `timedout` | Número; número total de solicitudes eliminadas de la cola por tiempo de espera |
| `overflows` | Número; número total de ocurrencias de desbordamiento de la cola |
### Upstream de stream
Para habilitar la recopilación de las siguientes métricas,
establezca la directiva [zone](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-zone) en el contexto [upstream](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-upstream),
por ejemplo:
```nginx
upstream upstream {
zone upstream 256k;
server backend.example.com service=_example._tcp resolve max_conns=5;
keepalive 4;
}
```
El uso de memoria de esta zona de memoria compartida se informa en la sección
de la API [/status/slabs/](#samp-status-slabs-zone), indexado por el nombre
de la zona.
#### `/status/stream/upstreams/`
Aquí, es el nombre de un [upstream](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream) que está
configurado con una directiva [zone](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone).
```json
{
"peers": {
"192.168.16.4:1935": {
"server": "backend.example.com",
"service": "_example._tcp",
"backup": false,
"weight": 5,
"state": "up",
"selected": {
"current": 2,
"total": 232
},
"max_conns": 5,
"data": {
"sent": 543866,
"received": 27349934
},
"health": {
"fails": 0,
"unavailable": 0,
"downtime": 0
}
}
}
}
```
| `peers` | Objeto; contiene las métricas de los peers del upstream como subobjetos cuyos nombres son representaciones canónicas de las direcciones de los peers. Miembros de cada subobjeto: |
|-----------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `server` | Cadena; dirección establecida por la directiva [server](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server) |
| `service` | Cadena; nombre del servicio, si está establecido por la directiva [server](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server) |
| `backup` | Booleano; `true` para servidores de respaldo |
| `weight` | Número; el [weight](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server) establecido para el peer |
| `state` | Cadena; el estado actual del peer y qué solicitudes se envían a él:
- `busy`: indica que el número de solicitudes al servidor ha alcanzado el límite establecido por [max_conns](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server), y no se envían nuevas solicitudes - `down`: deshabilitado manualmente, no se envían solicitudes - `draining`: similar a `down`, pero las solicitudes de sesiones previamente enlazadas (mediante [sticky](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-sticky)) siguen enviándose - `recovering`: recuperándose tras una falla según [slow_start](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-slow-start), se envían más y más solicitudes con el tiempo - `unavailable`: alcanzó el límite [max_fails](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-max-fails), solo se envían solicitudes de cliente de prueba en intervalos definidos por [fail_timeout](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-fail-timeout) - `up`: operativo, las solicitudes se envían como de costumbre
Estados adicionales en Angie PRO:
- `checking`: configurado como `essential` y siendo verificado, solo se envían [solicitudes de sondeo](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#s-u-upstream-probe) - `unhealthy`: no operativo, solo se envían [solicitudes de sondeo](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#s-u-upstream-probe) |
| `selected` | Objeto; estadísticas sobre la selección de este peer para conexiones |
| `current` | Número; número actual de conexiones al peer |
| `total` | Número; número total de conexiones reenviadas al peer |
| `last` | Cadena o número; momento en que el peer fue seleccionado por última vez, formateado como una [fecha](#api-date-format) |
| `max_conns` | Número; número [máximo](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server) de conexiones activas simultáneas al peer, si está establecido |
| `data` | Objeto; estadísticas de transferencia de datos |
| `received` | Número; bytes totales recibidos del peer |
| `sent` | Número; bytes totales enviados al peer |
| `health` | Objeto; estadísticas de salud del peer |
| `fails` | Número; total de intentos fallidos de alcanzar al peer |
| `unavailable` | Número; número total de veces que el peer se volvió `unavailable` debido a alcanzar el valor [max_fails](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-max-fails) |
| `downtime` | Número; tiempo total (en milisegundos) que el peer estuvo `unavailable` (no disponible para selección) |
| `downstart` | Cadena o número; momento en que el peer se volvió `unavailable` por última vez, formateado como una [fecha](#api-date-format). El campo solo está presente mientras el peer está en estado `unavailable`; de lo contrario, está ausente |
| `connect_time` | Número; tiempo promedio (en milisegundos) para establecer una conexión con el servidor; consulte la directiva [response_time_factor](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-response-time-factor) |
| `first_byte_time` | Número; tiempo promedio (en milisegundos) para recibir el primer byte de la respuesta del servidor; consulte la directiva [response_time_factor](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-response-time-factor) |
| `last_byte_time` | Número; tiempo promedio (en milisegundos) para recibir la respuesta completa del servidor; consulte la directiva [response_time_factor](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-response-time-factor) |
| `feedback` (PRO) | Número; el valor de feedback promedio actual utilizado por el método de balanceo de carga [feedback](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-feedback), presente solo cuando se usa este método |
| `backup_switch` (PRO 1.10.0+) | Objeto; contiene el estado actual de la lógica de respaldo activo, presente si [backup_switch (PRO)](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-backup-switch) está configurado para el upstream |
| `active` | Número; nivel del grupo activo actualmente utilizado para el balanceo de carga. Si el grupo activo es el grupo primario, el valor es 0 |
| `timeout` | Número; tiempo de espera restante en milisegundos tras el cual el balanceador de carga volverá a verificar nodos sanos en grupos con niveles inferiores, empezando por el grupo primario, mientras que los grupos con niveles superiores no se verifican; no se muestra para el grupo primario (nivel 0) |
En Angie PRO, si el upstream tiene sondas [upstream_probe (PRO)](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#s-u-upstream-probe) configuradas,
el objeto `health` también tiene un subobjeto `probes`
que almacena los contadores de sondas de salud del servidor,
mientras que `state`, además de los valores de la tabla anterior,
también puede ser `checking` y `unhealthy`:
```json
{
"192.168.16.4:80": {
"state": "unhealthy",
"...": "...",
"health": {
"...": "...",
"probes": {
"count": 2,
"fails": 2,
"last": "2026-07-17T11:03:54Z"
}
}
}
}
```
El valor `checking` de `state` significa que el servidor,
que tiene una sonda configurada con el parámetro `essential`,
aún no ha sido verificado;
el valor `unhealthy` significa que el servidor no está operativo.
Ambos estados también significan que el servidor no está incluido en el balanceo de carga.
Para detalles de las sondas de salud, consulte [upstream_probe](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#s-u-upstream-probe).
Contadores en `probes`:
| `count` | Número; número total de sondas para este servidor |
|-----------|------------------------------------------------------------------------------------------------|
| `fails` | Número; número de sondas fallidas |
| `last` | Cadena o número; momento de la última sonda, formateado como una [fecha](#api-date-format) |
## Certificados
### `/certificates/`
Un objeto de nivel superior de la API, independiente del árbol de estadísticas
[/status/](#metrics), que informa sobre los certificados TLS que Angie ha cargado.
Un certificado no se incluye bajo `static` si el nombre de su archivo de
certificado o de clave contiene una variable, incluida una proporcionada por un
cliente ACME a través de la variable [$acme_cert_](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#v-acme-cert-name).
Un certificado compartido por varios servidores se incluye una sola vez.
El siguiente ejemplo carga un certificado estático y obtiene otro certificado
con un cliente ACME. El cliente ACME requiere un [resolver](https://es.angie.software//angie/docs/configuration/modules/http/index.md#resolver) configurado
para resolver el nombre de host del directorio:
```nginx
http {
resolver 127.0.0.53;
acme_client example https://acme.example.com/directory;
server {
listen 443 ssl;
server_name www.example.com;
ssl_certificate example.com.crt;
ssl_certificate_key example.com.key;
location /certificates/ {
api /certificates/;
}
}
server {
listen 443 ssl;
server_name acme.example.com;
acme example;
ssl_certificate $acme_cert_example;
ssl_certificate_key $acme_cert_key_example;
}
}
```
En respuesta a la solicitud
`curl https://www.example.com/certificates/`, Angie devuelve:
```json
{
"static": {
"example.com.crt": {
"key": "RSA (2048 bits)",
"chain": [
{
"subject": {
"common_name": "example.com",
"alt_names": [
"example.com",
"www.example.com"
],
"organization": "Example, Inc."
},
"issuer": {
"common_name": "Example Root CA",
"country": "US",
"organization": "Example, Inc."
},
"validity": {
"since": "Sep 18 19:46:19 2022 GMT",
"until": "Jun 15 19:46:19 2025 GMT"
}
}
]
}
},
"acme_clients": {
"example": {
"key": "EC (prime256v1)",
"chain": [
{
"subject": {
"common_name": "acme.example.com"
},
"issuer": {
"common_name": "Example ACME CA"
},
"validity": {
"since": "Sep 18 19:46:19 2022 GMT",
"until": "Dec 17 19:46:19 2022 GMT"
}
}
]
}
}
}
```
| `static` | Objeto; certificados de servidor establecidos con [ssl_certificate](https://es.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-certificate) en HTTP, [ssl_certificate](https://es.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#s-ssl-certificate) en Stream, o [ssl_certificate](https://es.angie.software//angie/docs/configuration/modules/mail/mail_ssl.md#m-ssl-certificate) en Mail, cada uno indexado por el nombre del archivo de certificado. En compilaciones con `--with-ntls`, también incluye certificados establecidos con [proxy_ssl_certificate](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-ssl-certificate) en HTTP o [proxy_ssl_certificate](https://es.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-ssl-certificate) en Stream para autenticarse ante servidores proxy |
|----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `acme_clients` | Objeto; disponible cuando Angie se compila con el [módulo HTTP ACME](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme), que también es requerido por el [módulo Stream ACME](https://es.angie.software//angie/docs/configuration/modules/stream/stream_acme.md#stream-acme). Contiene certificados obtenidos por [clientes ACME](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client) para servidores HTTP y Stream. Cada entrada se indexa por el nombre de [acme_client](https://es.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client). Solo se listan los clientes que ya han obtenido un certificado |
Cada entrada de `static` y `acme_clients` describe un solo
paquete de certificados:
| `key` | Cadena; tipo y tamaño de la clave privada (o curva), por ejemplo `RSA (2048 bits)`, `EC (prime256v1)`, o `DH (2048 bits)` |
|---------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `chain` | Array; los certificados del paquete, comenzando por el certificado de hoja (servidor) seguido de los certificados intermedios, hacia la raíz. Cada elemento es un objeto que describe un certificado: |
| `subject` | Objeto; el nombre distinguido del asunto |
| `common_name` | Cadena; Common Name (`CN`) |
| `alt_names` | Array de cadenas; los nombres DNS y direcciones IP de la extensión Subject Alternative Name |
| `country` | Cadena; Country (`C`) |
| `state_or_province` | Cadena; State or Province Name (`ST`) |
| `organization` | Cadena; Organization (`O`) |
| `issuer` | Objeto; el nombre distinguido del emisor, con los mismos campos que `subject` |
| `validity` | Objeto; el período de validez del certificado |
| `since` | Cadena; inicio del período de validez (`notBefore`) |
| `until` | Cadena; fin del período de validez (`notAfter`) |
Los campos de `subject` y `issuer` solo aparecen cuando están
presentes en el certificado.
## API de Configuración Dinámica (PRO)
La API incluye una sección `/config` que permite actualizaciones dinámicas
a la configuración de Angie en formato JSON
con solicitudes HTTP `PUT`, `PATCH` y `DELETE`.
Todas las actualizaciones son atómicas: los nuevos ajustes se aplican en su totalidad,
o ninguno se aplica en absoluto.
En caso de error, Angie informa la razón.
### Subsecciones de `/config`
Actualmente, la configuración de servidores individuales dentro de upstreams está disponible
en la sección `/config` para los módulos [HTTP](#api-config-http-upstreams-servers) y [stream](#api-config-stream-upstreams-servers); el número de ajustes
elegibles para configuración dinámica está en constante aumento.
#### `/config/http/upstreams//servers/`
Permite configurar peers individuales de upstream,
incluyendo eliminar peers existentes o añadir nuevos.
Parámetros de la ruta URI:
| `` | Nombre del upstream; para configurarlo vía `/config`, debe tener configurada una directiva [zone](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone), que define una zona de memoria compartida. |
|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `` | El nombre del peer dentro del upstream, definido como `@`, donde:
- `@` es un nombre de servicio opcional, usado para la resolución de registros SRV. - `` es el nombre de dominio del servicio (si `resolve` está presente) o su IP; se puede definir un puerto opcional aquí. |
Por ejemplo, la siguiente configuración:
```nginx
upstream backend {
server backend.example.com service=_http._tcp resolve;
server 127.0.0.1;
zone backend 1m;
}
```
Permite los siguientes nombres de peer:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/_http._tcp@backend.example.com/
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/127.0.0.1:80/
```
Esta subsección de la API permite establecer los parámetros `weight`, `max_conns`,
`max_fails`, `fail_timeout`, `slow_start`, `backup`, `down` y
`sid`, tal como se describe en [server](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server).
#### NOTE
No existe un parámetro separado `drain`;
para habilitar `drain`,
establezca `down` al valor de cadena `drain`:
```console
$ curl -X PUT -d \"drain\" \
http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com/down
```
Ejemplo:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com?defaults=on
```
```json
{
"weight": 1,
"max_conns": 0,
"max_fails": 1,
"fail_timeout": 10,
"slow_start": 0,
"backup": true,
"down": false,
"sid": ""
}
```
Los parámetros realmente disponibles están limitados a los que son compatibles con el
método de balanceo de carga actual del [upstream](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream).
Por tanto, si el upstream está configurado con el método `random`:
```nginx
upstream backend {
zone backend 256k;
server backend.example.com resolve max_conns=5;
random;
}
```
No podrá añadir un nuevo peer que defina `backup`:
```console
$ curl -X PUT -d '{ "backup": true }' \
http://127.0.0.1/config/http/upstreams/backend/servers/backend1.example.com
```
```json
{
"error": "FormatError",
"description": "The \"backup\" field is unknown."
}
```
#### `/config/stream/upstreams//servers/`
Permite configurar peers individuales de upstream,
incluyendo eliminar peers existentes o añadir nuevos.
Parámetros de la ruta URI:
| `` | Nombre del bloque `upstream`; para configurarlo vía `/config`, debe tener configurada una directiva [zone](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-zone), que define una zona de memoria compartida. |
|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `` | El nombre del peer dentro del upstream, definido como `@`, donde:
- `@` es un nombre de servicio opcional, usado para la resolución de registros SRV. - `` es el nombre de dominio del servicio (si `resolve` está presente) o su IP; se puede definir un puerto opcional aquí. |
Por ejemplo, la siguiente configuración:
```nginx
upstream backend {
server backend.example.com:8080 service=_example._tcp resolve;
server 127.0.0.1:12345;
zone backend 1m;
}
```
Permite los siguientes nombres de peer:
```console
$ curl http://127.0.0.1/config/stream/upstreams/backend/servers/_example._tcp@backend.example.com:8080/
$ curl http://127.0.0.1/config/stream/upstreams/backend/servers/127.0.0.1:12345/
```
Esta subsección de la API permite establecer los parámetros `weight`,
`max_conns`, `max_fails`, `fail_timeout`, `slow_start`, `backup` y
`down`, tal como se describe en [server](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server).
#### NOTE
No existe un parámetro separado `drain`;
para habilitar el modo `drain`,
establezca `down` al valor de cadena `drain`:
```console
$ curl -X PUT -d \"drain\" \
http://127.0.0.1/config/stream/upstreams/backend/servers/backend.example.com/down
```
Ejemplo:
```console
curl http://127.0.0.1/config/stream/upstreams/backend/servers/backend.example.com?defaults=on
```
```json
{
"weight": 1,
"max_conns": 0,
"max_fails": 1,
"fail_timeout": 10,
"slow_start": 0,
"backup": true,
"down": false,
}
```
Los parámetros realmente disponibles están limitados a los que son compatibles con el
método de balanceo de carga actual del [upstream](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-upstream).
Por tanto, si el upstream está configurado con el método `random`:
```nginx
upstream backend {
zone backend 256k;
server backend.example.com resolve max_conns=5;
random;
}
```
No podrá añadir un nuevo peer que defina `backup`:
```console
$ curl -X PUT -d '{ "backup": true }' \
http://127.0.0.1/config/stream/upstreams/backend/servers/backend1.example.com
```
```json
{
"error": "FormatError",
"description": "The \"backup\" field is unknown."
}
```
Al eliminar peers, puede establecer el
argumento `connection_drop=` (PRO) para anular la
configuración de [proxy_connection_drop](https://es.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-connection-drop):
```console
$ curl -X DELETE \
http://127.0.0.1/config/stream/upstreams/backend/servers/backend1.example.com?connection_drop=off
$ curl -X DELETE \
http://127.0.0.1/config/stream/upstreams/backend/servers/backend2.example.com?connection_drop=on
$ curl -X DELETE \
http://127.0.0.1/config/stream/upstreams/backend/servers/backend3.example.com?connection_drop=1000
```
### Métodos HTTP
Consideremos la semántica de cada método HTTP aplicable a esta sección
utilizando la siguiente configuración de upstream como ejemplo:
```nginx
http {
# ...
upstream backend {
zone upstream 256k;
server backend.example.com resolve max_conns=5;
# ...
}
server {
# ...
location /config/ {
api /config/;
allow 127.0.0.1;
deny all;
}
}
}
```
#### GET
El método HTTP `GET` consulta una entidad en cualquier ruta existente dentro de
`/config`, tal como lo hace para otras secciones de la API.
Por ejemplo, la rama del servidor upstream
`/config/http/upstreams/backend/servers/`
permite estas consultas:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com/max_conns
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
$ curl http://127.0.0.1/config/http/upstreams/backend/servers
$ # ...
$ curl http://127.0.0.1/config
```
Puede obtener valores de parámetros predeterminados con el argumento
`defaults=on`; consulte [Argumentos de consulta](#api-query-arguments).
#### PUT
El método HTTP `PUT` crea una nueva entidad JSON en la ruta especificada
o reemplaza *completamente* una existente.
Por ejemplo, para añadir el parámetro `max_fails`, no especificado anteriormente,
al servidor `backend.example.com` dentro del upstream `backend`:
```console
$ curl -X PUT -d '2' \
http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com/max_fails
```
```json
{
"success": "Updated",
"description": "Existing configuration API entity \"/config/http/upstreams/backend/servers/backend.example.com/max_fails\" was updated with replacing."
}
```
Verifica los cambios:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
```
```json
{
"max_conns": 5,
"max_fails": 2
}
```
#### DELETE
El método HTTP `DELETE` elimina configuraciones *previamente definidas* en la ruta especificada;
al hacerlo, restaura los valores predeterminados si los hay.
Por ejemplo, para eliminar el parámetro `max_fails` previamente modificado
del servidor `backend.example.com` dentro del upstream `backend`:
```console
$ curl -X DELETE \
http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com/max_fails
```
```console
{
"success": "Reset",
"description": "Configuration API entity \"/config/http/upstreams/backend/servers/backend.example.com/max_fails\" was reset to default."
}
```
Verifica los cambios usando el argumento `defaults=on`:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com?defaults=on
```
```json
{
"weight": 1,
"max_conns": 5,
"max_fails": 1,
"fail_timeout": 10,
"slow_start": 0,
"backup": false,
"down": false,
"sid": ""
}
```
El parámetro `max_fails` ha vuelto a su valor predeterminado.
Al eliminar servidores, puede establecer el argumento `connection_drop=`
(PRO) para anular las configuraciones de [proxy_connection_drop](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-connection-drop), [grpc_connection_drop](https://es.angie.software//angie/docs/configuration/modules/http/http_grpc.md#grpc-connection-drop),
[fastcgi_connection_drop](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-connection-drop), [scgi_connection_drop](https://es.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-connection-drop) y
[uwsgi_connection_drop](https://es.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-connection-drop):
```console
$ curl -X DELETE \
http://127.0.0.1/config/http/upstreams/backend/servers/backend1.example.com?connection_drop=off
$ curl -X DELETE \
http://127.0.0.1/config/http/upstreams/backend/servers/backend2.example.com?connection_drop=on
$ curl -X DELETE \
http://127.0.0.1/config/http/upstreams/backend/servers/backend3.example.com?connection_drop=1000
```
#### PATCH
El método HTTP `PATCH` crea una nueva entidad en la ruta especificada
o reemplaza parcialmente o complementa una existente
([RFC 7386](https://datatracker.ietf.org/doc/html/rfc7396))
proporcionando una definición JSON en su carga útil.
El método opera de la siguiente manera: si las entidades de la nueva definición
existen en la configuración, se sobrescriben; de lo contrario, se añaden.
Por ejemplo, para cambiar el parámetro `down` del servidor
`backend.example.com` dentro del upstream `backend`,
dejando el resto intacto:
```console
$ curl -X PATCH -d '{ "down": true }' \
http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
```
```json
{
"success": "Updated",
"description": "Existing configuration API entity \"/config/http/upstreams/backend/servers/backend.example.com\" was updated with merging."
}
```
Verifica los cambios:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
```
```json
{
"max_conns": 5,
"down": true
}
```
Observa que el objeto JSON proporcionado con la solicitud `PATCH` *se fusionó* con el
existente en lugar de reemplazarlo completamente, como ocurriría con `PUT`.
Los valores `null` son un caso especial; se utilizan para eliminar
elementos específicos de configuración durante dicha fusión.
#### NOTE
Esta eliminación es idéntica a `DELETE`;
en particular, restaura los valores predeterminados.
Por ejemplo, para eliminar el parámetro `down` añadido anteriormente
y simultáneamente actualizar `max_conns`:
```console
$ curl -X PATCH -d '{ "down": null, "max_conns": 6 }' \
http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
```
```json
{
"success": "Updated",
"description": "Existing configuration API entity \"/config/http/upstreams/backend/servers/backend.example.com\" was updated with merging."
}
```
Verifica los cambios:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
```
```json
{
"max_conns": 6
}
```
El parámetro `down`, para el cual se proporcionó un valor `null`, fue eliminado;
el valor de `max_conns` fue actualizado.
# https://es.angie.software/angie/docs/configuration/modules/http/http_auth_basic.md
# Auth Basic
Permite limitar el acceso a recursos validando el nombre de usuario y la contraseña mediante el protocolo "HTTP Basic Authentication".
El acceso también puede limitarse por [dirección](https://es.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access) o por el
[resultado de una subpetición](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request). La limitación simultánea
por dirección y por contraseña se controla mediante la directiva [satisfy](https://es.angie.software//angie/docs/configuration/modules/http/index.md#satisfy).
## Ejemplo de configuración
```nginx
location / {
auth_basic "closed site";
auth_basic_user_file conf/htpasswd;
}
```
## Directivas
### auth_basic
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `auth_basic` string | `off`; |
|--------------------------------------------------------------------------------------------|--------------------------------------|
| Predeterminado | `auth_basic off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, limit_except |
Habilita la validación de nombre de usuario y contraseña mediante el protocolo "HTTP Basic Authentication". El parámetro especificado se utiliza como realm. El valor del parámetro puede contener [variables](https://es.angie.software//angie/docs/configuration/configfile.md#string-variables).
| `off` | cancela el efecto de la directiva auth_basic heredada del nivel de configuración anterior |
|---------|---------------------------------------------------------------------------------------------|
### auth_basic_user_file
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `auth_basic_user_file` file; |
|--------------------------------------------------------------------------------------------|--------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, limit_except |
Especifica un file que contiene los nombres de usuario y contraseñas. El formato es el siguiente:
```none
# comment
name1:password1
name2:password2:comment
name3:password3
```
El nombre del file puede contener variables.
Se admiten los siguientes tipos de contraseñas:
* cifradas con la función crypt(); pueden generarse mediante la utilidad `htpasswd` de la distribución de Apache HTTP Server o con el comando "openssl passwd";
* con hash mediante la variante Apache del algoritmo de contraseñas basado en MD5 (apr1); pueden generarse con las mismas herramientas;
* especificadas con la sintaxis "{scheme}data" según lo descrito en [RFC 2307](https://datatracker.ietf.org/doc/html/rfc2307#section-5.3); los esquemas actualmente implementados incluyen PLAIN (ejemplo, no debería usarse), SHA (hashing SHA-1 sin sal, no debería usarse) y SSHA (hashing SHA-1 con sal, usado por algunos paquetes de software, como OpenLDAP y Dovecot).
#### WARNING
El soporte para el esquema SHA se añadió únicamente para facilitar la migración desde otros servidores web. No debe utilizarse para nuevas contraseñas, ya que el hashing SHA-1 sin sal que emplea es vulnerable a ataques de [tablas arcoíris](http://en.wikipedia.org/wiki/Rainbow_attack).
# https://es.angie.software/angie/docs/configuration/modules/http/http_auth_request.md
# Auth Request
Implementa la autorización de clientes basada en el resultado de una subpetición. Si la subpetición devuelve un código de respuesta 2xx, se permite el acceso. Si devuelve 401 o 403, se deniega el acceso con el código de error correspondiente. Cualquier otro código de respuesta devuelto por la subpetición se considera un error.
Para el error 401, el cliente también recibe la cabecera `WWW-Authenticate` de la respuesta de la subpetición.
Cuando se [compila desde el código fuente](https://es.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild),
este módulo no se construye por defecto;
debe habilitarse con la
opción de compilación `‑‑with‑http_auth_request_module`
[build option](https://es.angie.software//angie/docs/installation/sourcebuild.md#configure).
En los paquetes e imágenes de [nuestros repositorios](https://es.angie.software//angie/docs/installation/index.md#install-packages),
el módulo está incluido en la compilación.
El módulo puede combinarse con otros módulos de acceso, como
[Access](https://es.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access) y [Auth Basic](https://es.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic), mediante la directiva [satisfy](https://es.angie.software//angie/docs/configuration/modules/http/index.md#satisfy).
## Ejemplo de configuración
```nginx
location /private/ {
auth_request /auth;
# ...
}
location = /auth {
proxy_pass ...;
proxy_pass_request_body off;
proxy_set_header Content-Length "";
proxy_set_header X-Original-URI $request_uri;
}
```
## Directivas
### auth_request
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `auth_request` `uri` | `off`; |
|--------------------------------------------------------------------------------------------|---------------------------------|
| Predeterminado | `auth_request off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita la autorización basada en el resultado de una subpetición y establece la URI a la que se enviará la subpetición.
### auth_request_set
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `auth_request_set` $variable value; |
|--------------------------------------------------------------------------------------------|---------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Establece la variable de petición al valor dado después de que se complete la petición de autorización. El valor puede contener [variables](https://es.angie.software//angie/docs/configuration/configfile.md#string-variables) de la petición de autorización, como `$upstream_http_*`.
# https://es.angie.software/angie/docs/configuration/modules/http/http_autoindex.md
# AutoIndex
Atiende solicitudes que terminan con una barra diagonal (`/`) y produce un listado de directorios. Normalmente, una solicitud se pasa al módulo `AutoIndex` cuando el módulo [Index](https://es.angie.software//angie/docs/configuration/modules/http/http_index.md#http-index) no puede encontrar un archivo índice.
## Ejemplo de configuración
```nginx
location / {
autoindex on;
}
```
## Directivas
### autoindex
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `autoindex` `on` | `off`; |
|--------------------------------------------------------------------------------------------|-----------------------------|
| Predeterminado | `autoindex off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita o deshabilita la salida del listado de directorios.
### autoindex_exact_size
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `autoindex_exact_size` `on` | `off`; |
|--------------------------------------------------------------------------------------------|----------------------------------------|
| Predeterminado | `autoindex_exact_size on;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Para el [formato](#autoindex-format) HTML, especifica si se deben mostrar los tamaños exactos de los archivos en el listado de directorios, o si se deben redondear a kilobytes, megabytes y gigabytes.
### autoindex_format
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `autoindex_format` `html` | `xml` | `json` | `jsonp`; |
|--------------------------------------------------------------------------------------------|---------------------------------------------------------|
| Predeterminado | `autoindex_format html;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Establece el formato del listado de directorios.
Cuando se utiliza el formato JSONP, el nombre de la función de callback se establece con el argumento de solicitud `callback`. Si el argumento falta o tiene un valor vacío, se utiliza el formato JSON.
La salida XML puede transformarse utilizando el módulo [XSLT](https://es.angie.software//angie/docs/configuration/modules/http/http_xslt.md#http-xslt).
### Formatos de salida
Los campos de objeto en las respuestas contienen los siguientes datos:
| Campo | Descripción |
|---------|---------------------------------------------------------------------------------------------------|
| `name` | Nombre del archivo o directorio |
| `type` | Tipo de objeto: `file` o `directory` |
| `size` | Tamaño del objeto según [autoindex_exact_size](#autoindex-exact-size); para directorios — `0` |
| `mtime` | Hora de última modificación en formato de tiempo Unix |
HTML
```html
Index of /files/
```
XML
```xml
example.txtfile12342025-06-12T14:21:00Zimage.pngfile43212025-06-12T14:21:00Z
```
JSON
```json
[
{
"name": "example.txt",
"type": "file",
"size": 1234,
"mtime": "2025-06-12T14:21:00Z"
},
{
"name": "image.png",
"type": "file",
"size": 4321,
"mtime": "2025-06-12T14:21:00Z"
}
]
```
JSONP
```javascript
callback([
{
"name": "example.txt",
"type": "file",
"size": 1234,
"mtime": "2025-06-12T14:21:00Z"
},
{
"name": "image.png",
"type": "file",
"size": 4321,
"mtime": "2025-06-12T14:21:00Z"
}
]);
```
### autoindex_localtime
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `autoindex_localtime` `on` | `off`; |
|--------------------------------------------------------------------------------------------|---------------------------------------|
| Predeterminado | `autoindex_localtime off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Para el [formato](#autoindex-format) HTML, especifica si las horas en el listado de directorios deben mostrarse en la zona horaria local o en UTC.
# https://es.angie.software/angie/docs/configuration/modules/http/http_browser.md
# Navegador
El módulo crea variables cuyos valores dependen del valor del campo de cabecera de solicitud `User-Agent`.
## Variables
### `$ancient_browser`
es igual al valor establecido por la directiva [ancient_browser_value](#ancient-browser-value), si un navegador fue identificado como antiguo;
### `$modern_browser`
es igual al valor establecido por la directiva [modern_browser_value](#modern-browser-value), si un navegador fue identificado como moderno;
### `$msie`
es igual a "1" si un navegador fue identificado como MSIE de cualquier versión.
## Ejemplo de configuración
### Elegir un archivo índice:
```nginx
modern_browser_value "modern.";
modern_browser msie 5.5;
modern_browser gecko 1.0.0;
modern_browser opera 9.0;
modern_browser safari 413;
modern_browser konqueror 3.0;
index index.${modern_browser}html index.html;
```
### Redirección para navegadores antiguos:
```nginx
modern_browser msie 5.0;
modern_browser gecko 0.9.1;
modern_browser opera 8.0;
modern_browser safari 413;
modern_browser konqueror 3.0;
modern_browser unlisted;
ancient_browser Links Lynx netscape4;
if ($ancient_browser) {
rewrite ^ /ancient.html;
}
```
## Directivas
### ancient_browser
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `ancient_browser` string ...; |
|--------------------------------------------------------------------------------------------|---------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Si cualquiera de las subcadenas especificadas se encuentra en el campo de cabecera de solicitud `User-Agent`, el navegador será considerado antiguo. La cadena especial "netscape4" corresponde a la expresión regular "^Mozilla/[1-4]".
### ancient_browser_value
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `ancient_browser_value` string; |
|--------------------------------------------------------------------------------------------|-----------------------------------|
| Predeterminado | `ancient_browser_value 1;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Establece un valor para la variable [$ancient_browser](#v-ancient-browser).
### modern_browser
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `modern_browser` browser version;
`modern_browser` `unlisted`; |
|--------------------------------------------------------------------------------------------|---------------------------------------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Especifica una versión a partir de la cual un navegador se considera moderno. Un
navegador puede ser cualquiera de los siguientes: `msie`, `gecko` (navegadores
basados en Mozilla), `opera`, `safari`, o `konqueror`.
Las versiones pueden especificarse en los siguientes formatos: X, X.X, X.X.X, o X.X.X.X. Los valores máximos para cada uno de los formatos son 4000, 4000.99, 4000.99.99, y 4000.99.99.99, respectivamente.
El valor especial `unlisted` especifica considerar un navegador como moderno si no fue listado por las directivas modern_browser y [ancient_browser](#id2). De lo contrario, dicho navegador se considera antiguo. Si una solicitud no proporciona el campo `User-Agent` en la cabecera, el navegador se trata como si no estuviera en la lista.
### modern_browser_value
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `modern_browser_value` string; |
|--------------------------------------------------------------------------------------------|----------------------------------|
| Predeterminado | `modern_browser_value 1;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Establece un valor para la variable [$modern_browser](#v-modern-browser).
# https://es.angie.software/angie/docs/configuration/modules/http/http_charset.md
# Charset
El módulo añade el charset especificado al campo de cabecera de respuesta `Content-Type`. Además, el módulo puede convertir datos de un charset a otro, con algunas limitaciones:
* la conversión se realiza en un solo sentido — del servidor al cliente,
* solo se pueden convertir charsets de un solo byte
* o charsets de un solo byte hacia/desde UTF-8.
## Ejemplo de configuración
```nginx
include conf/koi-win;
charset windows-1251;
source_charset koi8-r;
```
## Directivas
### charset
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `charset` charset | `off`; |
|--------------------------------------------------------------------------------------------|----------------------------------------|
| Predeterminado | `charset off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Añade el charset especificado al campo de cabecera de respuesta `Content-Type`. Si este charset es diferente del charset especificado en la directiva [source_charset](#source-charset), se realiza una conversión.
El parámetro `off` cancela la adición del charset al campo de cabecera de respuesta `Content-Type`.
Un charset puede definirse con una variable:
```nginx
charset $charset;
```
En tal caso, todos los posibles valores de una variable deben estar presentes en la configuración al menos una vez en forma de las directivas [charset_map](#charset-map), [charset](#id1) o [source_charset](#source-charset). Para los charsets `utf-8`, `windows-1251` y `koi8-r`, es suficiente incluir los archivos `conf/koi-win`, `conf/koi-utf` y `conf/win-utf` en la configuración. Para otros charsets, simplemente hacer una tabla de conversión ficticia funciona, por ejemplo:
```nginx
charset_map iso-8859-5 _ { }
```
Además, un charset puede establecerse en el campo de cabecera de respuesta `X-Accel-Charset`. Esta capacidad puede desactivarse usando las directivas [proxy_ignore_headers](https://es.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-ignore-headers), [fastcgi_ignore_headers](https://es.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-ignore-headers), [uwsgi_ignore_headers](https://es.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-ignore-headers), [scgi_ignore_headers](https://es.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-ignore-headers) y [grpc_ignore_headers](https://es.angie.software//angie/docs/configuration/modules/http/http_grpc.md#grpc-ignore-headers).
### charset_map
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `charset_map` charset1 charset2 { ... } |
|--------------------------------------------------------------------------------------------|--------------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Describe la tabla de conversión de un charset a otro. Una tabla de conversión inversa se construye utilizando los mismos datos. Los códigos de caracteres se dan en hexadecimal. Los caracteres faltantes en el rango 80-FF se reemplazan con "?". Al convertir desde UTF-8, los caracteres que faltan en un charset de un byte se reemplazan con "&#XXXX;".
Ejemplo:
```nginx
charset_map koi8-r windows-1251 {
C0 FE ; # small yu
C1 E0 ; # small a
C2 E1 ; # small b
C3 F6 ; # small ts
}
```
Al describir una tabla de conversión a UTF-8, los códigos para el charset UTF-8 deben darse en la segunda columna, por ejemplo:
```nginx
charset_map koi8-r utf-8 {
C0 D18E ; # small yu
C1 D0B0 ; # small a
C2 D0B1 ; # small b
C3 D186 ; # small ts
}
```
Las tablas de conversión completas de `koi8-r` a `windows-1251`, y de `koi8-r` y `windows-1251` a `utf-8` se proporcionan en los archivos de distribución `conf/koi-win`, `conf/koi-utf` y `conf/win-utf`.
### charset_types
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `charset_types` mime-type ...; |
|--------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------|
| Predeterminado | `charset_types text/html text/xml text/plain text/vnd.wap.wml application/javascript application/rss+xml;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita el procesamiento del módulo en respuestas con los tipos MIME especificados además de `text/html`. El valor especial `*` coincide con cualquier tipo MIME.
### override_charset
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `override_charset` `on` | `off`; |
|--------------------------------------------------------------------------------------------|----------------------------------------|
| Predeterminado | `override_charset off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Determina si debe realizarse una conversión para las respuestas recibidas de un servidor proxy o FastCGI/uwsgi/SCGI/gRPC cuando las respuestas ya llevan un charset en el campo de cabecera de respuesta `Content-Type`. Si la conversión está habilitada, un charset especificado en la respuesta recibida se utiliza como charset de origen.
#### NOTE
Si se recibe una respuesta en una subpetición, la conversión del charset de la respuesta al charset de la petición principal siempre se realiza, independientemente de la configuración de la directiva override_charset.
### source_charset
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `source_charset` charset; |
|--------------------------------------------------------------------------------------------|----------------------------------------|
| Predeterminado | — |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Define el charset de origen de una respuesta. Si este charset es diferente del charset especificado en la directiva [charset](#id1), se realiza una conversión.
# https://es.angie.software/angie/docs/configuration/modules/http/http_dav.md
# DAV
Este módulo está destinado a la automatización de la gestión de archivos a través del protocolo WebDAV. El módulo procesa los métodos HTTP y WebDAV PUT, DELETE, MKCOL, COPY y MOVE.
Al [compilar desde el código fuente](https://es.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild),
este módulo no se compila por defecto;
debe habilitarse con la
`‑‑with‑http_dav_module`
[opción de compilación](https://es.angie.software//angie/docs/installation/sourcebuild.md#configure).
En paquetes e imágenes de [nuestros repositorios](https://es.angie.software//angie/docs/installation/index.md#install-packages),
el módulo está incluido en la compilación.
#### NOTE
Los clientes WebDAV que requieren métodos WebDAV adicionales para funcionar no funcionarán con este módulo.
## Ejemplo de configuración
```nginx
location / {
root /data/www;
client_body_temp_path /data/client_temp;
dav_methods PUT DELETE MKCOL COPY MOVE;
create_full_put_path on;
dav_access group:rw all:r;
limit_except GET {
allow 192.168.1.0/32;
deny all;
}
}
```
## Directivas
### create_full_put_path
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `create_full_put_path` `on` | `off`; |
|--------------------------------------------------------------------------------------------|----------------------------------------|
| Predeterminado | `create_full_put_path off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
La especificación WebDAV solo permite crear archivos en directorios ya existentes. Esta directiva permite crear todos los directorios intermedios necesarios.
### dav_access
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `dav_access` users:permissions ...; |
|--------------------------------------------------------------------------------------------|---------------------------------------|
| Predeterminado | `dav_access user:rw;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Establece permisos de acceso para archivos y directorios recién creados, por ejemplo:
```nginx
dav_access user:rw group:rw all:r;
```
Si se especifican permisos de acceso para grupo o para todos, los permisos de usuario pueden omitirse:
```nginx
dav_access group:rw all:r;
```
### dav_methods
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `dav_methods` `off` | method ...; |
|--------------------------------------------------------------------------------------------|-------------------------------------|
| Predeterminado | `dav_methods off;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite los métodos HTTP y WebDAV especificados. El parámetro `off` deniega todos los métodos procesados por este módulo. Se admiten los siguientes métodos: PUT, DELETE, MKCOL, COPY y MOVE.
Un archivo cargado con el método PUT se escribe primero en un archivo temporal y luego se renombra. A partir de la versión 0.8.9, los archivos temporales y el almacenamiento persistente pueden colocarse en diferentes sistemas de archivos. Sin embargo, tenga en cuenta que en ese caso, un archivo se copia a través de dos sistemas de archivos en lugar de la operación barata de renombrado. Por lo tanto, se recomienda que para cualquier `location` dado, tanto los archivos guardados como el directorio que contiene archivos temporales, establecido por la directiva [client_body_temp_path](https://es.angie.software//angie/docs/configuration/modules/http/index.md#client-body-temp-path), se coloquen en el mismo sistema de archivos.
Al crear un archivo con el método PUT, es posible especificar la fecha de modificación pasándola en el campo de encabezado `Date`.
### min_delete_depth
| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | `min_delete_depth` number; |
|--------------------------------------------------------------------------------------------|------------------------------|
| Predeterminado | `min_delete_depth 0;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite que el método DELETE elimine archivos siempre que el número de elementos en la ruta de la solicitud no sea menor que el especificado. Por ejemplo, la directiva
```nginx
min_delete_depth 4;
```
permite eliminar archivos en las solicitudes
```console
/users/00/00/name
/users/00/00/name/pic.jpg
/users/00/00/page.html
```
y deniega la eliminación de
```console
/users/00/00
```
# https://es.angie.software/angie/docs/configuration/modules/http/http_docker.md
# Docker
#### Versionadded
Added in version 1.10.0.
El módulo proporciona configuración dinámica de grupos de servidores proxy
en los contextos [HTTP](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream) y [stream](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-upstream)
basándose en etiquetas de contenedores Docker.
Para que la funcionalidad funcione, debe configurarse una zona de memoria compartida
en el grupo (consulte la descripción de `zone` para [http](https://es.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone) y [stream](https://es.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-zone)).
#### NOTE
El módulo admite trabajar tanto con Docker como con sus alternativas,
como Podman, que implementan una API compatible.
La versión recomendada de Podman es 4.9.3 o superior.
El módulo se conecta al daemon de Docker mediante la API,
cuyo método de interacción se especifica mediante la directiva [docker_endpoint](#docker-endpoint).
Después de obtener una lista de contenedores en ejecución,
Angie los analiza para detectar la presencia de [etiquetas](#docker-labels) adecuadas.
Si la descripción de un contenedor contiene una etiqueta con un puerto,
entonces la dirección y el puerto de dicho contenedor,
así como los parámetros de otras etiquetas de este contenedor,
se añaden automáticamente al bloque `upstream` correspondiente
en la configuración de Angie.
#### NOTE
El mismo contenedor puede añadirse a varios grupos `upstream`.
Para ello, simplemente especifique varios conjuntos de etiquetas
con diferentes nombres de grupo y puertos.
Esto es especialmente útil
si el contenedor ejecuta varios servicios diferentes en diferentes puertos;
cada servicio puede asociarse con su propio grupo.
El módulo luego se suscribe a eventos del ciclo de vida del contenedor
y comienza a actualizar la configuración del servidor proxy sin recargar Angie:
- al iniciar un contenedor con etiquetas adecuadas,
su dirección IP interna se añade al grupo especificado;
- al detener o eliminar un contenedor,
se elimina automáticamente del grupo;
- al pausar un contenedor con el comando **docker pause**,
el servidor se marca como `down`,
y con **docker unpause** — como `up`.
## Ejemplo de configuración
Las directivas del módulo siempre se ubican en el contexto `http`,
pero los grupos de servidores proxy pueden definirse
tanto en el contexto `http` como en el contexto `stream`.
Ejemplo de configuración para `http`:
```nginx
http {
# Examples of connection options:
# docker_endpoint http://127.0.0.1:2375;
# docker_endpoint https://127.0.0.1:2376;
docker_endpoint unix:/var/run/docker.sock;
# maximum Docker response buffer size (optional)
# docker_max_object_size 128k;
upstream u {
zone z 1m; # shared memory zone is required
}
server {
listen 80;
server_name example.com;
location / {
proxy_pass http://u;
}
}
}
```
De manera similar en el contexto stream:
```nginx
http {
# Examples of connection options:
# docker_endpoint http://127.0.0.1:2375;
# docker_endpoint https://127.0.0.1:2376;
docker_endpoint unix:/var/run/docker.sock;
# maximum Docker response buffer size (optional)
# docker_max_object_size 128k;
}
stream {
upstream u {
zone z 1m;
}
server {
listen 12345;
proxy_pass u;
}
}
```
Al recibir un evento para un contenedor,
Angie busca etiquetas de la forma
`angie.http.upstreams..port=` (para el contexto HTTP)
o `angie.stream.upstreams..port=` (para el contexto stream).
Cuando hay una etiqueta presente, la dirección del contenedor en la red Docker especificada
(o la primera disponible si no se especifica la etiqueta `angie.network`)
se añade al grupo de servidores proxy correspondiente.
Si un contenedor se detiene o se elimina, el servidor se elimina del grupo;
si un contenedor se pausa, el servidor se marca como `down`.
Fragmento de un archivo `docker-compose.yml` con etiquetas que Angie reconoce:
```yaml
services:
myapp:
image: myapp:latest
labels:
- "angie.http.upstreams.u.port=8080"
- "angie.network=my_bridge"
- "angie.http.upstreams.u.weight=2"
- "angie.http.upstreams.u.max_conns=50"
- "angie.http.upstreams.u.max_fails=3"
- "angie.http.upstreams.u.fail_timeout=10s"
- "angie.http.upstreams.u.backup=true"
```
## Etiquetas
Las etiquetas especifican parámetros del servidor en el grupo de servidores proxy
de manera similar a los argumentos de la directiva `server`:
| Etiqueta | Propósito |
|---------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------|
| `angie.(http|stream).upstreams..port=` *(obligatorio)* | Puerto del contenedor al que Angie se conectará; el contenedor en sí se añade al grupo llamado ``. |
| `angie.network=` | Nombre de la red Docker de la cual tomar la dirección IP del contenedor. |
| `angie.(http|stream).upstreams..weight=` | Valor del parámetro `weight`. |
| `angie.(http|stream).upstreams..max_conns=` | Número máximo de conexiones simultáneas (`max_conns`). |
| `angie.(http|stream).upstreams..max_fails=` | Umbral para intentos fallidos (`max_fails`). |
| `angie.(http|stream).upstreams..fail_timeout=` | Intervalo para contar intentos fallidos (`fail_timeout`). |
| `angie.(http|stream).upstreams..backup=true|false` | Marca el servidor como `backup`. |
| `angie.(http|stream).upstreams..sid=` | Establece un identificador de servidor personalizado (`sid`) para el servidor proxy. |
| `angie.(http|stream).upstreams..slow_start=
