# Ejemplos de comandos guiados de la AWS CLI
La AWS Command Line Interface (AWS CLI) es una herramienta de código abierto que le permite interactuar con una amplia gama de Servicios de AWS mediante el uso de comandos en el intérprete de comandos de la línea de comandos. En esta sección se proporcionan ejemplos guiados que muestran cómo aprovechar la AWS CLI para acceder a algunos de los Servicios de AWS. Esto incluye algunos de los comandos de AWS CLI personalizados, como los comandos `aws s3` de alto nivel. Estos ejemplos de comandos muestran las acciones más comunes que se utilizan en algunos Servicios de AWS y proporcionan recursos adicionales para obtener más información.
Tanto si es un usuario de AWS con experiencia como si es nuevo en la AWS CLI, estos ejemplos guiados le servirán de recurso para agilizar sus operaciones de AWS.
Para obtener una referencia completa de todos los comandos disponibles para cada Servicio de AWS, consulte la [guía de referencia de la versión 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/index.html). Además, puede utilizar la [ayuda integrada de la línea de comandos](cli-usage-help.md) para explorar la variedad de Servicios de AWS, comandos, opciones y características de la AWS CLI.
Para ver más ejemplos de comandos que no están disponibles en esta sección, consulte la sección de [Ejemplos de comando de AWS CLI](cli_code_examples.md). Estos son ejemplos de comandos de código abierto que también están disponibles en la [guía de referencia de la versión 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/index.html). Los ejemplos de comandos están alojados en el repositorio de la [AWS CLI](https://github.com/aws/aws-cli/tree/develop/awscli/examples) en *GitHub*.
Para ver ejemplos de script bash de código abierto, consulte [Ejemplos de código de la AWS CLI con script Bash](bash_code_examples.md). Los ejemplos de script bash están alojados en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples) en *GitHub*.
**Topics**
+ [DynamoDB](cli-services-dynamodb.md)
+ [Amazon EC2](cli-services-ec2.md)
+ [Amazon Glacier](cli-services-glacier.md)
+ [IAM](cli-services-iam.md)
+ [Amazon S3](cli-services-s3.md)
+ [Amazon SNS](cli-services-sns.md)
# Amazon DynamoDB en la AWS CLI
La AWS Command Line Interface (AWS CLI) ofrece soporte para todos los servicios de base de datos de AWS, incluido Amazon DynamoDB. Puede usar la AWS CLI para operaciones impromptu, como crear una tabla. También puede usarla para incluir operaciones de DynamoDB en scripts de utilidades.
Para obtener más información acerca del uso de AWS CLI con DynamoDB, consulte ```[dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html)` en la *Referencia de comandos de AWS CLI*.
Para mostrar los comandos de la AWS CLI para DynamoDB, utilice el siguiente comando.
```
$ aws dynamodb help
```
**Topics**
+ [Requisitos previos](#cli-services-dynamodb-prereqs)
+ [Creación y uso de tablas de DynamoDB](#cli-services-dynamodb-using)
+ [Uso de DynamoDB Local](#cli-services-dynamodb-local)
+ [Recursos](#cli-services-dynamodb-resources)
## Requisitos previos
Para ejecutar los comandos de `dynamodb`, debe:
+ Instalar y configurar la AWS CLI. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de AWS CLI](getting-started-install.md) y [Credenciales de autenticación y acceso para la AWS CLI](cli-chap-authentication.md).
## Creación y uso de tablas de DynamoDB
El formato de la línea de comandos se compone de un nombre de comando de DynamoDB, seguido de los parámetros de dicho comando. La AWS CLI permite utilizar la [sintaxis abreviada](cli-usage-shorthand.md) de la CLI en los valores de los parámetros, además de todo el código JSON.
En el siguiente ejemplo, se crea una tabla llamada `MusicCollection`.
```
$ aws dynamodb create-table \
--table-name MusicCollection \
--attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=1,WriteCapacityUnits=1
```
A continuación, puede añadir nuevas líneas a la tabla con comandos similares a los que se muestran en el siguiente ejemplo. En estos ejemplos se usa una combinación de sintaxis abreviada y JSON.
```
$ aws dynamodb put-item \
--table-name MusicCollection \
--item '{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"} ,
"AlbumTitle": {"S": "Somewhat Famous"}
}' \
--return-consumed-capacity TOTAL
{
"ConsumedCapacity": {
"CapacityUnits": 1.0,
"TableName": "MusicCollection"
}
}
```
```
$ aws dynamodb put-item \
--table-name MusicCollection \
--item '{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"} ,
"AlbumTitle": {"S": "Songs About Life"}
}' \
--return-consumed-capacity TOTAL
{
"ConsumedCapacity": {
"CapacityUnits": 1.0,
"TableName": "MusicCollection"
}
}
```
Puede resultar difícil crear código JSON válido en una única línea de comandos. Para facilitar la operación, la AWS CLI puede leer archivos JSON. Por ejemplo, fíjese en el fragmento de código JSON siguiente, que se almacena en un archivo denominado `expression-attributes.json`.
```
{
":v1": {"S": "No One You Know"},
":v2": {"S": "Call Me Today"}
}
```
Puede utilizar ese archivo para emitir una solicitud de `query` mediante la AWS CLI. En el siguiente ejemplo, se usa el contenido del archivo `expression-attributes.json` como valor del parámetro `--expression-attribute-values`.
```
$ aws dynamodb query --table-name MusicCollection \
--key-condition-expression "Artist = :v1 AND SongTitle = :v2" \
--expression-attribute-values file://expression-attributes.json
{
"Count": 1,
"Items": [
{
"AlbumTitle": {
"S": "Somewhat Famous"
},
"SongTitle": {
"S": "Call Me Today"
},
"Artist": {
"S": "No One You Know"
}
}
],
"ScannedCount": 1,
"ConsumedCapacity": null
}
```
## Uso de DynamoDB Local
Además de con DynamoDB, también puede usar la AWS CLI con DynamoDB Local. DynamoDB Local es un pequeño servidor y base de datos del lado del cliente que imita el servicio de DynamoDB. DynamoDB Local le permite escribir aplicaciones que usan la API de DynamoDB sin manipular realmente las tablas o los datos del servicio web de DynamoDB. En lugar de eso, todas las acciones de la API se redirigen a una base de datos local. lo que le permite ahorrar en rendimiento aprovisionado, almacenamiento de datos y tarifas de transferencia de datos.
Para obtener más información sobre DynamoDB Local y cómo usarlo con la AWS CLI, consulte las secciones siguientes de [Guía de desarrollador de Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/):
+ [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html)
+ [Uso de la AWS CLI con DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.CLI.html#UsingWithDDBLocal)
## Recursos
**referencia de AWS CLI:**
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/create-table.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/create-table.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/query.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/query.html)
**Referencia de servicio:**
+ [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html) en la Guía para desarrolladores de Amazon DynamoDB
+ [Uso de la AWS CLI con DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.CLI.html#UsingWithDDBLocal) en la Guía para desarrolladores de Amazon DynamoDB
# Uso de Amazon EC2 en la AWS CLI
| Una introducción a Amazon Elastic Compute Cloud (EC2) |
| --- |
| [](http://www.youtube.com/watch?v=https://www.youtube.com/embed/TsRBftzZsQo) |
Amazon Elastic Compute Cloud (Amazon EC2) proporciona entornos informáticos virtuales altamente escalables y flexibles. Amazon EC2 le permite aprovisionar y administrar servidores virtuales, conocidos como instancias de Amazon EC2, para satisfacer una amplia gama de necesidades informáticas.
Las instancias de Amazon EC2 son máquinas virtuales que se pueden personalizar con varias configuraciones de CPU, memoria, almacenamiento y capacidades de red. Puede elegir entre una amplia selección de tipos de instancias, que van desde opciones ligeras y rentables hasta instancias potentes y de alto rendimiento, según los requisitos de la aplicación. Esta flexibilidad le permite adaptarse a las necesidades informáticas para optimizar el rendimiento y la rentabilidad.
Además, Amazon EC2 ofrece un conjunto de características que le permiten administrar los recursos informáticos de forma eficaz. Estas incluyen la capacidad de lanzar nuevas instancias con rapidez, crear imágenes de máquina personalizadas (AMI) para una implementación rápida y ampliar o reducir la capacidad informática según sea necesario.
Puede obtener acceso a las características de Amazon EC2 con la AWS Command Line Interface (AWS CLI). Para mostrar los comandos de la AWS CLI para Amazon EC2, utilice el siguiente comando.
```
aws ec2 help
```
Antes de ejecutar los comandos, defina sus credenciales predeterminadas. Para obtener más información, consulte [Configuración de los ajustes de AWS CLI](cli-chap-configure.md).
En este tema se muestran ejemplos de comandos de formato corto de la AWS CLI que realizan tareas comunes para Amazon EC2.
Para obtener ejemplos de formato largo de los comandos de la AWS CLI, consulte el [repositorio de ejemplos de código de AWS CLI](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli) en *GitHub*.
**Topics**
+ [Creación, visualización y eliminación de pares de claves de Amazon EC2 en la AWS CLI](cli-services-ec2-keypairs.md)
+ [Creación, configuración y eliminación de grupos de seguridad de Amazon EC2 en la AWS CLI](cli-services-ec2-sg.md)
+ [Lanzamiento, enumeración y eliminación de instancias de Amazon EC2 en la AWS CLI](cli-services-ec2-instances.md)
+ [Cambio de un tipo de instancia de Amazon EC2 con un script de Bash en la AWS CLI](cli-services-ec2-instance-type-script.md)
# Creación, visualización y eliminación de pares de claves de Amazon EC2 en la AWS CLI
Puede utilizar el AWS Command Line Interface (AWS CLI) para crear, mostrar y eliminar los pares de claves para Amazon Elastic Compute Cloud (Amazon EC2). Utilice un par de claves para conectarse a su instancia de Amazon EC2. Puede proporcionar el par de claves para Amazon EC2 al crear la instancia y, a continuación, utilice ese par de claves para autenticarse cuando se conecte a la instancia.
**nota**
Para ver ejemplos de comandos adicionales, consulte la [Guía de la referencia de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/index.html).
**Topics**
+ [Requisitos previos](#cli-services-ec2-keypairs-prereqs)
+ [Crear un par de claves](#creating-a-key-pair)
+ [Mostrar un par de claves](#displaying-a-key-pair)
+ [Eliminar un par de claves](#deleting-a-key-pair)
+ [Referencias](#cli-services-ec2-keypairs-references)
## Requisitos previos
Para ejecutar los comandos de `ec2`, debe:
+ Instalar y configurar la AWS CLI. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de AWS CLI](getting-started-install.md) y [Credenciales de autenticación y acceso para la AWS CLI](cli-chap-authentication.md).
+ Establezca sus permisos de IAM para permitir el acceso a Amazon EC2. Para obtener más información sobre los permisos de IAM para Amazon EC2, consulte [Políticas de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) en la *Guía del usuario de Amazon EC2*.
## Crear un par de claves
Para crear un par de claves, utilice el comando `[aws ec2 create-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-key-pair.html)` con la opción `--query` y la opción `--output text` para transferir su clave privada directamente a un archivo.
```
$ aws ec2 create-key-pair --key-name MyKeyPair --query 'KeyMaterial' --output text > MyKeyPair.pem
```
Para PowerShell, el redireccionamiento de `> file` adopta la codificación UTF-8 de forma predeterminada, que no se puede utilizar en algunos clientes SSH. Por lo tanto, debe convertir la salida transfiriéndola al comando `out-file` y establecer de forma explícita la codificación en `ascii`.
```
PS C:\>aws ec2 create-key-pair --key-name MyKeyPair --query 'KeyMaterial' --output text | out-file -encoding ascii -filepath MyKeyPair.pem
```
El archivo `MyKeyPair.pem` resultante tiene este aspecto.
```
-----BEGIN RSA PRIVATE KEY-----
EXAMPLEKEYKCAQEAy7WZhaDsrA1W3mRlQtvhwyORRX8gnxgDAfRt/gx42kWXsT4rXE/b5CpSgie/
vBoU7jLxx92pNHoFnByP+Dc21eyyz6CvjTmWA0JwfWiW5/akH7iO5dSrvC7dQkW2duV5QuUdE0QW
Z/aNxMniGQE6XAgfwlnXVBwrerrQo+ZWQeqiUwwMkuEbLeJFLhMCvYURpUMSC1oehm449ilx9X1F
G50TCFeOzfl8dqqCP6GzbPaIjiU19xX/azOR9V+tpUOzEL+wmXnZt3/nHPQ5xvD2OJH67km6SuPW
oPzev/D8V+x4+bHthfSjR9Y7DvQFjfBVwHXigBdtZcU2/wei8D/HYwIDAQABAoIBAGZ1kaEvnrqu
/uler7vgIn5m7lN5LKw4hJLAIW6tUT/fzvtcHK0SkbQCQXuriHmQ2MQyJX/0kn2NfjLV/ufGxbL1
mb5qwMGUnEpJaZD6QSSs3kICLwWUYUiGfc0uiSbmJoap/GTLU0W5Mfcv36PaBUNy5p53V6G7hXb2
bahyWyJNfjLe4M86yd2YK3V2CmK+X/BOsShnJ36+hjrXPPWmV3N9zEmCdJjA+K15DYmhm/tJWSD9
81oGk9TopEp7CkIfatEATyyZiVqoRq6k64iuM9JkA3OzdXzMQexXVJ1TLZVEH0E7bhlY9d8O1ozR
oQs/FiZNAx2iijCWyv0lpjE73+kCgYEA9mZtyhkHkFDpwrSM1APaL8oNAbbjwEy7Z5Mqfql+lIp1
YkriL0DbLXlvRAH+yHPRit2hHOjtUNZh4Axv+cpg09qbUI3+43eEy24B7G/Uh+GTfbjsXsOxQx/x
p9otyVwc7hsQ5TA5PZb+mvkJ5OBEKzet9XcKwONBYELGhnEPe7cCgYEA06Vgov6YHleHui9kHuws
ayav0elc5zkxjF9nfHFJRry21R1trw2Vdpn+9g481URrpzWVOEihvm+xTtmaZlSp//lkq75XDwnU
WA8gkn6O3QE3fq2yN98BURsAKdJfJ5RL1HvGQvTe10HLYYXpJnEkHv+Unl2ajLivWUt5pbBrKbUC
gYBjbO+OZk0sCcpZ29sbzjYjpIddErySIyRX5gV2uNQwAjLdp9PfN295yQ+BxMBXiIycWVQiw0bH
oMo7yykABY7Ozd5wQewBQ4AdSlWSX4nGDtsiFxWiI5sKuAAeOCbTosy1s8w8fxoJ5Tz1sdoxNeGs
Arq6Wv/G16zQuAE9zK9vvwKBgF+09VI/1wJBirsDGz9whVWfFPrTkJNvJZzYt69qezxlsjgFKshy
WBhd4xHZtmCqpBPlAymEjr/TOlbxyARmXMnIOWIAnNXMGB4KGSyl1mzSVAoQ+fqR+cJ3d0dyPl1j
jjb0Ed/NY8frlNDxAVHE8BSkdsx2f6ELEyBKJSRr9snRAoGAMrTwYneXzvTskF/S5Fyu0iOegLDa
NWUH38v/nDCgEpIXD5Hn3qAEcju1IjmbwlvtW+nY2jVhv7UGd8MjwUTNGItdb6nsYqM2asrnF3qS
VRkAKKKYeGjkpUfVTrW0YFjXkfcrR/V+QFL5OndHAKJXjW7a4ejJLncTzmZSpYzwApc=
-----END RSA PRIVATE KEY-----
```
Su clave privada no se almacena en AWS y ***solo*** se puede recuperar en el momento de crearla. No puede recuperarla más adelante. En vez de ello, si pierde la clave privada, debe crear un par de claves nuevo.
Si se está conectando a su instancia desde un equipo Linux, le recomendamos que utilice el siguiente comando para establecer los permisos de su archivo de clave privada de modo que solo usted pueda leerlo.
```
$ chmod 400 MyKeyPair.pem
```
## Mostrar un par de claves
Se genera una "huella digital" a partir del par de claves, que puede utilizar para verificar que la clave privada que tiene en su equipo local coincide con la clave pública almacenada en AWS.
La huella digital es un valor hash SHA1 tomado a partir de una copia de la clave privada con codificación DER. Este valor se captura cuando se crea el par de claves y se almacena en AWS junto con la clave pública. Puede consultar la huella digital en la consola de Amazon EC2 o ejecutando el comando de la AWS CLI `[aws ec2 describe-key-pairs](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-key-pairs.html)`.
En el siguiente ejemplo se muestra la huella digital de `MyKeyPair`.
```
$ aws ec2 describe-key-pairs --key-name MyKeyPair
{
"KeyPairs": [
{
"KeyName": "MyKeyPair",
"KeyFingerprint": "1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f"
}
]
}
```
Para obtener más información sobre las claves y huellas digitales, consulte [Pares de claves de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) en la *Guía del usuario de Amazon EC2*.
## Eliminar un par de claves
Para eliminar un par de claves, ejecute el comando `[aws ec2 delete-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-key-pair.html)`, sustituyendo *`MyKeyPair`* por el nombre del par de claves que desea eliminar.
```
$ aws ec2 delete-key-pair --key-name MyKeyPair
```
## Referencias
**AWS CLI referencia de:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/index.html)`
+ `[aws ec2 create-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-key-pair.html)`
+ `[aws ec2 delete-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-key-pair.html)`
+ `[aws ec2 describe-key-pairs](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-key-pairs.html)`
**Otra referencia:**
+ [Documentación de Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/ec2/)
+ Para ver y contribuir al SDK de AWS y los ejemplos de código de AWS CLI, consulte el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/) en *GitHub*.
# Creación, configuración y eliminación de grupos de seguridad de Amazon EC2 en la AWS CLI
Puede crear un grupo de seguridad para las instancias Amazon Elastic Compute Cloud (Amazon EC2) que básicamente funciona como un firewall, con reglas que determinan el tráfico de red que puede entrar y salir.
Utilice AWS Command Line Interface (AWS CLI) para crear un nuevo grupo de seguridad, añadir reglas a grupos de seguridad existentes y eliminar grupos de seguridad.
**nota**
Para ver ejemplos de comandos adicionales, consulte la [Guía de la referencia de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/index.html).
**Topics**
+ [Requisitos previos](#cli-services-ec2-sg-prereqs)
+ [Creación de un grupo de seguridad](#creating-a-security-group)
+ [Agregar reglas al grupo de seguridad](#configuring-a-security-group)
+ [Eliminación de un grupo de seguridad](#deleting-a-security-group)
+ [Referencias](#cli-services-ec2-sg-references)
## Requisitos previos
Para ejecutar los comandos de `ec2`, debe:
+ Instalar y configurar la AWS CLI. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de AWS CLI](getting-started-install.md) y [Credenciales de autenticación y acceso para la AWS CLI](cli-chap-authentication.md).
+ Establezca sus permisos de IAM para permitir el acceso a Amazon EC2. Para obtener más información sobre los permisos de IAM para Amazon EC2, consulte [Políticas de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) en la *Guía del usuario de Amazon EC2*.
## Creación de un grupo de seguridad
Puede crear grupos de seguridad asociados a nubes privadas virtuales (VPC).
En el siguiente ejemplo de `[aws ec2 create-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-security-group.html)` se muestra cómo crear un grupo de seguridad para una VPC especificada.
```
$ aws ec2 create-security-group --group-name my-sg --description "My security group" --vpc-id vpc-1a2b3c4d
{
"GroupId": "sg-903004f8"
}
```
Para ver la información inicial para un grupo de seguridad, ejecute el comando de `[aws ec2 describe-security-groups](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-security-groups.html)`. Solo puede hacer referencia a un grupo de seguridad de EC2-VPC por su `vpc-id`, no por su nombre.
```
$ aws ec2 describe-security-groups --group-ids sg-903004f8
{
"SecurityGroups": [
{
"IpPermissionsEgress": [
{
"IpProtocol": "-1",
"IpRanges": [
{
"CidrIp": "0.0.0.0/0"
}
],
"UserIdGroupPairs": []
}
],
"Description": "My security group"
"IpPermissions": [],
"GroupName": "my-sg",
"VpcId": "vpc-1a2b3c4d",
"OwnerId": "123456789012",
"GroupId": "sg-903004f8"
}
]
}
```
## Agregar reglas al grupo de seguridad
Cuando ejecute una instancia de Amazon EC2, debe habilitar reglas en el grupo de seguridad para permitir el tráfico de red entrante en el medio que utilice para conectarse a la imagen.
Por ejemplo, si lanza una instancia de Windows, normalmente debe añadir una regla para permitir el tráfico entrante en el puerto TCP 3389 (RDP) para dar soporte al protocolo de escritorio remoto (RDP). Si lanza una instancia de Linux, normalmente debe añadir una regla para permitir el tráfico entrante en el puerto TCP 22 (SSH) para dar soporte a las conexiones de SSH.
Use el comando `[aws ec2 authorize-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-ingress.html)` para añadir una regla a un grupo de seguridad. Uno de los parámetros obligatorios de este comando es la dirección IP pública de su equipo, o la red (en forma de un intervalo de direcciones) al que su equipo está asociada, en notación [CIDR](https://wikipedia.org/wiki/Classless_Inter-Domain_Routing).
**nota**
Proporcionamos el siguiente servicio, [https://checkip.global.api.aws/](https://checkip.global.api.aws/), para determinar su dirección IP pública. Para encontrar otros servicios que puedan ayudarle a identificar su dirección IP, utilice el navegador para buscar"*cuál es mi dirección IP*". Si se conecta a través de un ISP o protegido por su firewall mediante una dirección IP dinámica (a través de una gateway NAT desde una red privada), su dirección puede cambiar de forma periódica. En ese caso, debe averiguar el rango de direcciones IP que utilizan los equipos cliente.
En el siguiente ejemplo se muestra cómo añadir una regla para RDP (puerto TCP 3389) a un grupo de seguridad EC2-VPC con el ID `sg-903004f8` utilizando su dirección IP.
Para empezar, busque su dirección IP.
```
$ curl https://checkip.amazonaws.com
x.x.x.x
```
Luego, puede agregar la dirección IP a su grupo de seguridad mediante la ejecución del comando `[aws ec2 authorize-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-ingress.html)`.
```
$ aws ec2 authorize-security-group-ingress --group-id sg-903004f8 --protocol tcp --port 3389 --cidr x.x.x.x/x
```
El siguiente comando añade otra regla para habilitar SSH en instancias en el mismo grupo de seguridad.
```
$ aws ec2 authorize-security-group-ingress --group-id sg-903004f8 --protocol tcp --port 22 --cidr x.x.x.x/x
```
Para ver los cambios realizados en el grupo de seguridad, ejecute el comando `[aws ec2 describe-security-groups](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-security-groups.html)`.
```
$ aws ec2 describe-security-groups --group-ids sg-903004f8
{
"SecurityGroups": [
{
"IpPermissionsEgress": [
{
"IpProtocol": "-1",
"IpRanges": [
{
"CidrIp": "0.0.0.0/0"
}
],
"UserIdGroupPairs": []
}
],
"Description": "My security group"
"IpPermissions": [
{
"ToPort": 22,
"IpProtocol": "tcp",
"IpRanges": [
{
"CidrIp": "x.x.x.x/x"
}
]
"UserIdGroupPairs": [],
"FromPort": 22
}
],
"GroupName": "my-sg",
"OwnerId": "123456789012",
"GroupId": "sg-903004f8"
}
]
}
```
## Eliminación de un grupo de seguridad
Para eliminar un grupo de seguridad, ejecute el comando `[aws ec2 delete-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-security-group.html)`.
**nota**
No puede eliminar un grupo de seguridad que esté conectado actualmente a un entorno.
El siguiente ejemplo de comando elimina un grupo de seguridad EC2-VPC.
```
$ aws ec2 delete-security-group --group-id sg-903004f8
```
## Referencias
**AWS CLI referencia de:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/index.html)`
+ `[aws ec2 authorize-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-ingress.html)`
+ `[aws ec2 create-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-security-group.html)`
+ `[aws ec2 delete-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-security-group.html)`
+ `[aws ec2 describe-security-groups](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-security-groups.html)`
**Otra referencia:**
+ [Documentación de Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/ec2/)
+ Para ver y contribuir al SDK de AWS y los ejemplos de código de AWS CLI, consulte el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/) en *GitHub*.
# Lanzamiento, enumeración y eliminación de instancias de Amazon EC2 en la AWS CLI
Puede utilizar la AWS Command Line Interface (AWS CLI) para lanzar, enumerar y eliminar instancias de Amazon Elastic Compute Cloud (Amazon EC2). Si lanza una instancia que no figura en la capa gratuita de AWS, se le facturará en cuanto la lance y se le cobrará el tiempo en que la instancia esté funcionando, aunque permanezca inactiva.
**nota**
Para ver ejemplos de comandos adicionales, consulte la [Guía de la referencia de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/index.html).
**Topics**
+ [Requisitos previos](#cli-services-ec2-instances-prereqs)
+ [iniciar la instancia](#launching-instances)
+ [Agregar un dispositivo de bloques a la instancia](#block-device-mapping)
+ [Agregar una etiqueta a la instancia](#tagging-instances)
+ [Conéctese a su instancia](#connecting-to-instances)
+ [Enumerar las instancias](#listing-instances)
+ [Eliminar la instancia](#terminating-instances)
+ [Referencias](#cli-services-ec2-instances-references)
## Requisitos previos
Para ejecutar los comandos `ec2` en este tema, debe hacer lo siguiente:
+ Instalar y configurar la AWS CLI. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de AWS CLI](getting-started-install.md) y [Credenciales de autenticación y acceso para la AWS CLI](cli-chap-authentication.md).
+ Establezca sus permisos de IAM para permitir el acceso a Amazon EC2. Para obtener más información sobre los permisos de IAM para Amazon EC2, consulte [Políticas de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) en la *Guía del usuario de Amazon EC2*.
+ Cree un [par de claves](cli-services-ec2-keypairs.md) y un [grupo de seguridad](cli-services-ec2-sg.md).
+ Seleccione una Amazon Machine Image (AMI) y anotar su ID de AMI. Para obtener más información, consulte [Búsqueda de una AMI apta](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html) en la *Guía del usuario de Amazon EC2*.
## iniciar la instancia
Para lanzar una instancia de Amazon EC2 utilizando la AMI que ha seleccionado, utilice el comando `[aws ec2 run-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html)`. Puede lanzar la instancia en una nube privada virtual (VPC).
Al principio, la instancia aparece en el estado `pending`, pero cambia al estado `running` después de unos minutos.
En el siguiente ejemplo se muestra cómo lanzar una instancia `t2.micro` en la subred especificada de una VPC. Sustituya los valores del parámetro *en cursiva* por sus propios valores.
```
$ aws ec2 run-instances --image-id ami-xxxxxxxx --count 1 --instance-type t2.micro --key-name MyKeyPair --security-group-ids sg-903004f8 --subnet-id subnet-6e7f829e
{
"OwnerId": "123456789012",
"ReservationId": "r-5875ca20",
"Groups": [
{
"GroupName": "my-sg",
"GroupId": "sg-903004f8"
}
],
"Instances": [
{
"Monitoring": {
"State": "disabled"
},
"PublicDnsName": null,
"Platform": "windows",
"State": {
"Code": 0,
"Name": "pending"
},
"EbsOptimized": false,
"LaunchTime": "2013-07-19T02:42:39.000Z",
"PrivateIpAddress": "10.0.1.114",
"ProductCodes": [],
"VpcId": "vpc-1a2b3c4d",
"InstanceId": "i-5203422c",
"ImageId": "ami-173d747e",
"PrivateDnsName": "ip-10-0-1-114.ec2.internal",
"KeyName": "MyKeyPair",
"SecurityGroups": [
{
"GroupName": "my-sg",
"GroupId": "sg-903004f8"
}
],
"ClientToken": null,
"SubnetId": "subnet-6e7f829e",
"InstanceType": "t2.micro",
"NetworkInterfaces": [
{
"Status": "in-use",
"SourceDestCheck": true,
"VpcId": "vpc-1a2b3c4d",
"Description": "Primary network interface",
"NetworkInterfaceId": "eni-a7edb1c9",
"PrivateIpAddresses": [
{
"PrivateDnsName": "ip-10-0-1-114.ec2.internal",
"Primary": true,
"PrivateIpAddress": "10.0.1.114"
}
],
"PrivateDnsName": "ip-10-0-1-114.ec2.internal",
"Attachment": {
"Status": "attached",
"DeviceIndex": 0,
"DeleteOnTermination": true,
"AttachmentId": "eni-attach-52193138",
"AttachTime": "2013-07-19T02:42:39.000Z"
},
"Groups": [
{
"GroupName": "my-sg",
"GroupId": "sg-903004f8"
}
],
"SubnetId": "subnet-6e7f829e",
"OwnerId": "123456789012",
"PrivateIpAddress": "10.0.1.114"
}
],
"SourceDestCheck": true,
"Placement": {
"Tenancy": "default",
"GroupName": null,
"AvailabilityZone": "us-west-2b"
},
"Hypervisor": "xen",
"BlockDeviceMappings": [
{
"DeviceName": "/dev/sda1",
"Ebs": {
"Status": "attached",
"DeleteOnTermination": true,
"VolumeId": "vol-877166c8",
"AttachTime": "2013-07-19T02:42:39.000Z"
}
}
],
"Architecture": "x86_64",
"StateReason": {
"Message": "pending",
"Code": "pending"
},
"RootDeviceName": "/dev/sda1",
"VirtualizationType": "hvm",
"RootDeviceType": "ebs",
"Tags": [
{
"Value": "MyInstance",
"Key": "Name"
}
],
"AmiLaunchIndex": 0
}
]
}
```
## Agregar un dispositivo de bloques a la instancia
Cada instancia que lance tiene un volumen de dispositivo raíz asociado. Puede utilizar la asignación de dispositivos de bloques para especificar los volúmenes adicionales de Amazon Elastic Block Store (Amazon EBS) o los volúmenes de almacén de instancias que desea asociar a una instancia en el momento de lanzarla.
Para añadir un dispositivo de bloque a la instancia, especifique la opción `--block-device-mappings` cuando utilice `run-instances`.
El siguiente parámetro de ejemplo aprovisiona un volumen estándar de Amazon EBS con un tamaño de 20 GB y lo asigna a su instancia con el identificador `/dev/sdf`.
```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdf\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false}}]"
```
En el siguiente ejemplo se agrega un volumen de Amazon EBS, asignado a `/dev/sdf`, a partir de una instantánea existente. Una instantánea representa una imagen que se carga en el volumen por usted. Cuando se especifica una instantánea, no es necesario especificar un tamaño de volumen; será lo suficientemente grande como para almacenar la imagen. Sin embargo, si especifica un tamaño, este deberá ser igual o mayor que el tamaño de la instantánea.
```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdf\",\"Ebs\":{\"SnapshotId\":\"snap-a1b2c3d4\"}}]"
```
En el siguiente ejemplo se añaden dos volúmenes a la instancia. El número de volúmenes disponibles para su instancia depende del tipo de instancia.
```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdf\",\"VirtualName\":\"ephemeral0\"},{\"DeviceName\":\"/dev/sdg\",\"VirtualName\":\"ephemeral1\"}]"
```
En el siguiente ejemplo se crea el mapeo (`/dev/sdj`), pero no se aprovisiona un volumen para la instancia.
```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdj\",\"NoDevice\":\"\"}]"
```
Para obtener más información, consulte [Asignación de dispositivos de bloques](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html) en la *Guía del usuario de Amazon EC2*.
## Agregar una etiqueta a la instancia
Una etiqueta es una marca que se asigna a un recurso de AWS. Le permite añadir metadatos a los recursos que puede utilizar para distintos fines. Para obtener más información, consulte [Etiquetado de los recursos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) en la *Guía del usuario de Amazon EC2*.
En el siguiente ejemplo se muestra cómo añadir una etiqueta con el nombre de clave "`Name`" y el valor "`MyInstance`" a la instancia especificada, mediante el comando `[aws ec2 create-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-tags.html)`.
```
$ aws ec2 create-tags --resources i-5203422c --tags Key=Name,Value=MyInstance
```
## Conéctese a su instancia
Puede conectarse a su instancia mientras se esté ejecutando y utilizarla como si fuera un equipo que tiene delante. Para obtener más información, consulte [Conexión a la instancia de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) en la *Guía del usuario de Amazon EC2*.
## Enumerar las instancias
Puede utilizar la AWS CLI para mostrar las instancias y ver información de las mismas. Puede incluir todas sus instancias en la lista o filtrar los resultados en función de las instancias que le interesen.
Los siguientes ejemplos muestran cómo utilizar el comando `[aws ec2 describe-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html)`.
El siguiente comando muestra todas sus instancias.
```
$ aws ec2 describe-instances
```
El siguiente comando filtra únicamente las instancias `t2.micro` de la lista y devuelve únicamente los valores `InstanceId` para cada coincidencia.
```
$ aws ec2 describe-instances --filters "Name=instance-type,Values=t2.micro" --query "Reservations[].Instances[].InstanceId"
[
"i-05e998023d9c69f9a"
]
```
El siguiente comando muestra todas las instancias que tienen la etiqueta `Name=MyInstance`.
```
$ aws ec2 describe-instances --filters "Name=tag:Name,Values=MyInstance"
```
El siguiente comando muestra las instancias que tiene y que se iniciaron con cualquiera de las siguientes AMI: `ami-x0123456`, `ami-y0123456`y `ami-z0123456`.
```
$ aws ec2 describe-instances --filters "Name=image-id,Values=ami-x0123456,ami-y0123456,ami-z0123456"
```
## Eliminar la instancia
Puede usar la AWS CLI para terminar (eliminar) una instancia de Amazon EC2 cuando ya no la necesite.
**importante**
**La terminación de una instancia es permanente e irreversible.**
Después de terminar una instancia, ya no podrá conectarse a esta ni recuperarla. Todos los volúmenes de Amazon EBS asociados que estén configurados para eliminarse en la terminación también se eliminan de manera permanente y no se pueden recuperar. Todos los datos almacenados en volúmenes de almacén de instancias se perderán de forma permanente. Para obtener más información, consulte [Cómo funciona la terminación de instancias](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-ec2-instance-termination-works.html).
Antes de terminar una instancia, asegúrese de haber realizado una copia de seguridad en un almacenamiento persistente de todos los datos que necesite retener después de la terminación.
En cuanto el estado de la instancia cambie a `shutting-down` o a `terminated`, dejará de incurrir en costos por ella. Si desea volver a conectarse a una instancia más adelante, utilice [stop-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/stop-instances.html) en lugar de `terminate-instances`. Para obtener más información, consulte [Finalizar una instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) en la *Guía del usuario de Amazon EC2*.
En el ejemplo siguiente, se muestra cómo eliminar una instancia mediante el comando `[aws ec2 terminate-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/terminate-instances.html)`.
```
$ aws ec2 terminate-instances --instance-ids i-5203422c
{
"TerminatingInstances": [
{
"InstanceId": "i-5203422c",
"CurrentState": {
"Code": 32,
"Name": "shutting-down"
},
"PreviousState": {
"Code": 16,
"Name": "running"
}
}
]
}
```
## Referencias
**AWS CLI referencia de:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/index.html)`
+ `[aws ec2 create-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-tags.html)`
+ `[aws ec2 describe-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html)`
+ `[aws ec2 run-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html)`
+ `[aws ec2 terminate-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/terminate-instances.html)`
**Otra referencia:**
+ [Documentación de Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/ec2/)
+ Para ver y contribuir al SDK de AWS y los ejemplos de código de AWS CLI, consulte el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/) en *GitHub*.
# Cambio de un tipo de instancia de Amazon EC2 con un script de Bash en la AWS CLI
Este ejemplo de scripting de Bash para Amazon EC2 cambia el tipo de instancia de una instancia de Amazon EC2 con el método AWS Command Line Interface (AWS CLI). Detiene la instancia si se está ejecutando, cambia el tipo de instancia y, a continuación, si se solicita, reinicia la instancia. Los scripts de shell son programas diseñados para ejecutarse en una interfaz de línea de comandos.
**nota**
Para ver ejemplos de comandos adicionales, consulte la [Guía de la referencia de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/index.html).
**Topics**
+ [Antes de comenzar](#cli-services-ec2-instance-type-script-prereqs)
+ [Acerca de este ejemplo](#cli-services-ec2-instance-type-script-about)
+ [Parameters](#cli-services-ec2-instance-type-script-params)
+ [Archivos](#cli-services-ec2-instance-type-script-files.title)
+ [Referencias](#cli-services-ec2-instance-type-script-references)
## Antes de comenzar
Antes de que pueda ejecutar cualquiera de los siguientes ejemplos, se debe completar lo siguiente.
+ Instalar y configurar la AWS CLI. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de AWS CLI](getting-started-install.md), y [Credenciales de autenticación y acceso para la AWS CLI](cli-chap-authentication.md).
+ El perfil que utilice debe tener permisos que permitan que se realicen las operaciones de la AWS mediante ejemplos.
+ Una instancia de Amazon EC2 en ejecución en la cuenta para la que tiene permiso para detener y modificar. Si ejecuta el script de prueba, inicia una instancia, prueba el cambio del tipo y, a continuación, termina la instancia.
+ Como práctica recomendada de AWS, conceda privilegios mínimos a este código o solo los permisos necesarios para llevar a cabo una tarea. Para obtener más información, consulte [Otorgar privilegios mínimos](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) en la *Guía del usuario de AWS Identity and Access Management (IAM)*.
+ Este código no ha sido probado en todas las regiones de AWS. Algunos servicios de AWS solo están disponibles en regiones específicas. Para obtener más información, consulte [Puntos de enlace de servicio y cuotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) en la *Guía de referencia general de AWS*.
+ La ejecución de este código puede resultar en cargos en su cuenta de AWS. Es su responsabilidad asegurarse de que los recursos creados por este script se eliminen cuando haya terminado con ellos.
## Acerca de este ejemplo
Este ejemplo se escribe como una función en el archivo de script de shell `change_ec2_instance_type.sh` que puede `source` desde otro script o desde la línea de comandos. Cada archivo de script contiene comentarios que describen cada una de las funciones. Una vez la función esté en la memoria, puede invocarla desde la línea de comandos. Por ejemplo, los siguientes comandos cambian el tipo de instancia especificada a `t2.nano`:
```
$ source ./change_ec2_instance_type.sh
$ ./change_ec2_instance_type -i *instance-id* -t new-type
```
Para obtener el ejemplo completo y los archivos de script descargables, consulte el [Cambio del tipo de instancia de Amazon EC2](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/ec2/change-ec2-instance-type) en *AWS Ejemplos de código* en *GitHub*.
## Parameters
**-i**-*(string)* Especifica el ID de instancia que se va a modificar.
**-t**-*(string)*Especifica el tipo de instancia de Amazon EC2 al que se va a cambiar.
**-r**-*(switch)* De forma predeterminada, no se establece. Si se configura `-r`, reinicia la instancia después del modificador de tipo.
**-f**-*(switch)* De forma predeterminada, el script solicita al usuario que confirme el cierre de la instancia antes de realizar el cambio. Si se configura `-f`, la función no le pide al usuario antes de apagar la instancia para hacer el cambio de tipo
**-v**-*(switch)* De forma predeterminada, el script funciona silenciosamente y muestra la salida solo en caso de error. Si se configura `-v`, la función muestra el estado a lo largo de su operación.
## Archivos
**`change_ec2_instance_type.sh`**
El archivo de script principal contiene la función `change_ec2_instance_type()` que realiza las siguientes tareas:
+ Comprueba que existe la instancia de Amazon EC2 especificada.
+ A menos que se seleccione `-f`, advierte al usuario antes de detener la instancia.
+ Cambia el tipo de instancia
+ Si configura `-r`, reinicia la instancia y confirma que la instancia se está ejecutando
Ver el código de `[change\$1ec2\$1instance\$1type.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/ec2/change-ec2-instance-type/change_ec2_instance_type.sh)` en *GitHub*.
**`test_change_ec2_instance_type.sh`**
El script del archivo `test_change_ec2_instance_type.sh` prueba las diversas rutas de código para la función de `change_ec2_instance_type`. Si todos los pasos del script de prueba funcionan correctamente, este elimina todos los recursos que ha creado.
Puede ejecutar el script de prueba con los siguientes parámetros:
+ **-v**-*(switch)*Cada prueba muestra un estado de superación/fallo a medida que se ejecutan. De forma predeterminada, las pruebas se ejecutan silenciosamente y la salida incluye solo el estado final de aprobado o error.
+ **-i**-*(switch)* El script se detiene después de cada prueba para permitirle examinar los resultados intermedios de cada paso. Le permite examinar el estado actual de la instancia mediante la consola de Amazon EC2. El script pasa al siguiente paso después de presionar *ENTER* (INTRO) en el símbolo del sistema.
Ver el código de `[test\$1change\$1ec2\$1instance\$1type.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/ec2/change-ec2-instance-type/test_change_ec2_instance_type.sh)` en *GitHub*.
**`awsdocs_general.sh`**
El archivo de script `awsdocs_general.sh` contiene funciones de uso general utilizadas en ejemplos avanzados para el AWS CLI.
Ver el código de `[awsdocs\$1general.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/ec2/change-ec2-instance-type/awsdocs_general.sh)` en *GitHub*.
## Referencias
**AWS CLI referencia de:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/v1/reference/ec2/index.html)`
+ `[aws ec2 describe-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/describe-instances.html)`
+ `[aws ec2 modify-instance-attribute](https://docs.aws.amazon.com/cli/v1/reference/ec2/modify-instance-attribute.html)`
+ `[aws ec2 start-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/start-instances.html)`
+ `[aws ec2 stop-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/stop-instances.html)`
+ `[aws ec2 wait instance-running](https://docs.aws.amazon.com/cli/v1/reference/ec2/wait/instance-running.html)`
+ `[aws ec2 wait instance-stopped](https://docs.aws.amazon.com/cli/v1/reference/ec2/wait/instance-stopped.html)`
**Otra referencia:**
+ [Documentación de Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/ec2/)
+ Para ver y contribuir al SDK de AWS y los ejemplos de código de AWS CLI, consulte el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/) en *GitHub*.
# Uso de Amazon Glacier en la AWS CLI
| Introducción a Amazon Glacier |
| --- |
| |
En este tema se muestran ejemplos de los comandos de la AWS CLI que realizan tareas comunes para Amazon Glacier. En los ejemplos se muestra cómo utilizar la AWS CLI para cargar un archivo de gran tamaño en Amazon Glacier dividiéndolo en partes más pequeñas y cargándolas desde la línea de comandos.
Puede acceder a las características de Amazon Glacier con la AWS Command Line Interface (AWS CLI). Para mostrar los comandos de la AWS CLI para Amazon Glacier, utilice el siguiente comando.
```
aws glacier help
```
**nota**
Para obtener más ejemplos de referencia de comandos y ver otros ejemplos, consulte `[aws glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html)` en la *Referencia de comandos de AWS CLI*.
**Topics**
+ [Requisitos previos](#cli-services-glacier-prereqs)
+ [Creación de un almacén de Amazon Glacier](#cli-services-glacier-vault)
+ [Preparación de un archivo para cargarlo](#cli-services-glacier-prep)
+ [Inicio de una carga multiparte y carga de archivos](#cli-services-glacier-initiate)
+ [Finalización de la carga](#cli-services-glacier-complete)
+ [Recursos](#cli-services-glacier-resources)
## Requisitos previos
Para ejecutar los comandos de `glacier`, debe:
+ Instalar y configurar la AWS CLI. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de AWS CLI](getting-started-install.md) y [Credenciales de autenticación y acceso para la AWS CLI](cli-chap-authentication.md).
+ Este tutorial utiliza varias herramientas de línea de comandos que normalmente vienen preinstaladas en los sistemas operativos tipo Unix, como Linux y macOS. Los usuarios de Windows pueden usar las mismas herramientas instalando [Cygwin](https://www.cygwin.com/) y ejecutando los comandos desde el terminal de Cygwin. Se indicará en cada caso si hay disponibles utilidades y comandos nativos de Windows que realicen las mismas funciones.
## Creación de un almacén de Amazon Glacier
Cree un almacén con el comando `[create-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/create-vault.html)`.
```
$ aws glacier create-vault --account-id - --vault-name myvault
{
"location": "/123456789012/vaults/myvault"
}
```
**nota**
Todos los comandos de Amazon Glacier requieren un parámetro de ID de cuenta. Utilice el carácter de guion (`--account-id -`) para utilizar la cuenta actual.
## Preparación de un archivo para cargarlo
Cree un archivo para la carga de prueba. Los comandos siguientes crean un archivo llamado *largefile* que contiene exactamente 3 MiB de datos aleatorios.
**Linux o macOS**
```
$ dd if=/dev/urandom of=largefile bs=3145728 count=1
1+0 records in
1+0 records out
3145728 bytes (3.1 MB) copied, 0.205813 s, 15.3 MB/s
```
`dd` es una utilidad que copia un número de bytes de un archivo de entrada en un archivo de salida. En el ejemplo anterior se usa el archivo de dispositivo de sistema `/dev/urandom` como origen de datos aleatorios. `fsutil` realiza una función similar en Windows.
**Windows**
```
C:\> fsutil file createnew largefile 3145728
File C:\temp\largefile is created
```
A continuación, divida el archivo en fragmentos de 1 MiB (1 048 576 bytes) con un divisor de archivos.
```
$ split -b 1048576 --verbose largefile chunk
creating file `chunkaa'
creating file `chunkab'
creating file `chunkac'
```
## Inicio de una carga multiparte y carga de archivos
Cree una carga multiparte en Amazon Glacier con el comando `[initiate-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html)`.
```
$ aws glacier initiate-multipart-upload --account-id - --archive-description "multipart upload test" --part-size 1048576 --vault-name myvault
{
"uploadId": "19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ",
"location": "/123456789012/vaults/myvault/multipart-uploads/19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ"
}
```
Amazon Glacier requiere especificar el tamaño de cada parte en bytes (1 MiB en este ejemplo), el nombre del almacén y el ID de cuenta para configurar la carga multiparte. La AWS CLI genera un ID de carga al completarse la operación. Guarde el ID de carga en una variable de shell para su uso posterior.
**Linux o macOS**
```
$ UPLOADID="19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ"
```
**Windows**
```
C:\> set UPLOADID="19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ"
```
A continuación, use el comando `[upload-multipart-part](https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-multipart-part.html)` para cargar cada una de las tres partes.
```
$ aws glacier upload-multipart-part --upload-id $UPLOADID --body chunkaa --range 'bytes 0-1048575/*' --account-id - --vault-name myvault
{
"checksum": "e1f2a7cd6e047fa606fe2f0280350f69b9f8cfa602097a9a026360a7edc1f553"
}
$ aws glacier upload-multipart-part --upload-id $UPLOADID --body chunkab --range 'bytes 1048576-2097151/*' --account-id - --vault-name myvault
{
"checksum": "e1f2a7cd6e047fa606fe2f0280350f69b9f8cfa602097a9a026360a7edc1f553"
}
$ aws glacier upload-multipart-part --upload-id $UPLOADID --body chunkac --range 'bytes 2097152-3145727/*' --account-id - --vault-name myvault
{
"checksum": "e1f2a7cd6e047fa606fe2f0280350f69b9f8cfa602097a9a026360a7edc1f553"
}
```
**nota**
En el ejemplo anterior se usa el signo de dólar (`$`) para hacer referencia al contenido de la variable de shell `UPLOADID` en Linux. En la línea de comandos de Windows, inserte un signo de porcentaje (%) a ambos lados del nombre de la variable (por ejemplo, `%UPLOADID%`).
Debe especificar el intervalo de bytes de cada parte al cargarla, para que Amazon Glacier pueda volver a ensamblarlas en el orden adecuado. Cada parte tiene 1048576 bytes, por lo que la primera ocupa los bytes del 0 al 1048575, la segunda del 1048576 al 2097151 y la tercera del 2097152 al 3145727.
## Finalización de la carga
Amazon Glacier requiere un algoritmo hash en árbol del archivo original para poder confirmar que todas las partes cargadas llegan a AWS intactas.
Para calcular un algoritmo hash en árbol, divida el archivo en partes de 1 MiB y calcule un hash SHA-256 binario de cada fragmento. A continuación, divida la lista de hashes en pares, combine los dos hashes binarios de cada par y tome los hashes de los resultados. Repita este proceso hasta que solo quede un hash. Si hay un número impar de hashes en cualquier nivel, páselo al nivel siguiente sin modificarlo.
La clave para calcular un algoritmo hash en árbol correctamente al usar utilidades de línea de comandos es almacenar cada hash en formato binario y convertir a hexadecimal solamente en el último paso. Si la versión hexadecimal de cualquier hash del árbol se combina o se convierte a algoritmo hash, se obtendrá un resultado incorrecto.
**nota**
Los usuarios de Windows pueden utilizar el comando `type` en lugar de `cat`. OpenSSL está disponible para Windows en [OpenSSL.org](https://www.openssl.org/source/).
**Para calcular un algoritmo hash en árbol**
1. Divida el archivo original en partes de 1 MiB, si no lo ha hecho aún.
```
$ split --bytes=1048576 --verbose largefile chunk
creating file `chunkaa'
creating file `chunkab'
creating file `chunkac'
```
1. Calcule y almacene el hash SHA-256 binario de cada fragmento.
```
$ openssl dgst -sha256 -binary chunkaa > hash1
$ openssl dgst -sha256 -binary chunkab > hash2
$ openssl dgst -sha256 -binary chunkac > hash3
```
1. Combine los dos primeros hashes y tome el hash binario del resultado.
```
$ cat hash1 hash2 > hash12
$ openssl dgst -sha256 -binary hash12 > hash12hash
```
1. Combine el hash principal de los fragmentos `aa` y `ab` con el hash del fragmento `ac` y cree un hash del resultado, esta vez con formato hexadecimal. Almacene el resultado en una variable de shell.
```
$ cat hash12hash hash3 > hash123
$ openssl dgst -sha256 hash123
SHA256(hash123)= 9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67
$ TREEHASH=9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67
```
Por último, complete la carga con el comando `[complete-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html)`, que toma el tamaño del archivo original en bytes, el valor final del algoritmo hash en árbol en formato hexadecimal, su ID de cuenta y el nombre del almacén.
```
$ aws glacier complete-multipart-upload --checksum $TREEHASH --archive-size 3145728 --upload-id $UPLOADID --account-id - --vault-name myvault
{
"archiveId": "d3AbWhE0YE1m6f_fI1jPG82F8xzbMEEZmrAlLGAAONJAzo5QdP-N83MKqd96Unspoa5H5lItWX-sK8-QS0ZhwsyGiu9-R-kwWUyS1dSBlmgPPWkEbeFfqDSav053rU7FvVLHfRc6hg",
"checksum": "9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67",
"location": "/123456789012/vaults/myvault/archives/d3AbWhE0YE1m6f_fI1jPG82F8xzbMEEZmrAlLGAAONJAzo5QdP-N83MKqd96Unspoa5H5lItWX-sK8-QS0ZhwsyGiu9-R-kwWUyS1dSBlmgPPWkEbeFfqDSav053rU7FvVLHfRc6hg"
}
```
También puede comprobar el estado del almacén con el comando `[describe-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-vault.html)`.
```
$ aws glacier describe-vault --account-id - --vault-name myvault
{
"SizeInBytes": 3178496,
"VaultARN": "arn:aws:glacier:us-west-2:123456789012:vaults/myvault",
"LastInventoryDate": "2018-12-07T00:26:19.028Z",
"NumberOfArchives": 1,
"CreationDate": "2018-12-06T21:23:45.708Z",
"VaultName": "myvault"
}
```
**nota**
El estado del almacén se actualiza una vez al día. Consulte [Trabajar con almacenes](https://docs.aws.amazon.com/amazonglacier/latest/dev/working-with-vaults.html) para obtener más información.
Ahora puede quitar sin problemas el fragmento y los archivos hash que ha creado.
```
$ rm chunk* hash*
```
Para obtener más información sobre las cargas multiparte, consulte [Carga de archivos grandes por partes](https://docs.aws.amazon.com/amazonglacier/latest/dev/uploading-archive-mpu.html) y [Cálculo de sumas de comprobación](https://docs.aws.amazon.com/amazonglacier/latest/dev/checksum-calculations.html) en la *Guía para desarrolladores de Amazon Glacier*.
## Recursos
**AWS CLI referencia de:**
+ `[aws glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html)`
+ `[aws glacier complete-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html)`
+ `[aws glacier create-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/create-vault.html)`
+ `[aws glacier describe-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-vault.html)`
+ `[aws glacier initiate-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html)`
**Referencia de servicio:**
+ [Guía para desarrolladores de Amazon Glacier](https://docs.aws.amazon.com/amazonglacier/latest/dev/)
+ [Carga de archivos grandes por partes](https://docs.aws.amazon.com/amazonglacier/latest/dev/uploading-archive-mpu.html) en la *Guía para desarrolladores de Amazon Glacier*
+ [Cálculo de sumas de comprobación](https://docs.aws.amazon.com/amazonglacier/latest/dev/checksum-calculations.html) en la *Guía para desarrolladores de Amazon Glacier*
+ [Uso de almacenes](https://docs.aws.amazon.com/amazonglacier/latest/dev/working-with-vaults.html) en la *Guía para desarrolladores de Amazon Glacier*
# Uso de IAM en la AWS CLI
| Introducción a AWS Identity and Access Management |
| --- |
| |
Puede obtener acceso a las características de AWS Identity and Access Management (IAM) con la AWS Command Line Interface (AWS CLI). Para mostrar los comandos de la AWS CLI para IAM, utilice el siguiente comando.
```
aws iam help
```
En este tema se muestran ejemplos de comandos de la AWS CLI que realizan tareas comunes para IAM.
Antes de ejecutar los comandos, defina sus credenciales predeterminadas. Para obtener más información, consulte [Configuración de los ajustes de AWS CLI](cli-chap-configure.md).
Para obtener más información sobre el servicio IAM, consulte la [Guía del usuario de AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html).
**Topics**
+ [Creación de un grupo y usuarios de IAM](#cli-services-iam-new-user-group)
+ [Asociación de una política administrada de IAM a un usuario](#cli-services-iam-policy)
+ [Cómo establecer una contraseña inicial para un usuario de IAM](#cli-services-iam-set-pw)
+ [Creación de una clave de acceso para un usuario de IAM](#cli-services-iam-create-creds)
## Creación de un grupo y usuarios de IAM
**Para crear un grupo y añadirle un usuario**
1. Utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/iam/create-group.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-group.html) para crear el grupo.
```
$ aws iam create-group --group-name MyIamGroup
{
"Group": {
"GroupName": "MyIamGroup",
"CreateDate": "2018-12-14T03:03:52.834Z",
"GroupId": "AGPAJNUJ2W4IJVEXAMPLE",
"Arn": "arn:aws:iam::123456789012:group/MyIamGroup",
"Path": "/"
}
}
```
1. Use el comando [https://docs.aws.amazon.com/cli/latest/reference/iam/create-user.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-user.html) para crear el usuario.
```
$ aws iam create-user --user-name MyUser
{
"User": {
"UserName": "MyUser",
"Path": "/",
"CreateDate": "2018-12-14T03:13:02.581Z",
"UserId": "AIDAJY2PE5XUZ4EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/MyUser"
}
}
```
1. Use el comando [https://docs.aws.amazon.com/cli/latest/reference/iam/add-user-to-group.html](https://docs.aws.amazon.com/cli/latest/reference/iam/add-user-to-group.html) para agregar el usuario al grupo.
```
$ aws iam add-user-to-group --user-name MyUser --group-name MyIamGroup
```
1. Para verificar que el grupo `MyIamGroup` contiene `MyUser`, use el comando [https://docs.aws.amazon.com/cli/latest/reference/iam/get-group.html](https://docs.aws.amazon.com/cli/latest/reference/iam/get-group.html).
```
$ aws iam get-group --group-name MyIamGroup
{
"Group": {
"GroupName": "MyIamGroup",
"CreateDate": "2018-12-14T03:03:52Z",
"GroupId": "AGPAJNUJ2W4IJVEXAMPLE",
"Arn": "arn:aws:iam::123456789012:group/MyIamGroup",
"Path": "/"
},
"Users": [
{
"UserName": "MyUser",
"Path": "/",
"CreateDate": "2018-12-14T03:13:02Z",
"UserId": "AIDAJY2PE5XUZ4EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/MyUser"
}
],
"IsTruncated": "false"
}
```
## Asociación de una política administrada de IAM a un usuario
La política de este ejemplo ofrece al usuario "Power User Access" (acceso avanzado).
**Para asociar una política administrada de IAM a un usuario**
1. Determine el nombre de recurso de Amazon (ARN) de la política que desea asociar. El siguiente comando usa `list-policies` para buscar el ARN de la política con el nombre `PowerUserAccess`. A continuación, almacena dicho ARN en una variable de entorno.
```
$ export POLICYARN=$(aws iam list-policies --query 'Policies[?PolicyName==`PowerUserAccess`].{ARN:Arn}' --output text) ~
$ echo $POLICYARN
arn:aws:iam::aws:policy/PowerUserAccess
```
1. Para adjuntar la política, utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html) y haga referencia a la variable de entorno que contiene el ARN de política.
```
$ aws iam attach-user-policy --user-name MyUser --policy-arn $POLICYARN
```
1. Verifique que la política se ha adjuntado al usuario ejecutando el comando [https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-user-policies.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-user-policies.html).
```
$ aws iam list-attached-user-policies --user-name MyUser
{
"AttachedPolicies": [
{
"PolicyName": "PowerUserAccess",
"PolicyArn": "arn:aws:iam::aws:policy/PowerUserAccess"
}
]
}
```
Para obtener más información, consulte [Recursos de administración de acceso](https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-additional-resources.html). Este tema incluye vínculos a información general sobre permisos y políticas, además de vínculos a ejemplos de políticas para obtener acceso a Amazon S3, Amazon EC2 y otros servicios.
## Cómo establecer una contraseña inicial para un usuario de IAM
El comando siguiente utiliza `[create-login-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/create-login-profile.html)` para configurar una contraseña inicial en el usuario especificado. Cuando el usuario inicia sesión por primera vez, se le solicitará que cambie la contraseña y elija una que solo él conozca.
```
$ aws iam create-login-profile --user-name MyUser --password My!User1Login8P@ssword --password-reset-required
{
"LoginProfile": {
"UserName": "MyUser",
"CreateDate": "2018-12-14T17:27:18Z",
"PasswordResetRequired": true
}
}
```
Puede usar el comando `update-login-profile` para *cambiar* la contraseña de un usuario.
```
$ aws iam update-login-profile --user-name MyUser --password My!User1ADifferentP@ssword
```
## Creación de una clave de acceso para un usuario de IAM
Puede utilizar el comando [https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html) para crear una clave de acceso para un usuario. Una clave de acceso es un conjunto de credenciales de seguridad que se compone de un ID de clave de acceso y una clave secreta.
Un usuario solo puede crear dos claves de acceso al mismo tiempo. Si intenta crear un tercer conjunto, el comando devuelve un error `LimitExceeded`.
```
$ aws iam create-access-key --user-name MyUser
{
"AccessKey": {
"UserName": "MyUser",
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"Status": "Active",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"CreateDate": "2018-12-14T17:34:16Z"
}
}
```
Utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html) para eliminar una clave de acceso para un usuario. Especifique la clave de acceso que quiera eliminar mediante el ID de clave de acceso.
```
$ aws iam delete-access-key --user-name MyUser --access-key-id AKIAIOSFODNN7EXAMPLE
```
# Uso de Amazon S3 en la AWS CLI
| Una introducción a Amazon Simple Storage Service (Amazon S3) |
| --- |
| |
Para obtener acceso a las características de Amazon Simple Storage Service (Amazon S3), utilice la AWS Command Line Interface (AWS CLI). Amazon S3 es un servicio de almacenamiento de objetos altamente escalable y duradero. Amazon S3 está diseñado para ofrecer una capacidad de almacenamiento prácticamente ilimitada, lo que lo convierte en una solución ideal para una amplia gama de necesidades de almacenamiento y administración de datos.
Amazon S3 permite almacenar y recuperar cualquier cantidad de datos en forma de objetos, desde archivos pequeños hasta conjuntos de datos de gran tamaño. Cada objeto se almacena en un contenedor denominado bucket, al que se puede acceder y que se puede administrar mediante la Consola de administración de AWS o programáticamente mediante los AWS SDK, las herramientas y la AWS CLI.
Amazon S3, con almacenamiento básico, también ofrece una gama de características que incluyen la administración del ciclo de vida, el control de versiones, la escalabilidad y la seguridad. Se integran con otros Servicios de AWS, lo que le permite crear soluciones basadas en la nube que se adapten a sus necesidades.
La AWS CLI ofrece dos niveles de comandos para obtener acceso a Amazon S3:
+ **s3**: comandos de alto nivel personalizados, creados específicamente para AWS CLI, que simplifican la realización de tareas comunes, como crear, manipular, eliminar y sincronizar objetos y buckets.
+ **s3api**: expone el acceso directo a todas las operaciones de la API de Simple Storage Service (Amazon S3), lo que le permite llevar a cabo operaciones avanzadas.
**Topics**
+ [Uso de comandos de alto nivel (s3) en la AWS CLI](cli-services-s3-commands.md)
+ [Uso de comandos de nivel de API (s3api) en la AWS CLI](cli-services-s3-apicommands.md)
+ [Ejemplo de scripts para el ciclo de vida para un bucket de Amazon S3 en la AWS CLI](cli-services-s3-lifecycle-example.md)
# Uso de comandos de alto nivel (s3) en la AWS CLI
En este tema se describe alguno de los comandos que puede utilizar para administrar los buckets y los objetos de Amazon S3 mediante comandos [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) en la AWS CLI. Para ver los comandos que no se tratan en este tema y ejemplos de comandos adicionales, consulte los comandos [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) en la *Referencia de la AWS CLI*.
Los comandos de `aws s3` de alto nivel simplifican la administración de objetos de Amazon S3. Estos comandos le permiten administrar el contenido de Amazon S3 dentro de sí mismo y con directorios locales.
**Topics**
+ [Requisitos previos](#using-s3-commands-prereqs)
+ [Antes de comenzar](#using-s3-commands-before)
+ [Crear un bucket](#using-s3-commands-managing-buckets-creating)
+ [Lista de buckets y objetos](#using-s3-commands-listing-buckets)
+ [Eliminar buckets](#using-s3-commands-delete-buckets)
+ [Eliminar objetos](#using-s3-commands-delete-objects)
+ [Mover objetos](#using-s3-commands-managing-objects-move)
+ [Copia de objetos](#using-s3-commands-managing-objects-copy)
+ [Sincronización de objetos](#using-s3-commands-managing-objects-sync)
+ [Opciones utilizadas con frecuencia para los comandos s3](#using-s3-commands-managing-objects-param)
+ [Recursos](#using-s3-commands-managing-buckets-references)
## Requisitos previos
Para ejecutar los comandos de `s3`, debe:
+ Instalar y configurar la AWS CLI. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de AWS CLI](getting-started-install.md), y [Credenciales de autenticación y acceso para la AWS CLI](cli-chap-authentication.md).
+ El perfil que utilice debe tener permisos que permitan las operaciones que AWS realizó por los ejemplos.
+ Comprenda estos términos de Amazon S3:
+ **Bucket**: una carpeta de Amazon S3 de nivel superior.
+ **Prefijo**: una carpeta de Amazon S3 en un bucket.
+ **Objeto**: cualquier artículo alojado en un bucket de Amazon S3.
## Antes de comenzar
En esta sección se describen algunas cosas que hay que tener en cuenta antes de utilizar los comandos de `aws s3`.
### Cargas de objetos grandes
Cuando utiliza comandos `aws s3` para cargar objetos grandes en un bucket de Amazon S3, la AWS CLI automáticamente realiza una carga multiparte. Los errores de carga no pueden reanudarse cuando se usan estos comandos de `aws s3`.
Si la carga multiparte falla debido a que se agota el tiempo de espera, o si canceló en forma manual en la AWS CLI, la AWS CLI detiene la carga y limpia los archivos que se han creado. Este proceso puede tardar varios minutos.
Si el proceso de carga o limpieza multiparte se cancela por un comando de cierre o un error del sistema, los archivos creados permanecen en el bucket de Amazon S3. Para limpiar la carga multiparte, utilice el comando [s3api abort-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/s3api/abort-multipart-upload.html).
### Propiedades de archivo y etiquetas en copias multiparte
Cuando se utiliza la versión 1 de la AWS CLI de comandos en el espacio de nombres de `aws s3` para copiar un archivo de una ubicación de bucket de Amazon S3 a otra ubicación de bucket de Amazon S3, y esa operación utiliza la [copia multiparte](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CopyingObjctsMPUapi.html), no se copian propiedades de archivo del objeto fuente en el objeto de destino.
De forma predeterminada, los comandos de la versión 2 de la AWS CLI del espacio de nombres de `s3` que realizan copias multiparte transfieren todas las etiquetas y el siguiente conjunto de propiedades del origen a la copia de destino: `content-type`, `content-language`, `content-encoding`, `content-disposition`, `cache-control`, `expires` y `metadata`.
Esto puede dar lugar a llamadas de la API de AWS adicionales al punto de enlace de Amazon S3 que no se habrían realizado si hubiera utilizado la versión 1 de la AWS CLI. Estos pueden incluir: `HeadObject`, `GetObjectTagging` y `PutObjectTagging`.
Si necesita cambiar este comportamiento predeterminado en los comandos de la versión 2 de la AWS CLI, utilice el parámetro `--copy-props` para especificar una de las siguientes opciones:
+ **predeterminada**: el valor predeterminado. Especifica que la copia incluye todas las etiquetas asociadas al objeto de origen y las propiedades abarcadas por el parámetro `--metadata-directive` utilizado para copias no multiparte: `content-type`, `content-language`, `content-encoding`, `content-disposition`, `cache-control`, `expires` y `metadata`.
+ **directiva de metadatos**: especifica que la copia incluye solo las propiedades abarcadas por el parámetro `--metadata-directive` utilizado para copias no multiparte. No copia ninguna etiqueta.
+ **ninguno**: especifica que la copia no incluye ninguna de las propiedades del objeto fuente.
## Crear un bucket
Utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html) para crear un bucket. Los nombres de los buckets deben ser ***globalmente*** únicos (únicos en todo Amazon S3) y deben ser compatibles con DNS.
Los nombres de los buckets pueden contener minúsculas, números, guiones y puntos. Los nombres de los buckets solo pueden empezar y terminar con una letra o número, y no pueden contener un punto junto a un guion u otro punto.
**Sintaxis**
```
$ aws s3 mb [--options]
```
### Ejemplos de s3 mb
En el siguiente ejemplo se crea el bucket `s3://amzn-s3-demo-bucket`.
```
$ aws s3 mb s3://amzn-s3-demo-bucket
```
## Lista de buckets y objetos
Para mostrar los buckets, carpetas u objetos, utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html). El uso del comando sin destino u opciones muestra todos los buckets.
**Sintaxis**
```
$ aws s3 ls [--options]
```
Para ver algunas opciones comunes que se pueden utilizar con este comando y ejemplos, consulte [Opciones utilizadas con frecuencia para los comandos s3](#using-s3-commands-managing-objects-param). Para ver una lista completa de las opciones disponibles, consulte [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html) en la *Referencia de comandos de AWS CLI*.
### Ejemplos de s3 ls
En el siguiente ejemplo se enumeran todos los buckets de Amazon S3.
```
$ aws s3 ls
2018-12-11 17:08:50 amzn-s3-demo-bucket1
2018-12-14 14:55:44 amzn-s3-demo-bucket2
```
El siguiente comando muestra todos los objetos y prefijos de un bucket. En este resultado de ejemplo, el prefijo `example/` tiene un archivo llamado `MyFile1.txt`.
```
$ aws s3 ls s3://amzn-s3-demo-bucket
PRE example/
2018-12-04 19:05:48 3 MyFile1.txt
```
Para filtrar la salida por un prefijo específico, inclúyalo en el comando. El siguiente comando muestra los objetos en *bucket-name/example/* (es decir, los objetos que estén en *bucket-name* filtrados por el prefijo *example/*).
```
$ aws s3 ls s3://amzn-s3-demo-bucket/example/
2018-12-06 18:59:32 3 MyFile1.txt
```
Para mostrar solo los buckets y los objetos de una región específica, use las opciones de `--region`
```
$ aws s3 ls --region us-east-2
2018-12-06 18:59:32 3 MyFile1.txt
```
Si tiene una lista grande de buckets y objetos, puede paginar los resultados con las opciones `--max-items` o `--page-size`. La opción `--max-items` limita el número total de buckets y objetos que se devuelven en una llamada y la opción `--page-size` limita el número de objetos que se muestran en una página.
```
$ aws s3 ls --max-items 100 --page-size 10
```
Para obtener más información sobre paginación, consulte [Cómo usar el parámetro —page-size](cli-usage-pagination.md#cli-usage-pagination-pagesize) y [Cómo usar el parámetro —max-items](cli-usage-pagination.md#cli-usage-pagination-maxitems).
## Eliminar buckets
Para eliminar un bucket, utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html).
**Sintaxis**
```
$ aws s3 rb [--options]
```
### Ejemplos de s3 rb
En el siguiente ejemplo se quita el bucket `s3://amzn-s3-demo-bucket`.
```
$ aws s3 rb s3://amzn-s3-demo-bucket
```
De forma predeterminada, el bucket debe estar vacío para que la operación se realice correctamente. Para eliminar un bucket que no esté vacío, debe incluir la opción `--force`. Si utiliza un bucket versionado que contenga objetos eliminados previamente, pero que se conservan, este comando *no* le permitirá eliminar el bucket. En primer lugar, debe eliminar todo el contenido.
El siguiente ejemplo elimina todos los objetos y los prefijos en el bucket, luego elimina el bucket.
```
$ aws s3 rb s3://amzn-s3-demo-bucket --force
```
## Eliminar objetos
Para eliminar objetos en un bucket o en el directorio local, utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html).
**Sintaxis**
```
$ aws s3 rm [--options]
```
Para ver algunas opciones comunes que se pueden utilizar con este comando y ejemplos, consulte [Opciones utilizadas con frecuencia para los comandos s3](#using-s3-commands-managing-objects-param). Para ver una lista completa de opciones, consulte [https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) en la *Referencia de comandos de AWS CLI*.
### Ejemplos de s3 rm
En el siguiente ejemplo se elimina `filename.txt` de `s3://amzn-s3-demo-bucket/example`.
```
$ aws s3 rm s3://amzn-s3-demo-bucket/example/filename.txt
```
En el siguiente ejemplo se eliminan todos los objetos de `s3://amzn-s3-demo-bucket/example` utilizando la opción `--recursive`.
```
$ aws s3 rm s3://amzn-s3-demo-bucket/example --recursive
```
## Mover objetos
Use el comando [https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html) para mover objetos de un bucket o un directorio local. El comando `s3 mv` copia el objeto de origen o el archivo de origen en el destino especificado y, a continuación, elimina dicho objeto o archivo.
**Sintaxis**
```
$ aws s3 mv [--options]
```
Para ver algunas opciones comunes que se pueden utilizar con este comando y ejemplos, consulte [Opciones utilizadas con frecuencia para los comandos s3](#using-s3-commands-managing-objects-param). Para ver una lista completa de las opciones disponibles, consulte [https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html) en la *Referencia de comandos de AWS CLI*.
**aviso**
Si utiliza algún tipo de ARN de punto de acceso o alias de punto de acceso en las URI de origen o destino de Amazon S3, debe prestar especial atención a que los URI de Amazon S3 de origen y destino se resuelvan en diferentes buckets subyacentes. Si los buckets de origen y destino son los mismos, el archivo u objeto de origen se puede mover sobre sí mismo, lo que puede provocar la eliminación accidental dicho archivo u objeto. Para comprobar que los buckets de origen y destino no son los mismos, utilice el parámetro `--validate-same-s3-paths` o defina la variable de entorno ``AWS_CLI_S3_MV_VALIDATE_SAME_S3_PATHS`` en `true`.
### Ejemplos de s3 mv
En el siguiente ejemplo se mueven todos los objetos de `s3://amzn-s3-demo-bucket/example` a `s3://amzn-s3-demo-bucket/`.
```
$ aws s3 mv s3://amzn-s3-demo-bucket/example s3://amzn-s3-demo-bucket/
```
En el siguiente ejemplo se mueve un archivo local del directorio de trabajo actual al bucket de Amazon S3 con el comando de `s3 mv`.
```
$ aws s3 mv filename.txt s3://amzn-s3-demo-bucket
```
En el siguiente ejemplo se mueve un archivo del bucket de Amazon S3 a su directorio de trabajo actual, donde `./` especifica su directorio de trabajo actual.
```
$ aws s3 mv s3://amzn-s3-demo-bucket/filename.txt ./
```
## Copia de objetos
Use el comando [https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) para copiar objetos de un bucket o un directorio local.
**Sintaxis**
```
$ aws s3 cp [--options]
```
Puede usar el parámetro guión para el streaming de archivos a la entrada estándar (`stdin`) o salida estándar (`stdout`).
**aviso**
Si está utilizando PowerShell, el shell podría alterar la codificación de un CRLF o agregar un CRLF a la entrada o salida canalizada, o a la salida redirigida.
El comando `s3 cp` utiliza la siguiente sintaxis para cargar una secuencia de archivos desde `stdin` hasta un bucket especificado.
**Sintaxis**
```
$ aws s3 cp - [--options]
```
El comando `s3 cp` utiliza la siguiente sintaxis para descargar una secuencia de archivos de Amazon S3 para `stdout`.
**Sintaxis**
```
$ aws s3 cp [--options] -
```
Para ver algunas opciones comunes que se pueden utilizar con este comando y ejemplos, consulte [Opciones utilizadas con frecuencia para los comandos s3](#using-s3-commands-managing-objects-param). Para ver una lista completa de opciones, consulte [https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) en la *Referencia de comandos de AWS CLI*.
### `s3 cp`Ejemplos de
El siguiente ejemplo copia todos los registros de `s3://amzn-s3-demo-bucket/example` a `s3://amzn-s3-demo-bucket/`.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/example s3://amzn-s3-demo-bucket/
```
En el siguiente ejemplo se copian un archivo local del directorio de trabajo actual en el bucket de Amazon S3 con el`s3 cp`comando.
```
$ aws s3 cp filename.txt s3://amzn-s3-demo-bucket
```
En el siguiente ejemplo se copia un archivo de su bucket de Amazon S3 en su directorio de trabajo actual, donde `./` especifica su directorio de trabajo actual.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/filename.txt ./
```
En el siguiente ejemplo se utiliza la repetición para transmitir el texto “hola mundo” al archivo `s3://bucket-name/filename.txt`.
```
$ echo "hello world" | aws s3 cp - s3://amzn-s3-demo-bucket/filename.txt
```
En el ejemplo siguiente se transmite el archivo `s3://amzn-s3-demo-bucket/filename.txt` a `stdout` y se imprime el contenido en la consola.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/filename.txt -
hello world
```
En el siguiente ejemplo se transmiten los contenidos de `s3://bucket-name/pre` a `stdout`, se utiliza el comando `bzip2` para comprimir los archivos y se carga el nuevo archivo comprimido llamado `key.bz2` a `s3://bucket-name`.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/pre - | bzip2 --best | aws s3 cp - s3://amzn-s3-demo-bucket/key.bz2
```
## Sincronización de objetos
El comando [https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) sincroniza el contenido de un bucket y un directorio o los contenidos de dos buckets. Normalmente, `s3 sync` copia archivos u objetos que estén desactualizados o que falten entre el origen y el destino. Sin embargo, también puede introducir la opción `--delete` para quitar archivos u objetos desde el destino que no se encuentran en el origen.
**Sintaxis**
```
$ aws s3 sync [--options]
```
Para ver algunas opciones comunes que se pueden utilizar con este comando y ejemplos, consulte [Opciones utilizadas con frecuencia para los comandos s3](#using-s3-commands-managing-objects-param). Para ver una lista completa de opciones, consulte [https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) en la *Referencia de comandos de AWS CLI*.
### Ejemplos de sincronización de s3
En el siguiente ejemplo se sincroniza el contenido de un prefijo Amazon S3 llamado *ruta* en el bucket denominado *amzn-s3-demo-bucket* con el directorio activo actual.
`s3 sync` actualiza los archivos que tengan un tamaño o tiempo de modificación diferente que los archivos con el mismo nombre en el destino. La salida muestra las operaciones específica realizadas durante la sincronización. Observe que la operación sincroniza de forma recursiva el subdirectorio `MySubdirectory` y su contenido con `s3://amzn-s3-demo-bucket/path/MySubdirectory`.
```
$ aws s3 sync . s3://amzn-s3-demo-bucket/path
upload: MySubdirectory\MyFile3.txt to s3://amzn-s3-demo-bucket/path/MySubdirectory/MyFile3.txt
upload: MyFile2.txt to s3://amzn-s3-demo-bucket/path/MyFile2.txt
upload: MyFile1.txt to s3://amzn-s3-demo-bucket/path/MyFile1.txt
```
En el siguiente ejemplo, que amplía el anterior, se muestra cómo funciona la opción `--delete`.
```
// Delete local file
$ rm ./MyFile1.txt
// Attempt sync without --delete option - nothing happens
$ aws s3 sync . s3://amzn-s3-demo-bucket/path
// Sync with deletion - object is deleted from bucket
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --delete
delete: s3://amzn-s3-demo-bucket/path/MyFile1.txt
// Delete object from bucket
$ aws s3 rm s3://amzn-s3-demo-bucket/path/MySubdirectory/MyFile3.txt
delete: s3://amzn-s3-demo-bucket/path/MySubdirectory/MyFile3.txt
// Sync with deletion - local file is deleted
$ aws s3 sync s3://amzn-s3-demo-bucket/path . --delete
delete: MySubdirectory\MyFile3.txt
// Sync with Infrequent Access storage class
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --storage-class STANDARD_IA
```
Cuando se utiliza la opción `--delete`, las opciones `--exclude` y `--include` pueden filtrar archivos u objetos para eliminarlos durante una operación de `s3 sync`. En este caso, la cadena del parámetro debe especificar qué archivos se deben excluir o incluir en la eliminación, en el contexto del directorio o bucket de destino. A continuación se muestra un ejemplo.
```
Assume local directory and s3://amzn-s3-demo-bucket/path currently in sync and each contains 3 files:
MyFile1.txt
MyFile2.rtf
MyFile88.txt
'''
// Sync with delete, excluding files that match a pattern. MyFile88.txt is deleted, while remote MyFile1.txt is not.
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --delete --exclude "path/MyFile?.txt"
delete: s3://amzn-s3-demo-bucket/path/MyFile88.txt
'''
// Sync with delete, excluding MyFile2.rtf - local file is NOT deleted
$ aws s3 sync s3://amzn-s3-demo-bucket/path . --delete --exclude "./MyFile2.rtf"
download: s3://amzn-s3-demo-bucket/path/MyFile1.txt to MyFile1.txt
'''
// Sync with delete, local copy of MyFile2.rtf is deleted
$ aws s3 sync s3://amzn-s3-demo-bucket/path . --delete
delete: MyFile2.rtf
```
## Opciones utilizadas con frecuencia para los comandos s3
Las siguientes opciones se utilizan con frecuencia para los comandos descritos en este tema. Para obtener una lista completa de las opciones que puede utilizar en un comando, consulte el comando específico en la [Guía de referencia de la AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/reference/index.html).
**acl**
`s3 sync` y `s3 cp` pueden utilizar la opción `--acl`. Esto le permite configurar los permisos de acceso para archivos copiados en Amazon S3. La opción `--acl` admite los valores `private`, `public-read` y `public-read-write`. Para obtener más información, consulte [ACL predefinidas](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl) en la *Guía del usuario de Amazon S3*.
```
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --acl public-read
```
**excluya**
Cuando utiliza el comando `s3 cp`, `s3 mv`, `s3 sync` o `s3 rm`, puede filtrar los resultados mediante la opción `--exclude` o `--include`. La opción `--exclude` establece reglas para excluir únicamente objetos del comando y las opciones se aplican en el orden especificado. Esto se muestra en el siguiente ejemplo.
```
Local directory contains 3 files:
MyFile1.txt
MyFile2.rtf
MyFile88.txt
// Exclude all .txt files, resulting in only MyFile2.rtf being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --exclude "*.txt"
// Exclude all .txt files but include all files with the "MyFile*.txt" format, resulting in, MyFile1.txt, MyFile2.rtf, MyFile88.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --exclude "*.txt" --include "MyFile*.txt"
// Exclude all .txt files, but include all files with the "MyFile*.txt" format, but exclude all files with the "MyFile?.txt" format resulting in, MyFile2.rtf and MyFile88.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --exclude "*.txt" --include "MyFile*.txt" --exclude "MyFile?.txt"
```
**incluir**
Cuando utiliza el comando `s3 cp`, `s3 mv`, `s3 sync` o `s3 rm`, puede filtrar los resultados utilizando la opción `--exclude` o `--include`. La opción `--include` establece reglas para incluir únicamente objetos específicos para el comando y las opciones se aplican en el orden especificado. Esto se muestra en el siguiente ejemplo.
```
Local directory contains 3 files:
MyFile1.txt
MyFile2.rtf
MyFile88.txt
// Include all .txt files, resulting in MyFile1.txt and MyFile88.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "*.txt"
// Include all .txt files but exclude all files with the "MyFile*.txt" format, resulting in no files being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "*.txt" --exclude "MyFile*.txt"
// Include all .txt files, but exclude all files with the "MyFile*.txt" format, but include all files with the "MyFile?.txt" format resulting in MyFile1.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "*.txt" --exclude "MyFile*.txt" --include "MyFile?.txt"
```
**concesión**
Los comandos `s3 cp`, `s3 mv` y `s3 sync` incluyen una opción `--grants` que puede usar para conceder permisos sobre el objeto a usuarios o grupos específicos. Configure la opción `--grants` para obtener una lista de permisos mediante la siguiente sintaxis. Reemplace `Permission`, `Grantee_Type` y `Grantee_ID` por sus propios valores.
**Sintaxis**
```
--grants Permission=Grantee_Type=Grantee_ID
[Permission=Grantee_Type=Grantee_ID ...]
```
Cada valor contiene los siguientes elementos:
+ *Permiso*: especifica los permisos concedidos. Se puede establecer en `read`, `readacl`, `writeacl` o `full`.
+ *Tipo de beneficiario*: especifica cómo identificar al beneficiario. Se puede establecer en `uri`, `emailaddress` o `id`.
+ *Grantee\$1ID*: especifica el beneficiario del permiso según *Grantee\$1Type*.
+ `uri`: URI del grupo. Para obtener más información, consulte la sección [¿Quién es un beneficiario?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ACLOverview.html#SpecifyingGrantee)
+ `emailaddress`: dirección de correo electrónico de la cuenta.
+ `id`: ID canónico de la cuenta.
Para obtener más información acerca de cómo controlar el acceso a Amazon S3, consulte la sección de [Control de acceso](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingAuthAccess.html).
En el siguiente ejemplo se copia un objeto en un bucket. Concede permisos `read` sobre el objeto a todos los usuarios y permisos `full` (`read`, `readacl` y `writeacl`) a la cuenta asociada con `user@example.com`.
```
$ aws s3 cp file.txt s3://amzn-s3-demo-bucket/ --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers full=emailaddress=user@example.com
```
También puede especificar una clase de almacenamiento no predeterminada (`REDUCED_REDUNDANCY` o `STANDARD_IA`) para los objetos que se cargan en Amazon S3. Para ello, utilice la opción `--storage-class`.
```
$ aws s3 cp file.txt s3://amzn-s3-demo-bucket/ --storage-class REDUCED_REDUNDANCY
```
**no-overwrite**
Los comandos `s3 cp`, `s3 mv` y `s3 sync` incluyen una opción de `--no-overwrite` que puede utilizar para evitar que se sobrescriban los objetos que ya existen en el destino.
En el ejemplo siguiente, se copia un objeto de un bucket al directorio local solo si aún no existe en el directorio local.
```
$ aws s3 cp --no-overwrite s3://amzn-s3-demo-bucket/file.txt file.txt
```
En el ejemplo siguiente, se copian de forma recursiva archivos de un directorio local a un bucket. Solo copiará archivos que ya no existen en el bucket.
```
$ aws s3 cp --recursive --no-overwrite /path/to/demo-files/ s3://amzn-s3-demo-bucket/demo-files/
```
En el ejemplo siguiente, se mueve un objeto de un directorio local a un bucket solo si aún no existe en la ubicación de destino del bucket.
```
$ aws s3 mv --no-overwrite file.txt s3://amzn-s3-demo-bucket/file.txt
```
En el ejemplo siguiente, se sincronizan archivos de un directorio local a un bucket. Solo sincronizará archivos que ya no existen en el bucket de destino.
```
$ aws s3 sync --no-overwrite /path/to/demo-files/ s3://amzn-s3-demo-bucket/demo-files/
```
**recursive**
Cuando use esta opción, el comando se ejecuta en todos los objetos o archivos del directorio especificado o con el prefijo indicado. En el siguiente ejemplo se elimina `s3://amzn-s3-demo-bucket/path` y todos sus contenidos.
```
$ aws s3 rm s3://amzn-s3-demo-bucket/path --recursive
```
## Recursos
**AWS CLI referencia de:**
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html)
**Referencia de servicio:**
+ [Uso de buckets de Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingBucket.html) en la *Guía del usuario de Amazon S3*
+ [Uso de objetos de Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingObjects.html) en la *Guía del usuario de Amazon S3*
+ [Listado jerárquico de las claves con un prefijo y un delimitador](https://docs.aws.amazon.com//AmazonS3/latest/userguide/ListingKeysHierarchy.html) en la *Guía del usuario de Amazon S3*
+ [Anulación de cargas multiparte a un bucket de S3 con AWS SDK para .NET (bajo nivel)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/LLAbortMPUnet.html) en la *Guía del usuario de Amazon S3*
# Uso de comandos de nivel de API (s3api) en la AWS CLI
Los comandos de nivel de API (incluidos en el conjunto de comandos de `s3api`) proporcionan acceso directo a las API de Amazon Simple Storage Service (Amazon S3) y permiten realizar algunas operaciones no expuestas en los comandos de `s3` de alto nivel. Estos comandos son el equivalente de los otros servicios de AWS que proporcionan acceso de nivel de API a la funcionalidad de los servicios. Para obtener más información acerca de los comandos `s3`, consulte [Uso de comandos de alto nivel (s3) en la AWS CLI](cli-services-s3-commands.md)
En este tema, se incluyen ejemplos en los que se muestra cómo se usan los comandos de más bajo nivel que se asignan a las API de Amazon S3. Además, puede encontrar ejemplos para cada comando de API de S3 en la sección `s3api` de la [Guía de referencia de la AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html).
**Topics**
+ [Requisitos previos](#cli-services-s3-apicommands-prereqs)
+ [Aplicación de una ACL personalizada](#cli-services-s3-apicommands-acls)
+ [Configuración de una política de registro](#cli-services-s3-apicommands-logpol)
+ [Recursos](#cli-services-s3-apicommands-resources)
## Requisitos previos
Para ejecutar los comandos de `s3api`, debe:
+ Instalar y configurar la AWS CLI. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de AWS CLI](getting-started-install.md), y [Credenciales de autenticación y acceso para la AWS CLI](cli-chap-authentication.md).
+ El perfil que utilice debe tener permisos que permitan las operaciones que AWS realizó por los ejemplos.
+ Comprenda estos términos de Amazon S3:
+ **Bucket**: una carpeta de Amazon S3 de nivel superior.
+ **Prefijo**: una carpeta de Amazon S3 en un bucket.
+ **Objeto**: cualquier artículo alojado en un bucket de Amazon S3.
## Aplicación de una ACL personalizada
Con los comandos de alto nivel, puede utilizar la opción `--acl` para aplicar las listas de control de acceso (ACL) predefinidas en objetos de Amazon S3. Sin embargo, no puede usar ese comando para establecer ACL en todo el bucket. Sin embargo, puede hacerlo con el comando por API ```[put-bucket-acl](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-acl.html)`.
En el siguiente ejemplo se muestra cómo conceder control total a dos usuarios de AWS (*user1@example.com* y *user2@example.com*) y permisos de lectura a todos los usuarios. El identificador para "everyone" (todos) proviene de un URI especial que se pasa como parámetro.
```
$ aws s3api put-bucket-acl --bucket amzn-s3-demo-bucket --grant-full-control 'emailaddress="user1@example.com",emailaddress="user2@example.com"' --grant-read 'uri="http://acs.amazonaws.com/groups/global/AllUsers"'
```
Para obtener más información acerca de cómo construir las ACL, consulte [PUT Bucket acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTacl.html) en la *Referencia de la API de Amazon Simple Storage Service*. Los comandos ACL de `s3api` en la CLI, como `put-bucket-acl`, usan la misma [notación abreviada de argumentos](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-shorthand.html).
## Configuración de una política de registro
El comando de la API `put-bucket-logging` configura una política de registro del bucket.
En el siguiente ejemplo, se concede al usuario de AWS *user@example.com* control total sobre los archivos de registro, y todos los usuarios tendrán acceso de lectura a ellos. Tenga en cuenta que el comando `put-bucket-acl` también es necesario para conceder al sistema de entrega de registros de Amazon S3 (especificado por un URI) los permisos necesarios para leer y escribir los registros en el bucket.
```
$ aws s3api put-bucket-acl --bucket amzn-s3-demo-bucket --grant-read-acp 'URI="http://acs.amazonaws.com/groups/s3/LogDelivery"' --grant-write 'URI="http://acs.amazonaws.com/groups/s3/LogDelivery"'
$ aws s3api put-bucket-logging --bucket amzn-s3-demo-bucket --bucket-logging-status file://logging.json
```
El archivo `logging.json` del comando anterior contiene lo siguiente.
```
{
"LoggingEnabled": {
"TargetBucket": "amzn-s3-demo-bucket",
"TargetPrefix": "amzn-s3-demo-bucketLogs/",
"TargetGrants": [
{
"Grantee": {
"Type": "AmazonCustomerByEmail",
"EmailAddress": "user@example.com"
},
"Permission": "FULL_CONTROL"
},
{
"Grantee": {
"Type": "Group",
"URI": "http://acs.amazonaws.com/groups/global/AllUsers"
},
"Permission": "READ"
}
]
}
}
```
## Recursos
**AWS CLI referencia de:**
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-acl.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-acl.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-logging.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-logging.html)
**Referencia de servicio:**
+ [Uso de buckets de Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingBucket.html) en la *Guía del usuario de Amazon S3*
+ [Uso de objetos de Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingObjects.html) en la *Guía del usuario de Amazon S3*
+ [Listado jerárquico de las claves con un prefijo y un delimitador](https://docs.aws.amazon.com//AmazonS3/latest/userguide/ListingKeysHierarchy.html) en la *Guía del usuario de Amazon S3*
+ [Anulación de cargas multiparte a un bucket de S3 con AWS SDK para .NET (bajo nivel)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/LLAbortMPUnet.html) en la *Guía del usuario de Amazon S3*
# Ejemplo de scripts para el ciclo de vida para un bucket de Amazon S3 en la AWS CLI
En este tema se utiliza un ejemplo de scripting de Bash para las operaciones del ciclo de vida del bucket de Amazon S3 mediante la AWS Command Line Interface (AWS CLI). En este ejemplo de scripting se utiliza el conjunto de comandos de [https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html). Los scripts de shell son programas diseñados para ejecutarse en una interfaz de línea de comandos.
**Topics**
+ [Antes de comenzar](#cli-services-s3-lifecycle-example-before)
+ [Acerca de este ejemplo](#cli-services-s3-lifecycle-example-about)
+ [Archivos](#cli-services-s3-lifecycle-example-files)
+ [Referencias](#cli-services-s3-lifecycle-example-references)
## Antes de comenzar
Antes de que pueda ejecutar cualquiera de los siguientes ejemplos, se debe completar lo siguiente.
+ Instalar y configurar la AWS CLI. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de AWS CLI](getting-started-install.md), y [Credenciales de autenticación y acceso para la AWS CLI](cli-chap-authentication.md).
+ El perfil que utilice debe tener permisos que permitan las operaciones que AWS realizó por los ejemplos.
+ Como práctica recomendada de AWS, conceda a este código privilegios mínimos o solo los permisos necesarios para llevar a cabo una tarea. Para obtener más información, consulte [Concesión de mínimos privilegios](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) en la *Guía del usuario de IAM*.
+ Este código no se ha probado en todas las regiones de AWS. Algunos servicios de AWS solo están disponibles en regiones específicas. Para obtener más información, consulte [Puntos de enlace de servicio y cuotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) en la *Guía de referencia general de AWS*.
+ La ejecución de este código puede resultar en cargos en su cuenta de AWS. Es su responsabilidad asegurarse de que los recursos creados por este script se eliminen cuando haya terminado con ellos.
El servicio Amazon S3 utiliza los siguientes términos:
+ Bucket: una carpeta de Amazon S3 de nivel superior.
+ Prefijo: una carpeta de Amazon S3 en un bucket.
+ Objeto: cualquier artículo alojado en un bucket de Amazon S3.
## Acerca de este ejemplo
En este ejemplo se muestra cómo interactuar con algunas de las operaciones básicas de Amazon S3 mediante un conjunto de funciones en archivos de script de shell. Las funciones se encuentran en el archivo de script de shell llamado `bucket-operations.sh`. Puede llamar a estas funciones en otro archivo. Cada archivo de script contiene comentarios que describen cada una de las funciones.
Para ver los resultados intermedios de cada paso, ejecute el script con un parámetro `-i`. Para ver el estado actual del bucket o su contenido, puede usar la consola de Amazon S3. El scripting solo pasa al siguiente paso cuando se pulsa **Enter (Intro)** en el símbolo del sistema.
Para obtener el ejemplo completo y los archivos de script descargables, consulte [Operaciones del ciclo de vida de bucket de Amazon S3](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations) en el *Repositorio de ejemplos de código deAWS* en *GitHub*.
## Archivos
El ejemplo contiene los siguientes archivos:
**bucket-operations.sh**
Este archivo de script principal puede obtenerse de otro archivo. Incluye funciones que realizan las siguientes tareas:
+ Creación de un bucket y verificación de que existe
+ Copia de un archivo desde el equipo local a un bucket
+ Copia de un archivo desde una ubicación de bucket a otra ubicación de bucket
+ Listado de contenidos de un bucket
+ Eliminación a archivos desde un bucket
+ Eliminar un bucket
Vea el código de `[bucket-operations.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations/bucket_operations.sh)` en *GitHub*.
**test-bucket-operations.sh**
El archivo de script de shell `test-bucket-operations.sh` muestra cómo llamar a las funciones mediante el suministro de archivo `bucket-operations.sh` y el llamando a cada una de las funciones. Después de llamar a las funciones, el script de prueba elimina todos los recursos que creó.
Vea el código de `[test-bucket-operations.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations/test_bucket_operations.sh)` en *GitHub*.
**awsdocs-general.sh**
El archivo de script `awsdocs-general.sh` contiene funciones de uso general utilizadas en ejemplos de código avanzados para la AWS CLI.
Vea el código de `[awsdocs-general.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations/awsdocs_general.sh)` en *GitHub*.
## Referencias
**AWS CLI referencia de:**
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/create-bucket.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/create-bucket.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/copy-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/copy-object.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-bucket.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-bucket.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-object.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/head-bucket.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/head-bucket.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html)
**Otra referencia:**
+ [Uso de buckets de Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingBucket.html) en la *Guía del usuario de Amazon S3*
+ [Uso de objetos de Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingObjects.html) en la *Guía del usuario de Amazon S3*
+ Para ver y contribuir al AWS SDK y los ejemplos de código de AWS CLI, consulte el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/) en *GitHub*.
# Acceso a Amazon SNS en la AWS CLI
Puede acceder a las características de Amazon Simple Notification Service (Amazon SNS) a través de AWS Command Line Interface (AWS CLI). Para mostrar la lista de los comandos de AWS CLI para Amazon SNS, utilice el siguiente comando.
```
aws sns help
```
Antes de ejecutar los comandos, defina sus credenciales predeterminadas. Para obtener más información, consulte [Configuración de los ajustes de AWS CLI](cli-chap-configure.md).
En este tema se muestran ejemplos de comandos de la AWS CLI que realizan tareas comunes para Amazon SNS.
**Topics**
+ [Crear un tema](#cli-create-sns-topic)
+ [Suscripción a un tema](#cli-subscribe-sns-topic)
+ [Publicar en un tema](#cli-publish-sns-topic)
+ [Cancelación de la suscripción a un tema](#cli-unsubscribe-sns-topic)
+ [Eliminación de un tema](#cli-delete-sns-topic)
## Crear un tema
Para crear un tema, utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/sns/create-topic.html](https://docs.aws.amazon.com/cli/latest/reference/sns/create-topic.html) y especifique el nombre que desea asignar al tema.
```
$ aws sns create-topic --name my-topic
{
"TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
```
Anote el valor de `TopicArn` de la respuesta, que utilizará más adelante para publicar un mensaje.
## Suscripción a un tema
Para suscribirse a un tema, utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/sns/subscribe.html](https://docs.aws.amazon.com/cli/latest/reference/sns/subscribe.html).
En el siguiente ejemplo se especifica el protocolo `email` y una dirección de correo electrónico para el `notification-endpoint`.
```
$ aws sns subscribe --topic-arn arn:aws:sns:us-west-2:123456789012:my-topic --protocol email --notification-endpoint saanvi@example.com
{
"SubscriptionArn": "pending confirmation"
}
```
AWS envía inmediatamente un mensaje de confirmación a la dirección de correo electrónico que ha especificado en el comando `subscribe`. El mensaje de correo electrónico tiene este texto.
```
You have chosen to subscribe to the topic:
arn:aws:sns:us-west-2:123456789012:my-topic
To confirm this subscription, click or visit the following link (If this was in error no action is necessary):
Confirm subscription
```
Cuando el destinatario hace clic en el enlace **Confirm subscription (Confirmar suscripción)**, el navegador del destinatario muestra un mensaje de notificación con información similar a la siguiente.
```
Subscription confirmed!
You have subscribed saanvi@example.com to the topic:my-topic.
Your subscription's id is:
arn:aws:sns:us-west-2:123456789012:my-topic:1328f057-de93-4c15-512e-8bb22EXAMPLE
If it was not your intention to subscribe, click here to unsubscribe.
```
## Publicar en un tema
Para enviar un mensaje a todos los suscriptores de un tema, utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/sns/publish.html](https://docs.aws.amazon.com/cli/latest/reference/sns/publish.html).
En el siguiente ejemplo se envía el mensaje “Hola mundo” a todos los suscriptores del tema especificado.
```
$ aws sns publish --topic-arn arn:aws:sns:us-west-2:123456789012:my-topic --message "Hello World!"
{
"MessageId": "4e41661d-5eec-5ddf-8dab-2c867EXAMPLE"
}
```
En este ejemplo, AWS envía un mensaje de correo electrónico con el texto “Hola mundo” a `saanvi@example.com`.
## Cancelación de la suscripción a un tema
Para cancelar la suscripción a un tema y dejar de recibir los mensajes que se publican en él, utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/sns/unsubscribe.html](https://docs.aws.amazon.com/cli/latest/reference/sns/unsubscribe.html) y especifique el ARN del tema del que desea cancelar la suscripción.
```
$ aws sns unsubscribe --subscription-arn arn:aws:sns:us-west-2:123456789012:my-topic:1328f057-de93-4c15-512e-8bb22EXAMPLE
```
Para verificar que se ha cancelado la suscripción correctamente, utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/sns/list-subscriptions.html](https://docs.aws.amazon.com/cli/latest/reference/sns/list-subscriptions.html) para confirmar que el ARN ya no aparece en la lista.
```
$ aws sns list-subscriptions
```
## Eliminación de un tema
Para eliminar un tema, ejecute el comando [https://docs.aws.amazon.com/cli/latest/reference/sns/delete-topic.html](https://docs.aws.amazon.com/cli/latest/reference/sns/delete-topic.html).
```
$ aws sns delete-topic --topic-arn arn:aws:sns:us-west-2:123456789012:my-topic
```
Para verificar que AWS ha eliminado el tema correctamente, utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/sns/list-topics.html](https://docs.aws.amazon.com/cli/latest/reference/sns/list-topics.html) para confirmar que el tema ya no aparece en la lista.
```
$ aws sns list-topics
```