neulab/tldr huggingface dataset:
salt myminion boto_cloudwatch_event.list_rules region=us-east-1
salt.modules.boto_cloudwatch_event.list_targets(Rule, region=None, key=None, keyid=None, profile=None) Given a rule name list the targets of that rule.
salt myminion boto_cloudwatch_event.list_targets myrule
salt.modules.boto_cloudwatch_event.put_targets(Rule, Targets, region=None, key=None, keyid=None, profile=None) Add the given targets to the given rule
Returns a dictionary describing any failures.
salt myminion boto_cloudwatch_event.put_targets myrule [{'Id': 'target1', 'Arn': 'arn:***'}]
salt.modules.boto_cloudwatch_event.remove_targets(Rule, Ids, region=None, key=None, keyid=None, profile=None) Given a rule name remove the named targets from the target list
salt myminion boto_cloudwatch_event.remove_targets myrule ['Target1']
salt.modules.boto_cognitoidentity Connection module for Amazon CognitoIdentity
configuration This module accepts explicit CognitoIdentity credentials but can also utilize IAM roles assigned to the instance trough Instance Profiles.  Dynamic credentials are then automatically obtained from AWS API and no further configuration is necessary. More Information available at:
cognitoidentity.keyid: GKTADJGHEIQSXMKKRBJ08H cognitoidentity.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
cognitoidentity.region: us-east-1
Changed in version 2015.8.0: All methods now return a dictionary. Create, delete, set, and update methods return:
Request methods (e.g., describe_identity_pools) return:
identity_pools: - {...} - {...}
salt.modules.boto_cognitoidentity.create_identity_pool(IdentityPoolName, AllowUnauthenticatedIdentities=False, SupportedLoginProviders=None, DeveloperProviderName=None, OpenIdConnectProviderARNs=None, region=None, key=None, keyid=None, profile=None) Creates a new identity pool.  All parameters except for IdentityPoolName is optional.  SupportedLoginProviders should be a dictionary mapping provider names to provider app IDs. OpenIdConnectProviderARNs should be a list of OpenID Connect provider ARNs.
Returns the created identity pool if successful
salt myminion boto_cognitoidentity.create_identity_pool my_id_pool_name                              DeveloperProviderName=custom_developer_provider
salt.modules.boto_cognitoidentity.delete_identity_pools(IdentityPoolName, IdentityPoolId=None, region=None, key=None, keyid=None, profile=None) Given an identity pool name, (optionally if an identity pool id is given, the given name will be ignored)
Deletes all identity pools matching the given name, or the specific identity pool with the given identity pool id.
salt myminion boto_cognitoidentity.delete_identity_pools my_id_pool_name salt myminion boto_cognitoidentity.delete_identity_pools '' IdentityPoolId=my_id_pool_id
salt.modules.boto_cognitoidentity.describe_identity_pools(IdentityPoolName, IdentityPoolId=None, region=None, key=None, keyid=None, profile=None) Given an identity pool name, (optionally if an identity pool id is given, the given name will be ignored)
Returns a list of matched identity pool name's pool properties
salt myminion boto_cognitoidentity.describe_identity_pools my_id_pool_name salt myminion boto_cognitoidentity.describe_identity_pools '' IdentityPoolId=my_id_pool_id
salt.modules.boto_cognitoidentity.get_identity_pool_roles(IdentityPoolName, IdentityPoolId=None, region=None, key=None, keyid=None, profile=None) Given an identity pool name, (optionally if an identity pool id if given, the given name will be ignored)
Returns a list of matched identity pool name's associated roles
salt myminion boto_cognitoidentity.get_identity_pool_roles my_id_pool_name salt myminion boto_cognitoidentity.get_identity_pool_roles '' IdentityPoolId=my_id_pool_id
salt.modules.boto_cognitoidentity.set_identity_pool_roles(IdentityPoolId, AuthenticatedRole=None, UnauthenticatedRole=None, region=None, key=None, keyid=None, profile=None) Given an identity pool id, set the given AuthenticatedRole and UnauthenticatedRole (the Role can be an iam arn, or a role name) If AuthenticatedRole or UnauthenticatedRole is not given, the authenticated and/or the unauthenticated role associated previously with the pool will be cleared.
Returns set True if successful, set False if unsuccessful with the associated errors.
salt myminion boto_cognitoidentity.set_identity_pool_roles my_id_pool_roles  # this clears the roles salt myminion boto_cognitoidentity.set_identity_pool_roles my_id_pool_id             AuthenticatedRole=my_auth_role UnauthenticatedRole=my_unauth_role  # this set both roles salt myminion boto_cognitoidentity.set_identity_pool_roles my_id_pool_id             AuthenticatedRole=my_auth_role  # this will set the auth role and clear the unauth role salt myminion boto_cognitoidentity.set_identity_pool_roles my_id_pool_id             UnauthenticatedRole=my_unauth_role  # this will set the unauth role and clear the auth role
salt.modules.boto_cognitoidentity.update_identity_pool(IdentityPoolId, IdentityPoolName=None, AllowUnauthenticatedIdentities=False, SupportedLoginProviders=None, DeveloperProviderName=None, OpenIdConnectProviderARNs=None, region=None, key=None, keyid=None, profile=None) Updates the given IdentityPoolId's properties.  All parameters except for IdentityPoolId, is optional.  SupportedLoginProviders should be a dictionary mapping provider names to provider app IDs. OpenIdConnectProviderARNs should be a list of OpenID Connect provider ARNs.
To clear SupportedLoginProviders pass '{}'
To clear OpenIdConnectProviderARNs pass '[]'
boto3 api prevents DeveloperProviderName to be updated after it has been set for the first time.
Returns the updated identity pool if successful
salt myminion boto_cognitoidentity.update_identity_pool my_id_pool_id my_id_pool_name                              DeveloperProviderName=custom_developer_provider
salt.modules.boto_datapipeline Connection module for Amazon Data Pipeline
salt.modules.boto_datapipeline.activate_pipeline(pipeline_id, region=None, key=None, keyid=None, profile=None) Start processing pipeline tasks. This function is idempotent.
salt myminion boto_datapipeline.activate_pipeline my_pipeline_id
salt.modules.boto_datapipeline.create_pipeline(name, unique_id, description='', region=None, key=None, keyid=None, profile=None) Create a new, empty pipeline. This function is idempotent.
salt myminion boto_datapipeline.create_pipeline my_name my_unique_id
salt.modules.boto_datapipeline.delete_pipeline(pipeline_id, region=None, key=None, keyid=None, profile=None) Delete a pipeline, its pipeline definition, and its run history. This function is idempotent.
salt myminion boto_datapipeline.delete_pipeline my_pipeline_id
salt.modules.boto_datapipeline.describe_pipelines(pipeline_ids, region=None, key=None, keyid=None, profile=None) Retrieve metadata about one or more pipelines.
salt myminion boto_datapipeline.describe_pipelines ['my_pipeline_id']
salt.modules.boto_datapipeline.get_pipeline_definition(pipeline_id, version='latest', region=None, key=None, keyid=None, profile=None) Get the definition of the specified pipeline.
salt myminion boto_datapipeline.get_pipeline_definition my_pipeline_id
salt.modules.boto_datapipeline.list_pipelines(region=None, key=None, keyid=None, profile=None) Get a list of pipeline ids and names for all pipelines.
salt myminion boto_datapipeline.list_pipelines profile=myprofile
salt.modules.boto_datapipeline.pipeline_id_from_name(name, region=None, key=None, keyid=None, profile=None) Get the pipeline id, if it exists, for the given name.
salt myminion boto_datapipeline.pipeline_id_from_name my_pipeline_name
salt.modules.boto_datapipeline.put_pipeline_definition(pipeline_id, pipeline_objects, parameter_objects=None, parameter_values=None, region=None, key=None, keyid=None, profile=None) Add tasks, schedules, and preconditions to the specified pipeline. This function is idempotent and will replace an existing definition.
salt myminion boto_datapipeline.put_pipeline_definition my_pipeline_id my_pipeline_objects
salt.modules.boto_dynamodb Connection module for Amazon DynamoDB
configuration This module accepts explicit DynamoDB credentials but can also utilize IAM roles assigned to the instance through Instance Profiles.  Dynamic credentials are then automatically obtained from AWS API and no further configuration is necessary. More Information available at:
keyid: GKTADJGHEIQSXMKKRBJ08H key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
region: us-east-1
salt.modules.boto_dynamodb.create_global_secondary_index(table_name, global_index, region=None, key=None, keyid=None, profile=None) Creates a single global secondary index on a DynamoDB table.
salt myminion boto_dynamodb.create_global_secondary_index table_name / index_name
salt.modules.boto_dynamodb.create_table(table_name, region=None, key=None, keyid=None, profile=None, read_capacity_units=None, write_capacity_units=None, hash_key=None, hash_key_data_type=None, range_key=None, range_key_data_type=None, local_indexes=None, global_indexes=None) Creates a DynamoDB table.
salt myminion boto_dynamodb.create_table table_name / region=us-east-1 / hash_key=id / hash_key_data_type=N / range_key=created_at / range_key_data_type=N / read_capacity_units=1 / write_capacity_units=1
salt.modules.boto_dynamodb.delete(table_name, region=None, key=None, keyid=None, profile=None) Delete a DynamoDB table.
salt myminion boto_dynamodb.delete table_name region=us-east-1
salt.modules.boto_dynamodb.describe(table_name, region=None, key=None, keyid=None, profile=None) Describe a DynamoDB table.
salt myminion boto_dynamodb.describe table_name region=us-east-1
salt.modules.boto_dynamodb.exists(table_name, region=None, key=None, keyid=None, profile=None) Check to see if a table exists.
salt myminion boto_dynamodb.exists table_name region=us-east-1
salt.modules.boto_dynamodb.extract_index(index_data, global_index=False) Instantiates and returns an AllIndex object given a valid index configuration
salt myminion boto_dynamodb.extract_index index
salt.modules.boto_dynamodb.update(table_name, throughput=None, global_indexes=None, region=None, key=None, keyid=None, profile=None) Update a DynamoDB table.
salt myminion boto_dynamodb.update table_name region=us-east-1
salt.modules.boto_dynamodb.update_global_secondary_index(table_name, global_indexes, region=None, key=None, keyid=None, profile=None) Updates the throughput of the given global secondary indexes.
salt myminion boto_dynamodb.update_global_secondary_index table_name / indexes
salt.modules.boto_ec2 Connection module for Amazon EC2
configuration This module accepts explicit EC2 credentials but can also utilize IAM roles assigned to the instance through Instance Profiles. Dynamic credentials are then automatically obtained from AWS API and no further configuration is necessary. More Information available here.
ec2.keyid: GKTADJGHEIQSXMKKRBJ08H ec2.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
ec2.region: us-east-1
It's also possible to specify key, keyid, and region via a profile, either as a passed in dict, or as a string to pull from pillars or minion config:
salt.modules.boto_ec2.allocate_eip_address(domain=None, region=None, key=None, keyid=None, profile=None) Allocate a new Elastic IP address and associate it with your account.
domain (string) Optional param - if set to exactly 'vpc', the address will be allocated to the VPC.  The default simply maps the EIP to your account container.
returns (dict) dict of 'interesting' information about the newly allocated EIP, with probably the most interesting keys being 'public_ip'; and 'allocation_id' iff 'domain=vpc' was passed.
salt-call boto_ec2.allocate_eip_address domain=vpc
salt.modules.boto_ec2.assign_private_ip_addresses(network_interface_name=None, network_interface_id=None, private_ip_addresses=None, secondary_private_ip_address_count=None, allow_reassignment=False, region=None, key=None, keyid=None, profile=None) Assigns one or more secondary private IP addresses to a network interface.
network_interface_id (string) - ID of the network interface to associate the IP with (exclusive with 'network_interface_name')
network_interface_name (string) - Name of the network interface to associate the IP with (exclusive with 'network_interface_id')
private_ip_addresses (list) - Assigns the specified IP addresses as secondary IP addresses to the network interface (exclusive with 'secondary_private_ip_address_count')
secondary_private_ip_address_count (int) - The number of secondary IP addresses to assign to the network interface. (exclusive with 'private_ip_addresses')
allow_reassociation (bool)   – Allow a currently associated EIP to be re-associated with the new instance or interface.
returns (bool)   - True on success, False on failure.
salt myminion boto_ec2.assign_private_ip_addresses network_interface_name=my_eni private_ip_addresses=private_ip salt myminion boto_ec2.assign_private_ip_addresses network_interface_name=my_eni secondary_private_ip_address_count=2
salt.modules.boto_ec2.associate_eip_address(instance_id=None, instance_name=None, public_ip=None, allocation_id=None, network_interface_id=None, network_interface_name=None, private_ip_address=None, allow_reassociation=False, region=None, key=None, keyid=None, profile=None) Associate an Elastic IP address with a currently running instance or a network interface.  This requires exactly one of either 'public_ip' or 'allocation_id', depending on whether you’re associating a VPC address or a plain EC2 address.
instance_id (string) – ID of the instance to associate with (exclusive with 'instance_name')
instance_name (string) – Name tag of the instance to associate with (exclusive with 'instance_id')
public_ip (string) – Public IP address, for standard EC2 based allocations.
allocation_id (string) – Allocation ID for a VPC-based EIP.
network_interface_id (string) - ID of the network interface to associate the EIP with
network_interface_name (string) - Name of the network interface to associate the EIP with
private_ip_address (string) – The primary or secondary private IP address to associate with the Elastic IP address.
salt myminion boto_ec2.associate_eip_address instance_name=bubba.ho.tep allocation_id=eipalloc-ef382c8a
salt.modules.boto_ec2.attach_network_interface(device_index, name=None, network_interface_id=None, instance_name=None, instance_id=None, region=None, key=None, keyid=None, profile=None) Attach an Elastic Network Interface.
salt myminion boto_ec2.attach_network_interface my_eni instance_name=salt-master device_index=0
salt.modules.boto_ec2.attach_volume(volume_id, instance_id, device, region=None, key=None, keyid=None, profile=None) Attach an EBS volume to an EC2 instance.  ..
volume_id (string) – The ID of the EBS volume to be attached.
instance_id (string) – The ID of the EC2 instance to attach the volume to.
device (string) – The device on the instance through which the volume is exposed (e.g. /dev/sdh)
returns (bool) - True on success, False on failure.
salt-call boto_ec2.attach_volume vol-12345678 i-87654321 /dev/sdh
salt.modules.boto_ec2.create_image(ami_name, instance_id=None, instance_name=None, tags=None, region=None, key=None, keyid=None, profile=None, description=None, no_reboot=False, dry_run=False, filters=None) Given instance properties that define exactly one instance, create AMI and return AMI-id.
salt myminion boto_ec2.create_image ami_name instance_name=myinstance salt myminion boto_ec2.create_image another_ami_name tags='{"mytag": "value"}' description='this is my ami'
salt.modules.boto_ec2.create_key(key_name, save_path, region=None, key=None, keyid=None, profile=None) Creates a key and saves it to a given path.  Returns the private key.
salt myminion boto_ec2.create_key mykey /root/
salt.modules.boto_ec2.create_network_interface(name, subnet_id=None, subnet_name=None, private_ip_address=None, description=None, groups=None, region=None, key=None, keyid=None, profile=None) Create an Elastic Network Interface.
salt myminion boto_ec2.create_network_interface my_eni subnet-12345 description=my_eni groups=['my_group']
salt.modules.boto_ec2.create_tags(resource_ids, tags, region=None, key=None, keyid=None, profile=None) Create new metadata tags for the specified resource ids.
resource_ids (string) or (list) – List of resource IDs.  A plain string will be converted to a list of one element.
tags   (dict) – Dictionary of name/value pairs. To create only a tag name, pass '' as the value.
salt-call boto_ec2.create_tags vol-12345678 '{"Name": "myVolume01"}'
salt.modules.boto_ec2.create_volume(zone_name, size=None, snapshot_id=None, volume_type=None, iops=None, encrypted=False, kms_key_id=None, wait_for_creation=False, region=None, key=None, keyid=None, profile=None) Create an EBS volume to an availability zone.
zone_name (string) – The Availability zone name of the EBS volume to be created.
(int) – The size of the new volume, in GiB. If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
snapshot_id (string) –  The snapshot ID from which the new volume will be created.
volume_type
(string) - The type of the volume. Valid volume types for AWS can be found here: http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html
iops   (int) - The provisioned IOPS you want to associate with this volume.
encrypted (bool) - Specifies whether the volume should be encrypted.
kms_key_id
(string) - If encrypted is True, this KMS Key ID may be specified to encrypt volume with this key e.g.: arn:aws:kms:us-east-1:012345678910:key/abcd1234-a123-456a-a12b-a123b4cd56ef
wait_for_creation (bool) - Whether or not to wait for volume creation to complete.
returns (string) - created volume id on success, error message on failure.
salt-call boto_ec2.create_volume us-east-1a size=10 salt-call boto_ec2.create_volume us-east-1a snapshot_id=snap-0123abcd
salt.modules.boto_ec2.delete_key(key_name, region=None, key=None, keyid=None, profile=None) Deletes a key. Always returns True
salt myminion boto_ec2.delete_key mykey
salt.modules.boto_ec2.delete_network_interface(name=None, network_interface_id=None, region=None, key=None, keyid=None, profile=None) Create an Elastic Network Interface.
salt.modules.boto_ec2.delete_tags(resource_ids, tags, region=None, key=None, keyid=None, profile=None) Delete metadata tags for the specified resource ids.
(dict) or (list) – Either a dictionary containing name/value pairs or a list containing just tag names. If you pass in a dictionary, the values must match the actual tag values or the tag will not be deleted. If you pass in a value of None for the tag value, all tags with that name will be deleted.
salt-call boto_ec2.delete_tags vol-12345678 '{"Name": "myVolume01"}' salt-call boto_ec2.delete_tags vol-12345678 '["Name","MountPoint"]'
salt.modules.boto_ec2.delete_volume(volume_id, instance_id=None, device=None, force=False, region=None, key=None, keyid=None, profile=None) Detach an EBS volume from an EC2 instance.
volume_id (string) – The ID of the EBS volume to be deleted.
force  (bool) – Forces deletion even if the device has not yet been detached from its instance.
salt-call boto_ec2.delete_volume vol-12345678
salt.modules.boto_ec2.detach_network_interface(name=None, network_interface_id=None, attachment_id=None, force=False, region=None, key=None, keyid=None, profile=None) Detach an Elastic Network Interface.
salt myminion boto_ec2.detach_network_interface my_eni
salt.modules.boto_ec2.detach_volume(volume_id, instance_id=None, device=None, force=False, wait_for_detachement=False, region=None, key=None, keyid=None, profile=None) Detach an EBS volume from an EC2 instance.
volume_id (string) – The ID of the EBS volume to be detached.
instance_id (string) – The ID of the EC2 instance from which it will be detached.
device (string) – The device on the instance through which the volume is exposted (e.g. /dev/sdh)
(bool) – Forces detachment if the previous detachment attempt did not occur cleanly. This option can lead to data loss or a corrupted file system. Use this option only as a last resort to detach a volume from a failed instance. The instance will not have an opportunity to flush file system caches nor file system meta data.  If you use this option, you must perform file system check and repair procedures.
wait_for_detachement (bool) - Whether or not to wait for volume detachement to complete.
salt-call boto_ec2.detach_volume vol-12345678 i-87654321
salt.modules.boto_ec2.disassociate_eip_address(public_ip=None, association_id=None, region=None, key=None, keyid=None, profile=None) Disassociate an Elastic IP address from a currently running instance. This requires exactly one of either 'association_id' or 'public_ip', depending on whether you’re dealing with a VPC or EC2 Classic address.
public_ip (string) – Public IP address, for EC2 Classic allocations.
association_id (string) – Association ID for a VPC-bound EIP.
salt myminion boto_ec2.disassociate_eip_address association_id=eipassoc-e3ba2d16
salt.modules.boto_ec2.exists(instance_id=None, name=None, tags=None, region=None, key=None, keyid=None, profile=None, in_states=None, filters=None) Given an instance id, check to see if the given instance id exists.
Returns True if the given instance with the given id, name, or tags exists; otherwise, False is returned.
salt myminion boto_ec2.exists myinstance
salt.modules.boto_ec2.find_images(ami_name=None, executable_by=None, owners=None, image_ids=None, tags=None, region=None, key=None, keyid=None, profile=None, return_objs=False) Given image properties, find and return matching AMI ids
salt myminion boto_ec2.find_images tags='{"mytag": "value"}'
salt.modules.boto_ec2.find_instances(instance_id=None, name=None, tags=None, region=None, key=None, keyid=None, profile=None, return_objs=False, in_states=None, filters=None) Given instance properties, find and return matching instance ids
salt myminion boto_ec2.find_instances # Lists all instances salt myminion boto_ec2.find_instances name=myinstance salt myminion boto_ec2.find_instances tags='{"mytag": "value"}' salt myminion boto_ec2.find_instances filters='{"vpc-id": "vpc-12345678"}'
salt.modules.boto_ec2.get_all_eip_addresses(addresses=None, allocation_ids=None, region=None, key=None, keyid=None, profile=None) Get public addresses of some, or all EIPs associated with the current account.
addresses (list) - Optional list of addresses.  If provided, only the addresses associated with those in the list will be returned.
allocation_ids (list) - Optional list of allocation IDs.  If provided, only the addresses associated with the given allocation IDs will be returned.
returns (list) - A list of the requested EIP addresses
salt-call boto_ec2.get_all_eip_addresses
salt.modules.boto_ec2.get_all_tags(filters=None, region=None, key=None, keyid=None, profile=None) Describe all tags matching the filter criteria, or all tags in the account otherwise.
filters (dict) - Additional constraints on which volumes to return. Note that valid filters vary extensively depending on the resource type.  When in doubt, search first without a filter and then use the returned data to help fine-tune your search.  You can generally garner the resource type from its ID (e.g. vol-XXXXX is a volume, i-XXXXX is an instance, etc.
salt-call boto_ec2.get_all_tags '{"tag:Name": myInstanceNameTag, resource-type: instance}'
salt.modules.boto_ec2.get_all_volumes(volume_ids=None, filters=None, return_objs=False, region=None, key=None, keyid=None, profile=None) Get a list of all EBS volumes, optionally filtered by provided 'filters' param
volume_ids (list) - Optional list of volume_ids.  If provided, only the volumes associated with those in the list will be returned.
filters (dict) - Additional constraints on which volumes to return. Valid filters are:
• attachment.attach-time - The time stamp when the attachment initiated.
• attachment.delete-on-termination - Whether the volume is deleted on instance termination.
• attachment.device - The device name that is exposed to the instance (for example, /dev/sda1).
• attachment.instance-id - The ID of the instance the volume is attached to.
• attachment.status - The attachment state (attaching | attached | detaching | detached).
• availability-zone - The Availability Zone in which the volume was created.
• create-time - The time stamp when the volume was created.
• encrypted - The encryption status of the volume.
• size - The size of the volume, in GiB.
• snapshot-id - The snapshot from which the volume was created.
• status - The status of the volume (creating | available | in-use | deleting | deleted | error).
• tag:key=value - The key/value combination of a tag assigned to the resource.
• volume-id - The volume ID.
• volume-type - The Amazon EBS volume type. This can be gp2 for General Purpose SSD, io1 for Provisioned IOPS SSD, st1 for Throughput Optimized HDD, sc1 for Cold HDD, or standard for Magnetic volumes.
return_objs (bool) - Changes the return type from list of volume IDs to list of boto.ec2.volume.Volume objects
returns (list) - A list of the requested values: Either the volume IDs or, if return_objs is True, boto.ec2.volume.Volume objects.
salt-call boto_ec2.get_all_volumes filters='{"tag:Name": "myVolume01"}'
salt.modules.boto_ec2.get_attribute(attribute, instance_name=None, instance_id=None, region=None, key=None, keyid=None, profile=None, filters=None) Get an EC2 instance attribute.
salt myminion boto_ec2.get_attribute sourceDestCheck instance_name=my_instance
Available attributes:
• instanceType
• kernel
• ramdisk
• userData
• disableApiTermination
• instanceInitiatedShutdownBehavior
• rootDeviceName
• blockDeviceMapping
• productCodes
• sourceDestCheck
• groupSet
• ebsOptimized
• sriovNetSupport
salt.modules.boto_ec2.get_eip_address_info(addresses=None, allocation_ids=None, region=None, key=None, keyid=None, profile=None) Get 'interesting' info about some, or all EIPs associated with the current account.
returns (list of dicts) - A list of dicts, each containing the info for one of the requested EIPs.
salt-call boto_ec2.get_eip_address_info addresses=52.4.2.15
salt.modules.boto_ec2.get_id(name=None, tags=None, region=None, key=None, keyid=None, profile=None, in_states=None, filters=None) Given instance properties, return the instance id if it exists.
salt myminion boto_ec2.get_id myinstance
salt.modules.boto_ec2.get_key(key_name, region=None, key=None, keyid=None, profile=None) Check to see if a key exists. Returns fingerprint and name if it does and False if it doesn't
salt myminion boto_ec2.get_key mykey
salt.modules.boto_ec2.get_keys(keynames=None, filters=None, region=None, key=None, keyid=None, profile=None) Gets all keys or filters them by name and returns a list. keynames (list):: A list of the names of keypairs to retrieve.  If not provided, all key pairs will be returned.  filters (dict) :: Optional filters that can be used to limit the results returned. Filters are provided in the form of a dictionary consisting of filter names as the key and filter values as the value. The set of allowable filter names/values is dependent on the request being performed. Check the EC2 API guide for details.
salt myminion boto_ec2.get_keys
salt.modules.boto_ec2.get_network_interface(name=None, network_interface_id=None, region=None, key=None, keyid=None, profile=None) Get an Elastic Network Interface.
salt myminion boto_ec2.get_network_interface name=my_eni
salt.modules.boto_ec2.get_network_interface_id(name, region=None, key=None, keyid=None, profile=None) Get an Elastic Network Interface id from its name tag.
salt myminion boto_ec2.get_network_interface_id name=my_eni
salt.modules.boto_ec2.get_tags(instance_id=None, keyid=None, key=None, profile=None, region=None) Given an instance_id, return a list of tags associated with that instance.
returns (list) - list of tags as key/value pairs
salt myminion boto_ec2.get_tags instance_id
salt.modules.boto_ec2.get_unassociated_eip_address(domain='standard', region=None, key=None, keyid=None, profile=None) Return the first unassociated EIP
domain Indicates whether the address is an EC2 address or a VPC address (standard|vpc).
salt-call boto_ec2.get_unassociated_eip_address
salt.modules.boto_ec2.get_zones(region=None, key=None, keyid=None, profile=None) Get a list of AZs for the configured region.
salt myminion boto_ec2.get_zones
salt.modules.boto_ec2.import_key(key_name, public_key_material, region=None, key=None, keyid=None, profile=None) Imports the public key from an RSA key pair that you created with a third-party tool.  Supported formats: - OpenSSH public key format (e.g., the format in ~/.ssh/authorized_keys) - Base64 encoded DER format - SSH public key file format as specified in RFC4716 - DSA keys are not supported. Make sure your key generator is set up to create RSA keys.  Supported lengths: 1024, 2048, and 4096.
salt myminion boto_ec2.import mykey publickey
salt.modules.boto_ec2.modify_network_interface_attribute(name=None, network_interface_id=None, attr=None, value=None, region=None, key=None, keyid=None, profile=None) Modify an attribute of an Elastic Network Interface.
salt myminion boto_ec2.modify_network_interface_attribute my_eni attr=description value='example description'
salt.modules.boto_ec2.release_eip_address(public_ip=None, allocation_id=None, region=None, key=None, keyid=None, profile=None) Free an Elastic IP address.  Pass either a public IP address to release an EC2 Classic EIP, or an AllocationId to release a VPC EIP.
public_ip (string) - The public IP address - for EC2 elastic IPs.
allocation_id (string) - The Allocation ID - for VPC elastic IPs.
returns (bool) - True on success, False on failure
salt myminion boto_ec2.release_eip_address allocation_id=eipalloc-ef382c8a
salt.modules.boto_ec2.run(image_id, name=None, tags=None, key_name=None, security_groups=None, user_data=None, instance_type='m1.small', placement=None, kernel_id=None, ramdisk_id=None, monitoring_enabled=None, vpc_id=None, vpc_name=None, subnet_id=None, subnet_name=None, private_ip_address=None, block_device_map=None, disable_api_termination=None, instance_initiated_shutdown_behavior=None, placement_group=None, client_token=None, security_group_ids=None, security_group_names=None, additional_info=None, tenancy=None, instance_profile_arn=None, instance_profile_name=None, ebs_optimized=None, network_interface_id=None, network_interface_name=None, region=None, key=None, keyid=None, profile=None, network_interfaces=None) Create and start an EC2 instance.
Returns True if the instance was created; otherwise False.
salt myminion boto_ec2.run ami-b80c2b87 name=myinstance
image_id (string) – The ID of the image to run.
name   (string) - The name of the instance.
tags   (dict of key: value pairs) - tags to apply to the instance.
key_name (string) – The name of the key pair with which to launch instances.
security_groups (list of strings) – The names of the EC2 classic security groups with which to associate instances
user_data (string) – The Base64-encoded MIME user data to be made available to the instance(s) in this reservation.
instance_type (string) – The type of instance to run.  Note that some image types (e.g. hvm) only run on some instance types.
placement (string) – The Availability Zone to launch the instance into.
kernel_id (string) – The ID of the kernel with which to launch the instances.
ramdisk_id (string) – The ID of the RAM disk with which to launch the instances.
monitoring_enabled (bool) – Enable detailed CloudWatch monitoring on the instance.
vpc_id (string) - ID of a VPC to bind the instance to.  Exclusive with vpc_name.
vpc_name (string) - Name of a VPC to bind the instance to. Exclusive with vpc_id.
subnet_id (string) – The subnet ID within which to launch the instances for VPC.
subnet_name (string) – The name of a subnet within which to launch the instances for VPC.
private_ip_address (string) – If you’re using VPC, you can optionally use this parameter to assign the instance a specific available IP address from the subnet (e.g. 10.0.0.25).
block_device_map (boto.ec2.blockdevicemapping.BlockDeviceMapping) – A BlockDeviceMapping data structure describing the EBS volumes associated with the Image.  (string) - A string representation of a BlockDeviceMapping structure (dict) - A dict describing a BlockDeviceMapping structure
YAML example:
device-maps: /dev/sdb: ephemeral_name: ephemeral0 /dev/sdc: ephemeral_name: ephemeral1 /dev/sdd: ephemeral_name: ephemeral2 /dev/sde: ephemeral_name: ephemeral3 /dev/sdf: size: 20 volume_type: gp2
disable_api_termination (bool) – If True, the instances will be locked and will not be able to be terminated via the API.
instance_initiated_shutdown_behavior (string) – Specifies whether the instance stops or terminates on instance-initiated shutdown. Valid values are: stop, terminate
placement_group (string) – If specified, this is the name of the placement group in which the instance(s) will be launched.
client_token (string) – Unique, case-sensitive identifier you provide to ensure idempotency of the request. Maximum 64 ASCII characters.
security_group_ids (list of strings) – The ID(s) of the VPC security groups with which to associate instances.
security_group_names (list of strings) – The name(s) of the VPC security groups with which to associate instances.
additional_info (string) – Specifies additional information to make available to the instance(s).
tenancy (string) – The tenancy of the instance you want to launch. An instance with a tenancy of ‘dedicated’ runs on single-tenant hardware and can only be launched into a VPC. Valid values are:”default” or “dedicated”.  NOTE: To use dedicated tenancy you MUST specify a VPC subnet-ID as well.
instance_profile_arn (string) – The Amazon resource name (ARN) of the IAM Instance Profile (IIP) to associate with the instances.
instance_profile_name (string) – The name of the IAM Instance Profile (IIP) to associate with the instances.
ebs_optimized (bool) – Whether the instance is optimized for EBS I/O. This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal EBS I/O performance.  This optimization isn’t available with all instance types.
network_interfaces (boto.ec2.networkinterface.NetworkInterfaceCollection) – A NetworkInterfaceCollection data structure containing the ENI specifications for the instance.
network_interface_id (string) - ID of the network interface to attach to the instance
network_interface_name (string) - Name of the network interface to attach to the instance
salt.modules.boto_ec2.set_attribute(attribute, attribute_value, instance_name=None, instance_id=None, region=None, key=None, keyid=None, profile=None, filters=None) Set an EC2 instance attribute.  Returns whether the operation succeeded or not.
salt myminion boto_ec2.set_attribute sourceDestCheck False instance_name=my_instance
salt.modules.boto_ec2.set_volumes_tags(tag_maps, authoritative=False, dry_run=False, region=None, key=None, keyid=None, profile=None) New in version 2016.11.0.
tag_maps (list) List of dicts of filters and tags, where 'filters' is a dict suitable for passing to the 'filters' argument of get_all_volumes() above, and 'tags' is a dict of tags to be set on volumes (via create_tags/delete_tags) as matched by the given filters.  The filter syntax is extended to permit passing either a list of volume_ids or an instance_name (with instance_name being the Name tag of the instance to which the desired volumes are mapped).  Each mapping in the list is applied separately, so multiple sets of volumes can be all tagged differently with one call to this function. If filtering by instance Name, You may additionally limit the instances matched by passing in a list of desired instance states.  The default set of states is ('pending', 'rebooting', 'running', 'stopping', 'stopped').
YAML example fragment:
- filters: attachment.instance_id: i-abcdef12 tags: Name: dev-int-abcdef12.aws-foo.com - filters: attachment.device: /dev/sdf tags: ManagedSnapshots: true BillingGroup: bubba.hotep@aws-foo.com in_states: - stopped - terminated - filters: instance_name: prd-foo-01.aws-foo.com tags: Name: prd-foo-01.aws-foo.com BillingGroup: infra-team@aws-foo.com - filters: volume_ids: [ vol-12345689, vol-abcdef12 ] tags: BillingGroup: infra-team@aws-foo.com
authoritative (bool) If true, any existing tags on the matched volumes, and not explicitly requested here, will be removed.
dry_run (bool) If true, don't change anything, just return a dictionary describing any changes which would have been applied.
returns (dict) A dict describing status and any changes.
salt.modules.boto_ec2.terminate(instance_id=None, name=None, region=None, key=None, keyid=None, profile=None, filters=None) Terminate the instance described by instance_id or name.
salt myminion boto_ec2.terminate name=myinstance salt myminion boto_ec2.terminate instance_id=i-a46b9f
salt.modules.boto_ec2.unassign_private_ip_addresses(network_interface_name=None, network_interface_id=None, private_ip_addresses=None, region=None, key=None, keyid=None, profile=None) Unassigns one or more secondary private IP addresses from a network interface
private_ip_addresses (list) - Assigns the specified IP addresses as secondary IP addresses to the network interface.
salt myminion boto_ec2.unassign_private_ip_addresses network_interface_name=my_eni private_ip_addresses=private_ip
salt.modules.boto_efs Connection module for Amazon EFS
configuration This module accepts explicit EFS credentials but can also utilize IAM roles assigned to the instance through Instance Profiles or it can read them from the ~/.aws/credentials file or from these environment variables: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY. Dynamic credentials are then automatically obtained from AWS API and no further configuration is necessary.  More information available at:
http://docs.aws.amazon.com/efs/latest/ug/ access-control-managing-permissions.html
If IAM roles are not used you need to specify them either in a pillar or in the minion's config file
efs.keyid: GKTADJGHEIQSXMKKRBJ08H efs.key: askd+ghsdfjkghWupU/asdflkdfklgjsdfjajkghs
A region may also be specified in the configuration
efs.region: us-east-1
myprofile: keyid: GKTADJGHEIQSXMKKRBJ08H key: askd+ghsdfjkghWupU/asdflkdfklgjsdfjajkghs region: us-east-1
salt.modules.boto_efs.create_file_system(name, performance_mode='generalPurpose', keyid=None, key=None, profile=None, region=None, creation_token=None, **kwargs) Creates a new, empty file system.
name   (string) - The name for the new file system
performance_mode (string) - The PerformanceMode of the file system. Can be either generalPurpose or maxIO
creation_token (string) - A unique name to be used as reference when creating an EFS.  This will ensure idempotency. Set to name if not specified otherwise
returns (dict) - A dict of the data for the elastic file system
salt 'my-minion' boto_efs.create_file_system efs-name generalPurpose
salt.modules.boto_efs.create_mount_target(filesystemid, subnetid, ipaddress=None, securitygroups=None, keyid=None, key=None, profile=None, region=None, **kwargs) Creates a mount target for a file system.  You can then mount the file system on EC2 instances via the mount target.
You can create one mount target in each Availability Zone in your VPC.  All EC2 instances in a VPC within a given Availability Zone share a single mount target for a given file system.
If you have multiple subnets in an Availability Zone, you create a mount target in one of the subnets.  EC2 instances do not need to be in the same subnet as the mount target in order to access their file system.
filesystemid (string) - ID of the file system for which to create the mount target.
subnetid (string) - ID of the subnet to add the mount target in.
(string) - Valid IPv4 address within the address range of the specified subnet.
securitygroups
(list[string]) - Up to five VPC security group IDs, of the form sg-xxxxxxxx.  These must be for the same VPC as subnet specified.
returns (dict) - A dict of the response data
salt 'my-minion' boto_efs.create_mount_target filesystemid subnetid
salt.modules.boto_efs.create_tags(filesystemid, tags, keyid=None, key=None, profile=None, region=None, **kwargs) Creates or overwrites tags associated with a file system.  Each tag is a key-value pair. If a tag key specified in the request already exists on the file system, this operation overwrites its value with the value provided in the request.
filesystemid (string) - ID of the file system for whose tags will be modified.
tags   (dict) - The tags to add to the file system
salt 'my-minion' boto_efs.create_tags
salt.modules.boto_efs.delete_file_system(filesystemid, keyid=None, key=None, profile=None, region=None, **kwargs) Deletes a file system, permanently severing access to its contents.  Upon return, the file system no longer exists and you can't access any contents of the deleted file system. You can't delete a file system that is in use. That is, if the file system has any mount targets, you must first delete them.
filesystemid (string) - ID of the file system to delete.
salt 'my-minion' boto_efs.delete_file_system filesystemid
salt.modules.boto_efs.delete_mount_target(mounttargetid, keyid=None, key=None, profile=None, region=None, **kwargs) Deletes the specified mount target.
This operation forcibly breaks any mounts of the file system via the mount target that is being deleted, which might disrupt instances or applications using those mounts. To avoid applications getting cut off abruptly, you might consider unmounting any mounts of the mount target, if feasible. The operation also deletes the associated network interface. Uncommitted writes may be lost, but breaking a mount target using this operation does not corrupt the file system itself.  The file system you created remains.  You can mount an EC2 instance in your VPC via another mount target.
mounttargetid (string) - ID of the mount target to delete
salt 'my-minion' boto_efs.delete_mount_target mounttargetid
salt.modules.boto_efs.delete_tags(filesystemid, tags, keyid=None, key=None, profile=None, region=None, **kwargs) Deletes the specified tags from a file system.
filesystemid (string) - ID of the file system for whose tags will be removed.
tags   (list[string]) - The tag keys to delete to the file system
salt 'my-minion' boto_efs.delete_tags
salt.modules.boto_efs.get_file_systems(filesystemid=None, keyid=None, key=None, profile=None, region=None, creation_token=None, **kwargs) Get all EFS properties or a specific instance property if filesystemid is specified
filesystemid (string) - ID of the file system to retrieve properties
creation_token (string) - A unique token that identifies an EFS.  If fileysystem created via create_file_system this would either be explictitly passed in or set to name.  You can limit your search with this.
returns (list[dict]) - list of all elastic file system properties
salt 'my-minion' boto_efs.get_file_systems efs-id
salt.modules.boto_efs.get_mount_targets(filesystemid=None, mounttargetid=None, keyid=None, key=None, profile=None, region=None, **kwargs) Get all the EFS mount point properties for a specific filesystemid or the properties for a specific mounttargetid. One or the other must be specified
filesystemid
(string) - ID of the file system whose mount targets to list Must be specified if mounttargetid is not
mounttargetid
(string) - ID of the mount target to have its properties returned Must be specified if filesystemid is not
returns (list[dict]) - list of all mount point properties
salt 'my-minion' boto_efs.get_mount_targets
salt.modules.boto_efs.get_tags(filesystemid, keyid=None, key=None, profile=None, region=None, **kwargs) Return the tags associated with an EFS instance.
filesystemid (string) - ID of the file system whose tags to list
salt 'my-minion' boto_efs.get_tags efs-id
salt.modules.boto_efs.set_security_groups(mounttargetid, securitygroup, keyid=None, key=None, profile=None, region=None, **kwargs) Modifies the set of security groups in effect for a mount target
mounttargetid (string) - ID of the mount target whose security groups will be modified
securitygroups (list[string]) - list of no more than 5 VPC security group IDs.
salt 'my-minion' boto_efs.set_security_groups my-mount-target-id my-sec-group
salt.modules.boto_elasticache Connection module for Amazon Elasticache
salt.modules.boto_elasticache.authorize_cache_security_group_ingress(name, ec2_security_group_name, ec2_security_group_owner_id, region=None, key=None, keyid=None, profile=None) Authorize network ingress from an ec2 security group to a cache security group.
salt myminion boto_elasticache.authorize_cache_security_group_ingress myelasticachesg myec2sg 879879
salt.modules.boto_elasticache.create(name, num_cache_nodes=None, engine=None, cache_node_type=None, replication_group_id=None, engine_version=None, cache_parameter_group_name=None, cache_subnet_group_name=None, cache_security_group_names=None, security_group_ids=None, snapshot_arns=None, preferred_availability_zone=None, preferred_maintenance_window=None, port=None, notification_topic_arn=None, auto_minor_version_upgrade=None, wait=None, region=None, key=None, keyid=None, profile=None) Create a cache cluster.
salt myminion boto_elasticache.create myelasticache 1 redis cache.t1.micro cache_security_group_names='["myelasticachesg"]'
salt.modules.boto_elasticache.create_cache_security_group(name, description, region=None, key=None, keyid=None, profile=None) Create a cache security group.
salt myminion boto_elasticache.create_cache_security_group myelasticachesg 'My Cache Security Group'
salt.modules.boto_elasticache.create_replication_group(name, primary_cluster_id, replication_group_description, wait=None, region=None, key=None, keyid=None, profile=None) Create replication group.
salt myminion boto_elasticache.create_replication_group myelasticache myprimarycluster description
salt.modules.boto_elasticache.create_subnet_group(name, description, subnet_ids=None, subnet_names=None, tags=None, region=None, key=None, keyid=None, profile=None) Create an ElastiCache subnet group
CLI example to create an ElastiCache subnet group:
salt myminion boto_elasticache.create_subnet_group my-subnet-group             "group description" subnet_ids='[subnet-12345678, subnet-87654321]'             region=us-east-1
salt.modules.boto_elasticache.delete(name, wait=False, region=None, key=None, keyid=None, profile=None) Delete a cache cluster.
salt myminion boto_elasticache.delete myelasticache
salt.modules.boto_elasticache.delete_cache_security_group(name, region=None, key=None, keyid=None, profile=None) Delete a cache security group.
salt myminion boto_elasticache.delete_cache_security_group myelasticachesg 'My Cache Security Group'
salt.modules.boto_elasticache.delete_replication_group(name, region=None, key=None, keyid=None, profile=None) Delete an ElastiCache replication group.
salt myminion boto_elasticache.delete_replication_group my-replication-group                 region=us-east-1
salt.modules.boto_elasticache.delete_subnet_group(name, region=None, key=None, keyid=None, profile=None) Delete an ElastiCache subnet group.
salt myminion boto_elasticache.delete_subnet_group my-subnet-group                 region=us-east-1
salt.modules.boto_elasticache.describe_replication_group(name, region=None, key=None, keyid=None, profile=None, parameter=None) Get replication group information.
salt myminion boto_elasticache.describe_replication_group mygroup
salt.modules.boto_elasticache.exists(name, region=None, key=None, keyid=None, profile=None) Check to see if a cache cluster exists.
salt myminion boto_elasticache.exists myelasticache
salt.modules.boto_elasticache.get_all_cache_subnet_groups(name=None, region=None, key=None, keyid=None, profile=None) Return a list of all cache subnet groups with details
salt myminion boto_elasticache.get_all_subnet_groups region=us-east-1
salt.modules.boto_elasticache.get_cache_subnet_group(name, region=None, key=None, keyid=None, profile=None) Get information about a cache subnet group.
salt myminion boto_elasticache.get_cache_subnet_group mycache_subnet_group
salt.modules.boto_elasticache.get_config(name, region=None, key=None, keyid=None, profile=None) Get the configuration for a cache cluster.
salt myminion boto_elasticache.get_config myelasticache
salt.modules.boto_elasticache.get_group_host(name, region=None, key=None, keyid=None, profile=None) Get hostname from replication cache group
salt myminion boto_elasticache.get_group_host myelasticachegroup
salt.modules.boto_elasticache.get_node_host(name, region=None, key=None, keyid=None, profile=None) Get hostname from cache node
salt myminion boto_elasticache.get_node_host myelasticache
salt.modules.boto_elasticache.group_exists(name, region=None, key=None, keyid=None, profile=None) Check to see if a replication group exists.
salt myminion boto_elasticache.group_exists myelasticache