Despliegue automatizado de Kinesis con CloudFormation

Automatiza con confianza la creación de Kinesis Data Streams usando AWS CloudFormation e infraestructura como código: plantillas en YAML, parámetros reutilizables y nested stacks que facilitan versionado, control por ambiente y despliegues repetibles en minutos.

¿Qué es CloudFormation y por qué automatiza Kinesis?

CloudFormation gestiona recursos de AWS como código mediante templates en YAML o JSON. Aquí se usa para crear un Kinesis Data Stream de forma totalmente automatizada, evitando la configuración manual y habilitando buenas prácticas de DevOps.

• Infraestructura como código: plantillas versionables y reutilizables.
• Parámetros: definen valores dinámicos como environment y número de shards.
• Ambientes: posibilidad de condicionar despliegues por entorno: staging, preproducción o cuentas distintas.
• Composición: una plantilla master invoca otra por URL como nested stack.
• Outputs: exportan datos del stream para consumo por otros stacks.
• Tags: etiquetan recursos con el environment para trazabilidad.

¿Qué parámetros controlan el despliegue?

• environment: nombre del ambiente a incorporar en nombres y tags.
• Kinesis Shards Number: cantidad de shards; por defecto 1, configurable antes de crear.

¿Cómo se estructuran las plantillas master y Kinesis Distribution?

La plantilla master recibe parámetros (environment y shards) y llama por URL a una segunda plantilla que define el Kinesis. Esa segunda plantilla crea el stream, aplica retención de 24 horas, toma el número de shards de la master y etiqueta con el environment. Además, publica outputs para integraciones futuras, por ejemplo una función Lambda que consuma el stream.

¿Cómo luce la plantilla master en YAML?

AWSTemplateFormatVersion: '2010-09-09'
Description: 'Master para Kinesis Data Stream.'
Parameters:
  Environment:
    Type: String
  KinesisShardsNumber:
    Type: Number
    Default: 1
Resources:
  KinesisStream:
    Type: AWS::CloudFormation::Stack
    Properties:
      # URL del archivo Kinesis Distribution en S3.
      TemplateURL: https://s3.amazonaws.com/<bucket>/<carpeta>/KinesisDistribution.yaml
      Parameters:
        Environment: !Ref Environment
        KinesisShardsNumber: !Ref KinesisShardsNumber

¿Cómo define Kinesis la plantilla Kinesis Distribution?

AWSTemplateFormatVersion: '2010-09-09'
Description: 'Kinesis Distribution: define Kinesis Data Stream.'
Parameters:
  Environment:
    Type: String
  KinesisShardsNumber:
    Type: Number
Resources:
  KinesisRT:
    Type: AWS::Kinesis::Stream
    Properties:
      Name: !Sub '${Environment}-Kinesis-RT'
      RetentionPeriodHours: 24
      ShardCount: !Ref KinesisShardsNumber
      Tags:
        - Key: Environment
          Value: !Ref Environment
Outputs:
  KinesisStreamName:
    Description: 'Nombre del Kinesis Data Stream.'
    Value: !Ref KinesisRT
    Export:
      Name: !Sub '${Environment}-Kinesis-RT-Name'

• Nombre del recurso: incluye el environment y el sufijo Kinesis RT para identificar que es de real time.
• Retención: 24 horas definida en código.
• Shards: toma el valor de la master.
• Outputs: listos para que otros stacks (por ejemplo, Lambda) lean el nombre del stream.

¿Cómo se despliega con S3 y CloudFormation y cómo se reutiliza?

El flujo operativo conecta S3 con CloudFormation para referenciar plantillas por URL y crear el stack con parámetros. Luego, confirma en Kinesis que el stream quedó activo con la configuración deseada.

• Crear un bucket S3 para plantillas: por ejemplo, CFN Kinesis Lab.
• Cargar master y Kinesis Distribution al bucket.
• Copiar la URL de la master desde S3.
• En CloudFormation: crear stack desde URL, nombrarlo (ej.: Kinesis Lab Platzi), elegir environment (ej.: staging) y definir 5 shards.
• Avanzar sin opciones extra y presionar crear.
• Monitorear el estado: creación en proceso hasta ver create complete.
• Verificar en Kinesis: nombre con estructura basada en environment, 5 shards y retención de 24 horas en estado activo.

¿Cómo escalar reutilización y control por código?

• Nested stacks: segmentar una gran plantilla en bloques reutilizables.
• Repositorios: guardar templates en GitHub, BitBucket o CodeCommit.
• Automatización: orquestar con CodePipeline y CodeBuild para empaquetar y desplegar en CloudFormation.
• Portabilidad: replicar la arquitectura en otra región o cuenta desplegando las mismas plantillas.

¿Te gustaría que agreguemos validaciones de parámetros o ejemplos de integración con Lambda a partir de los outputs? Comparte tus dudas y experiencia en comentarios.