Tutorial: escalado de una aplicación de contenedor con métricas de Java

Azure Container Apps administra el escalado horizontal automático a través de un conjunto de reglas de escalado declarativas. Puede crear sus propias reglas de escalado con orígenes de eventos personalizados.

En este tutorial, agregará una regla de escalado personalizada para escalar la aplicación de contenedor con métricas de Java y observará cómo se escala la aplicación.

Requisitos previos

Una cuenta de Azure con una suscripción activa. Si aún no tiene ninguna, puede crear una gratis.
CLI de Azure.
Una aplicación Java implementada en Azure Container Apps.

Configuración del entorno

Siga estos pasos para definir variables de entorno y configurar el entorno.

Cree variables para admitir la configuración de escala.

export LOCATION=eastus
export TENANT_ID={tenant-id}
export SUBSCRIPTION_ID={subscription-id}
export RESOURCE_GROUP=my-resource-group
export APP_NAME=my-aca-app
export IDENTITY_NAME=my-identity

Variable	Descripción
`LOCATION`	La ubicación de la región de Azure en la que se crea Azure Container Apps.
`TENANT_ID`	Su identificador de inquilino.
`SUBSCRIPTION_ID`	Identificador de suscripción, que se usa para crear azure Container Apps.
`RESOURCE_GROUP`	Nombre del grupo de recursos de Azure para Azure Container Apps.
`APP_NAME`	Nombre de la aplicación para Azure Container Apps.
`IDENTITY_NAME`	Nombre de la identidad administrada, la cual se asigna a tus aplicaciones de contenedores en Azure.

Inicio de sesión en Azure con la CLI de Azure.
```
az login
```

Configuración de una identidad administrada para Azure Container Apps

Para escalar con métricas de la plataforma Azure Container Apps, necesita una identidad administrada para acceder a las métricas desde Azure Monitor.

Cree una identidad asignada por el usuario y asígnela a Azure Container Apps. Puede seguir la documentación Agregar una identidad asignada por el usuario. Después de crear la identidad, ejecute el comando de la CLI para establecer el identificador de identidad.
```
USER_ASSIGNED_IDENTITY_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $IDENTITY_NAME --query "id" --output tsv)
```

Conceda el rol Monitoring Reader a la identidad administrada para leer datos de Azure Monitor. Puede encontrar más detalles sobre los roles de Azure Monitor en Roles integrados de Azure para Monitor.

# Get the principal ID for your managed identity
PRINCIPAL_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $IDENTITY_NAME --query "principalId" --output tsv)

az role assignment create --assignee $PRINCIPAL_ID --role "Monitoring Reader" --scope /subscriptions/$SUBSCRIPTION_ID

Adición de una regla de escalado con métricas de Azure Monitor

Para escalar con métricas de Azure Monitor, puede consultar el escalador KEDA de Azure Monitor para escalado automático basado en eventos para definir la regla de escalado de Container Apps.

Esta es una lista de metadatos principales para configurar la regla de escalado.

Clave de metadatos	Descripción
ID de inquilino (tenantId)	Identificador del inquilino que contiene el recurso de Azure.
ID de suscripción	Identificador de la suscripción de Azure que contiene el recurso de Azure.
resourceGroupName	Nombre del grupo de recursos para el recurso de Azure.
URI de recurso	URI abreviado al recurso de Azure con formato `<resourceProviderNamespace>/<resourceType>/<resourceName>`.
metricName	Nombre de la métrica que se va a consultar.
metricAggregationType	Método de agregación de la métrica de Azure Monitor. Las opciones incluyen Promedio, Total, Máximo.
metricFilter	Nombre del filtro para que sea más específico mediante dimensiones enumeradas en la documentación oficial. (Opcional)
metricAggregationInterval	Tiempo de recopilación de la métrica en el formato `hh:mm:ss` (valor predeterminado: `0:5:0`, opcional)
targetValue	Valor de destino para desencadenar acciones de escalado. (Este valor puede ser un número flotante)

Agregue una regla de escalado con Métricas de Azure Monitor para Azure Container Apps para la aplicación.

CLI de Azure
Plantilla de ARM

az containerapp update \
        --name $APP_NAME \
        --resource-group $RESOURCE_GROUP \
        --min-replicas 1 \
        --max-replicas 10 \
        --scale-rule-name scale-with-azure-monitor-metrics \
        --scale-rule-type azure-monitor \
        --scale-rule-metadata "tenantId=${TENANT_ID}" \
                            "subscriptionId=${SUBSCRIPTION_ID}" \
                            "resourceGroupName=${RESOURCE_GROUP}" \
                            "resourceURI=Microsoft.App/containerapps/${APP_NAME}" \
                            "metricName=JvmGcCount" \
                            "metricAggregationType=Total" \
                            "metricAggregationInterval=0:1:0" \
                            "targetValue=30" \
        --scale-rule-identity $USER_ASSIGNED_IDENTITY_ID

{
    "resources": {
        "properties": {
            "template": {
                "scale": {
                    "minReplicas": 1,
                    "maxReplicas": 10,
                    "rules": [
                        {
                            "name": "scale-with-azure-monitor-metrics",
                            "custom": {
                                "type": "azure-monitor",
                                "metadata": {
                                    "metricAggregationInterval": "0:1:0",
                                    "metricAggregationType": "Total",
                                    "metricName": "JvmGcCount",
                                    "resourceGroupName": "<your-resource-group>",
                                    "resourceURI": "Microsoft.App/containerapps/<your-app>",
                                    "subscriptionId": "<your-subscription-id>",
                                    "targetValue": "30",
                                    "tenantId": "<your-tenant-id>"
                                },
                                "identity": "<your-managed-identity-id>"
                            }
                        }
                    ]
                }
            }
        }
    }
}

Este comando agrega una regla de escalado a la aplicación contenedora con el nombre scale-with-azure-monitor-metrics

El tipo de escala se establece en azure-monitor.
KEDA usa la identidad administrada con el identificador de recurso USER_ASSIGNED_IDENTITY_ID para autenticarse con Azure Monitor y consultar las métricas de la aplicación contenedora.
KEDA consulta la métrica JvmGcCount y agrega los valores de métrica en un minuto con el tipo de agregación Total.
El valor de destino se establece en 30, lo que significa que KEDA calcula desiredReplicas mediante ceil(AggregatedMetricValue(JvmGcCount)/30).

Nota:

La métrica JvmGcCount solo se usa como ejemplo. Puede usar cualquier métrica de Azure Monitor. Antes de configurar la regla de escalado, vea las métricas en Azure Portal para determinar la métrica, el intervalo de agregación y el valor de destino adecuados en función de los requisitos de la aplicación. Además, considere la posibilidad de usar las reglas de escalado HTTP/TCP integradas, que pueden cumplir los escenarios de escalado más comunes, antes de optar por una métrica personalizada.

Visualización del escalado en Azure Portal (opcional)

Una vez que la nueva revisión esté lista, envíe solicitudes a la aplicación contenedora para desencadenar el escalado automático con las métricas de Java.

Vaya a la hoja Metrics en Azure Portal para Azure Container Apps.
Agregue un gráfico, use la métrica jvm.gc.count, el filtro Revision=<your-revision>, la agregación mediante Sum y la división por Replica. Puede ver el valor de la métrica JvmGcCount para cada réplica de este chat.
Agregue un gráfico, use la métrica jvm.gc.count, el filtro Revision=<your-revision> y la agregación mediante Sum. Puede ver el valor total agregado de la métrica JvmGcCount para la revisión en este chat.
Agregue un gráfico, use la métrica Replica Count, el filtro Revision=<your-revision> y la agregación mediante Max. Puede ver el recuento de réplicas para la revisión en este chat.

Aquí tiene una instantánea de métricas de ejemplo para la regla de escala de ejemplo.

Inicialmente, existe una réplica de la aplicación (minReplicas).
Un aumento repentino de las solicitudes provoca que la aplicación Java experimente frecuentes procesos de recolección de basura (GC) de la máquina virtual Java (JVM).
KEDA observa que el valor de métrica agregado para jvm.gc.count aumenta a 256 y calcula el valor de desiredReplicas como ceil(256/30)=9.
KEDA escala automáticamente el recuento de réplicas de la aplicación de contenedores a 9.
El tráfico HTTP se distribuye entre más réplicas, lo que reduce el número medio de GC.
El recuento de GC disminuye aún más cuando no se reciben solicitudes.
Después de un período de enfriamiento, KEDA reduce el número de réplicas a minReplicas=1.

Registros de escalado

Para ver los registros de escalado de KEDA, puede ejecutar la consulta en el panel Logs.

ContainerAppSystemLogs
| where RevisionName == "<your-revision>"
| where EventSource == "KEDA"
| project TimeGenerated, Type, Reason, ContainerAppName, Log

Limpieza de recursos

Los recursos creados en este tutorial tienen un efecto en la factura de Azure. Si no va a usar estos servicios a largo plazo, ejecute el siguiente comando para quitar todo lo creado en este tutorial.

az group delete --resource-group $RESOURCE_GROUP

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-03-28