Saltar al contenido
P4 Software P4 Software / BarcoderX Español

Agrega esta documentación a Claude

Hazle preguntas a Claude sobre esta documentación. Claude lee las páginas publicadas y te enlaza a ellas. Copia esta dirección:

https://p4-software.opendocs.page/mcp

En claude.ai o Claude Desktop: abre Configuración, luego Conectores, elige Agregar conector personalizado y pega la dirección.

En Claude Code, ejecuta:

claude mcp add --transport http docs https://p4-software.opendocs.page/mcp

Despliegue del servicio de etiquetas

Despliegue del servicio de etiquetas

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.

Por qué un servidor web delante

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:

  1. Manejar https. El servicio habla solo http.
  2. Almacenar en búfer la solicitud y la respuesta. Un cliente que envía su plantilla despacio, o lee su respuesta despacio, gasta entonces el tiempo del servidor web y nunca llega al servicio. El servicio da a un cliente lento unos segundos y luego lo desconecta, y hasta entonces ese cliente retiene solo su propio lugar y una conexión, nunca un lugar para dibujar. Un proxy que almacena en búfer le quita incluso eso.
  3. Limitar las conexiones por dirección. El servicio limita las conexiones de un cliente, pero no puede contar los clientes que están detrás de un proxy, así que el proxy es el lugar para hacerlo.
  4. Decir quién llama. El servicio limita las solicitudes de cada cliente, y hay que decirle qué cliente envió una solicitud que llegó a través del proxy.

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.

Los ajustes del servicio detrás de un proxy

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:

  • El servicio escucha solo en este equipo. Nadie llega a él salvo a través del proxy.
  • Quién llama. Se confía en una conexión desde 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.
  • Las conexiones del proxy no se cuentan contra limits.maxConnectionsPerClient, porque todos los clientes pasan por él. Limítelas en el proxy, como se muestra abajo.
  • El proxy debe añadir la dirección del cliente y no debe pasar el encabezado sin cambios. Las configuraciones de abajo lo hacen.
  • El proxy debe escribir también 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.

nginx

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

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.

Azure App Service

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:

  • Los rangos son amplios. Todo lo que pueda llegar a la aplicación desde dentro de ellos tiene la confianza de decir quién es el cliente. Mantenga la aplicación accesible solo a través del balanceador, y no ponga en la misma red virtual otros programas que usted no controle.
  • Si pone Azure Front Door delante de App Service, no indique sus direcciones: vea la sección siguiente. Para otro servidor de entrada con pocas direcciones estables, indíquelas también; de lo contrario, el servicio toma ese servidor como el cliente y todos los visitantes cuentan como uno.
  • El cliente es la dirección que el proxy escribió en 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.
  • Después de desplegar, compruébelo en la aplicación en marcha: envíe solicitudes desde dos direcciones distintas y vea que se cuentan como dos clientes (a uno no se le rechaza por culpa del otro), y envíe una solicitud con un X-Forwarded-For: 203.0.113.9 falso y vea que la dirección falsa no es la que se cuenta.

Azure Front Door delante de App Service

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:

  1. Permita el acceso a la aplicación web solo desde su Front Door con una restricción de acceso (app-service-ip-restrictions): permita la etiqueta de servicio 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.
  2. 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.

  3. Lo que hace entonces el servicio con cada solicitud, salvo las dos rutas de comprobación de estado (/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:

  • La comprobación del servicio es tan fuerte como la privacidad del ID de Front Door. El servicio no puede saber de dónde vino una solicitud; la restricción del paso 1 sí. Si falta la restricción y alguien que conoce el ID llega directamente a la aplicación, esa persona puede elegir la dirección con la que se le cuenta. Trate el ID como una contraseña: manténgalo fuera del control de código fuente, de las solicitudes de cambios, de los registros y de los mensajes; escríbalo en settings.json solo al desplegar, y no comparta ese archivo.
  • Compruebe la restricción con frecuencia, no solo una vez: una solicitud sin encabezados a la dirección 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.
  • Compruebe la disposición una vez en la aplicación en marcha. El servicio espera la dirección del visitante en segundo lugar desde la derecha en 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é.
  • Compruebe también que dos visitantes en dos redes se cuentan como dos clientes, y que un navegador real a través de Front Door recibe 200 o 401 y nunca 431: Front Door y App Service añaden encabezados propios, y el servicio rechaza más de 50 encabezados o 16 KB.
  • Prueba única de la restricción (opcional, recomendada). Como otros clientes de Azure comparten las direcciones de Front Door, cree un segundo perfil de Front Door desechable que apunte a su aplicación y envíe una solicitud a través de él: debe responderse con 403, porque el ID de ese perfil no es el suyo. Envíe una segunda a través de él con un encabezado 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.
  • Los nombres de host internacionales van en hosts en su forma xn--. Un nombre con puerto, con punto al final o una lista de nombres no coincide.

Cómo comprobarlo

Después de iniciar el proxy y el servicio, compruebe desde otro equipo:

  1. curl https://labels.example.com/health/live responde {"status":"ok"}.
  2. curl https://labels.example.com/api/v1/meta/limits enumera los límites del servicio.
  3. Envíe una plantilla y mire la imagen, como en El servicio de etiquetas.
  4. Envíe más solicitudes en un minuto que el límite de un cliente. La respuesta es 429 con un encabezado 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.
  5. Mire el registro del servicio. Tiene una línea por solicitud: estado, ruta, tamaños, tiempo, el código de un problema y el identificador de seguimiento. Nunca tiene el contenido de una plantilla.

Lo que el servicio hace por sí mismo

Haga lo que haga el proxy, el servicio mantiene estos límites, y puede leer los números en /api/v1/meta/limits:

  • una solicitud a la vez por cliente; la plantilla completa se lee antes de tomar un lugar para dibujar, dentro de 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;
  • una reserva de memoria propia para las respuestas que esperan a sus lectores, y el tiempo que da a un lector para recibir una respuesta (5 segundos);
  • las conexiones de un cliente (16 de forma predeterminada), salvo desde un proxy que usted indique;
  • las solicitudes de un cliente en un minuto, y de todos los clientes juntos para las rutas que dibujan;
  • el tamaño de una plantilla, el tiempo de una solicitud y el tamaño de una respuesta.

Cuánta memoria dar al servicio

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:

  • los dibujos: limits.memoryBudgetMegabytes (1,024 MB de forma predeterminada);
  • las respuestas que esperan a sus lectores: limits.outputBudgetMegabytes (128 MB de forma predeterminada);
  • las plantillas que se están recibiendo: una cuarta parte de 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.

Lo que solo el proxy puede cerrar

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ó:

  • Un remitente lento todavía cuesta una conexión durante unos segundos. Retiene su propio lugar de cliente y una conexión como máximo durante 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.
  • Las 256 conexiones en total todavía se pueden llenar con muchas direcciones. El límite por dirección (16 de forma predeterminada) no impide que muchas direcciones tomen juntas las 256 conexiones. Una solicitud rechazada ahora termina su conexión de inmediato: la respuesta se envía con 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.
  • La cuota de todos los clientes es compartida. Las solicitudes que dibujan, desde muchas direcciones, pueden agotar la cuota de todos los clientes juntos (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.
  • Una solicitud a la vez por dirección. El servicio permite una solicitud en curso y 16 conexiones por dirección de cliente. Todos los que están detrás de una dirección compartida (una red de oficina o un operador móvil) comparten ese único lugar y deben enviar las etiquetas una a una. Si sus clientes están detrás de direcciones compartidas, aumente 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.

Aún no decidido

  • La dirección de la documentación de los códigos de problema. El miembro 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.
  • La marca de evaluación y la licencia. Hasta que se registre una licencia, cada imagen y cada conjunto de comandos lleva la marca de evaluación.

BarcoderX es un producto de P4 Software.

¿Te resultó útil esta página?