Leer en inglés

Compartir a través de


Actualización del código de aplicación para la carga de trabajo del flujo de trabajo controlado por eventos (EDW)

En este artículo se describen las actualizaciones clave del código de la aplicación para replicar la carga de trabajo de EDW en Azure mediante los SDK de Azure para trabajar con los servicios de Azure.

Código de acceso a datos

Implementación de AWS

La carga de trabajo de AWS se basa en los servicios de AWS y sus SDK de AWS de acceso a datos asociados. Ya hemos asignado servicios de AWS a servicios de Azure equivalentes, por lo que ahora podemos crear el código para acceder a los datos de la cola de productores y la tabla de base de datos de resultados de consumidores en Python mediante SDK de Azure.

Implementación en Azure

Para el plano de datos, el cuerpo del mensaje de productor (carga) es JSON, y no necesita ningún cambio de esquema para Azure. La aplicación de consumidor original guarda los mensajes procesados en una tabla de DynamoDB. Con pequeñas modificaciones en el código de la aplicación de consumidor, podemos almacenar los mensajes procesados en una tabla de Azure Storage.

Código de autenticación

Implementación de AWS

La carga de trabajo de AWS usa una directiva de roles de IAM que define el acceso total a un recurso de Amazon Simple Queue Service (SQS):

{
  "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "sqs:*",
            "Resource": "*"
        }
    ]
}

La carga de trabajo de AWS usa una directiva de roles de IAM que define el acceso total a un recurso de Amazon DynamoDB:

{
  "Version": "2012-10-17",
  "Statement": [
    {
        "Effect": "Allow",
        "Action": "dynamodb:*",
        "Resource": "*"
    }
  ]
}

En la carga de trabajo de AWS, asigne estas directivas mediante la CLI de AWS:

aws iam create-policy --policy-name sqs-sample-policy --policy-document <filepath/filename>.json
aws iam create-policy --policy-name dynamodb-sample-policy --policy-document <filepath/filename>.json
aws iam create-role --role-name keda-sample-iam-role  --assume-role-policy-document <filepath/filename>.json

aws iam attach-role-policy --role-name keda-sample-iam-role --policy-arn=arn:aws:iam::${<AWSAccountID>}:policy/sqs-sample-policy
aws iam attach-role-policy --role-name keda-sample-iam-role --policy-arn=arn:aws:iam::${<AWSAccountID>}:policy/dynamodb-sample-policy

# Set up trust relationship Kubernetes federated identity credential and map IAM role via kubectl annotate serviceaccount

Implementación en Azure

Vamos a explorar cómo realizar una lógica de comunicación de los servicios de AWS similar en el entorno de Azure mediante AKS.

Se aplican dos definiciones de roles de RBAC de Azure para controlar el acceso al plano de datos a la cola de Azure Storage y a la tabla de Azure Storage. Estos roles son como las directivas basadas en roles de IAM que AWS usa para controlar el acceso a SQS y DynamoDB. Los roles RBAC de Azure no se agrupan con el recurso. En su lugar, asigne los roles a una entidad de servicio asociada a un recurso determinado.

En la implementación de Azure de la carga de trabajo de EDW, asigne los roles a una identidad administrada asignada por el usuario vinculada a una identidad de carga de trabajo en un pod de AKS. Los SDK de Azure Python para la cola de Azure Storage y la tabla de Azure Storage usan automáticamente el contexto de la entidad de seguridad para acceder a los datos de ambos recursos.

Use el rol Colaborador de datos de cola de Storage para permitir que el receptor de roles lea, escriba o elimine en la cola de Azure Storage y el rol Colaborador de datos de tabla de Storage para permitir que el receptor lea, escriba o elimine datos en una tabla de Azure Storage.

En los pasos siguientes se muestra cómo crear una identidad administrada y asignar los roles Colaborador de datos de cola de Storage y Colaborador de datos de tabla de Storage mediante la CLI de Azure:

  1. Crear una identidad administrada usando el comando az identity create.

    managedIdentity=$(az identity create \
        --resource-group $resourceGroup \
        --name $managedIdentityName
    
  2. Asigne el rol Colaborador de datos de cola de Storage a la identidad administrada mediante el comando az role assignment create.

    principalId=$(echo $managedIdentity | jq -r `.principalId`)
    
    az role assignment create \
        --assignee-object-id $principalId \
        --assignee-principal-type ServicePrincipal
        --role "Storage Queue Data Contributor" \
        --scope $resourceId
    
  3. Asigne el rol Colaborador de datos de tabla de Storage a la identidad administrada mediante el comando az role assignment create.

    az role assignment create \
        --assignee-object-id $principalId \
        --assignee-principal-type ServicePrincipal
        --role "Storage Table Data Contributor" \
        --scope $resourceId
    

Para ver un ejemplo de trabajo, consulte el script deploy.sh en nuestro repositorio de GitHub.

Código de productor

Implementación de AWS

La carga de trabajo de AWS usa la biblioteca de Python boto3 de AWS para interactuar con las colas de Amazon SQS para configurar el acceso a la cola de almacenamiento. La funcionalidad AssumeRole de AWS IAM se autentica en el punto de conexión de SQS mediante la identidad de IAM asociada al pod EKS que hospeda la aplicación.

import boto3
# other imports removed for brevity
sqs_queue_url = "https://<region>.amazonaws.com/<queueid>/source-queue.fifo"
sqs_queue_client = boto3.client("sqs", region_name="<region>")    
response = sqs_client.send_message(
    QueueUrl = sqs_queue_url,
    MessageBody = 'messageBody1',
    MessageGroupId='messageGroup1')

Implementación en Azure

La implementación de Azure usa el SDK de Azure para Python y la autenticación de OAuth sin contraseña para interactuar con los servicios de cola de Azure Storage. La clase DefaultAzureCredential de Python es compatible con la identidad de carga de trabajo y usa la identidad administrada asociada a la identidad de carga de trabajo para autenticarse en la cola de almacenamiento.

En el ejemplo siguiente se muestra cómo autenticarse en una cola de Azure Storage mediante la clase DefaultAzureCredential:

from azure.identity import DefaultAzureCredential
from azure.storage.queue import QueueClient
# other imports removed for brevity

# authenticate to the storage queue.
account_url = "https://<storageaccountname>.queue.core.windows.net"
default_credential = DefaultAzureCredential()
aqs_queue_client = QueueClient(account_url, queue_name=queue_name ,credential=default_credential)

aqs_queue_client.create_queue()
aqs_queue_client.send_message('messageBody1')

Puede revisar el código del productor de cola (aqs-producer.py) en nuestro repositorio de GitHub.

Código de consumidor

Implementación de AWS

El código original de AWS para el acceso a DynamoDB usa la biblioteca de Python boto3 de AWS para interactuar con las colas de Amazon SQS. La parte del consumidor de la carga de trabajo usa el mismo código que el productor para conectarse a la cola de Amazon SQS para leer los mensajes. El consumidor también contiene código de Python para conectarse a DynamoDB mediante la funcionalidad AssumeRole de AWS IAM para autenticarse en el punto de conexión de DynamoDB mediante la identidad de IAM asociada al pod EKS que hospeda la aplicación.

# presumes policy deployment ahead of time such as: aws iam create-policy --policy-name <policy_name> --policy-document <policy_document.json>
dynamodb = boto3.resource('dynamodb', region_name='<region>')
table = dynamodb.Table('<dynamodb_table_name>')
table.put_item(
    Item = {
      'id':'<guid>',
      'data':jsonMessage["<message_data>"],
      'srcStamp':jsonMessage["<source_timestamp_from_message>"],
      'destStamp':'<current_timestamp_now>',
      'messageProcessingTime':'<duration>'
    }
)

Implementación en Azure

La implementación de Azure usa el SDK de Azure para Python para interactuar con las tablas de Azure Storage.

Ahora necesita el código de productor para autenticarse en la tabla de Azure Storage. Como se explicó anteriormente, el esquema usado en la sección anterior con DynamoDB no es compatible con la tabla de Azure Storage. Use un esquema de tabla compatible con Azure Cosmos DB para almacenar los mismos datos que la carga de trabajo de AWS en DynamoDB.

En el ejemplo siguiente se muestra el código necesario para Azure:

from azure.storage.queue import QueueClient
from azure.data.tables import (TableServiceClient)

    creds = DefaultAzureCredential()
    table = TableServiceClient(
        endpoint=f"https://{storage_account_name}.table.core.windows.net/",  
        credential=creds).get_table_client(table_name=azure_table)

entity={
    'PartitionKey': _id,
    'RowKey': str(messageProcessingTime.total_seconds()),
    'data': jsonMessage['msg'],
    'srcStamp': jsonMessage['srcStamp'],
    'dateStamp': current_dateTime
}
        
response = table.insert_entity(
    table_name=azure_table,
    entity=entity,
    timeout=60
)

A diferencia de DynamoDB, el código de tabla de Azure Storage especifica tanto PartitionKey como RowKey. El PartitionKey es similar al identificador uniqueidentifer en DynamoDB. Un PartitionKey es un uniqueidentifier para una partición en un contenedor lógico en la tabla de Azure Storage. El RowKey es un uniqueidentifier para todas las filas de una partición determinada.

Puede revisar el código completo de productor y consumidor en nuestro repositorio de GitHub.

Creación de imágenes de contenedor e inserción en Azure Container Registry

Ahora, puede compilar las imágenes de contenedor e insertarlas en Azure Container Registry (ACR).

En el directorio app del repositorio clonado, un script de shell denominado docker-command.sh compila las imágenes de contenedor y las inserta en ACR. Abra el archivo .sh y revise el código. El script compila las imágenes de contenedor de productor y consumidor y las inserta en ACR. Para obtener más información, consulte Introducción a los registros de contenedor en Azure e Inserción y extracción de imágenes en ACR.

Para compilar las imágenes de contenedor e insertarlas en ACR, asegúrese de que la variable de entorno AZURE_CONTAINER_REGISTRY esté establecida en el nombre del registro en el que desea insertar las imágenes y, a continuación, ejecute el siguiente comando:

./app/docker-command.sh

Pasos siguientes

Colaboradores

Microsoft se encarga del mantenimiento de este artículo. Los siguientes colaboradores lo escribieron originalmente:

  • Ken Kilty | TPM de entidad de seguridad
  • Russell de Pina | TPM de entidad de seguridad
  • Jenny Hayes | Desarrollador de contenido sénior
  • Carol Smith | Desarrollador de contenido sénior
  • Erin Schaffer | Desarrollador de contenido 2