P4 Software
/
BarcoderX Español
Aplica a: BarcoderX Basic y Ultimate
Estado: Construido, aún sin publicar. Esta página es para quien pone el servicio de etiquetas donde otras personas pueden llegar a él. El servicio es un programa pequeño, descrito en El servicio de etiquetas. Habla http sin cifrar y está pensado para estar detrás de un servidor web que usted ejecuta. Las dos configuraciones de abajo son de referencia, escritas a partir de la documentación de nginx y de Caddy, salvo las dos líneas que indican
X-Forwarded-Proto, que se escribieron por conocimiento general de esos programas y no se comprobaron en su documentación. Todavía no se han probado contra un servicio real, así que pruébelas antes de confiar en ellas.
El servicio tiene límites propios: el tamaño de una plantilla, el tiempo de una solicitud, el número de solicitudes y de conexiones de un cliente, y el tiempo que da a un cliente para recibir una respuesta. Evitan que un solo cliente use todo el servicio. Son la última línea, no la primera. Ponga delante un servidor web y haga que ese servidor haga cuatro cosas:
Obligatorio antes de un lanzamiento público. Estas cuatro cosas son obligatorias antes de dejar que alguien que usted no conoce llegue al servicio. Otras dos cosas no dependen del servidor web: las imágenes y los comandos llevan la marca de evaluación hasta que se registra una licencia, y el servicio no es para uso en producción. Mantenga actualizado el entorno de ejecución de .NET que ejecuta el servicio.
Edite settings.json junto al programa:
{
// Listen on this computer only. Only the proxy reaches the service.
"listenAddress": "http://127.0.0.1:5187",
// Believe the address that the proxy reports, from this proxy only.
"network": {
"trustForwardedHeaders": true,
"trustedProxies": ["127.0.0.1"]
}
}
Con estos ajustes:
127.0.0.1 cuando lleva X-Forwarded-For, y el servicio toma la última dirección de ese encabezado, la que añadió el propio proxy (network.trustedProxyHops es 1 de forma predeterminada). Las direcciones a su izquierda las envió el cliente y se ignoran. Una conexión desde cualquier otra dirección conserva su propia dirección.limits.maxConnectionsPerClient, porque todos los clientes pasan por él. Limítelas en el proxy, como se muestra abajo.X-Forwarded-Proto por sí mismo. El servicio envía Strict-Transport-Security solo cuando el proxy indicado dice https (la entrada del extremo derecho del encabezado), así que un proxy que pasa sin cambios el encabezado del cliente deja que un cliente por http sin cifrar haga que el servicio lo envíe. Las configuraciones de abajo lo sobrescriben. Si su proxy atiende también http sin cifrar, debe escribir http ahí. Para no enviar ese encabezado en absoluto, ponga network.sendStrictTransportSecurity en false.Si el proxy se ejecuta en otro equipo, indique su dirección en network.trustedProxies y ponga en listenAddress una dirección de este equipo a la que solo el proxy pueda llegar. Una entrada es una dirección sola (10.0.0.5, 2001:db8::5) o un rango (10.0.0.0/8), con un máximo de 32 entradas. Un rango debe escribirse con exactitud (10.0.0.1/8 se rechaza: su inicio es 10.0.0.0). "Cualquier dirección" (0.0.0.0 o ::) y un rango que abarca todas las direcciones o casi todas (0.0.0.0/0, ::/0, cualquier rango más amplio que /8 en IPv4 o que /7 en IPv6, porque dos mitades también cubrirían todo) se rechazan; un rango así solo se permite si además pone network.acceptAnyProxyAddress en true, lo que no debería hacer, porque entonces todo cliente es un proxy de confianza y puede elegir su propia dirección.
Este es un bloque server completo con los ajustes que importan. Los comentarios dicen para qué sirve cada parte, y están en inglés. Los números son una primera elección: el límite de plantilla del servicio es de 262,144 bytes de forma predeterminada, y las respuestas más grandes son de 2,000,000 bytes (una imagen) y 16,777,216 bytes (comandos de impresora), de modo que los búferes de abajo alcanzan para las respuestas de una imagen y pasan las mayores a un archivo temporal.
# Reference configuration for nginx in front of the BarcoderX label service.
# Change the name, the certificate paths and the numbers to fit your site.
# Count the connections and the requests of each client address.
# 10 MB of shared memory holds the state of many thousands of addresses.
limit_conn_zone $binary_remote_addr zone=bx_conn:10m;
limit_req_zone $binary_remote_addr zone=bx_req:10m rate=30r/m;
upstream barcoderx_label_service {
server 127.0.0.1:5187;
keepalive 8;
}
server {
listen 443 ssl;
server_name labels.example.com;
ssl_certificate /etc/ssl/labels.example.com/fullchain.pem;
ssl_certificate_key /etc/ssl/labels.example.com/privkey.pem;
# A caller that sends its headers or its template slowly is dropped here,
# and so is a caller that is slow to take the answer.
client_header_timeout 10s;
client_body_timeout 10s;
send_timeout 15s;
# The service refuses a template over 262144 bytes (its default). Refuse it here first.
client_max_body_size 300k;
# At most 20 connections and a steady 30 requests a minute for each address,
# with a burst of 10. The service has its own, smaller limits behind this.
limit_conn bx_conn 20;
limit_req zone=bx_req burst=10 nodelay;
location / {
proxy_pass http://barcoderx_label_service;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
# Add the address of the caller to the header. $proxy_add_x_forwarded_for is
# what the caller sent, with the address nginx saw appended at the end. The
# service believes only that last address.
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
# Say which scheme the visitor used, replacing whatever the caller sent. The
# service sends the Strict-Transport-Security header only when this says https.
proxy_set_header X-Forwarded-Proto $scheme;
# Read the whole request here before the service sees it, and read the
# whole answer from the service at once. A slow caller then spends nginx's
# time, not a place of the service.
proxy_request_buffering on;
proxy_buffering on;
proxy_buffers 16 64k;
proxy_busy_buffers_size 128k;
proxy_max_temp_file_size 32m;
proxy_connect_timeout 3s;
proxy_send_timeout 15s;
proxy_read_timeout 15s;
}
}
Caddy prepara https por sí mismo para un nombre de host real. Este es un Caddyfile con la misma intención. Los comentarios dicen para qué sirve cada parte, y están en inglés.
# Reference configuration for Caddy in front of the BarcoderX label service.
# Change the host name and the numbers to fit your site.
{
servers {
timeouts {
# A caller that sends its headers or its template slowly is dropped,
# and so is a caller that is slow to take the answer.
read_header 10s
read_body 10s
write 20s
idle 30s
}
max_header_size 16KB
}
}
labels.example.com {
# The service refuses a template over 262144 bytes (its default). Refuse it here first.
request_body {
max_size 300KB
}
reverse_proxy 127.0.0.1:5187 {
# Read the whole request here before the service sees it, and read the
# whole answer from the service at once. Make the second number at least
# as large as the largest answer you allow (limits.maxOutputBytes and
# limits.maxCommandsBytes), or the answer is streamed and a slow caller
# reaches the service.
request_buffers 300KB
response_buffers 20MB
# Caddy sets X-Forwarded-For to the address it saw and, by default, ignores
# the value that the caller sent. That is what the service needs.
# Do not add trusted_proxies here unless another proxy is in front of Caddy.
# Say which scheme the visitor used, replacing whatever the caller sent. The
# service sends the Strict-Transport-Security header only when this says https.
header_up X-Forwarded-Proto {http.request.scheme}
}
}
Caddy no limita por sí mismo las conexiones ni las solicitudes de una dirección. Hágalo donde su sistema lo permita: una regla de cortafuegos que cuente las conexiones de cada dirección, o un módulo de Caddy que limite las solicitudes. Los límites propios del servicio siguen vigentes, pero son solo la última línea.
App Service termina https en sus balanceadores de carga de red, y la aplicación recibe http simple. El balanceador está dentro de los rangos de direcciones privadas, y la página de Microsoft para aplicaciones ASP.NET Core (configure-language-dotnetcore, la sección "Detect HTTPS session") dice que se confíe en tres rangos privados y que no se pueden acotar más. Indíquelos en la configuración:
"network": {
"trustForwardedHeaders": true,
"trustedProxies": ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"]
}
La página escribe los mismos rangos como ::ffff:10.0.0.0/104, ::ffff:172.16.0.0/108 y ::ffff:192.168.0.0/112; el servicio acepta también esa forma y la trata como la misma. Sin esto, el servicio ve a todos los visitantes como el balanceador, así que todos comparten una solicitud a la vez y un único límite de frecuencia.
Los mismos dos ajustes hacen que el servicio envíe el encabezado Strict-Transport-Security: el balanceador le dice a la aplicación que quien visita usó https (X-Forwarded-Proto: https), y el servicio lo cree solo porque el balanceador está indicado. No hace falta nada más. Para desactivar el encabezado, ponga network.sendStrictTransportSecurity en false (vea Servicio de etiquetas).
Lo que conviene saber:
X-Forwarded-For: con network.trustedProxyHops en su valor predeterminado de 1, la última entrada. Las direcciones a su izquierda son afirmaciones del propio cliente y se ignoran, así que un visitante no puede elegir su dirección enviando el encabezado, ni siquiera un visitante cuya propia dirección está dentro de los rangos privados indicados. Si pone otro servidor de entrada indicado delante de App Service, ponga network.trustedProxyHops en 2, indique ese servidor y restrinja la aplicación para que solo él pueda llegar a ella. Eso tiene un costo: con dos saltos, un visitante que se conecta desde dentro de los rangos indicados puede elegir una vez la dirección con la que se le cuenta, y los límites por cliente no valen para él. Más saltos lo empeoran, así que no use más de los que tiene la cadena. Una dirección que lleva un puerto se lee sin el puerto.X-Forwarded-For: 203.0.113.9 falso y vea que la dirección falsa no es la que se cuenta.No intente indicar las direcciones de Front Door. Son cientos de rangos (la etiqueta de servicio AzureFrontDoor.Backend), cambian, el servicio admite como máximo 32 entradas, y otros clientes de Azure usan las mismas direcciones (origin-security). En cambio, el servicio reconoce su Front Door por una prueba:
AzureFrontDoor.Backend con los filtros de encabezado x-azure-fdid (el ID de Front Door de su perfil) y x-forwarded-host (sus nombres de host), y niegue todo lo demás. Azure responde entonces 403 a cualquier otra solicitud, antes de que el servicio la vea. Eso incluye la dirección azurewebsites.net de la aplicación y el nombre predeterminado azurefd.net de Front Door.Dígaselo al servicio en settings.json (los rangos son los tres rangos privados de App Service de la sección anterior, y los saltos siguen en 1):
"network": {
"trustForwardedHeaders": true,
"trustedProxies": ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"],
"trustedProxyHops": 1,
"edge": {
"mode": "azureFrontDoor",
"frontDoorId": "<el ID de Front Door de su perfil>",
"hosts": ["<el nombre de host que escriben sus visitantes>"]
}
}
El servicio no arranca si el ID no está escrito como lo muestra el portal, si la lista de hosts está vacía o si network.trustedProxyHops no es 1. El mensaje dice qué cambiar.
/health/live y /health/ready, que necesita la comprobación de estado de la propia plataforma): comprueba de nuevo que la conexión viene de su servidor web, que hay exactamente un X-Azure-FDID y que es su ID, y que hay exactamente un X-Forwarded-Host y que es uno de sus nombres de host. Una solicitud que falla se rechaza con 403 y BX6024, antes de leer el cuerpo, y no gasta la cuota de nadie. Si todo está bien, quita la última entrada de X-Forwarded-For (la dirección de Front Door, escrita por App Service) y luego lee un salto como antes: el cliente es la dirección que vio Front Door, y todo lo que está a su izquierda es una afirmación del propio visitante.Lo que conviene saber:
settings.json solo al desplegar, y no comparta ese archivo.azurewebsites.net de la aplicación, y otra al nombre predeterminado azurefd.net de Front Door, deben responderse las dos con 403 (de parte de Azure, sin ningún código de BarcoderX en la respuesta). Hágalo después de cada despliegue y una vez al día.X-Forwarded-For: la escribe Front Door, y luego App Service escribe la dirección de Front Door. Envíe 30 solicitudes a través de Front Door, cada una con un X-Forwarded-For: 203.0.113.N falso distinto: las últimas deben responderse con 429 (demasiadas solicitudes). Si no es así, la disposición es distinta de la que espera el servicio, y el modo de puerta de entrada no debe usarse hasta entender por qué.X-Azure-FDID: <su ID> falso: también debe responderse con 403. (Las páginas que se leyeron no dicen si Front Door reemplaza o añade un encabezado que envió el visitante; el servicio rechaza una solicitud con dos valores de ID, así que el segundo caso se rechaza de cualquier forma.) Elimine después el perfil desechable: un perfil se factura hasta que se elimina.hosts en su forma xn--. Un nombre con puerto, con punto al final o una lista de nombres no coincide.Después de iniciar el proxy y el servicio, compruebe desde otro equipo:
curl https://labels.example.com/health/live responde {"status":"ok"}.curl https://labels.example.com/api/v1/meta/limits enumera los límites del servicio.Retry-After. Si la respuesta es 429 para un cliente solo después de una única solicitud, el servicio ve a todos los clientes como el proxy: revise network.trustForwardedHeaders y network.trustedProxies.Haga lo que haga el proxy, el servicio mantiene estos límites, y puede leer los números en /api/v1/meta/limits:
limits.bodyReadMilliseconds (5 segundos), de modo que un remitente lento no retiene ningún lugar para dibujar (el servidor también detiene a un remitente que envía menos de 240 bytes por segundo en promedio una vez pasados sus primeros 5 segundos, sea cual sea ese ajuste); y un lugar para dibujar solo mientras se genera la etiqueta;Tres presupuestos pueden estar llenos al mismo tiempo, y la memoria del equipo tiene que alcanzar para todos, además de lo que usa el propio entorno de ejecución:
limits.memoryBudgetMegabytes (1,024 MB de forma predeterminada);limits.outputBudgetMegabytes (128 MB de forma predeterminada);limits.memoryBudgetMegabytes (256 MB de forma predeterminada).Con los valores predeterminados son 1,024 + 128 + 256 = 1,408 MB, así que dé al servicio al menos 2 GB, y más si usa el recolector de basura del servidor, que conserva por más tiempo la memoria que el programa ya liberó. Si aumenta limits.maxBodyBytes para el editor web, aumente también limits.memoryBudgetMegabytes: cuenta 60 veces el límite del cuerpo por cada solicitud, además de su imagen y su texto.
Hay una cantidad más que se retiene un momento fuera de estos presupuestos: un cliente que pide los comandos de impresora como JSON (Accept: application/json) hace que el documento JSON se arme en memoria antes de contarse en la reserva de respuestas, y ocupa más o menos lo mismo que los comandos (como máximo cerca del doble de limits.maxCommandsBytes, que son 16 MB de forma predeterminada, en el peor caso) por cada solicitud que lo pide en ese momento. Con los valores predeterminados, un cliente hace una solicitud a la vez (limits.maxRequestsInFlightPerClient), así que son hasta decenas de megabytes por cliente que lo pide, y se devuelven en cuanto la respuesta se cuenta o se rechaza. Una respuesta JSON mayor que toda la reserva se rechaza con BX6019 y sin Retry-After; el texto simple de los mismos comandos siempre cabe en la reserva.
Una solicitud de imágenes de elementos sueltos (POST /api/v1/render/elements) retiene más memoria que una imagen. La peor solicitud encontrada, 64 elementos rellenos y redondeados de 40 milímetros a 300 dpi, asignó entre 299 y 319 MB a lo largo de su vida, y su memoria llegó a 136 MB por encima del inicio en un proceso nuevo y hasta 270 MB en uno que ya llevaba tiempo en marcha, porque el recolector deja que se acumule basura cuando ha estado ocupado. El servicio supone 350 MB para el motor, el codificador de las imágenes y la respuesta, 16 MB más de margen y, como en toda solicitud, 60 veces el límite del cuerpo y 1.7 KB por cada carácter de la etiqueta. Con los valores predeterminados son unos 390 MB, que es más de lo que retiene un lugar (unos 207 MB), así que una solicitud así ocupa dos de los lugares. Con el presupuesto predeterminado (1,024 MB) hay cuatro lugares, así que mientras se ejecuta una solicitud de elementos todavía se dibujan imágenes y puede ejecutarse una segunda solicitud de elementos; una tercera se rechaza de inmediato con BX6006. Además, un cliente solo puede hacer 6 solicitudes de elementos por minuto de forma predeterminada (rateLimit.elementRequestsPerMinutePerClient), así que un solo cliente no puede quedarse con los lugares. Con un limits.memoryBudgetMegabytes menor una solicitud de elementos ocupa más lugares, o todos; con uno mayor hay más lugares y se ejecutan más de estas solicitudes a la vez. La cifra es medida, no supuesta: una prueba repite la medición en cada compilación y falla si la peor solicitud asigna más que la cifra.
El servicio limita lo que puede hacer una dirección, y como la plantilla se lee antes de tomar un lugar para dibujar, un remitente lento ya no retiene los pocos lugares para dibujar. Sigue sin poder distinguir a los clientes reales cuando el problema son muchas direcciones juntas. Por eso el proxy de esta página es obligatorio para un servicio público, no un extra. Estas brechas quedan, y cada una se midió:
limits.bodyReadMilliseconds (5 segundos), y luego se detiene con BX6017. No retiene ningún lugar para dibujar, así que los clientes normales se atienden mientras tanto. Un proxy que almacena en búfer todo el cuerpo de la solicitud antes de pasarla quita incluso ese costo. La línea proxy_request_buffering on del ejemplo de nginx y la línea request_buffers del ejemplo de Caddy lo hacen. Pruébelo con un remitente lento antes de confiar en ello.Connection: close, el servicio espera un segundo por el resto del cuerpo, y corta la conexión si no llegó. Así un rechazo ya no mantiene su conexión varios segundos, pero suficientes direcciones aún pueden llenar el total. Limite en el proxy las conexiones de cada dirección y el tiempo del encabezado de una solicitud, como hacen los ejemplos.rateLimit.requestsPerMinuteAllClients), y un cliente nuevo recibe entonces BX6014 aunque no hizo nada mal. Solo un límite de frecuencia en el proxy puede distinguir a los clientes reales.limits.maxRequestsInFlightPerClient. Un proxy no ayuda aquí, porque ve la misma dirección compartida; solo importa que el servicio lea la dirección del cliente desde el proxy (network.trustForwardedHeaders) cuando el proxy está delante.type de un documento de problema es una dirección bajo docs.barcoderx.example. El dominio real aún no está decidido, y nada sigue esa dirección.BarcoderX es un producto de P4 Software.
¿Te resultó útil esta página?