StackPractices
intermediate Por Mathias Paulenko

Scripts de Bash para AWS CLI

Un conjunto de scripts de Bash que envuelven AWS CLI para aprovisionar, etiquetar, auditar y limpiar recursos de AWS, incluidos despliegues multi-cuenta.

Temas: devops

Visión General

Navegar la consola de AWS para levantar un VPC, etiquetar una flota de instancias o averiguar quién dejó recursos sin tags corriendo no escala, y es justo el tipo de trabajo que se desincroniza entre entornos. Estos scripts de Bash envuelven AWS CLI —la herramienta de línea de comandos oficial de Amazon para hacer scripting contra sus APIs— para que aprovisionar, etiquetar, auditar y limpiar sea un solo comando en lugar de una docena de clics en la consola.

Cada script es autocontenido: ajusta las variables de arriba, ejecútalo y listo. Todos asumen AWS CLI v2 configurado (aws configure, variables de entorno o SSO) y set -euo pipefail para que una llamada a la API fallida detenga el script en vez de aplicar cambios a medias. Si estás empezando con scripting en shell para tareas de ops, Automatización con Bash para DevOps cubre primero los fundamentos.

Cuándo Usar

  • Necesitas aprovisionar o destruir recursos de AWS repetidamente: stacks de prueba, sandboxes, entornos de demo.
  • Quieres etiquetado consistente en recursos EC2, S3 y VPC; combínalo con una política escrita como la plantilla de política de etiquetado de recursos cloud.
  • Estás auditando usuarios IAM, access keys o cobertura de tags requeridos en una cuenta.
  • Estás automatizando la limpieza de entornos de desarrollo para controlar la factura; úsalo junto con la Guía completa de optimización de costos en AWS.
  • Despliegas la misma carga de trabajo en varias cuentas de AWS desde un pipeline o tu equipo.
  • Esta no es la herramienta adecuada para infraestructura de producción de larga duración. Para eso necesitas Terraform, CloudFormation o CDK. Mantienen estado y detectan drift, algo que un script de shell no puede hacer.

Solución

Aprovisionar una instancia EC2

El caso clásico: lanzar una instancia y esperar a que esté realmente corriendo antes de imprimir su IP pública. aws ec2 wait bloquea hasta que cambia el estado, mucho mejor que hacer polling con sleep.

#!/bin/bash

set -euo pipefail

INSTANCE_NAME="web-server-01"
AMI_ID="ami-0c55b159cbfafe1f0"  # example ID — pick a current AMI for your region
INSTANCE_TYPE="t3.micro"
KEY_NAME="my-key-pair"         # your key pair name
SECURITY_GROUP="sg-12345678"   # your security group ID
SUBNET_ID="subnet-12345678"    # your subnet ID

INSTANCE_ID=$(aws ec2 run-instances \
    --image-id "$AMI_ID" \
    --instance-type "$INSTANCE_TYPE" \
    --key-name "$KEY_NAME" \
    --security-group-ids "$SECURITY_GROUP" \
    --subnet-id "$SUBNET_ID" \
    --tag-specifications "ResourceType=instance,Tags=[{Key=Name,Value=${INSTANCE_NAME}}]" \
    --query 'Instances[0].InstanceId' \
    --output text)

echo "Launched instance: $INSTANCE_ID"

# Wait for instance to be running
aws ec2 wait instance-running --instance-ids "$INSTANCE_ID"

# Get public IP
PUBLIC_IP=$(aws ec2 describe-instances \
    --instance-ids "$INSTANCE_ID" \
    --query 'Reservations[0].Instances[0].PublicIpAddress' \
    --output text)

echo "Instance running at: $PUBLIC_IP"

Listar todas las instancias EC2 con detalles

Un comando de una línea que produce una tabla tipo reporte, útil para una vista rápida de la cuenta o un resumen diario por cron.

#!/bin/bash

set -euo pipefail

aws ec2 describe-instances \
    --query 'Reservations[*].Instances[*].[InstanceId,State.Name,InstanceType,PublicIpAddress,Tags[?Key==`Name`].Value | [0]]' \
    --output table

Crear un VPC de prueba efímero con limpieza automática

Para stacks de prueba quieres recursos etiquetados y eliminados cuando terminas. El trap EXIT borra la subnet y el VPC automáticamente; exporta KEEP=1 para conservarlos. Sin el trap, un script fallido deja una red a medio construir facturándote por horas.

#!/usr/bin/env bash
set -euo pipefail

REGION="${AWS_REGION:-us-east-1}"
PROJECT="${1:-demo}"
ENV="${2:-dev}"

TAGS="Key=Project,Value=$PROJECT Key=Environment,Value=$ENV Key=ManagedBy,Value=bash-script"

# Create a VPC with tags
VPC_ID=$(aws ec2 create-vpc --cidr-block 10.0.0.0/16 --region "$REGION" --query 'Vpc.VpcId' --output text)
aws ec2 create-tags --resources "$VPC_ID" --tags $TAGS --region "$REGION"

SUBNET_ID=""

# Cleanup function: deletes in dependency order (subnet before VPC)
cleanup() {
    echo "Tearing down ${SUBNET_ID:-none} and $VPC_ID"
    if [ -n "$SUBNET_ID" ]; then
        aws ec2 delete-subnet --subnet-id "$SUBNET_ID" --region "$REGION" || true
    fi
    aws ec2 delete-vpc --vpc-id "$VPC_ID" --region "$REGION" || true
}

# Register the teardown right away, before anything else can fail —
# unless KEEP=1 is exported
if [ "${KEEP:-0}" != "1" ]; then
    trap cleanup EXIT
fi

# Create a subnet
SUBNET_ID=$(aws ec2 create-subnet --vpc-id "$VPC_ID" --cidr-block 10.0.1.0/24 --region "$REGION" --query 'Subnet.SubnetId' --output text)
aws ec2 create-tags --resources "$SUBNET_ID" --tags $TAGS --region "$REGION"

echo "Created VPC $VPC_ID and subnet $SUBNET_ID"

El || true en cleanup importa: si la subnet ya no existe, el fallo de la limpieza no enmascara el exit status real del script.

Crear y configurar un bucket S3

La creación de buckets tiene un detalle trampa: us-east-1 no acepta LocationConstraint y todas las demás regiones sí lo necesitan. Este script además habilita versionado y aplica una política de ciclo de vida que mueve objetos entre clases de almacenamiento antes de expirarlos.

#!/bin/bash

set -euo pipefail

BUCKET_NAME="my-app-backups-$(date +%Y%m%d)"
REGION="us-east-1"

# Create bucket: us-east-1 takes no LocationConstraint
if [ "$REGION" = "us-east-1" ]; then
    aws s3api create-bucket --bucket "$BUCKET_NAME"
else
    aws s3api create-bucket \
        --bucket "$BUCKET_NAME" \
        --region "$REGION" \
        --create-bucket-configuration LocationConstraint="$REGION"
fi

echo "Created bucket: $BUCKET_NAME"

# Enable versioning
aws s3api put-bucket-versioning \
    --bucket "$BUCKET_NAME" \
    --versioning-configuration Status=Enabled

# Lifecycle: logs move to Infrequent Access at 30 days, Glacier at 90, expire at 365
cat > /tmp/lifecycle.json << 'EOF'
{
    "Rules": [
        {
            "ID": "LogLifecycleRule",
            "Status": "Enabled",
            "Filter": { "Prefix": "logs/" },
            "Transitions": [
                { "Days": 30, "StorageClass": "STANDARD_IA" },
                { "Days": 90, "StorageClass": "GLACIER" }
            ],
            "Expiration": { "Days": 365 },
            "NoncurrentVersionExpiration": { "NoncurrentDays": 30 }
        }
    ]
}
EOF

aws s3api put-bucket-lifecycle-configuration \
    --bucket "$BUCKET_NAME" \
    --lifecycle-configuration file:///tmp/lifecycle.json

echo "Versioning and lifecycle policy configured"

# Audit: list objects under the prefix older than 90 days
# date -d is GNU date — on macOS install coreutils and use gdate
aws s3api list-objects-v2 \
    --bucket "$BUCKET_NAME" \
    --prefix "logs/" \
    --query "Contents[?LastModified<='$(date -d '90 days ago' -I)'].[Key,LastModified,Size]" \
    --output table

Sincronizar un directorio local a S3

aws s3 sync es el caballo de batalla para backups y subida de assets estáticos. --delete también replica borrados, así que trata el destino como la fuente de verdad.

#!/bin/bash

set -euo pipefail

LOCAL_DIR="/var/backups/app"
S3_BUCKET="my-app-backups"
S3_PREFIX="daily"

# Sync with delete and exclude temp files
aws s3 sync "$LOCAL_DIR" "s3://${S3_BUCKET}/${S3_PREFIX}/" \
    --delete \
    --exclude "*.tmp" \
    --exclude "*.lock" \
    --storage-class STANDARD_IA

echo "Synced $LOCAL_DIR to s3://${S3_BUCKET}/${S3_PREFIX}/"

Detener instancias EC2 por tag

Este es el clásico ahorro de viernes por la tarde: apaga todo lo etiquetado Environment=dev. El inverso funciona igual —cambia stop-instances/instance-stopped por start-instances/instance-running.

#!/bin/bash

set -euo pipefail

# Stop all instances tagged Environment=dev
INSTANCE_IDS=$(aws ec2 describe-instances \
    --filters "Name=tag:Environment,Values=dev" "Name=instance-state-name,Values=running" \
    --query 'Reservations[*].Instances[*].InstanceId' \
    --output text)

if [ -z "$INSTANCE_IDS" ]; then
    echo "No running dev instances found"
    exit 0
fi

echo "Stopping instances: $INSTANCE_IDS"
aws ec2 stop-instances --instance-ids $INSTANCE_IDS

# Wait for stop
aws ec2 wait instance-stopped --instance-ids $INSTANCE_IDS
echo "All dev instances stopped"

Auditoría de usuarios IAM

Ejecuta esto antes de que lo haga la próxima auditoría de seguridad: el script vuelca las access keys, políticas adjuntas y grupos de cada usuario IAM, la forma rápida de sacar a la luz claves viejas y cuentas con privilegios de más.

#!/bin/bash

set -euo pipefail

echo "=== IAM User Audit ==="
echo "Date: $(date)"
echo ""

# List all users
USERS=$(aws iam list-users --query 'Users[*].UserName' --output text)

for user in $USERS; do
    echo "--- User: $user ---"

    # Get access keys (tolerate per-user permission failures)
    KEYS=$(aws iam list-access-keys --user-name "$user" --output text 2>/dev/null || echo "")
    if [ -n "$KEYS" ]; then
        echo "Access keys:"
        echo "$KEYS" | tr '\t' '\n'
    else
        echo "No access keys"
    fi

    # Get attached policies
    POLICIES=$(aws iam list-attached-user-policies --user-name "$user" \
        --query 'AttachedPolicies[*].PolicyName' --output text 2>/dev/null || echo "")
    if [ -n "$POLICIES" ]; then
        echo "Attached policies: $POLICIES"
    fi

    # Get groups
    GROUPS=$(aws iam list-groups-for-user --user-name "$user" \
        --query 'Groups[*].GroupName' --output text 2>/dev/null || echo "")
    if [ -n "$GROUPS" ]; then
        echo "Groups: $GROUPS"
    fi

    echo ""
done

Backup de snapshot RDS

Crea un snapshot, espera a que termine y luego poda todo lo anterior a tu ventana de retención. Ejecútalo cada noche desde cron o una tarea programada de CI.

#!/bin/bash

set -euo pipefail

DB_INSTANCE="my-database"
SNAPSHOT_ID="${DB_INSTANCE}-snapshot-$(date +%Y%m%d-%H%M%S)"

aws rds create-db-snapshot \
    --db-instance-identifier "$DB_INSTANCE" \
    --db-snapshot-identifier "$SNAPSHOT_ID"

echo "Creating snapshot: $SNAPSHOT_ID"

# Wait for snapshot to complete
aws rds wait db-snapshot-available \
    --db-snapshot-identifier "$SNAPSHOT_ID"

echo "Snapshot created: $SNAPSHOT_ID"

# Clean up manual snapshots older than 30 days
# --snapshot-type manual skips automated backups, which delete-db-snapshot can't remove
OLD_SNAPSHOTS=$(aws rds describe-db-snapshots \
    --db-instance-identifier "$DB_INSTANCE" \
    --snapshot-type manual \
    --query "DBSnapshots[?SnapshotCreateTime<\`$(date -d '30 days ago' -I)\`].DBSnapshotIdentifier" \
    --output text)

for snapshot in $OLD_SNAPSHOTS; do
    echo "Deleting old snapshot: $snapshot"
    aws rds delete-db-snapshot --db-snapshot-identifier "$snapshot"
done

Más Scripts: Auditoría, Limpieza y Despliegue

El siguiente lote cubre el lado operativo: hacer cumplir la política de tags, rotar backups, publicar dashboards y empujar el mismo artefacto a varias cuentas.

Auditar tags requeridos en EC2 y S3

Este es el script que se paga solo en una revisión de asignación de costos: reporta cada instancia corriendo y cada bucket al que le falte un tag requerido. Necesita jq para los arrays de tags anidados: brew install jq o apt install jq.

#!/usr/bin/env bash
set -euo pipefail

REGION="${AWS_REGION:-us-east-1}"
REQUIRED_TAGS=("Project" "Environment" "Owner" "CostCenter")

# Audit EC2 instances for missing required tags
INSTANCES=$(aws ec2 describe-instances \
    --query 'Reservations[*].Instances[?State.Name==`running`].[InstanceId,Tags]' \
    --output json \
    --region "$REGION")

echo "$INSTANCES" | jq -c '.[]' | while read -r instance; do
    instance_id=$(echo "$instance" | jq -r '.[0]')
    tags=$(echo "$instance" | jq -r '.[1] // [] | map(.Key)')
    missing=()
    for req_tag in "${REQUIRED_TAGS[@]}"; do
        if ! echo "$tags" | grep -q "\"$req_tag\""; then
            missing+=("$req_tag")
        fi
    done
    if [ ${#missing[@]} -gt 0 ]; then
        echo "VIOLATION: $instance_id missing tags: ${missing[*]}"
    fi
done

# Audit S3 buckets for missing tags
# Buckets can live in other regions — resolve each one's location first,
# otherwise get-bucket-tagging fails with PermanentRedirect and reports false positives
BUCKETS=$(aws s3api list-buckets --query 'Buckets[*].Name' --output text --region "$REGION")
for bucket in $BUCKETS; do
    BUCKET_REGION=$(aws s3api get-bucket-location --bucket "$bucket" \
        --query 'LocationConstraint' --output text 2>/dev/null || echo "")
    [ "$BUCKET_REGION" = "None" ] && BUCKET_REGION="us-east-1"
    bucket_tags=$(aws s3api get-bucket-tagging --bucket "$bucket" \
        --region "${BUCKET_REGION:-$REGION}" \
        --query 'TagSet[*].Key' --output text 2>/dev/null || echo "")
    missing=()
    for req_tag in "${REQUIRED_TAGS[@]}"; do
        if ! echo "$bucket_tags" | grep -qw "$req_tag"; then
            missing+=("$req_tag")
        fi
    done
    if [ ${#missing[@]} -gt 0 ]; then
        echo "VIOLATION: bucket $bucket missing tags: ${missing[*]}"
    fi
done

La auditoría de arriba solo mira EC2 y S3; para el mismo chequeo en RDS, Lambda y el resto de tu cuenta, recurre a aws resourcegroupstaggingapi get-resources — las preguntas frecuentes muestran cómo filtrarlo hasta los ARNs sin tags.

Rotar snapshots de EBS con retención

Saca snapshot de cada volumen etiquetado Backup=true, etiqueta cada snapshot con su fecha de creación y luego elimina los que superan la retención. Programado a diario, te da una cadena de backups que se limpia sola.

#!/usr/bin/env bash
set -euo pipefail

REGION="${AWS_REGION:-us-east-1}"
RETENTION_DAYS="${1:-30}"

# Create snapshots of all EBS volumes with the Backup tag
VOLUME_IDS=$(aws ec2 describe-volumes \
    --filters "Name=tag:Backup,Values=true" \
    --query 'Volumes[*].VolumeId' \
    --output text \
    --region "$REGION")

for vol_id in $VOLUME_IDS; do
    SNAP_ID=$(aws ec2 create-snapshot \
        --volume-id "$vol_id" \
        --description "Automated backup $(date -I)" \
        --tag-specifications "ResourceType=snapshot,Tags=[{Key=CreatedBy,Value=bash-script},{Key=Date,Value=$(date -I)}]" \
        --query 'SnapshotId' \
        --output text \
        --region "$REGION")
    echo "Created snapshot $SNAP_ID for volume $vol_id"
done

# Delete snapshots older than retention period
CUTOFF=$(date -d "$RETENTION_DAYS days ago" -I)
OLD_SNAPS=$(aws ec2 describe-snapshots \
    --owner-ids self \
    --filters "Name=tag:CreatedBy,Values=bash-script" \
    --query "Snapshots[?StartTime<='$CUTOFF'].SnapshotId" \
    --output text \
    --region "$REGION")

for snap_id in $OLD_SNAPS; do
    aws ec2 delete-snapshot --snapshot-id "$snap_id" --region "$REGION"
    echo "Deleted old snapshot $snap_id"
done

Limpiar volúmenes EBS desconectados

Los volúmenes desconectados te siguen facturando mucho después de que la instancia que servían haya desaparecido. Esto encuentra cada volumen available y lo elimina. Haz primero una pasada en seco comentando la llamada a delete-volume.

#!/bin/bash

set -euo pipefail

# Find unattached volumes
VOLUMES=$(aws ec2 describe-volumes \
    --filters "Name=status,Values=available" \
    --query 'Volumes[*].[VolumeId,Size,Tags[?Key==`Name`].Value | [0]]' \
    --output text)

if [ -z "$VOLUMES" ]; then
    echo "No unused volumes found"
    exit 0
fi

echo "Unused EBS volumes:"
echo "$VOLUMES"

# Delete each volume
for vol_id in $(echo "$VOLUMES" | awk '{print $1}'); do
    echo "Deleting volume: $vol_id"
    aws ec2 delete-volume --volume-id "$vol_id"
done

echo "Cleanup complete"

Monitorear costos con AWS Cost Explorer

La API de Cost Explorer reporta el gasto diario por servicio; esto imprime los últimos 30 días, listos para canalizar a un archivo o a un webhook de Slack como reporte de costos matutino.

#!/bin/bash

set -euo pipefail

START_DATE=$(date -d "30 days ago" +%Y-%m-%d)
END_DATE=$(date +%Y-%m-%d)

aws ce get-cost-and-usage \
    --time-period Start="$START_DATE",End="$END_DATE" \
    --granularity DAILY \
    --metrics UnblendedCost \
    --group-by Type=DIMENSION,Key=SERVICE \
    --query 'ResultsByTime[*].[TimePeriod.Start,Groups[*].[Keys[0],Metrics.UnblendedCost.Amount]]' \
    --output table

Publicar un dashboard de CloudWatch

Los dashboards son solo documentos JSON. Tener uno en un script significa que cada entorno obtiene los mismos paneles en vez de una vista armada a mano en la consola.

#!/usr/bin/env bash
set -euo pipefail

REGION="${AWS_REGION:-us-east-1}"
DASHBOARD_NAME="${1:-app-overview}"

DASHBOARD_BODY=$(cat <<EOF
{
    "widgets": [
        {
            "type": "metric",
            "x": 0, "y": 0, "width": 12, "height": 6,
            "properties": {
                "metrics": [
                    ["AWS/EC2", "CPUUtilization", "AutoScalingGroupName", "app-asg"],
                    [".", "NetworkIn", ".", "."]
                ],
                "period": 300,
                "stat": "Average",
                "region": "$REGION",
                "title": "EC2 CPU and Network"
            }
        },
        {
            "type": "metric",
            "x": 12, "y": 0, "width": 12, "height": 6,
            "properties": {
                "metrics": [
                    ["AWS/RDS", "CPUUtilization", "DBInstanceIdentifier", "app-db"],
                    [".", "DatabaseConnections", ".", "."]
                ],
                "period": 300,
                "stat": "Average",
                "region": "$REGION",
                "title": "RDS CPU and Connections"
            }
        },
        {
            "type": "log",
            "x": 0, "y": 6, "width": 24, "height": 6,
            "properties": {
                "query": "SOURCE 'app-logs' | fields @timestamp, level, message | filter level = \"ERROR\" | sort @timestamp desc | limit 20",
                "region": "$REGION",
                "title": "Recent Errors"
            }
        }
    ]
}
EOF
)

aws cloudwatch put-dashboard \
    --dashboard-name "$DASHBOARD_NAME" \
    --dashboard-body "$DASHBOARD_BODY" \
    --region "$REGION"

echo "Dashboard $DASHBOARD_NAME created"

Fíjate en el EOF sin comillas: el heredoc expande $REGION dentro del JSON. Usa <<'EOF' si no quieres expansión.

Desplegar en múltiples cuentas AWS con assume-role

Para un artefacto que sale a cuentas dev, staging y prod: itera sobre assume-role, exporta las credenciales temporales, despliega y límpialas antes de la siguiente cuenta. Nunca uses claves de larga duración para esto.

#!/usr/bin/env bash
set -euo pipefail

REGION="${AWS_REGION:-us-east-1}"
ACCOUNTS=("dev:111111111111" "staging:222222222222" "prod:333333333333")  # replace with your account IDs
ROLE_NAME="DeploymentRole"

for account in "${ACCOUNTS[@]}"; do
    ENV="${account%%:*}"
    ACCOUNT_ID="${account##*:}"

    echo "=== Deploying to $ENV ($ACCOUNT_ID) ==="

    # Assume the deployment role in this account
    CREDS=$(aws sts assume-role \
        --role-arn "arn:aws:iam::$ACCOUNT_ID:role/$ROLE_NAME" \
        --role-session-name "deploy-$ENV-$(date +%s)" \
        --query 'Credentials' \
        --output json)

    export AWS_ACCESS_KEY_ID=$(echo "$CREDS" | jq -r '.AccessKeyId')
    export AWS_SECRET_ACCESS_KEY=$(echo "$CREDS" | jq -r '.SecretAccessKey')
    export AWS_SESSION_TOKEN=$(echo "$CREDS" | jq -r '.SessionToken')

    # Deploy: update Lambda function
    aws lambda update-function-code \
        --function-name "app-handler" \
        --zip-file "fileb://dist/handler.zip" \
        --region "$REGION"

    # Verify deployment
    STATUS=$(aws lambda get-function \
        --function-name "app-handler" \
        --query 'Configuration.LastUpdateStatus' \
        --output text)

    echo "Deployment to $ENV: $STATUS"

    # Clear credentials before the next account
    unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
done
Bucle de despliegue multi-cuenta: para cada cuenta, assume-role, exportar credenciales temporales, actualizar el código Lambda, verificar el estado, limpiar credenciales y pasar a la siguiente cuenta

Archivos complementarios: todos estos scripts están reunidos en el repositorio complementario de bash-aws-cli-scripts, un archivo .sh por script, listos para copiar y ejecutar.

Explicación

Por defecto el CLI responde con JSON, incómodo de parsear en bash. --query toma una expresión JMESPath que filtra y da forma a la respuesta del lado del cliente, después de recibirla completa —no lo confundas con --filters, que algunas APIs aceptan para filtrar del lado del servidor antes de devolver nada—. --output text te da un valor plano por línea, perfecto para capturar con $(...), mientras --output table imprime algo que un humano puede leer de verdad. Cuando el filtro se complica más de lo que JMESPath maneja cómodamente, cambia a --output json y canaliza por jq, como hace la auditoría de tags.

Conviene saber antes de programar estos scripts:

  • Códigos de salida: 0 éxito, 252 para errores de sintaxis o parámetros, 253 para problemas de configuración o credenciales, 254 cuando la petición llegó al servicio pero este devolvió error, 255 como catch-all general. Con set -e, cualquier valor distinto de cero detiene el script. Envuelve llamadas opcionales en if ! aws ...; then o agrega || true.
  • --dry-run funciona en la mayoría de llamadas que modifican recursos de EC2: AWS chequea permisos y parámetros y no toca nada. Ejecuta así cualquier script destructivo la primera vez.
  • Comandos wait: hacen polling hasta que un recurso alcanza un estado (running, stopped, snapshot-available). Más confiables que sleep fijos.
  • date -d es específico de GNU: falla en macOS, donde el equivalente es date -v-30d. Instala coreutils (gdate) o ramifica según uname.
  • trap ... EXIT: la forma más segura de garantizar la limpieza de recursos, pero hazla opcional (el patrón KEEP=1 de arriba) para que nadie aprovisione un stack y lo vea borrarse solo.

Variantes

EnfoqueHerramientaComplejidadUsar Cuando
AWS CLI + bashaws cliBajaScripts rápidos, tareas de ops programadas
AWS SDK (Python)boto3MediaLógica compleja, manejo de errores más rico
AWS SDK (JavaScript)aws-sdkMediaEntornos Node.js
TerraformterraformAltaInfraestructura declarativa como código
CloudFormationaws cloudformationAltaIaC nativo de AWS, ciclo de vida de stacks

Bash + AWS CLI gana cuando la tarea es operativa (sincronizar, auditar, rotar, limpiar) y pierde cuando la tarea es infraestructura declarativa que necesita estado. En el momento en que te encuentres registrando “qué creé en la última ejecución” en un archivo de texto, es hora de Terraform.

Lo que funciona

  • Define siempre set -euo pipefail al inicio de los scripts. Falla rápido ante errores.
  • Usa --query para extraer solo los campos que necesitas; recurre a jq solo cuando el filtrado se anida.
  • Cada aws <servicio> wait hace el polling por ti y devuelve control en cuanto el recurso está listo, sin tener que adivinar cuánto sleep hace falta.
  • Etiqueta todo al momento de crear; la auditoría de cumplimiento de arriba muestra por qué volver a etiquetar después es doloroso.
  • Prueba las llamadas que modifican recursos con --dry-run (o un delete comentado) antes de dejar que un script toque recursos reales.
  • Asume roles de mínimo privilegio con aws sts assume-role en vez de embeber access keys de larga duración.
  • Ejecuta primero los scripts que modifican recursos contra una cuenta sandbox —un --profile dedicado o un OU de prueba en AWS Organizations mantiene un mal run lejos de prod.

Errores Comunes

  • Embeber credenciales de AWS en scripts. Usa variables de entorno, roles IAM o SSO en su lugar.
  • No manejar los rate limits de la API. AWS aplica throttling; el CLI ya reintenta solo en su modo standard por defecto, pero puedes subir el techo con AWS_MAX_ATTEMPTS o cambiar retry_mode en ~/.aws/config —y espacia las llamadas en bucles cerrados.
  • Olvidar esperar operaciones asíncronas, y el script continúa antes de que el recurso esté listo.
  • Borrar un VPC antes que sus subnets y dependencias. La limpieza tiene que correr en orden de dependencias.
  • Confiar en la región por defecto en silencio. Define siempre AWS_REGION o pasa --region explícitamente.
  • Registrar el trap de limpieza demasiado tarde. Si el script muere entre crear un recurso y registrar su trap EXIT, el recurso queda huérfano —registra el trap justo después de la primera llamada de creación, como hace el script del VPC efímero.

Lecturas recomendadas

Preguntas frecuentes

¿Cómo manejo errores de AWS CLI en bash?

Verifica el exit code y captura stderr:

if ! aws s3 ls "s3://my-bucket" 2>/dev/null; then
    echo "Bucket does not exist or access denied"
    exit 1
fi

El CLI devuelve 0 en caso de éxito, 252 para problemas de sintaxis o parámetros, 253 para problemas de configuración o credenciales, 254 para errores del lado del servicio y 255 como catch-all general.

¿Puedo ejecutar comandos con un rol IAM asumido?
ROLE_ARN="arn:aws:iam::123456789012:role/MyRole"

CREDENTIALS=$(aws sts assume-role \
    --role-arn "$ROLE_ARN" \
    --role-session-name "my-script" \
    --query 'Credentials' \
    --output json)

export AWS_ACCESS_KEY_ID=$(echo "$CREDENTIALS" | jq -r '.AccessKeyId')
export AWS_SECRET_ACCESS_KEY=$(echo "$CREDENTIALS" | jq -r '.SecretAccessKey')
export AWS_SESSION_TOKEN=$(echo "$CREDENTIALS" | jq -r '.SessionToken')

# Now run AWS commands as the assumed role
aws s3 ls
¿Cómo ejecuto el mismo comando en múltiples regiones?
REGIONS=("us-east-1" "us-west-2" "eu-west-1")

for region in "${REGIONS[@]}"; do
    echo "=== Region: $region ==="
    aws ec2 describe-instances --region "$region" \
        --query 'Reservations[*].Instances[*].[InstanceId,State.Name]' \
        --output table
done

Si no quieres fijar la lista en el código, aws ec2 describe-regions --query 'Regions[].RegionName' --output text te devuelve todas las regiones que tu cuenta puede ver.

¿Puedo probar operaciones destructivas sin aplicarlas?

Usa --dry-run. AWS valida la petición sin hacer cambios:

aws ec2 terminate-instances --instance-ids "i-12345678" --dry-run

Un error DryRunOperation significa que la petición habría funcionado; UnauthorizedOperation significa que tus credenciales no llegan.

¿Qué cubre los recursos sin tags más allá de EC2 y S3?

La Resource Groups Tagging API cubre la mayoría de servicios de AWS en una sola llamada. Este filtro JMESPath devuelve solo los ARNs que no llevan ningún tag:

aws resourcegroupstaggingapi get-resources \
    --query 'ResourceTagMappingList[?Tags==`[]`].ResourceARN' \
    --output text

Desde ahí canalizas cada ARN al comando de borrado de su servicio. No hay una API universal de borrado, así que toca aws ec2 delete-snapshot para snapshots, aws s3 rb para buckets, y así sucesivamente.