# Specifying parameter values in the AWS CLI Specify Parameter Values Many parameters used in the AWS Command Line Interface (AWS CLI) are simple string or numeric values, such as the key-pair name `my-key-pair` in the following `aws ec2 create-key-pair` command example. ``` $ aws ec2 create-key-pair --key-name my-key-pair ``` Formatting for command can vary between terminals. For example, most terminals are case sensitive but Powershell is case insensitive. This means the two following command examples would yield different results for case sensitive terminals as they view `MyFile*.txt` and `myfile*.txt` as **different** parameters. However, PowerShell would process these requests as the same as it sees `MyFile*.txt` and `myfile*.txt` as the **same** parameters. The following command example demonstrates these paramaters using the `aws s3 cp` command: ``` $ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "MyFile*.txt" $ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "myfile*.txt" ``` For more information on PowerShell's case insensitivy, see [about\$1Case-Sensitivity](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_case-sensitivity) in the *PowerShell documentation*. Sometimes you need to use quotation marks or literals around strings that include special or space characters. The rules around this formatting can also vary between terminals. For more information about using quotation marks around complex parameters, see [Using quotation marks and literals with strings in the AWS CLI](cli-usage-parameters-quoting-strings.md). These topics cover the most common terminal formatting rules. If you are having issues with your terminal recognizing your parameter values, be sure to review the topics in this section and also to check your terminal's documentation for their specific syntax rules. **Topics** + [ # Common parameter types in the AWS CLI ](cli-usage-parameters-types.md) + [ # Using quotation marks and literals with strings in the AWS CLI ](cli-usage-parameters-quoting-strings.md) + [ # Loading a parameter from a file in the AWS CLI ](cli-usage-parameters-file.md) + [ # AWS CLI skeletons and input files in the AWS CLI ](cli-usage-skeleton.md) + [ # Using shorthand syntax in the AWS CLI ](cli-usage-shorthand.md) # Common parameter types in the AWS CLI Common Parameter Types This section describes some of the common parameter types and the typical required format. If you are having trouble formatting a parameter for a specific command, check the help by entering **help** after the command name. The help for each subcommand includes an option's name and description. The option's parameter type is listed in parentheses. For more information on viewing help, see [Accessing help and resources for the AWS CLI](cli-usage-help.md). **Topics** + [ ## String ](#parameter-type-string) + [ ## Timestamp ](#parameter-type-timestamp) + [ ## List ](#parameter-type-list) + [ ## Boolean ](#parameter-type-boolean) + [ ## Integer ](#parameter-type-integer) + [ ## Binary / blob (binary large object) and streaming blob ](#parameter-type-blobs) + [ ## Map ](#parameter-type-map) + [ ## Document ](#parameter-type-document) ## String String parameters can contain alphanumeric characters, symbols, and white spaces from the [ASCII](https://wikipedia.org/wiki/ASCII) character set. Strings that contain white spaces must be surrounded by quotation marks. We recommend that you don't use symbols or white spaces other than the standard space character and to observe your terminal's [quoting rules](cli-usage-parameters-quoting-strings.md) to prevent unexpected results. Some string parameters can accept binary data from a file. See [Binary files](cli-usage-parameters-file.md#cli-usage-parameters-file-binary) for an example. ## Timestamp Timestamps are formatted according to the [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) standard. These are often referred to as "`DateTime`" or "`Date`" parameters. ``` $ aws ec2 describe-spot-price-history --start-time 2014-10-13T19:00:00Z ``` Acceptable formats include: + *YYYY*-*MM*-*DD*T*hh*:*mm*:*ss.sss**TZD (UTC)*, for example, 2014-10-01T20:30:00.000Z + *YYYY*-*MM*-*DD*T*hh*:*mm*:*ss.sss**TZD (with offset)*, for example, 2014-10-01T12:30:00.000-08:00 + *YYYY*-*MM*-*DD*, for example, 2014-10-01 + Unix time in seconds, for example, 1412195400. This is sometimes referred to as [Unix Epoch time](https://wikipedia.org/wiki/Unix_time) and represents the number of seconds since midnight, January 1, 1970 UTC. By default, the AWS CLI version 2 translates all ***response*** DateTime values to ISO 8601 format. You can set the timestamp format by using the `cli\$1timestamp\$1format` file setting. ## List One or more strings separated by spaces. If any of the string items contain a space, you must put quotation marks around that item. Observe your terminal's [quoting rules](cli-usage-parameters-quoting-strings.md) to prevent unexpected results. ``` $ aws ec2 describe-spot-price-history --instance-types m1.xlarge m1.medium ``` ## Boolean Binary flag that turns an option on or off. For example, `ec2 describe-spot-price-history` has a Boolean `--dry-run` parameter that, when specified, validates the query with the service without actually running the query. ``` $ aws ec2 describe-spot-price-history --dry-run ``` The output indicates whether the command was well formed. This command also includes a `--no-dry-run` version of the parameter that you can use to explicitly indicate that the command should be run normally. Including it isn't necessary because this is the default behavior. ## Integer An unsigned, whole number. ``` $ aws ec2 describe-spot-price-history --max-items 5 ``` ## Binary / blob (binary large object) and streaming blob In the AWS CLI, you can pass a binary value as a string directly on the command line. There are two types of blobs: + [Blob](#parameter-type-blob) + [Streaming blob](#parameter-type-streaming-blob) ### Blob To pass a value to a parameter with type `blob`, you must specify a path to a local file that contains the binary data using the `fileb://` prefix. Files referenced using the `fileb://` prefix are always treated as raw unencoded binary. The specified path is interpreted as being relative to the current working directory. For example, the `--plaintext` parameter for `aws kms encrypt` is a blob. ``` $ aws kms encrypt \ --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \ --plaintext fileb://ExamplePlaintextFile \ --output text \ --query CiphertextBlob | base64 \ --decode > ExampleEncryptedFile ``` **Note** For backwards compatibility, you can use the `file://` prefix. There are two formats used based on the file setting `cli\$1binary\$1format` or `--cli-binary-format` command line option: Default for the AWS CLI version 2. If the setting's value is `base64`, files referenced using the `file://` prefix are treated as base64-encoded text. Default for the AWS CLI version 1. If the setting's value is `raw-in-base64-out`, files referenced using the `file://` prefix is read as text and then the AWS CLI attempts to encode it to binary. For more information, see the file setting `cli\$1binary\$1format` or `--cli-binary-format` command line option. ### Streaming blob Streaming blobs such as `aws cloudsearchdomain upload-documents` do not use prefixes. Instead, streaming blob parameters are formatted using the direct file path. The following example uses the direct file path `document-batch.json` for the `aws cloudsearchdomain upload-documents` command: ``` $ aws cloudsearchdomain upload-documents \ --endpoint-url https://doc-my-domain.us-west-1.cloudsearch.amazonaws.com \ --content-type application/json \ --documents document-batch.json ``` ## Map A set of key-value pairs specified in JSON or by using the CLI's [shorthand syntax](cli-usage-shorthand.md). The following JSON example reads an item from an Amazon DynamoDB table named *my-table* with a map parameter, `--key`. The parameter specifies the primary key named *id* with a number value of *1* in a nested JSON structure. For more advanced JSON usage in a command line, consider using a command line JSON processor, like `jq`, to create JSON strings. For more information on `jq`, see the [jq repository](http://stedolan.github.io/jq/) on *GitHub*. ``` $ aws dynamodb get-item --table-name my-table --key '{"id": {"N":"1"}}' { "Item": { "name": { "S": "John" }, "id": { "N": "1" } } } ``` ## Document **Note** [Shorthand syntax](cli-usage-shorthand.md) is not compatible with document types. Document types are used to send data without needing to embed JSON inside strings. The document type enables services to provide arbitrary schemas for you to use more flexible data types. This allows for sending JSON data without needing to escape values. For example, instead of using the following escaped JSON input: ``` {"document": "{\"key\":true}"} ``` You can use the following document type: ``` {"document": {"key": true}} ``` ### Valid values for document types Due to the flexible nature of document types, there are multiple valid value types. Valid values include the following: **String** ``` --option '"value"' ``` **Number** ``` --option 123 --option 123.456 ``` **Boolean** ``` --option true ``` **Null** ``` --option null ``` **Array** ``` --option '["value1", "value2", "value3"]' --option '["value", 1, true, null, ["key1", 2.34], {"key2": "value2"}]' ``` **Object** ``` --option '{"key": "value"}' --option '{"key1": "value1", "key2": 123, "key3": true, "key4": null, "key5": ["value3", "value4"], "key6": {"value5": "value6"}' ``` # Using quotation marks and literals with strings in the AWS CLI Quotes with Strings There are primarily two ways single and double quotes are used in the AWS CLI. + [Using quotation marks around strings that contain white spaces](#cli-usage-parameters-quoting-strings-around) + [Using quotation marks inside strings](#cli-usage-parameters-quoting-strings-containing) ## Using quotation marks around strings that contain white spaces Parameter names and their values are separated by spaces on the command line. If a string value contains an embedded space, then you must surround the entire string with quotation marks to prevent the AWS CLI from misinterpreting the space as a divider between the value and the next parameter name. Which type of quotation mark you use depends on the operating system you are running the AWS CLI on. ------ #### [ Linux and macOS ] Use single quotation marks `' '` ``` $ aws ec2 create-key-pair --key-name 'my key pair' ``` For more information on using quotes, see the user documentation for your preferred shell. ------ #### [ PowerShell ] **Single quotations (recommended)** Single quotation marks `' '` are called `verbatim` strings. The string is passed to the command exactly as you type it, which means PowerShell variables will not pass through. ``` PS C:\> aws ec2 create-key-pair --key-name 'my key pair' ``` **Double quotations** Double quotation marks `" "` are called `expandable` string. Variables can be passed in expandable strings. ``` PS C:\> aws ec2 create-key-pair --key-name "my key pair" ``` For more information on using quotes, see [About Quoting Rules](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) in the *Microsoft PowerShell Docs*. ------ #### [ Windows command prompt ] Use double quotation marks `" "` . ``` C:\> aws ec2 create-key-pair --key-name "my key pair" ``` ------ Optionally, you can separate the parameter name from the value with an equals sign `=` instead of a space. This is typically necessary only if the value of the parameter starts with a hyphen. ``` $ aws ec2 delete-key-pair --key-name=-mykey ``` ## Using quotation marks inside strings Strings might contain quotation marks, and your shell might require escaping quotations for them to work properly. One of the common parameter value types is a JSON string. This is complex since it includes spaces and double quotation marks `" "` around each element name and value in the JSON structure. The way you enter JSON-formatted parameters on the command line differs depending on your operating system. For more advanced JSON usage in the command line, consider using a command line JSON processor, like `jq`, to create JSON strings. For more information on `jq`, see the [jq repository](http://stedolan.github.io/jq/) on *GitHub*. ------ #### [ Linux and macOS ] For Linux and macOS to interpret strings literally use single quotation marks `' '` to enclose the JSON data structure, as in the following example. You do not need to escape double quotation marks embedded in the JSON string, as they are being treated literally. Since the JSON is enclosed in single quotation marks, any single quotation marks in the string will need to be escaped, this is usually accomplished using a backslash before the single quote `\'`. ``` $ aws ec2 run-instances \ --image-id ami-12345678 \ --block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]' ``` For more information on using quotes, see the user documentation for your preferred shell. ------ #### [ PowerShell ] Use single quotation marks `' '` or double quotation marks `" "`. **Single quotations (recommended)** Single quotation marks `' '` are called `verbatim` strings. The string is passed to the command exactly as you type it, which means PowerShell variables will not pass through. Since JSON data structures include double quotes, we suggest **single** quotation marks `' '` to enclose it. If you use **single** quotation marks, you do not need to escape **double** quotation marks embedded in the JSON string. However, you need to escape each **single** quotation mark with a backtick ``` within the JSON structure. ``` PS C:\> aws ec2 run-instances ` --image-id ami-12345678 ` --block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]' ``` **Double quotations** Double quotation marks `" "` are called `expandable` strings. Variables can be passed in expandable strings. If you use **double** quotation marks, you do not need to escape **single** quotation marks embedded in the JSON string. However, you need to escape each **double** quotation mark with a backtick ``` within the JSON structure, as with the following example. ``` PS C:\> aws ec2 run-instances ` --image-id ami-12345678 ` --block-device-mappings "[{`"DeviceName`":`"/dev/sdb`",`"Ebs`":{`"VolumeSize`":20,`"DeleteOnTermination`":false,`"VolumeType`":`"standard`"}}]" ``` For more information on using quotes, see [About Quoting Rules](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) in the *Microsoft PowerShell Docs*. **Warning** Before PowerShell sends a command to the AWS CLI, it determines if your command is interpreted using typical PowerShell or `CommandLineToArgvW` quoting rules. When PowerShell processes using `CommandLineToArgvW`, you must escape characters with a backslash `\`. For more information on `CommandLineToArgvW` in PowerShell, see [What's up with the strange treatment of quotation marks and backslashes by CommandLineToArgvW](https://devblogs.microsoft.com/oldnewthing/20100917-00/?p=12833) in the *Microsoft DevBlogs*, [Everyone quotes command line arguments the wrong way](https://docs.microsoft.com/en-us/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way) in the *Microsoft Docs Blog*, and [CommandLineToArgvW function](https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-commandlinetoargvw#remarks) in the *Microsoft Docs*. **Single quotations** Single quotation marks `' '` are called `verbatim` strings. The string is passed to the command exactly as you type it, which means PowerShell variables will not pass through. Escape characters with a backslash `\`. ``` PS C:\> aws ec2 run-instances ` --image-id ami-12345678 ` --block-device-mappings '[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]' ``` **Double quotations** Double quotation marks `" "` are called `expandable` strings. Variables can be passed in `expandable` strings. For double quoted strings you have to escape twice using *`\$1* for each quote instead of only using a backtick. The backtick escapes the backslash, and then the backslash is used as an escape character for the `CommandLineToArgvW` process. ``` PS C:\> aws ec2 run-instances ` --image-id ami-12345678 ` --block-device-mappings "[{`\"DeviceName`\":`\"/dev/sdb`\",`\"Ebs`\":{`\"VolumeSize`\":20,`\"DeleteOnTermination`\":false,`\"VolumeType`\":`\"standard`\"}}]" ``` **Blobs (recommended)** To bypass PowerShell quoting rules for JSON data input, use Blobs to pass your JSON data directly to the AWS CLI. For more information on Blobs, see [Blob](cli-usage-parameters-types.md#parameter-type-blob). ------ #### [ Windows command prompt ] The Windows command prompt requires double quotation marks `" "` to enclose the JSON data structure. Also, to prevent the command processor from misinterpreting the double quotation marks embedded in the JSON, you must also escape (precede with a backslash `\` character) each double quotation mark `"` within the JSON data structure itself, as in the following example. ``` C:\> aws ec2 run-instances ^ --image-id ami-12345678 ^ --block-device-mappings "[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]" ``` Only the outermost double quotation marks are not escaped. ------ # Loading a parameter from a file in the AWS CLI File Parameters Some parameters expect file names as arguments, from which the AWS CLI loads the data. Other parameters enable you to specify the parameter value as either text typed on the command line or read from a file. Whether a file is required or optional, you must encode the file correctly so that the AWS CLI can understand it. The file's encoding must match the reading system's default locale. You can determine this by using the Python `locale.getpreferredencoding()` method. This method is for loading a file for a single parameter. For information on loading multiple parameters with a single file, see [AWS CLI skeletons and input files in the AWS CLI](cli-usage-skeleton.md). **Note** By default, Windows PowerShell outputs text as UTF-16, which conflicts with the UTF-8 encoding used by JSON files and many Linux systems. We recommend that you use `-Encoding ascii` with your PowerShell `Out-File` commands to ensure the AWS CLI can read the resulting file. **Topics** + [ ## How to load a parameter from a file ](#cli-usage-parameters-file-how) + [ ## Binary files ](#cli-usage-parameters-file-binary) + [ ## Loading a file as a shorthand syntax value ](#cli-usage-parameters-file-shorthand) ## How to load a parameter from a file Sometimes it's convenient to load a parameter value from a file instead of trying to type it all as a command line parameter value, such as when the parameter is a complex JSON string. To specify a file that contains the value, specify a file URL in the following format. ``` file://complete/path/to/file ``` + The first two slash '/' characters are part of the specification. If the required path begins with a '/', the result is three slash characters: `file:///folder/file`. + The URL provides the path to the file that contains the actual parameter content. + When using files with spaces or special characters, follow the [quoting and escaping rules](cli-usage-parameters-quoting-strings.md) for your terminal. The file paths in the following examples are interpreted to be relative to the current working directory. ------ #### [ 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" ``` ------ The `file://` prefix option supports Unix-style expansions, including "`~/`", "`./`", and "`../`". On Windows, the "`~/`" expression expands to your user directory, stored in the `%USERPROFILE%` environment variable. For example, on Windows 10 you would typically have a user directory under `%USERPROFILE%`. You must still escape JSON documents that are embedded as the value of another JSON document. ``` $ 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\"}" } ``` ## Binary files For commands that take binary data as a parameter, specify that the data is binary content by using the `fileb://` prefix. Commands that accept binary data include: + **`aws ec2 run-instances:`** `--user-data` parameter. + **`aws s3api put-object:`** `--sse-customer-key` parameter. + **`aws kms decrypt:`** `--ciphertext-blob` parameter. The following example generates a binary 256-bit AES key using a Linux command line tool, and then provides it to Amazon S3 to encrypt an uploaded file server-side. ``` $ 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\"" } ``` For another example referencing a file containing JSON-formatted parameters, see [Attaching an IAM managed policy to a user](cli-services-iam.md#cli-services-iam-policy). ## Loading a file as a shorthand syntax value When using shorthand syntax where a value is large or complex, it is often easier to load in a file as a value. To load a file as a shorthand syntax value, the formatting will change slightly. Instead of `key=value` you'll use the `@=` operator instead of the `=` operator. The `@=` signifies to the AWS CLI that the value should be read as a file path and not a string. The following example shows a key-value pair loading a file for its value. ------ #### [ Linux or macOS ] ``` --option key@=file://template.txt ``` ------ #### [ Windows ] ``` --option "key1@=file://template.txt" ``` ------ The following example demonstrates loading a certificate file for the `aws rolesanywhere create-trust-anchor` command. ``` $ aws rolesanywhere create-trust-anchor --name TrustAnchor \ --source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \ --enabled ``` For more information on shorthand syntax, see [Using shorthand syntax in the AWS CLI](cli-usage-shorthand.md). # AWS CLI skeletons and input files in the AWS CLI Generate a CLI Skeleton Template Most of the AWS CLI commands accept importing parameter inputs from a file. These templates can be generated using the `generate-cli-skeleton` option and then be imported using the `--cli-input-json` and `--cli-input-yaml` parameters. **Topics** + [ ## About AWS CLI skeletons and input files ](#cli-usage-skeleton-about) + [ ## Generate and import a command skeleton ](#cli-usage-skeleton-generate) + [ ## Combining input files and command line parameters ](#cli-usage-skeleton-combine) ## About AWS CLI skeletons and input files Most of the AWS Command Line Interface (AWS CLI) commands support the ability to accept parameter inputs from a file using the `--cli-input-json` and `--cli-input-yaml` parameters. Those same commands use the `--generate-cli-skeleton` parameter to generate a file in either JSON or YAML format with all of the parameters that you can edit and fill in. Then you can run the command with the `--cli-input-json` or `--cli-input-yaml` parameter and point to the filled-in file. **Important** Custom AWS CLI commands, such as the [`aws s3` commands](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) don't support either the `--generate-cli-skeleton` or `--cli-input-json` and `--cli-input-yaml` parameters described in this topic. To check if a specific command supports these parameters, run the [`help` command](cli-usage-help.md#cli-usage-help-command) for the command you want to use or refer to the [AWS CLI version 2 reference guide](https://docs.aws.amazon.com/cli/latest/reference/index.html). The `--generate-cli-skeleton` generates and displays a parameter template that you can customize and use as input on a command. The generated template includes all of the parameters that the command supports. The `--generate-cli-skeleton` parameter accepts one of the following values: + `input` – The generated template includes all input parameters formatted as JSON. This is the default value. + `yaml-input` – The generated template includes all input parameters formatted as YAML. + `output` – The generated template includes all output parameters formatted as JSON. You can't currently request the output parameters as YAML. Because the AWS CLI is essentially a "wrapper" around the service's API, the skeleton file expects you to reference all parameters by their underlying API parameter names. This is likely different from the AWS CLI parameter name. For example, an AWS CLI parameter named `user-name` might map to the AWS service's API parameter named `UserName` (notice the altered capitalization and missing dash). We recommend that you use the `--generate-cli-skeleton` option to generate the template with the "correct" parameter names to avoid errors. You can reference the API Reference Guide for the service to see the expected parameter names. You can delete any parameters from the template that are not required and for which you don't want to supply a value. For example, if you run the following command, it generates the parameter template for the Amazon Elastic Compute Cloud (Amazon EC2) command **run-instances**. ------ #### [ JSON ] The following example shows how to generate a template formatted in JSON by using the default value (`input`) for the `--generate-cli-skeleton` parameter. ``` $ 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 ] The following example shows how to generate a template formatted in YAML by using the value `yaml-input` for the `--generate-cli-skeleton` parameter. ``` $ 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. ``` ------ ## Generate and import a command skeleton **To generate and use a parameter skeleton file** 1. Run the command with the `--generate-cli-skeleton` parameter to produce either JSON or YAML and direct the output to a file to save it. ------ #### [ JSON ] ``` $ aws ec2 run-instances --generate-cli-skeleton input > ec2runinst.json ``` ------ #### [ YAML ] ``` $ aws ec2 run-instances --generate-cli-skeleton yaml-input > ec2runinst.yaml ``` ------ 1. Open the parameter skeleton file in your text editor and remove any of the parameters that you don't need. For example, you might strip the template down to the following. Confirm the file is still valid JSON or YAML after you remove the elements you don't need. ------ #### [ JSON ] ``` { "DryRun": true, "ImageId": "", "KeyName": "", "SecurityGroups": [ "" ], "InstanceType": "", "Monitoring": { "Enabled": true } } ``` ------ #### [ YAML ] ``` DryRun: true ImageId: '' KeyName: '' SecurityGroups: - '' InstanceType: Monitoring: Enabled: true ``` ------ In this example, we leave the `DryRun` parameter set to `true` to use the Amazon EC2 dry run feature. This feature lets you safely test the command without actually creating or modifying any resources. 1. Fill in the remaining values with values appropriate for your scenario. In this example, we provide the instance type, key name, security group, and identifier of the Amazon Machine Image (AMI) to use. This example assumes the default AWS Region. The AMI `ami-dfc39aef` is a 64-bit Amazon Linux image hosted in the `us-west-2` Region. If you use a different Region, you must [find the correct AMI ID to use](http://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. Run the command with the completed parameters by passing the completed template file to either the `--cli-input-json` or --`cli-input-yaml` parameter by using the `file://` prefix. The AWS CLI interprets the path to be relative to your current working directory. The following example the AWS CLI looks for the file in the current working directory. ------ #### [ 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. ``` ------ The dry run error indicates that the JSON or YAML is formed correctly and that the parameter values are valid. If other issues are reported in the output, fix them and repeat the previous step until the "`Request would have succeeded`" message is displayed. 1. Now you can set the `DryRun` parameter to `false` to disable dry run. ------ #### [ 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. Run the command, and `run-instances` actually launches an Amazon EC2 instance and displays the details generated by the successful launch. The format of the output is controlled by the `--output` parameter, separately from the format of your input parameter template. ------ #### [ 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: ... ``` ------ ## Combining input files and command line parameters An input file can be used for all parameters, or can be combined with parameters specified in the AWS CLI. You can use this feature for settings you frequently reuse in an input file, while keeping your individual settings in the command itself. The following `aws ec2 run-instances` examples combine the use of an input file and parameters. We provide the instance type, key name, security group, identifier of the Amazon Machine Image (AMI) to use and assume the default AWS Region. The AMI `ami-dfc39aef` is a 64-bit Amazon Linux image hosted in the `us-west-2` Region. If you use a different Region, you must [find the correct AMI ID to use](http://aws.amazon.com/amazon-linux-ami/). ------ #### [ JSON ] Contents of the JSON file: ``` { "ImageId": "ami-dfc39aef", "KeyName": "mykey", "SecurityGroups": [ "my-sg" ], "InstanceType": "t2.micro", "Monitoring": { "Enabled": true } } ``` ------ #### [ YAML ] Contents of the YAML file: ``` ImageId: 'ami-dfc39aef' KeyName: 'mykey' SecurityGroups: - 'my-sg' InstanceType: 't2.micro' Monitoring: Enabled: true ``` ------ The following example uses the input file in combination with the `--dry-run` parameter to perform a dry-run of the command to confirm whether you have the required permissions and have filled out the file with valid values. ------ #### [ 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. ``` ------ The following example then uses the same input file, but with the `--no-dry-run` parameter to perform the command in full. ------ #### [ 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: ... ``` ------ # Using shorthand syntax in the AWS CLI Shorthand Syntax The AWS Command Line Interface (AWS CLI) can accept many of its option parameters in JSON format. However, it can be tedious to enter large JSON lists or structures on the command line. To make this easier, the AWS CLI also supports a shorthand syntax that enables a simpler representation of your option parameters than using the full JSON format. **Topics** + [ ## Structure parameters with key-value pairs ](#shorthand-structure-parameters) + [ ## Loading a file as a shorthand syntax value ](#shorthand-files) + [ ## Using shorthand syntax with the AWS CLI ](#shorthand-list-parameters) ## Structure parameters with key-value pairs The shorthand syntax in the AWS CLI makes it easier for users to input parameters that are flat (non-nested structures). The format is a comma-separated list of key-value pairs. Be sure to use the [quoting](cli-usage-parameters-quoting-strings.md) and escaping rules appropriate for your terminal as shorthand syntax are strings. ------ #### [ Linux or macOS ] ``` --option key1=value1,key2=value2,key3=value3 ``` Is equivalent to the following example, formatted in JSON. ``` --option '{"key1":"value1","key2":"value2","key3":"value3"}' ``` ------ #### [ Windows ] ``` --option "key1=value1,key2=value2,key3=value3" ``` Is equivalent to the following example, formatted in JSON. ``` --option '{"key1":"value1","key2":"value2","key3":"value3"}' ``` ------ There must be no white space between each comma-separated key-value pair. Here is an example of the Amazon DynamoDB `update-table` command with the `--provisioned-throughput` option specified in shorthand. ``` $ aws dynamodb update-table \ --provisioned-throughput ReadCapacityUnits=15,WriteCapacityUnits=10 \ --table-name MyDDBTable ``` This is equivalent to the following example formatted in JSON. ``` $ aws dynamodb update-table \ --provisioned-throughput '{"ReadCapacityUnits":15,"WriteCapacityUnits":10}' \ --table-name MyDDBTable ``` ## Loading a file as a shorthand syntax value When a value is large or complex, it is often easier to load in as a value. To load a file as a shorthand syntax value, the formatting will change slightly. Instead of `key=value` you'll use the `@=` operator instead of the `=` operator. The `@=` signifies to the AWS CLI that the value should be read as a file path and not a string. When loading files in shorthand syntax, the usual [AWS CLI file formatting rules apply](cli-usage-parameters-file.md). The following example shows a key-value pair loading a file for its value. ------ #### [ Linux or macOS ] ``` --option key@=file://template.txt ``` ------ #### [ Windows ] ``` --option "key1@=file://template.txt" ``` ------ The following example demonstrates loading a certificate file for the `aws rolesanywhere create-trust-anchor` command. ``` $ aws rolesanywhere create-trust-anchor --name TrustAnchor \ --source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \ --enabled ``` ## Using shorthand syntax with the AWS CLI Shorthand Syntax You can specify Input parameters in a list form in two ways: JSON or shorthand. The AWS CLI shorthand syntax is designed to make it easier to pass in lists with number, string, or non-nested structures. The basic format is shown here, where values in the list are separated by a single space. ``` --option value1 value2 value3 ``` This is equivalent to the following example, formatted in JSON. ``` --option '[value1,value2,value3]' ``` As previously mentioned, you can specify a list of numbers, a list of strings, or a list of non-nested structures in shorthand. The following is an example of the `stop-instances` command for Amazon Elastic Compute Cloud (Amazon EC2), where the input parameter (list of strings) for the `--instance-ids` option is specified in shorthand. ``` $ aws ec2 stop-instances \ --instance-ids i-1486157a i-1286157c i-ec3a7e87 ``` This is equivalent to the following example formatted in JSON. ``` $ aws ec2 stop-instances \ --instance-ids '["i-1486157a","i-1286157c","i-ec3a7e87"]' ``` The following example shows the Amazon EC2 `create-tags` command, which takes a list of non-nested structures for the `--tags` option. The `--resources` option specifies the ID of the instance to tag. ``` $ aws ec2 create-tags \ --resources i-1286157c \ --tags Key=My1stTag,Value=Value1 Key=My2ndTag,Value=Value2 Key=My3rdTag,Value=Value3 ``` This is equivalent to the following example, formatted in JSON. The JSON parameter is written over multiple lines for readability. ``` $ aws ec2 create-tags \ --resources i-1286157c \ --tags '[ {"Key": "My1stTag", "Value": "Value1"}, {"Key": "My2ndTag", "Value": "Value2"}, {"Key": "My3rdTag", "Value": "Value3"} ]' ```