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.
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
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,252para errores de sintaxis o parámetros,253para problemas de configuración o credenciales,254cuando la petición llegó al servicio pero este devolvió error,255como catch-all general. Conset -e, cualquier valor distinto de cero detiene el script. Envuelve llamadas opcionales enif ! aws ...; theno agrega|| true. --dry-runfunciona 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 quesleepfijos. date -des específico de GNU: falla en macOS, donde el equivalente esdate -v-30d. Instala coreutils (gdate) o ramifica segúnuname.trap ... EXIT: la forma más segura de garantizar la limpieza de recursos, pero hazla opcional (el patrónKEEP=1de arriba) para que nadie aprovisione un stack y lo vea borrarse solo.
Variantes
| Enfoque | Herramienta | Complejidad | Usar Cuando |
|---|---|---|---|
| AWS CLI + bash | aws cli | Baja | Scripts rápidos, tareas de ops programadas |
| AWS SDK (Python) | boto3 | Media | Lógica compleja, manejo de errores más rico |
| AWS SDK (JavaScript) | aws-sdk | Media | Entornos Node.js |
| Terraform | terraform | Alta | Infraestructura declarativa como código |
| CloudFormation | aws cloudformation | Alta | IaC 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 pipefailal inicio de los scripts. Falla rápido ante errores. - Usa
--querypara extraer solo los campos que necesitas; recurre ajqsolo cuando el filtrado se anida. - Cada
aws <servicio> waithace el polling por ti y devuelve control en cuanto el recurso está listo, sin tener que adivinar cuántosleephace 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-roleen vez de embeber access keys de larga duración. - Ejecuta primero los scripts que modifican recursos contra una cuenta sandbox —un
--profilededicado 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_ATTEMPTSo cambiarretry_modeen~/.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_REGIONo pasa--regionexplí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
- AWS CLI User Guide — Ejemplos de código con Bash: los ejemplos oficiales para cada servicio de AWS.
- AWS CLI Command Reference: documentación completa de flags y JMESPath por comando.
- Tutorial de JMESPath: el lenguaje de consulta detrás de
--query. - Repositorio complementario de scripts AWS CLI en Bash: cada script de esta página como archivo
.shejecutable.
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.
Recursos Relacionados
Plantilla de Politica de Etiquetado de Recursos Cloud
Una plantilla de politica para aplicar etiquetas consistentes en recursos cloud y mejorar la asignacion de costos, la seguridad y las operaciones.
GuideGuía Completa de Optimización de Costos en AWS
Reduce el gasto en AWS entre un 30 y un 50%: dimensiona EC2, usa instancias Spot, Reserved Instances, Savings Plans, ciclo de vida de S3, RDS y monitoreo.
RecipeDesplegar Contenedores en ECS con Fargate
Cómo desplegar contenedores Docker en AWS ECS usando cómputo serverless de Fargate con Terraform y GitHub Actions
RecipeScripting en Bash para Automatización DevOps y Tareas de
Como escribir scripts Bash robustos para automatizar despliegues, monitoreo de sistemas, rotacion de logs y tareas de mantenimiento rutinarias
RecipeRotación de copias en Bash: retención e integridad
Automatiza la rotación de copias en Bash con archivos diarios, semanales y mensuales, retención, cifrado y verificación de integridad.
RecipeMonitorear Uso de Disco
Alerta cuando el espacio en disco cruza umbrales usando un script de Bash que verifica mount points y notifica operadores.