# Especificar valores de parâmetro na AWS CLI
Muitos parâmetros usados na AWS Command Line Interface (AWS CLI) são strings ou valores numéricos simples, como o nome do par de chaves `my-key-pair` no exemplo de comando `aws ec2 create-key-pair` a seguir.
```
$ aws ec2 create-key-pair --key-name my-key-pair
```
A formatação para comandos pode variar entre os terminais. Por exemplo, a maioria dos terminais faz distinção entre letras maiúsculas e minúsculas, mas não é o caso do Powershell. Isso significa que os dois exemplos de comando a seguir produziriam resultados diferentes para terminais com distinção entre letras maiúsculas e minúsculas, pois eles veem `MyFile*.txt` e `myfile*.txt` como parâmetros **diferentes**.
No entanto, o PowerShell processaria essas solicitações da mesma forma, já que vê `MyFile*.txt` e `myfile*.txt` como os **mesmos** parâmetros. O exemplo de comando a seguir demonstra esses parâmetros usando o 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 obter mais informações sobre a indistinção de letras maiúsculas e minúsculas do PowerShell, consulte [about\$1Case-Sensitivity](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_case-sensitivity) na *documentação do PowerShell*.
Às vezes, é necessário usar aspas ou literais em strings que incluem caracteres especiais ou de espaço. As regras sobre essa formatação também podem variar entre os terminais. Para obter mais informações sobre como usar aspas em parâmetros complexos, consulte [Usar aspas e literais com strings na AWS CLI](cli-usage-parameters-quoting-strings.md).
Esses tópicos abordam as regras de formatação de terminal mais comuns. Se você estiver tendo problemas em seu terminal com o reconhecimento de valores de parâmetros, revise os tópicos desta seção e também verifique a documentação do seu terminal para ver as regras de sintaxe específicas.
**Topics**
+ [
# Tipos comuns de parâmetros na AWS CLI
](cli-usage-parameters-types.md)
+ [
# Usar aspas e literais com strings na AWS CLI
](cli-usage-parameters-quoting-strings.md)
+ [
# Carregar um parâmetro de um arquivo na AWS CLI
](cli-usage-parameters-file.md)
+ [
# Esqueletos da AWS CLI e arquivos de entrada na AWS CLI
](cli-usage-skeleton.md)
+ [
# Uso da sintaxe simplificada na AWS CLI
](cli-usage-shorthand.md)
# Tipos comuns de parâmetros na AWS CLI
Esta seção descreve alguns dos tipos de parâmetros comuns e o formato típico necessário.
Caso haja problemas com a formatação de um parâmetro para um comando específico, verifique a ajuda inserindo **help** após o nome do comando. A ajuda de cada subcomando inclui o nome e a descrição de uma opção. O tipo de parâmetro da opção está listado entre parênteses. Para obter mais informações sobre a exibição da ajuda, consulte [Acesso a ajuda e recursos para a AWS CLI](cli-usage-help.md).
**Topics**
+ [
## String
](#parameter-type-string)
+ [
## Timestamp
](#parameter-type-timestamp)
+ [
## Lista
](#parameter-type-list)
+ [
## Booleano
](#parameter-type-boolean)
+ [
## Inteiro
](#parameter-type-integer)
+ [
## Binário/blob (objeto grande binário) e blob de streaming
](#parameter-type-blobs)
+ [
## Mapa
](#parameter-type-map)
+ [
## Documento
](#parameter-type-document)
## String
Os parâmetros de string podem conter caracteres alfanuméricos, símbolos e espaço em branco no conjunto de caracteres [ASCII](https://wikipedia.org/wiki/ASCII). Strings com espaço em branco devem ser incluídas entre aspas. Recomendamos que você não use símbolos nem espaços em branco diferentes do caractere de espaço padrão e observe as [regras de aspas](cli-usage-parameters-quoting-strings.md) para evitar resultados inesperados.
Alguns parâmetros de sequência de caracteres pode aceitar dados binários a partir de um arquivo. Para ver um exemplo, consulte [Arquivos binários](cli-usage-parameters-file.md#cli-usage-parameters-file-binary).
## Timestamp
As marcas de tempo são formatadas de acordo com a norma [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html). São geralmente chamados de parâmetros “`DateTime`” ou “`Date`”.
```
$ aws ec2 describe-spot-price-history --start-time 2014-10-13T19:00:00Z
```
Os formatos aceitos incluem:
+ *AAAA*-*MM*-*DD*T*hh*:*mm*:*ss.sss**TZD (UTC)*, por exemplo, 2014-10-01T20:30:00.000Z
+ *AAAA*-*MM*-*DD*T*hh*:*mm*:*ss.sss**TZD (com deslocamento)*, por exemplo, 2014-10-01T12:30:00.000-08:00
+ *AAAA*-*MM*-*DD*, por exemplo, 2014-10-01
+ Tempo do Unix em segundos, por exemplo, 1412195400. Isso às vezes é conhecido como [Tempo epoch Unix](https://wikipedia.org/wiki/Unix_time) e representa o número de segundos desde a meia-noite, 1º de janeiro de 1970 UTC.
Por padrão, a AWS CLI versão 2 converte todos os valores DateTime da ***resposta*** no formato ISO 8601.
Você pode definir o formato do carimbo de data/hora usando a configuração do arquivo `cli\$1timestamp\$1format`.
## Lista
Uma ou mais strings separadas por espaços. Se qualquer um dos itens de string contiver espaços, você deverá colocar esse item entre aspas. Observe as [regras de aspas](cli-usage-parameters-quoting-strings.md) de seu terminal para evitar resultados inesperados
```
$ aws ec2 describe-spot-price-history --instance-types m1.xlarge m1.medium
```
## Booleano
Sinalizador binário que ativa ou desativa uma opção. Por exemplo, `ec2 describe-spot-price-history` tem um parâmetro booleano `--dry-run` que, quando especificado, valida a consulta com o serviço sem realmente executá-la.
```
$ aws ec2 describe-spot-price-history --dry-run
```
A saída indica se o comando foi bem formado. Esse comando também inclui uma versão `--no-dry-run` do parâmetro que você pode usar para indicar explicitamente que o comando deve ser executado normalmente. A inclusão não é necessária, pois esse é o comportamento padrão.
## Inteiro
Um número inteiro não assinado.
```
$ aws ec2 describe-spot-price-history --max-items 5
```
## Binário/blob (objeto grande binário) e blob de streaming
Na AWS CLI, é possível transmitir um valor binário como uma string diretamente na linha de comando. Há dois tipos de blobs:
+ [Blob](#parameter-type-blob)
+ [Blob de streaming](#parameter-type-streaming-blob)
### BLOB
Para transmitir um valor para um parâmetro com o tipo `blob`, é necessário especificar um caminho para um arquivo local que contenha os dados binários usando o prefixo `fileb://`. Arquivos referenciados usando o prefixo `fileb://` são sempre tratados como um binário bruto não codificado. O caminho especificado é interpretado como sendo relativo ao diretório de trabalho atual. Por exemplo, o parâmetro `--plaintext` para `aws kms encrypt` é um blob.
```
$ aws kms encrypt \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--plaintext fileb://ExamplePlaintextFile \
--output text \
--query CiphertextBlob | base64 \
--decode > ExampleEncryptedFile
```
**nota**
Para compatibilidade com versões anteriores, é possível usar o prefixo `file://`. Há dois formatos usados com base na opção da linha de comando `cli\$1binary\$1format` ou `--cli-binary-format` da configuração do arquivo:
Padrão para a AWS CLI versão 2. Se o valor da configuração for `base64`, os arquivos referenciados com o prefixo `file://` serão tratados como texto codificado em base64.
Padrão para a AWS CLI versão 1. Se o valor da configuração for `raw-in-base64-out`, os arquivos referenciados usando o prefixo `file://` serão lidos como texto e, então, a AWS CLI tenta codificá-lo em binário.
Para obter mais informações, consulte a configuração do arquivo `cli\$1binary\$1format` ou a opção `--cli-binary-format` da linha de comando.
### Blob de streaming
Blobs de streaming como `aws cloudsearchdomain upload-documents` não usam prefixos. Em vez disso, os parâmetros de blob de streaming são formatados usando o caminho direto do arquivo. O seguinte exemplo usa o caminho direto do arquivo `document-batch.json` para o 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
```
## Mapa
Um conjunto de pares de chave-valor especificado em JSON ou com a [sintaxe abreviada](cli-usage-shorthand.md) da CLI. O exemplo de JSON a seguir lê um item de uma tabela do Amazon DynamoDB chamada *my-table* com um parâmetro de mapa, `--key`. O parâmetro especifica a chave primária chamada *id* com um valor numérico de *1* em uma estrutura JSON aninhada.
Para uso mais avançado de JSON em uma linha de comando, considere usar um processador JSON de linha de comando, como `jq`, para criar strings JSON. Para obter mais informações sobre o `jq`, consulte o [repositório do jq](http://stedolan.github.io/jq/) no *GitHub*.
```
$ aws dynamodb get-item --table-name my-table --key '{"id": {"N":"1"}}'
{
"Item": {
"name": {
"S": "John"
},
"id": {
"N": "1"
}
}
}
```
## Documento
**nota**
A [sintaxe simplificada](cli-usage-shorthand.md) não é compatível com tipos de documento.
Os tipos de documento são usados para enviar dados sem a necessidade de incorporar JSON dentro de strings. O tipo de documento permite que os serviços forneçam esquemas arbitrários para você usar tipos de dados mais flexíveis.
Isso permite enviar dados JSON sem precisar usar caracteres escape nos valores. Por exemplo, em vez de usar a seguinte entrada JSON com escape:
```
{"document": "{\"key\":true}"}
```
Você pode usar o seguinte tipo de documento:
```
{"document": {"key": true}}
```
### Valores válidos para tipos de documento
Devido à natureza flexível dos tipos de documento, existem vários tipos de valor válidos. Entre os valores válidos estão os seguintes:
**String**
```
--option '"value"'
```
**Número**
```
--option 123
--option 123.456
```
**Booleano**
```
--option true
```
**Null**
```
--option null
```
**Array**
```
--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"}'
```
# Usar aspas e literais com strings na AWS CLI
Há duas formas principais de usar aspas simples e duplas na AWS CLI.
+ [Uso de aspas em torno de strings que contêm espaços em branco](#cli-usage-parameters-quoting-strings-around)
+ [Uso de aspas dentro de strings](#cli-usage-parameters-quoting-strings-containing)
## Uso de aspas em torno de strings que contêm espaços em branco
Os nomes dos parâmetros e valores são separados por espaços na linha de comando. Se um valor de string contiver um espaço incorporado, você deve fechar a string inteira com aspas para evitar que a AWS CLI interprete mal o espaço como um divisor entre o valor e o próximo nome de parâmetro. O tipo de aspas depende do sistema operacional em que você executa a AWS CLI.
------
#### [ Linux and macOS ]
Uso de aspas simples `' '`
```
$ aws ec2 create-key-pair --key-name 'my key pair'
```
Para obter mais informações sobre como usar aspas, consulte a documentação do usuário para o seu shell preferido.
------
#### [ PowerShell ]
**Aspas simples (recomendado)**
As aspas simples `' '` são chamadas de strings `verbatim`. A string é passada ao comando exatamente como você a digita, o que significa que as variáveis do PowerShell não serão passadas.
```
PS C:\> aws ec2 create-key-pair --key-name 'my key pair'
```
**Aspas duplas**
As aspas duplas `" "` são chamadas de string `expandable`. As variáveis podem ser passadas em strings expansíveis.
```
PS C:\> aws ec2 create-key-pair --key-name "my key pair"
```
Para obter mais informações sobre como usar aspas, consulte [Sobre regras de aspas](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) na *Documentação do Microsoft PowerShell*.
------
#### [ Windows command prompt ]
Uso de aspas duplas `" "` .
```
C:\> aws ec2 create-key-pair --key-name "my key pair"
```
------
Opcionalmente, você pode separar o nome de parâmetro do valor com um sinal de igual `=`, em vez de um espaço. Isso geralmente é necessário apenas se o valor do parâmetro começa com um hífen.
```
$ aws ec2 delete-key-pair --key-name=-mykey
```
## Uso de aspas dentro de strings
As strings podem conter aspas, e seu shell pode exigir aspas de escape para que funcionem corretamente. Um dos tipos de valor de parâmetro comuns é uma string JSON. Isso é complexo, pois inclui espaços e aspas duplas `" "` em torno de cada nome de elemento e valor na estrutura JSON. A maneira como insere os parâmetros formatados pelo JSON na linha de comando difere dependendo de seu sistema operacional.
Para uso mais avançado de JSON na linha de comando, considere usar um processador JSON de linha de comando, como `jq`, para criar strings JSON. Para obter mais informações sobre o `jq`, consulte o [repositório do jq](http://stedolan.github.io/jq/) no *GitHub*.
------
#### [ Linux and macOS ]
Para que o Linux e o macOS interpretem strings literalmente, use aspas simples `' '` para delimitar estrutura de dados JSON, como no exemplo a seguir. Você não precisa adicionar sequências de escape para as aspas duplas incorporadas na string JSON, pois elas são tratadas literalmente. Como o JSON é delimitado por aspas simples, quaisquer aspas simples na string precisarão utilizar sequências de escape. Isso geralmente é feito usando-se uma barra invertida antes da aspas simples `\'`.
```
$ aws ec2 run-instances \
--image-id ami-12345678 \
--block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]'
```
Para obter mais informações sobre como usar aspas, consulte a documentação do usuário para o seu shell preferido.
------
#### [ PowerShell ]
Use aspas simples `' '` ou aspas duplas`" "`.
**Aspas simples (recomendado)**
As aspas simples `' '` são chamadas de strings `verbatim`. A string é passada ao comando exatamente como você a digita, o que significa que as variáveis do PowerShell não serão passadas.
Como as estruturas de dados JSON incluem aspas duplas, sugerimos utilizar **aspas simples** `' '`para delimitá-las. Se você usar aspas **simples**, não será necessário usar uma sequência de escape para as aspas **duplas** incorporadas na string JSON. No entanto, será necessário usar a sequência de escape para cada uma das aspas **simples**utilizando um apóstrofe ``` dentro da estrutura JSON.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]'
```
**Aspas duplas**
As aspas duplas `" "` são chamadas de string `expandable`. As variáveis podem ser passadas em strings expansíveis.
Se você usar aspas **duplas**, não será necessário usar uma sequência de escape para as aspas **simples** incorporadas na string JSON. No entanto, será necessário usar a sequência de escape para cada uma das aspas **duplas**utilizando um apóstrofe ``` dentro da estrutura JSON, conforme mostrado no exemplo a seguir.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings "[{`"DeviceName`":`"/dev/sdb`",`"Ebs`":{`"VolumeSize`":20,`"DeleteOnTermination`":false,`"VolumeType`":`"standard`"}}]"
```
Para obter mais informações sobre como usar aspas, consulte [Sobre regras de aspas](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) na *Documentação do Microsoft PowerShell*.
**Atenção**
Antes que o PowerShell envie um comando para a AWS CLI, ele determina se seu comando é interpretado usando o PowerShell típico ou regras de aspas da `CommandLineToArgvW`. Quando o PowerShell usa `CommandLineToArgvW` no processamento, é necessário escapar dos caracteres com barra invertida `\`.
Para obter mais informações sobre `CommandLineToArgvW` no PowerShell, consulte [O que há com o estranho tratamento de aspas e barras invertidas por CommandlineToArgVW](https://devblogs.microsoft.com/oldnewthing/20100917-00/?p=12833) no *Blog de desenvolvedores da Microsoft*, [Todos delimitam argumentos de linha de comando da maneira errada](https://docs.microsoft.com/en-us/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way) no *Blog de documentação da Microsoft* e [Função CommandLineToArGVW](https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-commandlinetoargvw#remarks) na *Documentação da Microsoft*.
**Aspas simples**
As aspas simples `' '` são chamadas de strings `verbatim`. A string é passada ao comando exatamente como você a digita, o que significa que as variáveis do PowerShell não serão passadas. Caracteres de escape com 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\"}}]'
```
**Aspas duplas**
As aspas duplas `" "` são chamadas de string `expandable`. As variáveis podem ser passadas em strings expansíveis. Para strings entre aspas duplas, é necessário escapar duas vezes usando*`\$1* para cada aspa, em vez de usar um único backtick. O backtick escapa da barra invertida e, em seguida, a barra invertida é usada como um caractere de escape para o processo `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 (recomendados)**
Para ignorar as regras de aspas do PowerShell para entrada de dados JSON, use Blobs para passar seus dados JSON diretamente para a AWS CLI. Para obter mais informações sobre o Blobs, consulte [BLOB](cli-usage-parameters-types.md#parameter-type-blob).
------
#### [ Windows command prompt ]
O prompt de comando do Windows exige aspas duplas `" "` para delimitar a estrutura de dados JSON. Além disso, para evitar que o processador de comando interprete mal as aspas duplas incorporadas no JSON, você também deve usar um caractere de escape (preceder com um caractere de barra invertida `\`) cada uma das aspas duplas `"` dentro da própria estrutura de dados JSON, como no exemplo a seguir.
```
C:\> aws ec2 run-instances ^
--image-id ami-12345678 ^
--block-device-mappings "[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]"
```
Somente as aspas duplas mais externas não são de escape.
------
# Carregar um parâmetro de um arquivo na AWS CLI
Alguns parâmetros esperam nomes de arquivos como argumentos, dos quais a AWS CLI carrega os dados. Outros parâmetros permitem que você especifique o valor do parâmetro como texto digitado na linha de comando ou lido de um arquivo. Independentemente se um arquivo for obrigatório ou opcional, você deverá codificá-lo corretamente para que a AWS CLI possa entendê-lo. A codificação do arquivo deve corresponder à localidade padrão do sistema de leitura. É possível determinar isso usando o método `locale.getpreferredencoding()` do Python.
Esse método serve para carregar um arquivo para um único parâmetro. Consulte informações sobre como carregar vários parâmetros com um único arquivo em [Esqueletos da AWS CLI e arquivos de entrada na AWS CLI](cli-usage-skeleton.md).
**nota**
Por padrão, o Windows PowerShell gera texto como UTF-16, o que entra em conflito com a codificação UTF-8 usada por arquivos JSON e muitos sistemas Linux. Recomendamos que você use `-Encoding ascii` com os comandos `Out-File` do PowerShell para garantir que a AWS CLI possa ler o arquivo resultante.
**Topics**
+ [
## Como carregar um parâmetro de um arquivo
](#cli-usage-parameters-file-how)
+ [
## Arquivos binários
](#cli-usage-parameters-file-binary)
+ [
## Carregar um arquivo como um valor de sintaxe abreviada
](#cli-usage-parameters-file-shorthand)
## Como carregar um parâmetro de um arquivo
Às vezes é conveniente carregar um valor de parâmetro de um arquivo, em vez de tentar digitá-lo como um valor de parâmetro de linha de comando, por exemplo, quando o parâmetro é uma string JSON complexa. Para especificar um arquivo que contém o valor, especifique um URL de arquivo no formato a seguir.
```
file://complete/path/to/file
```
+ Os dois primeiros caracteres de barra “/” fazem parte da especificação. Se o caminho exigido começar com “/”, o resultado será três caracteres de barra: `file:///folder/file`.
+ O URL fornece o caminho para o arquivo que apresenta o conteúdo real do parâmetro.
+ Ao usar arquivos com espaços ou caracteres especiais, siga as [regras de aspas e escape](cli-usage-parameters-quoting-strings.md) para o terminal.
Os caminhos do arquivo no exemplo a seguir são interpretados como sendo relativos ao diretório de trabalho atual.
------
#### [ 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"
```
------
A opção de prefixo `file://` é compatível com as expansões de estilo Unix, inclusive "`~/`", "`./`" e "`../`". No Windows, a expressão "`~/`" se expande para o seu diretório de usuário, armazenado na variável de ambiente `%USERPROFILE%`. Por exemplo, no Windows 10, haveria normalmente um diretório de usuário em `%USERPROFILE%`.
Ainda é necessário inserir um caractere de escape nos documentos JSON que são incorporados como o valor de outro 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\"}"
}
```
## Arquivos binários
Para comandos que incluem dados binários como um parâmetro, especifique que os dados são conteúdo binário usando o prefixo `fileb://`. Comandos que aceitam dados binários incluem:
+ **`aws ec2 run-instances:`** `--user-data` parâmetro .
+ **`aws s3api put-object:`** `--sse-customer-key` parâmetro .
+ **`aws kms decrypt:`** `--ciphertext-blob` parâmetro .
O exemplo a seguir gera uma chave binária AES de 256 bits usando uma ferramenta de linha de comando do Linux e a fornece ao Amazon S3 para criptografar o arquivo enviado no lado do 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\""
}
```
Para outro exemplo com referência a um arquivo que contém parâmetros formatados pelo JSON, consulte [Associar uma política gerenciada do IAM a um usuário](cli-services-iam.md#cli-services-iam-policy).
## Carregar um arquivo como um valor de sintaxe abreviada
Ao usar a sintaxe abreviada quando um valor é grande ou complexo, geralmente é mais fácil carregar um arquivo como um valor. Ao carregar um arquivo como um valor de sintaxe abreviada, a formatação muda um pouco. Em vez de `key=value`, você usa o operador `@=` no lugar do operador `=`. O `@=` indica à AWS CLI que o valor deve ser lido como um caminho de arquivo e não como uma string. O exemplo a seguir mostra um par de chave-valor carregando um arquivo como seu valor.
------
#### [ Linux or macOS ]
```
--option key@=file://template.txt
```
------
#### [ Windows ]
```
--option "key1@=file://template.txt"
```
------
O exemplo a seguir demonstra o carregamento de um arquivo de certificado para o comando `aws rolesanywhere create-trust-anchor`.
```
$ aws rolesanywhere create-trust-anchor --name TrustAnchor \
--source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \
--enabled
```
Consulte mais informações sobre a sintaxe abreviada em [Uso da sintaxe simplificada na AWS CLI](cli-usage-shorthand.md).
# Esqueletos da AWS CLI e arquivos de entrada na AWS CLI
A maioria dos comandos da AWS CLI aceita as entradas de parâmetro importadas de um arquivo. Esses modelos podem ser gerados usando a opção `generate-cli-skeleton` e, depois, ser importados usando os parâmetros `--cli-input-json` e `--cli-input-yaml`.
**Topics**
+ [
## Sobre esqueletos e arquivos de entrada da AWS CLI
](#cli-usage-skeleton-about)
+ [
## Gerar e importar um esqueleto de comando
](#cli-usage-skeleton-generate)
+ [
## Combinar arquivos de entrada e parâmetros da linha de comandos
](#cli-usage-skeleton-combine)
## Sobre esqueletos e arquivos de entrada da AWS CLI
A maioria dos comandos da AWS Command Line Interface (AWS CLI) permite aceitar as entradas de parâmetro usando os parâmetros `--cli-input-json` e `--cli-input-yaml`.
Esses mesmos comandos usam o parâmetro `--generate-cli-skeleton` para gerar um arquivo tanto no formato JSON como YAML com todos os parâmetros que você pode editar e preencher. Depois, é possível executar o comando com o parâmetro `--cli-input-json` ou `--cli-input-yaml` e apontar para o arquivo preenchido.
**Importante**
Comandos personalizados da AWS CLI, como os [comandos `aws s3`](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) não são compatíveis com os parâmetros `--generate-cli-skeleton` ou `--cli-input-json` e `--cli-input-yaml` descritos neste tópico. Para verificar se um comando específico é compatível com esses parâmetros, execute o [comando `help`](cli-usage-help.md#cli-usage-help-command) para o comando que você deseja usar ou consulte o ou o [Guia de referência da AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/reference/index.html).
O `--generate-cli-skeleton` gera e exibe um modelo de parâmetro que pode ser personalizado e usado como entrada em um comando. O modelo gerado inclui todos os parâmetros compatíveis com o comando.
O parâmetro `--generate-cli-skeleton` aceita um dos seguintes valores:
+ `input`: o modelo gerado inclui todos os parâmetros de entrada formatados como JSON. Este é o valor padrão.
+ `yaml-input`: o modelo gerado inclui todos os parâmetros de entrada formatados como YAML.
+ `output` – o modelo gerado inclui todos os parâmetros de saída formatados como JSON. No momento, não é possível solicitar os parâmetros de saída como YAML.
Como a AWS CLI é essencialmente um “wrapper” em torno da API de serviço, o arquivo de esqueleto espera que você faça referência a todos os parâmetros pelo nome do parâmetro da API subjacente. Isso provavelmente é diferente do nome do parâmetro da AWS CLI. Por exemplo, um parâmetro da AWS CLI chamado `user-name` pode ser mapeado para o parâmetro da API do serviço da AWS chamado `UserName` (observe a capitalização alterada e o traço ausente). Recomendamos usar a opção `--generate-cli-skeleton` para gerar o modelo com os nomes de parâmetro “corretos” a fim de evitar erros. Consulte o Guia de referência da API do serviço para ver os nomes de parâmetro esperados. É possível excluir quaisquer parâmetros do modelo que não sejam necessários e para os quais você não deseja fornecer um valor.
Por exemplo, se você executar o seguinte comando, ele gerará o modelo de parâmetro para o comando do Amazon Elastic Compute Cloud (Amazon EC2) **run-instances**.
------
#### [ JSON ]
O exemplo a seguir mostra como gerar um modelo formatado em JSON usando o valor padrão (`input`) para o `--generate-cli-skeleton` parâmetro.
```
$ 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
}
```
------
#### [ YAML ]
O exemplo a seguir mostra como gerar um modelo formatado em YAML usando o valor `yaml-input` para o parâmetro `--generate-cli-skeleton`.
```
$ aws ec2 run-instances --generate-cli-skeleton yaml-input
```
```
BlockDeviceMappings: # The block device mapping entries.
- DeviceName: '' # The device name (for example, /dev/sdh or xvdh).
VirtualName: '' # The virtual device name (ephemeralN).
Ebs: # Parameters used to automatically set up Amazon EBS volumes when the instance is launched.
DeleteOnTermination: true # Indicates whether the EBS volume is deleted on instance termination.
Iops: 0 # The number of I/O operations per second (IOPS) that the volume supports.
SnapshotId: '' # The ID of the snapshot.
VolumeSize: 0 # The size of the volume, in GiB.
VolumeType: st1 # The volume type. Valid values are: standard, io1, gp2, sc1, st1.
Encrypted: true # Indicates whether the encryption state of an EBS volume is changed while being restored from a backing snapshot.
KmsKeyId: '' # Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed KMS key under which the EBS volume is encrypted.
NoDevice: '' # Suppresses the specified device included in the block device mapping of the AMI.
ImageId: '' # The ID of the AMI.
InstanceType: c4.4xlarge # The instance type. Valid values are: t1.micro, t2.nano, t2.micro, t2.small, t2.medium, t2.large, t2.xlarge, t2.2xlarge, t3.nano, t3.micro, t3.small, t3.medium, t3.large, t3.xlarge, t3.2xlarge, t3a.nano, t3a.micro, t3a.small, t3a.medium, t3a.large, t3a.xlarge, t3a.2xlarge, m1.small, m1.medium, m1.large, m1.xlarge, m3.medium, m3.large, m3.xlarge, m3.2xlarge, m4.large, m4.xlarge, m4.2xlarge, m4.4xlarge, m4.10xlarge, m4.16xlarge, m2.xlarge, m2.2xlarge, m2.4xlarge, cr1.8xlarge, r3.large, r3.xlarge, r3.2xlarge, r3.4xlarge, r3.8xlarge, r4.large, r4.xlarge, r4.2xlarge, r4.4xlarge, r4.8xlarge, r4.16xlarge, r5.large, r5.xlarge, r5.2xlarge, r5.4xlarge, r5.8xlarge, r5.12xlarge, r5.16xlarge, r5.24xlarge, r5.metal, r5a.large, r5a.xlarge, r5a.2xlarge, r5a.4xlarge, r5a.8xlarge, r5a.12xlarge, r5a.16xlarge, r5a.24xlarge, r5d.large, r5d.xlarge, r5d.2xlarge, r5d.4xlarge, r5d.8xlarge, r5d.12xlarge, r5d.16xlarge, r5d.24xlarge, r5d.metal, r5ad.large, r5ad.xlarge, r5ad.2xlarge, r5ad.4xlarge, r5ad.8xlarge, r5ad.12xlarge, r5ad.16xlarge, r5ad.24xlarge, x1.16xlarge, x1.32xlarge, x1e.xlarge, x1e.2xlarge, x1e.4xlarge, x1e.8xlarge, x1e.16xlarge, x1e.32xlarge, i2.xlarge, i2.2xlarge, i2.4xlarge, i2.8xlarge, i3.large, i3.xlarge, i3.2xlarge, i3.4xlarge, i3.8xlarge, i3.16xlarge, i3.metal, i3en.large, i3en.xlarge, i3en.2xlarge, i3en.3xlarge, i3en.6xlarge, i3en.12xlarge, i3en.24xlarge, i3en.metal, hi1.4xlarge, hs1.8xlarge, c1.medium, c1.xlarge, c3.large, c3.xlarge, c3.2xlarge, c3.4xlarge, c3.8xlarge, c4.large, c4.xlarge, c4.2xlarge, c4.4xlarge, c4.8xlarge, c5.large, c5.xlarge, c5.2xlarge, c5.4xlarge, c5.9xlarge, c5.12xlarge, c5.18xlarge, c5.24xlarge, c5.metal, c5d.large, c5d.xlarge, c5d.2xlarge, c5d.4xlarge, c5d.9xlarge, c5d.18xlarge, c5n.large, c5n.xlarge, c5n.2xlarge, c5n.4xlarge, c5n.9xlarge, c5n.18xlarge, cc1.4xlarge, cc2.8xlarge, g2.2xlarge, g2.8xlarge, g3.4xlarge, g3.8xlarge, g3.16xlarge, g3s.xlarge, g4dn.xlarge, g4dn.2xlarge, g4dn.4xlarge, g4dn.8xlarge, g4dn.12xlarge, g4dn.16xlarge, cg1.4xlarge, p2.xlarge, p2.8xlarge, p2.16xlarge, p3.2xlarge, p3.8xlarge, p3.16xlarge, p3dn.24xlarge, d2.xlarge, d2.2xlarge, d2.4xlarge, d2.8xlarge, f1.2xlarge, f1.4xlarge, f1.16xlarge, m5.large, m5.xlarge, m5.2xlarge, m5.4xlarge, m5.8xlarge, m5.12xlarge, m5.16xlarge, m5.24xlarge, m5.metal, m5a.large, m5a.xlarge, m5a.2xlarge, m5a.4xlarge, m5a.8xlarge, m5a.12xlarge, m5a.16xlarge, m5a.24xlarge, m5d.large, m5d.xlarge, m5d.2xlarge, m5d.4xlarge, m5d.8xlarge, m5d.12xlarge, m5d.16xlarge, m5d.24xlarge, m5d.metal, m5ad.large, m5ad.xlarge, m5ad.2xlarge, m5ad.4xlarge, m5ad.8xlarge, m5ad.12xlarge, m5ad.16xlarge, m5ad.24xlarge, h1.2xlarge, h1.4xlarge, h1.8xlarge, h1.16xlarge, z1d.large, z1d.xlarge, z1d.2xlarge, z1d.3xlarge, z1d.6xlarge, z1d.12xlarge, z1d.metal, u-6tb1.metal, u-9tb1.metal, u-12tb1.metal, u-18tb1.metal, u-24tb1.metal, a1.medium, a1.large, a1.xlarge, a1.2xlarge, a1.4xlarge, a1.metal, m5dn.large, m5dn.xlarge, m5dn.2xlarge, m5dn.4xlarge, m5dn.8xlarge, m5dn.12xlarge, m5dn.16xlarge, m5dn.24xlarge, m5n.large, m5n.xlarge, m5n.2xlarge, m5n.4xlarge, m5n.8xlarge, m5n.12xlarge, m5n.16xlarge, m5n.24xlarge, r5dn.large, r5dn.xlarge, r5dn.2xlarge, r5dn.4xlarge, r5dn.8xlarge, r5dn.12xlarge, r5dn.16xlarge, r5dn.24xlarge, r5n.large, r5n.xlarge, r5n.2xlarge, r5n.4xlarge, r5n.8xlarge, r5n.12xlarge, r5n.16xlarge, r5n.24xlarge.
Ipv6AddressCount: 0 # [EC2-VPC] The number of IPv6 addresses to associate with the primary network interface.
Ipv6Addresses: # [EC2-VPC] The IPv6 addresses from the range of the subnet to associate with the primary network interface.
- Ipv6Address: '' # The IPv6 address.
KernelId: '' # The ID of the kernel.
KeyName: '' # The name of the key pair.
MaxCount: 0 # [REQUIRED] The maximum number of instances to launch.
MinCount: 0 # [REQUIRED] The minimum number of instances to launch.
Monitoring: # Specifies whether detailed monitoring is enabled for the instance.
Enabled: true # [REQUIRED] Indicates whether detailed monitoring is enabled.
Placement: # The placement for the instance.
AvailabilityZone: '' # The Availability Zone of the instance.
Affinity: '' # The affinity setting for the instance on the Dedicated Host.
GroupName: '' # The name of the placement group the instance is in.
PartitionNumber: 0 # The number of the partition the instance is in.
HostId: '' # The ID of the Dedicated Host on which the instance resides.
Tenancy: dedicated # The tenancy of the instance (if the instance is running in a VPC). Valid values are: default, dedicated, host.
SpreadDomain: '' # Reserved for future use.
RamdiskId: '' # The ID of the RAM disk to select.
SecurityGroupIds: # The IDs of the security groups.
- ''
SecurityGroups: # [default VPC] The names of the security groups.
- ''
SubnetId: '' # [EC2-VPC] The ID of the subnet to launch the instance into.
UserData: '' # The user data to make available to the instance.
AdditionalInfo: '' # Reserved.
ClientToken: '' # Unique, case-sensitive identifier you provide to ensure the idempotency of the request.
DisableApiTermination: true # If you set this parameter to true, you can't terminate the instance using the Amazon EC2 console, CLI, or API; otherwise, you can.
DryRun: true # Checks whether you have the required permissions for the action, without actually making the request, and provides an error response.
EbsOptimized: true # Indicates whether the instance is optimized for Amazon EBS I/O.
IamInstanceProfile: # The IAM instance profile.
Arn: '' # The Amazon Resource Name (ARN) of the instance profile.
Name: '' # The name of the instance profile.
InstanceInitiatedShutdownBehavior: stop # Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown). Valid values are: stop, terminate.
NetworkInterfaces: # The network interfaces to associate with the instance.
- AssociatePublicIpAddress: true # Indicates whether to assign a public IPv4 address to an instance you launch in a VPC.
DeleteOnTermination: true # If set to true, the interface is deleted when the instance is terminated.
Description: '' # The description of the network interface.
DeviceIndex: 0 # The position of the network interface in the attachment order.
Groups: # The IDs of the security groups for the network interface.
- ''
Ipv6AddressCount: 0 # A number of IPv6 addresses to assign to the network interface.
Ipv6Addresses: # One or more IPv6 addresses to assign to the network interface.
- Ipv6Address: '' # The IPv6 address.
NetworkInterfaceId: '' # The ID of the network interface.
PrivateIpAddress: '' # The private IPv4 address of the network interface.
PrivateIpAddresses: # One or more private IPv4 addresses to assign to the network interface.
- Primary: true # Indicates whether the private IPv4 address is the primary private IPv4 address.
PrivateIpAddress: '' # The private IPv4 addresses.
SecondaryPrivateIpAddressCount: 0 # The number of secondary private IPv4 addresses.
SubnetId: '' # The ID of the subnet associated with the network interface.
InterfaceType: '' # The type of network interface.
PrivateIpAddress: '' # [EC2-VPC] The primary IPv4 address.
ElasticGpuSpecification: # An elastic GPU to associate with the instance.
- Type: '' # [REQUIRED] The type of Elastic Graphics accelerator.
ElasticInferenceAccelerators: # An elastic inference accelerator to associate with the instance.
- Type: '' # [REQUIRED] The type of elastic inference accelerator.
TagSpecifications: # The tags to apply to the resources during launch.
- ResourceType: network-interface # The type of resource to tag. Valid values are: client-vpn-endpoint, customer-gateway, dedicated-host, dhcp-options, elastic-ip, fleet, fpga-image, host-reservation, image, instance, internet-gateway, launch-template, natgateway, network-acl, network-interface, reserved-instances, route-table, security-group, snapshot, spot-instances-request, subnet, traffic-mirror-filter, traffic-mirror-session, traffic-mirror-target, transit-gateway, transit-gateway-attachment, transit-gateway-route-table, volume, vpc, vpc-peering-connection, vpn-connection, vpn-gateway.
Tags: # The tags to apply to the resource.
- Key: '' # The key of the tag.
Value: '' # The value of the tag.
LaunchTemplate: # The launch template to use to launch the instances.
LaunchTemplateId: '' # The ID of the launch template.
LaunchTemplateName: '' # The name of the launch template.
Version: '' # The version number of the launch template.
InstanceMarketOptions: # The market (purchasing) option for the instances.
MarketType: spot # The market type. Valid values are: spot.
SpotOptions: # The options for Spot Instances.
MaxPrice: '' # The maximum hourly price you're willing to pay for the Spot Instances.
SpotInstanceType: one-time # The Spot Instance request type. Valid values are: one-time, persistent.
BlockDurationMinutes: 0 # The required duration for the Spot Instances (also known as Spot blocks), in minutes.
ValidUntil: 1970-01-01 00:00:00 # The end date of the request.
InstanceInterruptionBehavior: terminate # The behavior when a Spot Instance is interrupted. Valid values are: hibernate, stop, terminate.
CreditSpecification: # The credit option for CPU usage of the T2 or T3 instance.
CpuCredits: '' # [REQUIRED] The credit option for CPU usage of a T2 or T3 instance.
CpuOptions: # The CPU options for the instance.
CoreCount: 0 # The number of CPU cores for the instance.
ThreadsPerCore: 0 # The number of threads per CPU core.
CapacityReservationSpecification: # Information about the Capacity Reservation targeting option.
CapacityReservationPreference: none # Indicates the instance's Capacity Reservation preferences. Valid values are: open, none.
CapacityReservationTarget: # Information about the target Capacity Reservation.
CapacityReservationId: '' # The ID of the Capacity Reservation.
HibernationOptions: # Indicates whether an instance is enabled for hibernation.
Configured: true # If you set this parameter to true, your instance is enabled for hibernation.
LicenseSpecifications: # The license configurations.
- LicenseConfigurationArn: '' # The Amazon Resource Name (ARN) of the license configuration.
```
------
## Gerar e importar um esqueleto de comando
**Para gerar e usar um arquivo de esqueleto de parâmetro**
1. Execute o comando com o parâmetro `--generate-cli-skeleton` para produzir tanto JSON quanto YAML e direcionar a saída a um arquivo para salvá-lo.
------
#### [ JSON ]
```
$ aws ec2 run-instances --generate-cli-skeleton input > ec2runinst.json
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --generate-cli-skeleton yaml-input > ec2runinst.yaml
```
------
1. Abra o arquivo de esqueleto do parâmetro em seu editor de texto e remova os parâmetros que não são mais necessários. Por exemplo, você pode reduzir o modelo ao indicado a seguir. Confirme se o arquivo ainda é JSON ou YAML válido depois de remover os elementos que não são necessários.
------
#### [ JSON ]
```
{
"DryRun": true,
"ImageId": "",
"KeyName": "",
"SecurityGroups": [
""
],
"InstanceType": "",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: true
ImageId: ''
KeyName: ''
SecurityGroups:
- ''
InstanceType:
Monitoring:
Enabled: true
```
------
Neste exemplo, deixamos o parâmetro `DryRun` definido como `true` para usar o recurso de simulação do Amazon EC2. Esse recurso permite que você teste com segurança o comando sem realmente criar ou modificar nenhum recursos.
1. Preencha os valores restantes com valores apropriados para seu cenário. Neste exemplo, fornecemos o tipo de instância, o nome da chave, o grupo de segurança e o identificador da imagem de máquina da Amazon (AMI) que devem ser usados. Este exemplo assume a Região da AWS padrão. A AMI `ami-dfc39aef` é uma imagem de 64 bits do hospedada na região `us-west-2`. Se você usar uma região diferente, será necessário [encontrar o ID da AMI correta para usar](https://aws.amazon.com/amazon-linux-ami/).
------
#### [ JSON ]
```
{
"DryRun": true,
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: true
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
1. Execute o comando com os parâmetros concluídos, transmitindo o arquivo do modelo concluído tanto ao parâmetro `--cli-input-json` quanto ao `cli-input-yaml` usando o prefixo `file://`. A AWS CLI interpreta o caminho como sendo relativo ao diretório de trabalho atual. No exemplo a seguir, a AWS CLI procura o arquivo no diretório de trabalho atual.
------
#### [ 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.
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
O erro de simulação indica que JSON ou YAML está formado corretamente e os valores de parâmetro são válidos. Se outros problemas forem relatados na saída, corrija-os e repita a etapa anterior até que a mensagem “`Request would have succeeded`“ seja exibida.
1. Agora você pode definir o parâmetro `DryRun` como `false` para desativar a simulação.
------
#### [ JSON ]
```
{
"DryRun": false,
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: false
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
1. Execute o comando, e `run-instances` realmente iniciará uma instância do Amazon EC2 e exibirá os detalhes gerados pelo início bem-sucedido. O formato da saída é controlado pelo parâmetro `--output`, separadamente do formato do modelo de parâmetro de entrada.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --output json
```
```
{
"OwnerId": "123456789012",
"ReservationId": "r-d94a2b1",
"Groups": [],
"Instances": [
...
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --output yaml
```
```
OwnerId: '123456789012'
ReservationId: 'r-d94a2b1',
Groups":
- ''
Instances:
...
```
------
## Combinar arquivos de entrada e parâmetros da linha de comandos
Um arquivo de entrada pode ser usado para todos os parâmetros ou pode ser combinado com os parâmetros especificados na AWS CLI. É possível usar esse recurso para configurações que você reutiliza com frequência em um arquivo de entrada, mantendo suas configurações individuais no próprio comando.
Os exemplos de `aws ec2 run-instances` a seguir combinam o uso de um arquivo de entrada e parâmetros. Fornecemos o tipo de instância, o nome da chave, o grupo de segurança e o identificador da imagem de máquina da Amazon (AMI) que devem ser usados e assumimos a Região da AWS padrão. A AMI `ami-dfc39aef` é uma imagem de 64 bits do hospedada na região `us-west-2`. Se você usar uma região diferente, será necessário [encontrar o ID da AMI correta para usar](https://aws.amazon.com/amazon-linux-ami/).
------
#### [ JSON ]
Conteúdo do arquivo JSON:
```
{
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
Conteúdo do arquivo YAML:
```
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
O exemplo a seguir usa o arquivo de entrada em conjunto com o parâmetro `--dry-run` para executar uma simulação do comando e confirmar se você tem as permissões necessárias e se preencheu o arquivo com 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.
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --dry-run
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
O exemplo a seguir usa o mesmo arquivo de entrada, mas com o parâmetro `--no-dry-run` para executar o comando na íntegra.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --no-dry-run --output json
```
```
{
"OwnerId": "123456789012",
"ReservationId": "r-d94a2b1",
"Groups": [],
"Instances": [
...
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --no-dry-run --output yaml
```
```
OwnerId: '123456789012'
ReservationId: 'r-d94a2b1',
Groups":
- ''
Instances:
...
```
------
# Uso da sintaxe simplificada na AWS CLI
A AWS Command Line Interface (AWS CLI) pode aceitar muitos de seus parâmetros de opção no formato JSON. No entanto, pode ser entediante inserir grandes estruturas ou listas de JSON na linha de comando. Para tornar isso mais fácil, a AWS CLI também oferece suporte a uma sintaxe abreviada mais simples que permite a representação de seus parâmetros de opção em vez de utilizar o formato JSON completo.
**Topics**
+ [
## Estruturar parâmetros com pares de chave-valor
](#shorthand-structure-parameters)
+ [
## Carregar um arquivo como um valor de sintaxe abreviada
](#shorthand-files)
+ [
## Usar sintaxe simplificada com a AWS CLI
](#shorthand-list-parameters)
## Estruturar parâmetros com pares de chave-valor
A sintaxe abreviada no AWS CLI facilita a inserção de parâmetros simples de entrada pelos usuários (estruturas não aninhadas). O formato é uma lista de pares de chave/valor separados por vírgula. Use as regras de [aspas](cli-usage-parameters-quoting-strings.md) e escape apropriadas para seu terminal, pois a sintaxe abreviada são strings.
------
#### [ Linux or macOS ]
```
--option key1=value1,key2=value2,key3=value3
```
É equivalente ao exemplo a seguir, formatado em JSON.
```
--option '{"key1":"value1","key2":"value2","key3":"value3"}'
```
------
#### [ Windows ]
```
--option "key1=value1,key2=value2,key3=value3"
```
É equivalente ao exemplo a seguir, formatado em JSON.
```
--option '{"key1":"value1","key2":"value2","key3":"value3"}'
```
------
Não pode haver nenhum espaço em branco entre cada par de chave/valor separado por vírgula. Aqui está um exemplo do comando `update-table` do Amazon DynamoDB com a opção `--provisioned-throughput` especificada no formato simplificado.
```
$ aws dynamodb update-table \
--provisioned-throughput ReadCapacityUnits=15,WriteCapacityUnits=10 \
--table-name MyDDBTable
```
Isso é equivalente ao exemplo a seguir formatado em JSON.
```
$ aws dynamodb update-table \
--provisioned-throughput '{"ReadCapacityUnits":15,"WriteCapacityUnits":10}' \
--table-name MyDDBTable
```
## Carregar um arquivo como um valor de sintaxe abreviada
Quando um valor é grande ou complexo, geralmente é mais fácil carregar como um valor. Ao carregar um arquivo como um valor de sintaxe abreviada, a formatação muda um pouco. Em vez de `key=value`, você usa o operador `@=` no lugar do operador `=`. O `@=` indica à AWS CLI que o valor deve ser lido como um caminho de arquivo e não como uma string. Ao carregar arquivos em sintaxe abreviada, [aplicam-se as regras comuns de formatação de arquivos da AWS CLI](cli-usage-parameters-file.md). O exemplo a seguir mostra um par de chave-valor carregando um arquivo como seu valor.
------
#### [ Linux or macOS ]
```
--option key@=file://template.txt
```
------
#### [ Windows ]
```
--option "key1@=file://template.txt"
```
------
O exemplo a seguir demonstra o carregamento de um arquivo de certificado para o comando `aws rolesanywhere create-trust-anchor`.
```
$ aws rolesanywhere create-trust-anchor --name TrustAnchor \
--source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \
--enabled
```
## Usar sintaxe simplificada com a AWS CLI
Você pode especificar os parâmetros de entrada em um formulário de lista de duas formas: JSON ou abreviada. A sintaxe abreviada da AWS CLI é projetada para facilitar a inserção de listas com número, sequência de caracteres, estruturas aninhados ou não.
O formato básico é mostrada aqui, onde os valores na lista são separados por um único espaço.
```
--option value1 value2 value3
```
Isso é equivalente ao exemplo a seguir, formatado em JSON.
```
--option '[value1,value2,value3]'
```
Como mencionado anteriormente, é possível especificar uma lista de números, uma lista de strings ou uma lista de estruturas de dados não aninhados em formato abreviado. Veja a seguir um exemplo do comando `stop-instances` do Amazon Elastic Compute Cloud (Amazon EC2), onde o parâmetro de entrada (lista de strings) para a opção `--instance-ids` é especificado no formato simplificado.
```
$ aws ec2 stop-instances \
--instance-ids i-1486157a i-1286157c i-ec3a7e87
```
Isso é equivalente ao exemplo a seguir formatado em JSON.
```
$ aws ec2 stop-instances \
--instance-ids '["i-1486157a","i-1286157c","i-ec3a7e87"]'
```
A seguir está um exemplo do comando `create-tags` do Amazon EC2, que leva uma lista de estruturas não aninhadas para a opção `--tags`. A opção `--resources` especifica o ID da instância a ser marcada.
```
$ aws ec2 create-tags \
--resources i-1286157c \
--tags Key=My1stTag,Value=Value1 Key=My2ndTag,Value=Value2 Key=My3rdTag,Value=Value3
```
Isso é equivalente ao exemplo a seguir, formatado em JSON. O parâmetro JSON é escrito em várias linhas para melhor leitura.
```
$ aws ec2 create-tags \
--resources i-1286157c \
--tags '[
{"Key": "My1stTag", "Value": "Value1"},
{"Key": "My2ndTag", "Value": "Value2"},
{"Key": "My3rdTag", "Value": "Value3"}
]'
```