**Esta documentación es para la versión 1 de AWS CLI.** Anunciamos el próximo fin del soporte para la versión 1 de AWS CLI. Recomendamos migrarse a la versión 2 de AWS CLI. Para ver las fechas, los detalles adicionales y la información sobre cómo realizar la migración, consulte el [anuncio](https://aws.amazon.com/blogs/developer/cli-v1-maintenance-mode-announcement/). Para obtener documentación relacionada con la versión 2 de AWS CLI, consulte la [Guía del usuario de la versión 2](https://docs.aws.amazon.com/cli/latest/userguide/). # Especificación de valores de parámetros en la AWS CLI Muchos de los parámetros que se utilizan en AWS Command Line Interface (AWS CLI) son simples valores numéricos o de cadena, como el nombre del par de claves `my-key-pair` en el siguiente ejemplo de comando `aws ec2 create-key-pair`. ``` $ aws ec2 create-key-pair --key-name my-key-pair ``` El formato del comando puede variar entre terminales. Por ejemplo, la mayoría de los terminales distinguen entre mayúsculas y minúsculas, pero Powershell no distingue entre mayúsculas y minúsculas. Esto significa que los dos ejemplos de comandos siguientes arrojarían resultados diferentes para los terminales que distinguen entre mayúsculas y minúsculas, ya que ven `MyFile*.txt` y `myfile*.txt` como parámetros **diferentes**. Sin embargo, PowerShell procesaría estas solicitudes de la misma manera que ve `MyFile*.txt` y `myfile*.txt` como los **mismos** parámetros. En el siguiente ejemplo de comando se muestran estos parámetros con el comando `aws s3 cp`: ``` $ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "MyFile*.txt" $ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "myfile*.txt" ``` Para obtener más información sobre no distinguir entre mayúsculas y minúsculas de casos en PowerShell, consulte [about\$1Case-Sensitivity](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_case-sensitivity) en la *documentación de PowerShell*. A veces es necesario utilizar comillas o literales en las cadenas que incluyen caracteres especiales o de espacio. Las reglas en torno a este formato también pueden variar entre terminales. Para obtener más información sobre el uso de las comillas alrededor de parámetros complejos, consulte [Entrecomillado de cadenas y uso de literales en la AWS CLI](cli-usage-parameters-quoting-strings.md). En estos temas se tratan las reglas de formato de terminal más habituales. Si tiene problemas para que su terminal reconozca los valores de los parámetros, asegúrese de revisar los temas de esta sección y también de consultar la documentación del terminal para conocer sus reglas de sintaxis específicas. **Topics** + [Tipos de parámetros comunes en la AWS CLI](cli-usage-parameters-types.md) + [Entrecomillado de cadenas y uso de literales en la AWS CLI](cli-usage-parameters-quoting-strings.md) + [Carga de un parámetro de un archivo en la AWS CLI](cli-usage-parameters-file.md) + [Esqueletos de la AWS CLI y archivos de entrada en la AWS CLI](cli-usage-skeleton.md) + [Uso de la sintaxis abreviada en la AWS CLI](cli-usage-shorthand.md) # Tipos de parámetros comunes en la AWS CLI En esta sección, se describen algunos de los tipos de parámetros comunes y el formato requerido típico. Si tiene problemas con el formato de un parámetro para un comando específico, compruebe la ayuda escribiendo **help** después del nombre del comando. La ayuda de cada subcomando incluye el nombre y la descripción de una opción. El tipo de parámetro de la opción se muestra entre paréntesis. Para obtener más información acerca de obtener ayuda, consulte [Acceso a la ayuda y a los recursos para la AWS CLI](cli-usage-help.md). **Topics** + [Cadena](#parameter-type-string) + [Marca de tiempo](#parameter-type-timestamp) + [Enumeración](#parameter-type-list) + [Booleano](#parameter-type-boolean) + [Entero](#parameter-type-integer) + [Binario/blob (objeto binario grande) y blob en streaming](#parameter-type-blobs) + [Asignación](#parameter-type-map) + [Documento](#parameter-type-document) ## Cadena Los parámetros de cadena pueden contener caracteres alfanuméricos, símbolos y espacios en blanco del conjunto de caracteres [ASCII](https://wikipedia.org/wiki/ASCII). Las cadenas que contienen espacios en blanco se deben entrecomillar. Le recomendamos que no utilice símbolos ni espacios en blanco diferentes del carácter de espacio estándar, y que observe las [reglas de entrecomillado](cli-usage-parameters-quoting-strings.md) del terminal para evitar resultados inesperados. Algunos parámetros de cadena pueden aceptar datos binarios de un archivo. Consulte [Archivos binarios](cli-usage-parameters-file.md#cli-usage-parameters-file-binary) para ver un ejemplo. ## Marca de tiempo Las marcas temporales tienen un formato conforme a la norma [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html). A menudo se conocen como parámetros "`DateTime`" o "`Date`". ``` $ aws ec2 describe-spot-price-history --start-time 2014-10-13T19:00:00Z ``` Los formatos aceptados son: + *AAAA*-*MM*-*DD*T*hh*:*mm*:*ss.sss**TZD (UTC)*, por ejemplo, 2014-10-01T20:30:00.000Z + *AAAA*-*MM*-*DD*T*hh*:*mm*:*ss.sss**TZD (con compensación)*, por ejemplo, 2014-10-01T12:30:00.000-08:00 + *AAAA*:*MM*:*DD*, por ejemplo, 2014-10-01 + Hora Unix en segundos; por ejemplo, 1412195400. Esto es lo que a veces se denomina [fecha de inicio UNIX](https://wikipedia.org/wiki/Unix_time) y representa el número de segundos desde la medianoche del 1 de enero de 1970 UTC. Puede establecer el formato de la marca de tiempo con el ajuste de archivo `cli\$1timestamp\$1format`. ## Enumeración Una o varias cadenas separadas por espacios. Si cualquiera de los elementos de cadena contiene un espacio, debe escribir dicho elemento entre comillas. Observe las [normas de entrecomillado](cli-usage-parameters-quoting-strings.md) del terminal para evitar resultados inesperados ``` $ aws ec2 describe-spot-price-history --instance-types m1.xlarge m1.medium ``` ## Booleano Marcador binario que activa o desactiva una opción. Por ejemplo, `ec2 describe-spot-price-history` tiene con un parámetro `--dry-run` booleano que, cuando se especifica, valida la consulta con el servicio sin ejecutar realmente una consulta. ``` $ aws ec2 describe-spot-price-history --dry-run ``` El resultado indica si el comando tenía el formato correcto o no. Este comando también incluye una versión `--no-dry-run` del parámetro que puede utilizarse para indicar de forma explícita que el comando debe ejecutarse con normalidad, aunque no es necesario incluirlo, ya que este es el comportamiento predeterminado. ## Entero Un número entero sin firma. ``` $ aws ec2 describe-spot-price-history --max-items 5 ``` ## Binario/blob (objeto binario grande) y blob en streaming En la AWS CLI, puede pasar un valor binario como una cadena directamente en la línea de comandos. Existen dos tipos de blobs: + [Blob](#parameter-type-blob) + [Blob de streaming](#parameter-type-streaming-blob) ### Blob Para pasar un valor a un parámetro con el tipo `blob`, debe especificar una ruta a un archivo local que contenga los datos binarios mediante el prefijo `fileb://`. Los archivos a los que se hace referencia mediante el prefijo `fileb://` siempre se tratan como binarios sin codificar. La ruta especificada se interpreta como una ruta relativa al directorio de trabajo actual. Por ejemplo, el parámetro `--plaintext` para `aws kms encrypt` es un blob. ``` $ aws kms encrypt \ --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \ --plaintext fileb://ExamplePlaintextFile \ --output text \ --query CiphertextBlob | base64 \ --decode > ExampleEncryptedFile ``` ### Blob de streaming Los blobs de streaming como `aws cloudsearchdomain upload-documents` no utilizan prefijos. En cambio, los parámetros de blob de streaming se formatean mediante la ruta de archivo directa. En el siguiente ejemplo se utiliza la ruta de archivo directa `document-batch.json` para el comando `aws cloudsearchdomain upload-documents`: ``` $ aws cloudsearchdomain upload-documents \ --endpoint-url https://doc-my-domain.us-west-1.cloudsearch.amazonaws.com \ --content-type application/json \ --documents document-batch.json ``` ## Asignación Un conjunto de pares de clave-valor especificado en JSON o mediante la [sintaxis abreviada](cli-usage-shorthand.md) de la CLI. En el siguiente ejemplo de JSON, se lee un elemento de una tabla de Amazon DynamoDB denominada *my-table* con un parámetro de mapa, `--key`. El parámetro especifica la clave principal denominada *id* con un valor numérico de *1* en una estructura JSON anidada. Para conocer un uso más avanzado de JSON en una línea de comandos, considere usar un procesador JSON de línea de comandos, como`jq`, para crear cadenas JSON. Para obtener más información sobre `jq`, consulte el [repositorio jq](http://stedolan.github.io/jq/) en *GitHub*. ``` $ aws dynamodb get-item --table-name my-table --key '{"id": {"N":"1"}}' { "Item": { "name": { "S": "John" }, "id": { "N": "1" } } } ``` ## Documento **nota** La [sintaxis abreviada](cli-usage-shorthand.md) no es compatible con los tipos de documento. Los tipos de documento se utilizan para enviar datos sin necesidad de integrar JSON‎ dentro de cadenas. El tipo de documento permite a los servicios proporcionar esquemas arbitrarios para que utilice tipos de datos más flexibles. Esto permite enviar datos JSON sin necesidad de valores de escape. Por ejemplo, en lugar de utilizar la siguiente entrada JSON de escape: ``` {"document": "{\"key\":true}"} ``` Puede utilizar el tipo de documento que se muestra a continuación: ``` {"document": {"key": true}} ``` ### Valores válidos para tipos de documentos Debido a la naturaleza flexible de los tipos de documentos, existen varios tipos de valores válidos. Entre los valores válidos se incluyen los siguientes: **Cadena** ``` --option '"value"' ``` **Número** ``` --option 123 --option 123.456 ``` **Booleano** ``` --option true ``` **Nulo** ``` --option null ``` **Matriz** ``` --option '["value1", "value2", "value3"]' --option '["value", 1, true, null, ["key1", 2.34], {"key2": "value2"}]' ``` **Objeto** ``` --option '{"key": "value"}' --option '{"key1": "value1", "key2": 123, "key3": true, "key4": null, "key5": ["value3", "value4"], "key6": {"value5": "value6"}' ``` # Entrecomillado de cadenas y uso de literales en la AWS CLI Hay dos maneras principales en las que se usan comillas simples y dobles en el AWS CLI. + [Usar comillas alrededor de cadenas que contienen espacios en blanco](#cli-usage-parameters-quoting-strings-around) + [Uso de comillas dentro de cadenas](#cli-usage-parameters-quoting-strings-containing) ## Usar comillas alrededor de cadenas que contienen espacios en blanco Los nombres de los parámetros y sus valores están separados por espacios en la línea de comandos. Si un valor de cadena contiene un espacio incrustado, debe rodear toda la cadena con comillas para evitar que la AWS CLI malinterprete el espacio como un divisor entre el valor y el siguiente nombre del parámetro. El tipo de comillas que utilice depende del sistema operativo en el que esté ejecutando la AWS CLI. ------ #### [ Linux and macOS ] Uso de comillas simples `' '` ``` $ aws ec2 create-key-pair --key-name 'my key pair' ``` Para obtener más información sobre el uso de las comillas, consulte documentación del usuario de su shell preferido. ------ #### [ PowerShell ] **Comillas simples (recomendadas)** Las marcas de comillas simples `' '` se llaman cadenas `verbatim`. La cadena se pasa al comando exactamente como se escribe, lo que significa que las variables de PowerShell no pasarán. ``` PS C:\> aws ec2 create-key-pair --key-name 'my key pair' ``` **Comillas dobles** Las marcas de comillas dobles `" "` se llaman cadenas `expandable`. Las variables se pueden pasar en cadenas expandibles. ``` PS C:\> aws ec2 create-key-pair --key-name "my key pair" ``` Para obtener más información sobre el uso de las comillas, consulte [Acerca de las reglas de entrecomillado](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) en los *Documentos de Microsoft PowerShell*. ------ #### [ Windows command prompt ] Uso de comillas dobles `" "` . ``` C:\> aws ec2 create-key-pair --key-name "my key pair" ``` ------ Si lo desea, puede separar el nombre del parámetro del valor con un signo de igual `=` en lugar de un espacio. Normalmente, esto solo es necesario si el valor del parámetro comienza con un guion. ``` $ aws ec2 delete-key-pair --key-name=-mykey ``` ## Uso de comillas dentro de cadenas Las cadenas pueden contener comillas y el shell puede requerir comillas de cierre para que funcionen correctamente. Uno de los tipos de valor de parámetro comunes es una cadena JSON. Esto es complejo, ya que incluye espacios y comillas dobles `" "` alrededor de cada nombre de elemento y valor en la estructura JSON. El modo en que introduzca parámetros con formato JSON en la línea de comandos varía en función de su sistema operativo. Para conocer un uso más avanzado de JSON en la línea de comandos, considere usar un procesador JSON de línea de comandos, como`jq`, para crear cadenas JSON. Para obtener más información sobre `jq`, consulte el [repositorio jq](http://stedolan.github.io/jq/) en *GitHub*. ------ #### [ Linux and macOS ] Para que Linux y macOS interpreten cadenas en forma literal, use comillas simples `' '` para entrecomillar la estructura de datos JSON, como en el siguiente ejemplo. No necesita cerrar las comillas dobles incrustadas en la cadena JSON, ya que se las trata de manera literal. Dado que la cadena JSON está encerrada entre comillas simples, se deberá cerrar cualquier comilla simple en la cadena. Esto generalmente se logra usando una barra diagonal inversa antes de la comilla simple `\'`. ``` $ aws ec2 run-instances \ --image-id ami-12345678 \ --block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]' ``` Para obtener más información sobre el uso de las comillas, consulte documentación del usuario de su shell preferido. ------ #### [ PowerShell ] Utilice comillas simples `' '` o comillas dobles `" "`. **Comillas simples (recomendadas)** Las marcas de comillas simples `' '` se llaman cadenas `verbatim`. La cadena se pasa al comando exactamente como se escribe, lo que significa que las variables de PowerShell no pasarán. Dado que las estructuras de datos JSON incluyen comillas dobles, sugerimos comillas **simples** `' '` para encerrarlas. Si usa comillas **simples**, no necesita cerrar las comillas **dobles** incrustadas en la cadena JSON. Sin embargo, debe cerrar cada comilla **simple** con una tilde invertido ``` dentro de la estructura JSON. ``` PS C:\> aws ec2 run-instances ` --image-id ami-12345678 ` --block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]' ``` **Comillas dobles** Las marcas de comillas dobles `" "` se llaman cadenas `expandable`. Las variables se pueden pasar en cadenas expandibles. Si usa comillas **dobles**, no necesita cerrar las comillas **simples** incrustadas en la cadena JSON. Sin embargo, debe cerrar cada comilla **doble** con un acento grave ``` dentro de la estructura JSON, como con el siguiente ejemplo. ``` PS C:\> aws ec2 run-instances ` --image-id ami-12345678 ` --block-device-mappings "[{`"DeviceName`":`"/dev/sdb`",`"Ebs`":{`"VolumeSize`":20,`"DeleteOnTermination`":false,`"VolumeType`":`"standard`"}}]" ``` Para obtener más información sobre el uso de las comillas, consulte [Acerca de las reglas de entrecomillado](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) en los *Documentos de Microsoft PowerShell*. **aviso** Antes de que PowerShell envíe un comando a la AWS CLI, determina si su comando se interpreta usando PowerShell típico o reglas de entrecomillado de `CommandLineToArgvW`. Cuando PowerShell procesa mediante `CommandLineToArgvW`, deben escaparse los caracteres con una barra invertida `\`. Para obtener más información sobre `CommandLineToArgvW` en PowerShell, consulte [¿Qué pasa con el extraño tratamiento de comillas y barras invertidas por CommandLineToArgVW?](https://devblogs.microsoft.com/oldnewthing/20100917-00/?p=12833) en *Microsoft DevBlogs*, [Todos citan los argumentos de la línea de comandos de forma incorrecta](https://docs.microsoft.com/en-us/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way) en *Microsoft Docs Blog* y[Función CommandLineToArgVW](https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-commandlinetoargvw#remarks) en los *Documentos de Microsoft*. **Comillas simples** Las marcas de comillas simples `' '` se llaman cadenas `verbatim`. La cadena se pasa al comando exactamente como se escribe, lo que significa que las variables de PowerShell no pasarán. Los caracteres se escapan con una barra invertida`\`. ``` PS C:\> aws ec2 run-instances ` --image-id ami-12345678 ` --block-device-mappings '[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]' ``` **Comillas dobles** Las marcas de comillas dobles `" "` se llaman cadenas `expandable`. Las variables se pueden pasar en cadenas `expandable`. Para cadenas con comillas dobles, tiene que escapar dos veces usando *`\$1* para cada comilla en lugar de usar solo un signo de acento. La barra invertida escapa la barra invertida y, a continuación, la barra invertida se utiliza como un carácter de escape para proceso `CommandLineToArgvW`. ``` PS C:\> aws ec2 run-instances ` --image-id ami-12345678 ` --block-device-mappings "[{`\"DeviceName`\":`\"/dev/sdb`\",`\"Ebs`\":{`\"VolumeSize`\":20,`\"DeleteOnTermination`\":false,`\"VolumeType`\":`\"standard`\"}}]" ``` **Blobs (recomendado)** Para omitir las reglas de entrecomillado de PowerShell para la entrada de datos JSON, use Blobs para pasar los datos JSON directamente a la AWS CLI. Para obtener más información acerca de Blobs, consulte o [Blob](cli-usage-parameters-types.md#parameter-type-blob). ------ #### [ Windows command prompt ] El símbolo del sistema de Windows requiere comillas dobles `" "` para entrecomillar la estructura de datos JSON. Además, para evitar que el procesador de comandos malinterprete las comillas dobles incrustadas en el JSON, también debe cerrar (precedido por un carácter de barra invertida `\`) cada comilla doble `"` dentro de la propia estructura de datos JSON, como en el siguiente ejemplo. ``` C:\> aws ec2 run-instances ^ --image-id ami-12345678 ^ --block-device-mappings "[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]" ``` El único caso en el que no se utiliza el carácter de cierre es con las comillas dobles de los extremos. ------ # Carga de un parámetro de un archivo en la AWS CLI Algunos parámetros esperan nombres de archivo como argumentos, desde los que la AWS CLI carga los datos. Otros parámetros le permiten especificar el valor del parámetro como texto escrito en la línea de comandos o leído de un archivo. Tanto si un archivo es obligatorio como si es opcional, debe codificarlo correctamente para que la AWS CLI pueda entenderlo. La codificación del archivo debe coincidir con la configuración regional predeterminada del sistema de lectura. Esto se puede determinar utilizando el método Python `locale.getpreferredencoding()`. Este método sirve para cargar un archivo para un único parámetro. Para obtener información sobre la carga de varios parámetros con un único archivo, consulte [Esqueletos de la AWS CLI y archivos de entrada en la AWS CLI](cli-usage-skeleton.md). **nota** De forma predeterminada, Windows PowerShell genera texto como UTF-16, lo que está en conflicto con la codificación UTF-8 utilizada por archivos JSON y muchos sistemas Linux. Le recomendamos que utilice `-Encoding ascii` con los comandos `Out-File` de PowerShell para asegurarse de que la AWS CLI puede leer el archivo resultante. **Topics** + [Cómo cargar un parámetro de un archivo](#cli-usage-parameters-file-how) + [Archivos binarios](#cli-usage-parameters-file-binary) + [Archivos remotos](#cli-usage-parameters-file-remote) + [Carga de un archivo como un valor sintáctico abreviado](#cli-usage-parameters-file-shorthand) ## Cómo cargar un parámetro de un archivo En ocasiones, resulta conveniente cargar el valor de un parámetro desde un archivo en lugar de intentar escribirlo como un valor de parámetro de la línea de comandos, como, por ejemplo, cuando el parámetro es una cadena JSON compleja. Para especificar un archivo que contenga el valor, especifique la URL del archivo con el siguiente formato. ``` file://complete/path/to/file ``` + Los dos primeros caracteres de barra inclinada "/" forman parte de la especificación. Si la ruta requerida comienza con '/', el resultado será tres caracteres de barra inclinada: `file:///folder/file`. + La dirección URL proporciona la ruta al archivo que incluye el contenido del parámetro real. + Cuando se utilizan archivos con espacios o caracteres especiales, siga las [normas de escape y entrecomillado](cli-usage-parameters-quoting-strings.md) para el terminal. **nota** Este comportamiento se deshabilita de forma automática en los parámetros que ya esperan una URL, como el parámetro que identifica una URL de plantilla de CloudFormation. También puede desactivar este comportamiento desactivando la ‎configuración de [`cli_follow_urlparam`](cli-configure-files.md#cli-config-cli_follow_urlparam) en el archivo de ‎configuración de ‎AWS CLI. Las rutas de archivo en los siguientes ejemplos se interpretan como rutas relativas al directorio de trabajo actual. ------ #### [ Linux or macOS ] ``` // Read from a file in the current directory $ aws ec2 describe-instances --filters file://filter.json // Read from a file in /tmp $ aws ec2 describe-instances --filters file:///tmp/filter.json // Read from a file with a filename with whitespaces $ aws ec2 describe-instances --filters 'file://filter content.json' ``` ------ #### [ Windows command prompt ] ``` // Read from a file in C:\temp C:\> aws ec2 describe-instances --filters file://C:\temp\filter.json // Read from a file with a filename with whitespaces C:\> aws ec2 describe-instances --filters "file://C:\temp\filter content.json" ``` ------ La opción de prefijo `file://` admite ampliaciones tipo Unix, incluidas "`~/`", "`./`" y "`../`". En Windows, la expresión "`~/`" se amplía a su directorio de usuarios, guardado en la variable de entorno `%USERPROFILE%`. Por ejemplo, en Windows 10 normalmente tendría un directorio de usuarios en `%USERPROFILE%`. Debe añadir el carácter de escape a los documentos JSON que están integrados como valor de otro documento JSON. ``` $ aws sqs create-queue --queue-name my-queue --attributes file://attributes.json ``` **attributes.json** ``` { "RedrivePolicy": "{\"deadLetterTargetArn\":\"arn:aws:sqs:us-west-2:0123456789012:deadletter\", \"maxReceiveCount\":\"5\"}" } ``` ## Archivos binarios Para los comandos que toman datos binarios como un parámetro, especifique que los datos son contenido binario utilizando el prefijo `fileb://`. Los comandos que aceptan datos binarios son: + **`aws ec2 run-instances:`** `--user-data` parámetro . + **`aws s3api put-object:`** `--sse-customer-key` parámetro . + **`aws kms decrypt:`** `--ciphertext-blob` parámetro . En el siguiente ejemplo, se genera una clave AES binaria de 256 bits utilizando una herramienta de línea de comandos de Linux y después se proporciona dicha clave a Amazon S3 para cifrar un archivo cargado en el lado del servidor. ``` $ dd if=/dev/urandom bs=1 count=32 > sse.key 32+0 records in 32+0 records out 32 bytes (32 B) copied, 0.000164441 s, 195 kB/s $ aws s3api put-object \ --bucket amzn-s3-demo-bucket \ --key test.txt \ --body test.txt \ --sse-customer-key fileb://sse.key \ --sse-customer-algorithm AES256 { "SSECustomerKeyMD5": "iVg8oWa8sy714+FjtesrJg==", "SSECustomerAlgorithm": "AES256", "ETag": "\"a6118e84b76cf98bf04bbe14b6045c6c\"" } ``` ## Archivos remotos La AWS CLI también permite cargar parámetros desde un archivo ubicado en Internet con una URL `http://` o `https://`. En el siguiente ejemplo, se hace referencia a un archivo almacenado en un bucket Amazon S3. Esto le permite obtener acceso a archivos de parámetros desde cualquier equipo, pero requiere que el contenedor sea de acceso público. ``` $ aws ec2 run-instances \ --image-id ami-12345678 \ --block-device-mappings http://amzn-s3-demo-bucket.s3.amazonaws.com/filename.json ``` En el ejemplo anterior se presupone que el archivo `filename.json` contiene los siguientes datos JSON. ``` [ { "DeviceName": "/dev/sdb", "Ebs": { "VolumeSize": 20, "DeleteOnTermination": false, "VolumeType": "standard" } } ] ``` Por ver otro ejemplo que haga referencia a un archivo que contenga parámetros con formato JSON, consulte [Asociación de una política administrada de IAM a un usuario](cli-services-iam.md#cli-services-iam-policy). ## Carga de un archivo como un valor sintáctico abreviado Cuando se utiliza una sintaxis abreviada en la que un valor es grande o complejo, suele ser más fácil cargarlo en un archivo como un valor. Para cargar un archivo como un valor sintáctico abreviado, el formato cambiará ligeramente. En lugar de `key=value`, usará el operador `@=`, en lugar del operador `=`. El valor `@=` se refiere a la AWS CLI que el valor se debe leer como una ruta de archivo y no como una cadena. En el siguiente ejemplo se muestra un par clave-valor que carga un archivo por su valor. ------ #### [ Linux or macOS ] ``` --option key@=file://template.txt ``` ------ #### [ Windows ] ``` --option "key1@=file://template.txt" ``` ------ En el siguiente ejemplo, se muestra la carga de un archivo de certificado para el comando `aws rolesanywhere create-trust-anchor`. ``` $ aws rolesanywhere create-trust-anchor --name TrustAnchor \ --source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \ --enabled ``` Para obtener más información sobre la sintaxis abreviada, consulte [Uso de la sintaxis abreviada en la AWS CLI](cli-usage-shorthand.md). # Esqueletos de la AWS CLI y archivos de entrada en la AWS CLI La mayoría de los comandos de la AWS CLI aceptan la importación de las entradas de parámetros de un archivo. Estas plantillas se pueden generar con la opción `generate-cli-skeleton` y, a continuación, se pueden importar con los parámetros `--cli-input-json`. **Topics** + [Sobre esqueletos y archivos de ‎entrada de AWS CLI](#cli-usage-skeleton-about) + [Generación e importación de un esqueleto de comandos](#cli-usage-skeleton-generate) + [Combinación de archivos de entrada y parámetros de línea de comandos](#cli-usage-skeleton-combine) ## Sobre esqueletos y archivos de ‎entrada de AWS CLI ‎La mayoría de los comandos de AWS Command Line Interface (AWS CLI) pueden aceptar las entradas de parámetros desde un archivo con los parámetros ‎`--cli-input-json`. Esos mismos comandos usan el parámetro `--generate-cli-skeleton` para generar un archivo en formato JSON con todos los parámetros que pueda editar y completar. ‎A continuación, puede ejecutar el comando con el parámetro `--cli-input-json` y apuntar al archivo cumplimentado. **importante** Los comandos de la AWS CLI personalizados, como los [comandos `aws s3`](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) no admiten los parámetros `--generate-cli-skeleton` o `--cli-input-json` descritos en este tema. Para comprobar si un comando específico admite estos parámetros, ejecute el [comando `help`](cli-usage-help.md#cli-usage-help-command) correspondiente al comando que desee utilizar o consulte la [guía de referencia de la versión 1 de AWS CLI](https://docs.aws.amazon.com/cli/v1/reference/). `--generate-cli-skeleton` genera y muestra una plantilla de parámetros que puede personalizar y utilizar como entrada en un comando. La plantilla generada incluye todos los parámetros que admite el comando. El parámetro `--generate-cli-skeleton` acepta uno de los siguientes valores: + `input`: la plantilla generada incluye todos los parámetros de entrada formateados como JSON. Este es el valor predeterminado. + `output` – la plantilla generada incluye todos los parámetros de salida formateados como JSON. Como la AWS CLI es esencialmente un "encapsulador" de la API del servicio, el archivo de esqueleto espera que el usuario haga referencia a todos los parámetros utilizando los nombres de parámetro de la API subyacente. Es probable que este nombre sea distinto al nombre del parámetro de la AWS CLI. Por ejemplo, un parámetro de la AWS CLI llamado `user-name` podría corresponderse con un parámetro de la API de servicio de AWS llamado `UserName` (observe cómo se usan las mayúsculas y que falta un guion). Le recomendamos que utilice la opción `--generate-cli-skeleton` para generar la plantilla con los nombres de parámetros "correctos" con el fin de evitar errores. Puede hacer referencia a la Guía de referencia de la API del servicio para ver los nombres de los parámetros esperados. Puede eliminar cualquier parámetro de la plantilla que no sea necesario y para el que no desee proporcionar un valor. Por ejemplo, si ejecuta el siguiente comando, se genera la plantilla de parámetros para el comando Amazon Elastic Compute Cloud (Amazon EC2) **run-instances**. ------ #### [ JSON ] En el siguiente ejemplo, se muestra cómo se genera una plantilla con formato JSON utilizando el valor predeterminado (`input`) en el parámetro `--generate-cli-skeleton`. ``` $ aws ec2 run-instances --generate-cli-skeleton ``` ``` { "DryRun": true, "ImageId": "", "MinCount": 0, "MaxCount": 0, "KeyName": "", "SecurityGroups": [ "" ], "SecurityGroupIds": [ "" ], "UserData": "", "InstanceType": "", "Placement": { "AvailabilityZone": "", "GroupName": "", "Tenancy": "" }, "KernelId": "", "RamdiskId": "", "BlockDeviceMappings": [ { "VirtualName": "", "DeviceName": "", "Ebs": { "SnapshotId": "", "VolumeSize": 0, "DeleteOnTermination": true, "VolumeType": "", "Iops": 0, "Encrypted": true }, "NoDevice": "" } ], "Monitoring": { "Enabled": true }, "SubnetId": "", "DisableApiTermination": true, "InstanceInitiatedShutdownBehavior": "", "PrivateIpAddress": "", "ClientToken": "", "AdditionalInfo": "", "NetworkInterfaces": [ { "NetworkInterfaceId": "", "DeviceIndex": 0, "SubnetId": "", "Description": "", "PrivateIpAddress": "", "Groups": [ "" ], "DeleteOnTermination": true, "PrivateIpAddresses": [ { "PrivateIpAddress": "", "Primary": true } ], "SecondaryPrivateIpAddressCount": 0, "AssociatePublicIpAddress": true } ], "IamInstanceProfile": { "Arn": "", "Name": "" }, "EbsOptimized": true } ``` ------ ## Generación e importación de un esqueleto de comandos **Para generar y utilizar un archivo de esqueleto de parámetros** 1. ‎Ejecute el comando con el pa‎rámetro `--generate-cli-skeleton` para producir JSON y dirigirla a un archivo para guardarla. ------ #### [ JSON ] ``` $ aws ec2 run-instances --generate-cli-skeleton input > ec2runinst.json ``` ------ 1. Abra el archivo de esqueleto de parámetros en el editor de texto y quite todos los parámetros que no necesite. Por ejemplo, puede reducir la plantilla hasta dejarla tal y como se muestra a continuación. Confirme que el código JSON del archivo sigue siendo válido después de eliminar los elementos que no necesita. ------ #### [ JSON ] ``` { "DryRun": true, "ImageId": "", "KeyName": "", "SecurityGroups": [ "" ], "InstanceType": "", "Monitoring": { "Enabled": true } } ``` ------ En este ejemplo, dejamos el parámetro `DryRun` establecido en `true` para utilizar la característica “dry run” (simulacro) de Amazon EC2. Esta característica le permite probar el comando de forma segura sin crear ni modificar ningún recurso. 1. Rellene los valores restantes con valores adecuados para su escenario. En este ejemplo, proporcionamos el tipo de instancia, el nombre de la clave, el grupo de seguridad y el identificador de Amazon Machine Image (AMI) que vamos a utilizar. En este ejemplo, se asume la Región de AWS predeterminada. La AMI `ami-dfc39aef` es una imagen de Amazon Linux de 64 bits alojada en la región `us-west-2`. Si utiliza una región diferente, debe [encontrar el ID apropiado de la AMI que desea utilizar](https://aws.amazon.com/amazon-linux-ami/). ------ #### [ JSON ] ``` { "DryRun": true, "ImageId": "ami-dfc39aef", "KeyName": "mykey", "SecurityGroups": [ "my-sg" ], "InstanceType": "t2.micro", "Monitoring": { "Enabled": true } } ``` ------ 1. Ejecute el comando con los parámetros completados pasando el archivo de plantilla relleno al parámetro `--cli-input-json` al utilizar ‎el prefijo `file://`. La AWS CLI interpreta la ruta como relativa al directorio de trabajo actual. En el siguiente ejemplo, la AWS CLI busca el archivo en el directorio de trabajo actual. ------ #### [ JSON ] ``` $ aws ec2 run-instances --cli-input-json file://ec2runinst.json ``` ``` A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set. ``` ------ El error del simulacro indica que el código JSON está formado correctament‎e y que los valores de los parámetros son válidos. Si se informa de cualquier otro problema en la salida, corríjalo y repita el paso anterior hasta que aparezca el mensaje "`Request would have succeeded`". 1. Ahora puede establecer el parámetro `DryRun` en `false` para deshabilitar el simulacro. ------ #### [ JSON ] ``` { "DryRun": false, "ImageId": "ami-dfc39aef", "KeyName": "mykey", "SecurityGroups": [ "my-sg" ], "InstanceType": "t2.micro", "Monitoring": { "Enabled": true } } ``` ------ 1. Ejecute el comando para que `run-instances` lance una instancia de Amazon EC2 y muestre los detalles que se generan cuando el lanzamiento se realiza correctamente. El parámetro `--output` controla el formato de salida, independientemente del formato de la plantilla de parámetros de entrada. ------ #### [ JSON ] ``` $ aws ec2 run-instances --cli-input-json file://ec2runinst.json --output json ``` ``` { "OwnerId": "123456789012", "ReservationId": "r-d94a2b1", "Groups": [], "Instances": [ ... ``` ------ ## Combinación de archivos de entrada y parámetros de línea de comandos Se puede usar un archivo de entrada para todos los parámetros o se puede combinar con los parámetros especificados en la AWS CLI. Puede utilizar esta característica para los ajustes que reutiliza con frecuencia en un archivo de entrada y, al mismo tiempo, conservar los ajustes individuales en el propio comando. En los siguientes ejemplos de `aws ec2 run-instances`, se combinan el uso de un archivo de entrada y parámetros. Proporcionamos el tipo de instancia, el nombre de la clave, el grupo de seguridad y el identificador de la imagen de máquina de Amazon (AMI) que se va a utilizar y se asume la Región de AWS predeterminada. La AMI `ami-dfc39aef` es una imagen de Amazon Linux de 64 bits alojada en la región `us-west-2`. Si utiliza una región diferente, debe [encontrar el ID apropiado de la AMI que desea utilizar](https://aws.amazon.com/amazon-linux-ami/). ------ #### [ JSON ] Contenido del archivo JSON: ``` { "ImageId": "ami-dfc39aef", "KeyName": "mykey", "SecurityGroups": [ "my-sg" ], "InstanceType": "t2.micro", "Monitoring": { "Enabled": true } } ``` ------ En el siguiente ejemplo, se utiliza el archivo de entrada en combinación con el parámetro `--dry-run` para realizar una actualización de prueba del comando para confirmar si tiene los permisos necesarios y si ha rellenado el archivo con valores válidos. ------ #### [ JSON ] ``` $ aws ec2 run-instances --cli-input-json file://ec2runinst.json --dry-run ``` ``` A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set. ``` ------ A continuación, en el siguiente ejemplo se utiliza el mismo archivo de entrada, pero con el parámetro `--no-dry-run` para ejecutar el comando en su totalidad. ------ #### [ JSON ] ``` $ aws ec2 run-instances --cli-input-json file://ec2runinst.json --no-dry-run --output json ``` ``` { "OwnerId": "123456789012", "ReservationId": "r-d94a2b1", "Groups": [], "Instances": [ ... ``` ------ # Uso de la sintaxis abreviada en la AWS CLI La AWS Command Line Interface (AWS CLI) puede aceptar muchos de sus parámetros de opciones en formato JSON. Sin embargo, resultaría tedioso escribir largas listas o estructuras de JSON en la línea de comandos. Para simplificarlo, la AWS CLI también admite una sintaxis abreviada que permite una representación de los parámetros de opciones más sencilla que si se usara el formato JSON íntegro. **Topics** + [Parámetros de estructura con pares clave-valor](#shorthand-structure-parameters) + [Carga de un archivo como un valor sintáctico abreviado](#shorthand-files) + [Uso de sintaxis abreviada con la AWS CLI](#shorthand-list-parameters) ## Parámetros de estructura con pares clave-valor La sintaxis abreviada de la AWS CLI facilita a los usuarios la introducción de parámetros planos (con estructuras no anidadas). El formato consiste en una lista de pares de clave-valor separados por comas. Asegúrese de utilizar las reglas de [comillas](cli-usage-parameters-quoting-strings.md) y caracteres de escape apropiadas para el terminal como sintaxis abreviada son cadenas. ------ #### [ Linux or macOS ] ``` --option key1=value1,key2=value2,key3=value3 ``` Equivale al siguiente ejemplo con formato JSON. ``` --option '{"key1":"value1","key2":"value2","key3":"value3"}' ``` ------ #### [ Windows ] ``` --option "key1=value1,key2=value2,key3=value3" ``` Equivale al siguiente ejemplo con formato JSON. ``` --option '{"key1":"value1","key2":"value2","key3":"value3"}' ``` ------ No debe haber espacios en blanco entre cada uno de los pares de clave-valor separados por comas. A continuación, se muestra un ejemplo del comando de `update-table` de Amazon DynamoDB con la opción `--provisioned-throughput` especificada en modo abreviado. ``` $ aws dynamodb update-table \ --provisioned-throughput ReadCapacityUnits=15,WriteCapacityUnits=10 \ --table-name MyDDBTable ``` Esto equivale al siguiente ejemplo con formato JSON. ``` $ aws dynamodb update-table \ --provisioned-throughput '{"ReadCapacityUnits":15,"WriteCapacityUnits":10}' \ --table-name MyDDBTable ``` ## Carga de un archivo como un valor sintáctico abreviado Cuando un valor es grande o complejo, suele ser más fácil cargarlo en un archivo como un valor. Para cargar un archivo como un valor sintáctico abreviado, el formato cambiará ligeramente. En lugar de `key=value`, usará el operador `@=`, en lugar del operador `=`. El valor `@=` se refiere a la AWS CLI que el valor se debe leer como una ruta de archivo y no como una cadena. Al cargar archivos en una sintaxis abreviada, [se aplican las reglas de formato de archivo de la AWS CLI](cli-usage-parameters-file.md) habituales. En el siguiente ejemplo, se muestra un par clave-valor que carga un archivo por su valor. ------ #### [ Linux or macOS ] ``` --option key@=file://template.txt ``` ------ #### [ Windows ] ``` --option "key1@=file://template.txt" ``` ------ En el siguiente ejemplo, se muestra la carga de un archivo de certificado para el comando `aws rolesanywhere create-trust-anchor`. ``` $ aws rolesanywhere create-trust-anchor --name TrustAnchor \ --source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \ --enabled ``` ## Uso de sintaxis abreviada con la AWS CLI Puede especificar los parámetros de entrada en una lista de dos formas: en JSON o en sintaxis abreviada. La sintaxis abreviada de la AWS CLI ha sido diseñada para que su inserción en listas con números, cadenas o estructuras no anidadas resulte más sencilla. A continuación se muestra el formato básico, en el que los valores de la lista están separados por un único espacio. ``` --option value1 value2 value3 ``` Esto equivale al siguiente ejemplo con formato JSON. ``` --option '[value1,value2,value3]' ``` Como ya hemos mencionado anteriormente, puede especificar una lista de números, una lista de cadenas o una lista de estructuras no anidadas en formato abreviado. A continuación, se muestra un ejemplo del comando `stop-instances` para Amazon Elastic Compute Cloud (Amazon EC2), en el que el parámetro de entrada (lista de cadenas) de la opción `--instance-ids` se especifica en forma abreviada. ``` $ aws ec2 stop-instances \ --instance-ids i-1486157a i-1286157c i-ec3a7e87 ``` Esto equivale al siguiente ejemplo con formato JSON. ``` $ aws ec2 stop-instances \ --instance-ids '["i-1486157a","i-1286157c","i-ec3a7e87"]' ``` En el siguiente ejemplo se muestra el comando de `create-tags` de Amazon EC2, que toma una lista de estructuras no anidadas para la opción `--tags`. La opción `--resources` especifica el identificador de la instancia que debe etiquetarse. ``` $ aws ec2 create-tags \ --resources i-1286157c \ --tags Key=My1stTag,Value=Value1 Key=My2ndTag,Value=Value2 Key=My3rdTag,Value=Value3 ``` Esto equivale al siguiente ejemplo con formato JSON. El parámetro JSON está escrito en varias líneas para facilitar su lectura. ``` $ aws ec2 create-tags \ --resources i-1286157c \ --tags '[ {"Key": "My1stTag", "Value": "Value1"}, {"Key": "My2ndTag", "Value": "Value2"}, {"Key": "My3rdTag", "Value": "Value3"} ]' ```