Permítanme empezar por el principio. En mi función como ingeniero de la nube de AWS en uno de mis clientes anteriores, se utilizó una arquitectura basada en eventos en la que terceros enviaban constantemente muchos eventos a nuestro entorno de AWS a través de EventBridge. Para cada tercero, proporcionamos un bus de eventos con varias reglas de EventBridge.

El desafío aquí fue realizar un seguimiento de la estructura del evento: cómo se organizó. Los eventos se actualizaban con frecuencia, lo que daba lugar a muchas reuniones para aclarar las cosas.

A finales de 2019, gran parte de nuestro problema se resolvió gracias a EventBridge Schema Discovery. Al habilitar esto en los buses de eventos, los esquemas se generaron automáticamente en función de los eventos recibidos. Esto nos permitió generar enlaces de código a partir de estos esquemas, lo que fue de gran ayuda en nuestro entorno orientado a objetos.

A continuación puedes ver un evento de ejemplo muy básico de un tercero.

{
  "version": "0",
  "id": "ef21d5fc-a5ba-e2c6-fc4b-a8807455c64d",
  "detail-type": "orderType",
  "source": "com.company.A",
  "account": "xxx",
  "time": "2024-08-22T08:04:26Z",
  "region": "eu-west-1",
  "resources": [],
  "detail": {
    "orderId": 123456789,
    "customer": {
      "customerId": "C001",
      "name": "John Doe"
    },
    "orderDate": "2024-08-22"
  }
}

AWS descubrió un esquema para este tipo de eventos:

Al utilizar AWS Toolkit para Visual Studio Code, podríamos representar fácilmente nuestros eventos como objetos fuertemente tipados en nuestro código.

A continuación se muestra un ejemplo muy básico de cómo utilizamos los enlaces de código.

Producción:

123456789
C001

Esto mejoró nuestra forma de trabajar, pero aún así encontramos un problema. De vez en cuando, terceros agregaban nuevos atributos a sus eventos. EventBridge descubriría estos cambios, pero los desarrolladores a menudo olvidaban actualizar los enlaces de código para el nuevo esquema. Aunque nuestra implementación fue lo suficientemente sólida como para evitar fallas cuando se agregaron nuevos atributos, generó nuevos datos que no estábamos utilizando. Tuvimos que confiar en que los desarrolladores recordaran actualizar sus enlaces de código de vez en cuando, y no existía un proceso claro para gestionar esto.

A veces, un enlace de código no se actualizaba durante meses y, en ocasiones, dos desarrolladores lo actualizaban simultáneamente, lo que generaba conflictos o trabajo duplicado.

Para manejar esto mejor, decidimos crear una solución que crea automáticamente un ticket de Jira cada vez que un tercero actualiza su evento y se descubre un nuevo esquema.

La solución está disponible en CloudFormation en mi GitHub. Consulte el archivo LÉAME.

El primer paso fue crear una regla de EventBridge en nuestro bus predeterminado que se activaría cada vez que se descubriera un nuevo esquema o una actualización de la versión del esquema. Luego, este evento se envió a una cola SQS para que sirviera como entrada para un EventBridge Pipe. Aquí, podríamos agregar filtrado adicional (opcional en este ejemplo) y enriquecer nuestro evento usando una función Lambda.

Para el enriquecimiento, utilizamos describe_schema usando boto3.

data = event[0]["input"]["detail"]

try:
    response = client.describe_schema(
        RegistryName=data["RegistryName"],
        SchemaName=data["SchemaName"],
        SchemaVersion=data["Version"],
    )
except ClientError as e:
    raise e

return_data = {
    "SchemaName": response["SchemaName"],
    "SchemaVersion": response["SchemaVersion"],
    "SchemaArn": response["SchemaArn"],
    "Content": json.loads(response["Content"]),
}

Después de enriquecer nuestros datos, los enviamos a un flujo de trabajo de Step Function. Este flujo de trabajo, a su vez, activó la automatización AWS-CreateJiraIssue SSM proporcionada por AWS, que creó automáticamente un ticket de Jira.

El ticket incluía detalles como el nombre del esquema, la nueva versión del esquema y el ARN del esquema. (También se puede agregar contenido adicional del evento si es necesario).

 ----------------        --------        -------------------------        ----------------        ------------------------- 
| EventBridge    | ---> | SQS    | ---> | EventBridge Pipe        | ---> | Step Function  | ---> | SSM Automation Document |
| Rule           |      |        |      | (Filtering & Enrichment)|      |                |      |                         |
 ----------------        --------        -------------------------        ----------------        ------------------------- 

Hagamos una demostración de esta solución. Aquí ves un evento actualizado, basado en el original. El estado del atributo es nuevo.

{
  "version": "0",
  "id": "dffbd38b-9258-d028-21f3-da0ba3c9e314",
  "detail-type": "orderType",
  "source": "com.company.A",
  "account": "xxx",
  "time": "2024-08-22T08:04:26Z",
  "region": "eu-west-1",
  "resources": [],
  "detail": {
    "orderId": 123456789,
    "status": "Completed",
    "customer": {
      "customerId": "C001",
      "name": "John Doe"
    },
    "orderDate": "2024-08-22"
  }
}

Se descubrirá un nuevo esquema. Esto desencadenará toda la solución. Después de que Lambda enriqueciera nuestro evento, ese evento actualizado se utilizará como entrada para nuestra función de paso.

El evento de entrada de nuestra función de paso se enriquece y tiene este aspecto.

[
  {
    "statusCode": 200,
    "data": {
      "SchemaName": "com.company.A@OrderType",
      "SchemaVersion": "2",
      "SchemaArn": "arn:aws:schemas:eu-west-1:xxx:schema/discovered-schemas/com.company.A@OrderType",
      "Content": {
        "openapi": "3.0.0",
        "info": {
          "version": "1.0.0",
          "title": "OrderType"
        },
        "paths": {},
        "components": {
          "schemas": {
            "AWSEvent": {
              "type": "object",
              "required": [
                "detail-type",
                "resources",
                "detail",
                "id",
                "source",
                "time",
                "region",
                "version",
                "account"
              ],
              "x-amazon-events-detail-type": "orderType",
              "x-amazon-events-source": "com.company.A",
              "properties": {
                "detail": {
                  "$ref": "#/components/schemas/OrderType"
                },
                "account": {
                  "type": "string"
                },
                "detail-type": {
                  "type": "string"
                },
                "id": {
                  "type": "string"
                },
                "region": {
                  "type": "string"
                },
                "resources": {
                  "type": "array",
                  "items": {
                    "type": "object"
                  }
                },
                "source": {
                  "type": "string"
                },
                "time": {
                  "type": "string",
                  "format": "date-time"
                },
                "version": {
                  "type": "string"
                }
              }
            },
            "OrderType": {
              "type": "object",
              "required": [
                "orderId",
                "orderDate",
                "customer",
                "status"
              ],
              "properties": {
                "customer": {
                  "$ref": "#/components/schemas/Customer"
                },
                "orderDate": {
                  "type": "string",
                  "format": "date"
                },
                "orderId": {
                  "type": "number"
                },
                "status": {
                  "type": "string"
                }
              }
            },
            "Customer": {
              "type": "object",
              "required": [
                "customerId",
                "name"
              ],
              "properties": {
                "customerId": {
                  "type": "string"
                },
                "name": {
                  "type": "string"
                }
              }
            }
          }
        }
      }
    }
  }
]

El flujo de trabajo de la función de paso, a su vez, activará la automatización de SSM y creará un ticket de Jira.

Para mayor comodidad, mantuve el contenido del ticket breve. Sin embargo, dado que el Contenido también se envía como entrada a la Función de Paso, también podría incluirse en el ticket. De esa manera, puedes mencionar directamente los nuevos atributos o cambios en el esquema en tu ticket.

Esta solución también se activará cuando se descubra un evento completamente nuevo, ya que creará una versión 1 del nuevo evento, lo que provocará que se active la regla EventBridge.

De esta manera, nos informaron sobre las actualizaciones y pudimos programarlas en nuestro sprint. Esto conduce a una aceleración de nuestro ciclo de desarrollo.

Soy consciente de que este es un caso bastante específico, pero se pueden crear soluciones similares configurando reglas de EventBridge para activar los eventos deseados y luego usando enriquecimiento y funciones de pasos en combinación con SSM para crear más automatizaciones.