neulab/tldr huggingface dataset:
VPCRegion When creating a private hosted zone, the region of the associated VPC is required.  If not provided, an effort will be made to determine it from VPCId or VPCName, if possible.  If this fails, you'll need to provide an explicit value for this option.  Ignored if passed for a non-private zone.
CallerReference A unique string that identifies the request and that allows create_hosted_zone() calls to be retried without the risk of executing the operation twice.  This is a required parameter when creating new Hosted Zones.  Maximum length of 128.
Comment Any comments you want to include about the hosted zone.
PrivateZone Boolean - Set to True if creating a private hosted zone.
DelegationSetId If you want to associate a reusable delegation set with this hosted zone, the ID that Amazon Route 53 assigned to the reusable delegation set when you created it.  Note that XXX TODO create_delegation_set() is not yet implemented, so you'd need to manually create any delegation sets before utilizing this.
region Region endpoint to connect to.
key    AWS key to bind with.
keyid  AWS keyid to bind with.
profile Dict, or pillar key pointing to a dict, containing AWS region/key/keyid.
salt myminion boto3_route53.create_hosted_zone example.org.
salt.modules.boto3_route53.delete_hosted_zone(Id, region=None, key=None, keyid=None, profile=None) Delete a Route53 hosted zone.
salt myminion boto3_route53.delete_hosted_zone Z1234567890
salt.modules.boto3_route53.delete_hosted_zone_by_domain(Name, PrivateZone=None, region=None, key=None, keyid=None, profile=None) Delete a Route53 hosted zone by domain name, and PrivateZone status if provided.
salt myminion boto3_route53.delete_hosted_zone_by_domain example.org.
salt.modules.boto3_route53.disassociate_vpc_from_hosted_zone(HostedZoneId=None, Name=None, VPCId=None, VPCName=None, VPCRegion=None, Comment=None, region=None, key=None, keyid=None, profile=None) Disassociates an Amazon VPC from a private hosted zone.
You can't disassociate the last VPC from a private hosted zone. You also can't convert a private hosted zone into a public hosted zone.
Note that looking up hosted zones by name (e.g. using the Name parameter) only works XXX FACTCHECK within a single AWS account - if you're disassociating a VPC in one account from a hosted zone in a different account you unfortunately MUST use the HostedZoneId parameter exclusively. XXX FIXME DOCU
salt myminion boto3_route53.disassociate_vpc_from_hosted_zone                     Name=example.org. VPCName=myVPC                     VPCRegion=us-east-1 Comment="Whoops!  Don't wanna talk to this-here zone no more."
salt.modules.boto3_route53.find_hosted_zone(Id=None, Name=None, PrivateZone=None, region=None, key=None, keyid=None, profile=None) Find a hosted zone with the given characteristics.
Id     The unique Zone Identifier for the Hosted Zone.  Exclusive with Name.
Name   The domain name associated with the Hosted Zone.  Exclusive with Id.  Note this has the potential to match more then one hosted zone (e.g. a public and a private if both exist) which will raise an error unless PrivateZone has also been passed in order split the different.
PrivateZone Boolean - Set to True if searching for a private hosted zone.
region Region to connect to.
key    Secret key to be used.
keyid  Access key to be used.
salt myminion boto3_route53.find_hosted_zone Name=salt.org.                 profile='{"region": "us-east-1", "keyid": "A12345678AB", "key": "xblahblahblah"}'
salt.modules.boto3_route53.get_hosted_zone(Id, region=None, key=None, keyid=None, profile=None) Return detailed info about the given zone.
Id     The unique Zone Identifier for the Hosted Zone.
salt myminion boto3_route53.get_hosted_zone Z1234567690                 profile='{"region": "us-east-1", "keyid": "A12345678AB", "key": "xblahblahblah"}'
salt.modules.boto3_route53.get_hosted_zones_by_domain(Name, region=None, key=None, keyid=None, profile=None) Find any zones with the given domain name and return detailed info about them.  Note that this can return multiple Route53 zones, since a domain name can be used in both public and private zones.
salt myminion boto3_route53.get_hosted_zones_by_domain salt.org.                 profile='{"region": "us-east-1", "keyid": "A12345678AB", "key": "xblahblahblah"}'
salt.modules.boto3_route53.get_resource_records(HostedZoneId=None, Name=None, StartRecordName=None, StartRecordType=None, PrivateZone=None, region=None, key=None, keyid=None, profile=None) Get all resource records from a given zone matching the provided StartRecordName (if given) or all records in the zone (if not), optionally filtered by a specific StartRecordType.  This will return any and all RRs matching, regardless of their special AWS flavors (weighted, geolocation, alias, etc.) so your code should be prepared for potentially large numbers of records back from this function - for example, if you've created a complex geolocation mapping with lots of entries all over the world providing the same server name to many different regional clients.
If you want EXACTLY ONE record to operate on, you'll need to implement any logic required to pick the specific RR you care about from those returned.
Note that if you pass in Name without providing a value for PrivateZone (either True or False), CommandExecutionError can be raised in the case of both public and private zones matching the domain. XXX FIXME DOCU
salt myminion boto3_route53.get_records test.example.org example.org A
salt.modules.boto3_route53.list_hosted_zones(DelegationSetId=None, region=None, key=None, keyid=None, profile=None) Return detailed info about all zones in the bound account.
DelegationSetId If you're using reusable delegation sets and you want to list all of the hosted zones that are associated with a reusable delegation set, specify the ID of that delegation set.
salt myminion boto3_route53.describe_hosted_zones                 profile='{"region": "us-east-1", "keyid": "A12345678AB", "key": "xblahblahblah"}'
salt.modules.boto3_route53.update_hosted_zone_comment(Id=None, Name=None, Comment=None, PrivateZone=None, region=None, key=None, keyid=None, profile=None) Update the comment on an existing Route 53 hosted zone.
PrivateZone Boolean - Set to True if changing a private hosted zone.
salt myminion boto3_route53.update_hosted_zone_comment Name=example.org.                 Comment="This is an example comment for an example zone"
salt.modules.boto3_sns Connection module for Amazon SNS
configuration This module accepts explicit sns 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:
sns.keyid: GKTADJGHEIQSXMKKRBJ08H sns.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
sns.region: us-east-1
salt.modules.boto3_sns.create_topic(Name, region=None, key=None, keyid=None, profile=None) Create an SNS topic.
salt myminion boto3_sns.create_topic mytopic region=us-east-1
salt.modules.boto3_sns.delete_topic(TopicArn, region=None, key=None, keyid=None, profile=None) Delete an SNS topic.
salt myminion boto3_sns.delete_topic mytopic region=us-east-1
salt.modules.boto3_sns.describe_topic(name, region=None, key=None, keyid=None, profile=None) Returns details about a specific SNS topic, specified by name or ARN.
salt my_favorite_client boto3_sns.describe_topic a_sns_topic_of_my_choice
salt.modules.boto3_sns.get_subscription_attributes(SubscriptionArn, region=None, key=None, keyid=None, profile=None) Returns all of the properties of a subscription.
salt myminion boto3_sns.get_subscription_attributes somesubscription region=us-west-1
salt.modules.boto3_sns.get_topic_attributes(TopicArn, region=None, key=None, keyid=None, profile=None) Returns all of the properties of a topic.  Topic properties returned might differ based on the authorization of the user.
salt myminion boto3_sns.get_topic_attributes someTopic region=us-west-1
salt.modules.boto3_sns.list_subscriptions(region=None, key=None, keyid=None, profile=None) Returns a list of the requester's topics
salt myminion boto3_sns.list_subscriptions region=us-east-1
salt.modules.boto3_sns.list_subscriptions_by_topic(TopicArn, region=None, key=None, keyid=None, profile=None) Returns a list of the subscriptions to a specific topic
salt myminion boto3_sns.list_subscriptions_by_topic mytopic region=us-east-1
salt.modules.boto3_sns.list_topics(region=None, key=None, keyid=None, profile=None) Returns a list of the requester's topics
salt myminion boto3_sns.list_topics
salt.modules.boto3_sns.set_subscription_attributes(SubscriptionArn, AttributeName, AttributeValue, region=None, key=None, keyid=None, profile=None) Set an attribute of a subscription to a new value.
salt myminion boto3_sns.set_subscription_attributes someSubscription RawMessageDelivery jsonStringValue
salt.modules.boto3_sns.set_topic_attributes(TopicArn, AttributeName, AttributeValue, region=None, key=None, keyid=None, profile=None) Set an attribute of a topic to a new value.
salt myminion boto3_sns.set_topic_attributes someTopic DisplayName myDisplayNameValue
salt.modules.boto3_sns.subscribe(TopicArn, Protocol, Endpoint, region=None, key=None, keyid=None, profile=None) Subscribe to a Topic.
salt myminion boto3_sns.subscribe mytopic https https://www.example.com/sns-endpoint
salt.modules.boto3_sns.topic_exists(name, region=None, key=None, keyid=None, profile=None) Check to see if an SNS topic exists.
salt myminion boto3_sns.topic_exists mytopic region=us-east-1
salt.modules.boto3_sns.unsubscribe(SubscriptionArn, region=None, key=None, keyid=None, profile=None) Unsubscribe a specific SubscriptionArn of a topic.
salt myminion boto3_sns.unsubscribe my_subscription_arn region=us-east-1
salt.modules.boto_apigateway Connection module for Amazon APIGateway
• boto >= 2.8.0
• boto3 >= 1.2.1
• botocore >= 1.4.49
configuration This module accepts explicit Lambda 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:
apigateway.keyid: GKTADJGHEIQSXMKKRBJ08H apigateway.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
apigateway.region: us-west-2
myprofile: keyid: GKTADJGHEIQSXMKKRBJ08H key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs region: us-west-2
Changed in version 2015.8.0: All methods now return a dictionary. Create and delete methods return:
created: true
created: false error: message: error message
Request methods (e.g., describe_apigateway) return:
apigateway: - {...} - {...}
error: message: error message
salt.modules.boto_apigateway.activate_api_deployment(restApiId, stageName, deploymentId, region=None, key=None, keyid=None, profile=None) Activates previously deployed deployment for a given stage
salt myminion boto_apigateway.activate_api_deployent restApiId stagename deploymentId
salt.modules.boto_apigateway.api_exists(name, description=None, region=None, key=None, keyid=None, profile=None) Check to see if the given Rest API Name and optionally description exists.
salt myminion boto_apigateway.exists myapi_name
salt.modules.boto_apigateway.api_model_exists(restApiId, modelName, region=None, key=None, keyid=None, profile=None) Check to see if the given modelName exists in the given restApiId
salt myminion boto_apigateway.api_model_exists restApiId modelName
salt.modules.boto_apigateway.associate_api_key_stagekeys(apiKey, stagekeyslist, region=None, key=None, keyid=None, profile=None) associate the given stagekeyslist to the given apiKey.
salt myminion boto_apigateway.associate_stagekeys_api_key \ api_key '["restapi id/stage name", ...]'
salt.modules.boto_apigateway.attach_usage_plan_to_apis(plan_id, apis, region=None, key=None, keyid=None, profile=None) Attaches given usage plan to each of the apis provided in a list of apiId and stage values
apis   a list of dictionaries, where each dictionary contains the following:
apiId  a string, which is the id of the created API in AWS ApiGateway
stage  a string, which is the stage that the created API is deployed to.
salt myminion boto_apigateway.attach_usage_plan_to_apis plan_id='usage plan id' apis='[{"apiId": "some id 1", "stage": "some stage 1"}]'
salt.modules.boto_apigateway.create_api(name, description, cloneFrom=None, region=None, key=None, keyid=None, profile=None) Create a new REST API Service with the given name
Returns {created: True} if the rest api was created and returns {created: False} if the rest api was not created.
salt myminion boto_apigateway.create_api myapi_name api_description
salt.modules.boto_apigateway.create_api_deployment(restApiId, stageName, stageDescription='', description='', cacheClusterEnabled=False, cacheClusterSize='0.5', variables=None, region=None, key=None, keyid=None, profile=None) Creates a new API deployment.
salt myminion boto_apigateway.create_api_deployent restApiId stagename stageDescription='' \ description='' cacheClusterEnabled=True|False cacheClusterSize=0.5 variables='{"name": "value"}'
salt.modules.boto_apigateway.create_api_integration(restApiId, resourcePath, httpMethod, integrationType, integrationHttpMethod, uri, credentials, requestParameters=None, requestTemplates=None, region=None, key=None, keyid=None, profile=None) Creates an integration for a given method in a given API.  If integrationType is MOCK, uri and credential parameters will be ignored.
uri is in the form of (substitute APIGATEWAY_REGION and LAMBDA_FUNC_ARN) "arn:aws:apigateway:APIGATEWAY_REGION:lambda:path/2015-03-31/functions/LAMBDA_FUNC_ARN/invocations"
credentials is in the form of an iam role name or role arn.
salt myminion boto_apigateway.create_api_integration restApiId resourcePath httpMethod \ integrationType integrationHttpMethod uri credentials ['{}' ['{}']]
salt.modules.boto_apigateway.create_api_integration_response(restApiId, resourcePath, httpMethod, statusCode, selectionPattern, responseParameters=None, responseTemplates=None, region=None, key=None, keyid=None, profile=None) Creates an integration response for a given method in a given API
salt myminion boto_apigateway.create_api_integration_response restApiId resourcePath httpMethod \ statusCode selectionPattern ['{}' ['{}']]
salt.modules.boto_apigateway.create_api_key(name, description, enabled=True, stageKeys=None, region=None, key=None, keyid=None, profile=None) Create an API key given name and description.
An optional enabled argument can be provided.  If provided, the valid values are True|False.  This argument defaults to True.
An optional stageKeys argument can be provided in the form of list of dictionary with 'restApiId' and 'stageName' as keys.
salt myminion boto_apigateway.create_api_key name description
salt myminion boto_apigateway.create_api_key name description enabled=False
salt myminion boto_apigateway.create_api_key name description \ stageKeys='[{"restApiId": "id", "stageName": "stagename"}]'
salt.modules.boto_apigateway.create_api_method(restApiId, resourcePath, httpMethod, authorizationType, apiKeyRequired=False, requestParameters=None, requestModels=None, region=None, key=None, keyid=None, profile=None) Creates API method for a resource in the given API
salt myminion boto_apigateway.create_api_method restApiId resourcePath, httpMethod, authorizationType, \ apiKeyRequired=False, requestParameters='{"name", "value"}', requestModels='{"content-type", "value"}'
salt.modules.boto_apigateway.create_api_method_response(restApiId, resourcePath, httpMethod, statusCode, responseParameters=None, responseModels=None, region=None, key=None, keyid=None, profile=None) Create API method response for a method on a given resource in the given API
salt myminion boto_apigateway.create_api_method_response restApiId resourcePath httpMethod \ statusCode responseParameters='{"name", "True|False"}' responseModels='{"content-type", "model"}'
salt.modules.boto_apigateway.create_api_model(restApiId, modelName, modelDescription, schema, contentType='application/json', region=None, key=None, keyid=None, profile=None) Create a new model in a given API with a given schema, currently only contentType supported is 'application/json'
salt myminion boto_apigateway.create_api_model restApiId modelName modelDescription '<schema>' 'content-type'
salt.modules.boto_apigateway.create_api_resources(restApiId, path, region=None, key=None, keyid=None, profile=None) Given rest api id, and an absolute resource path, create all the resources and return all resources in the resourcepath, returns False on failure.
salt myminion boto_apigateway.create_api_resources myapi_id resource_path
salt.modules.boto_apigateway.create_api_stage(restApiId, stageName, deploymentId, description='', cacheClusterEnabled=False, cacheClusterSize='0.5', variables=None, region=None, key=None, keyid=None, profile=None) Creates a new API stage for a given restApiId and deploymentId.
salt myminion boto_apigateway.create_api_stage restApiId stagename deploymentId \ description='' cacheClusterEnabled=True|False cacheClusterSize='0.5' variables='{"name": "value"}'
salt.modules.boto_apigateway.create_usage_plan(name, description=None, throttle=None, quota=None, region=None, key=None, keyid=None, profile=None) Creates a new usage plan with throttling and quotas optionally applied
name   Name of the usage plan
throttle A dictionary consisting of the following keys:
rateLimit requests per second at steady rate, float
burstLimit maximum number of requests per second, integer
quota  A dictionary consisting of the following keys:
limit  number of allowed requests per specified quota period [required if quota parameter is present]
offset number of requests to be subtracted from limit at the beginning of the period [optional]
period quota period, must be one of DAY, WEEK, or MONTH. [required if quota parameter is present
salt myminion boto_apigateway.create_usage_plan name='usage plan name' throttle='{"rateLimit": 10.0, "burstLimit": 10}'
salt.modules.boto_apigateway.delete_api(name, description=None, region=None, key=None, keyid=None, profile=None) Delete all REST API Service with the given name and an optional API description
Returns {deleted: True, count: deleted_count} if apis were deleted, and returns {deleted: False} if error or not found.
salt myminion boto_apigateway.delete_api myapi_name
salt myminion boto_apigateway.delete_api myapi_name description='api description'
salt.modules.boto_apigateway.delete_api_deployment(restApiId, deploymentId, region=None, key=None, keyid=None, profile=None) Deletes API deployment for a given restApiId and deploymentID
salt myminion boto_apigateway.delete_api_deployent restApiId deploymentId
salt.modules.boto_apigateway.delete_api_integration(restApiId, resourcePath, httpMethod, region=None, key=None, keyid=None, profile=None) Deletes an integration for a given method in a given API
salt myminion boto_apigateway.delete_api_integration restApiId resourcePath httpMethod
salt.modules.boto_apigateway.delete_api_integration_response(restApiId, resourcePath, httpMethod, statusCode, region=None, key=None, keyid=None, profile=None) Deletes an integration response for a given method in a given API
salt myminion boto_apigateway.delete_api_integration_response restApiId resourcePath httpMethod statusCode
salt.modules.boto_apigateway.delete_api_key(apiKey, region=None, key=None, keyid=None, profile=None) Deletes a given apiKey
salt myminion boto_apigateway.delete_api_key apikeystring
salt.modules.boto_apigateway.delete_api_method(restApiId, resourcePath, httpMethod, region=None, key=None, keyid=None, profile=None) Delete API method for a resource in the given API
salt myminion boto_apigateway.delete_api_method restApiId resourcePath httpMethod
salt.modules.boto_apigateway.delete_api_method_response(restApiId, resourcePath, httpMethod, statusCode, region=None, key=None, keyid=None, profile=None) Delete API method response for a resource in the given API
salt myminion boto_apigateway.delete_api_method_response restApiId resourcePath httpMethod statusCode
salt.modules.boto_apigateway.delete_api_model(restApiId, modelName, region=None, key=None, keyid=None, profile=None) Delete a model identified by name in a given API
salt myminion boto_apigateway.delete_api_model restApiId modelName
salt.modules.boto_apigateway.delete_api_resources(restApiId, path, region=None, key=None, keyid=None, profile=None) Given restApiId and an absolute resource path, delete the resources starting from the absolute resource path. If resourcepath is the root resource '/', the function will return False. Returns False on failure.
salt myminion boto_apigateway.delete_api_resources myapi_id, resource_path
salt.modules.boto_apigateway.delete_api_stage(restApiId, stageName, region=None, key=None, keyid=None, profile=None) Deletes stage identified by stageName from API identified by restApiId
salt myminion boto_apigateway.delete_api_stage restApiId stageName
salt.modules.boto_apigateway.delete_usage_plan(plan_id, region=None, key=None, keyid=None, profile=None) Deletes usage plan identified by plan_id
salt myminion boto_apigateway.delete_usage_plan plan_id='usage plan id'
salt.modules.boto_apigateway.describe_api_deployment(restApiId, deploymentId, region=None, key=None, keyid=None, profile=None) Get API deployment for a given restApiId and deploymentId.
salt myminion boto_apigateway.describe_api_deployent restApiId deploymentId
salt.modules.boto_apigateway.describe_api_deployments(restApiId, region=None, key=None, keyid=None, profile=None) Gets information about the defined API Deployments.  Return list of api deployments.
salt myminion boto_apigateway.describe_api_deployments restApiId
salt.modules.boto_apigateway.describe_api_integration(restApiId, resourcePath, httpMethod, region=None, key=None, keyid=None, profile=None) Get an integration for a given method in a given API
salt myminion boto_apigateway.describe_api_integration restApiId resourcePath httpMethod
salt.modules.boto_apigateway.describe_api_integration_response(restApiId, resourcePath, httpMethod, statusCode, region=None, key=None, keyid=None, profile=None) Get an integration response for a given method in a given API
salt myminion boto_apigateway.describe_api_integration_response restApiId resourcePath httpMethod statusCode
salt.modules.boto_apigateway.describe_api_key(apiKey, region=None, key=None, keyid=None, profile=None) Gets info about the given api key
salt myminion boto_apigateway.describe_api_key apigw_api_key
salt.modules.boto_apigateway.describe_api_keys(region=None, key=None, keyid=None, profile=None) Gets information about the defined API Keys.  Return list of apiKeys.
salt myminion boto_apigateway.describe_api_keys
salt.modules.boto_apigateway.describe_api_method(restApiId, resourcePath, httpMethod, region=None, key=None, keyid=None, profile=None) Get API method for a resource in the given API
salt myminion boto_apigateway.describe_api_method restApiId resourcePath httpMethod
salt.modules.boto_apigateway.describe_api_method_response(restApiId, resourcePath, httpMethod, statusCode, region=None, key=None, keyid=None, profile=None) Get API method response for a resource in the given API
salt myminion boto_apigateway.describe_api_method_response restApiId resourcePath httpMethod statusCode
salt.modules.boto_apigateway.describe_api_model(restApiId, modelName, flatten=True, region=None, key=None, keyid=None, profile=None) Get a model by name for a given API
salt myminion boto_apigateway.describe_api_model restApiId modelName [True]
salt.modules.boto_apigateway.describe_api_models(restApiId, region=None, key=None, keyid=None, profile=None) Get all models for a given API
salt myminion boto_apigateway.describe_api_models restApiId
salt.modules.boto_apigateway.describe_api_resource(restApiId, path, region=None, key=None, keyid=None, profile=None) Given rest api id, and an absolute resource path, returns the resource id for the given path.
salt myminion boto_apigateway.describe_api_resource myapi_id resource_path
salt.modules.boto_apigateway.describe_api_resource_method(restApiId, resourcePath, httpMethod, region=None, key=None, keyid=None, profile=None) Given rest api id, resource path, and http method (must be one of DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT), return the method for the api/resource path if defined.  Return False if method is not defined.
salt myminion boto_apigateway.describe_api_resource_method myapi_id resource_path httpmethod
salt.modules.boto_apigateway.describe_api_resources(restApiId, region=None, key=None, keyid=None, profile=None) Given rest api id, return all resources for this api.
salt myminion boto_apigateway.describe_api_resources myapi_id
salt.modules.boto_apigateway.describe_api_stage(restApiId, stageName, region=None, key=None, keyid=None, profile=None) Get API stage for a given apiID and stage name
salt myminion boto_apigateway.describe_api_stage restApiId stageName
salt.modules.boto_apigateway.describe_api_stages(restApiId, deploymentId, region=None, key=None, keyid=None, profile=None) Get all API stages for a given apiID and deploymentID
salt myminion boto_apigateway.describe_api_stages restApiId deploymentId
salt.modules.boto_apigateway.describe_apis(name=None, description=None, region=None, key=None, keyid=None, profile=None) Returns all rest apis in the defined region.  If optional parameter name is included, returns all rest apis matching the name in the defined region.
salt myminion boto_apigateway.describe_apis
salt myminion boto_apigateway.describe_apis name='api name'
salt myminion boto_apigateway.describe_apis name='api name' description='desc str'
salt.modules.boto_apigateway.describe_usage_plans(name=None, plan_id=None, region=None, key=None, keyid=None, profile=None) Returns a list of existing usage plans, optionally filtered to match a given plan name
salt myminion boto_apigateway.describe_usage_plans salt myminion boto_apigateway.describe_usage_plans name='usage plan name' salt myminion boto_apigateway.describe_usage_plans plan_id='usage plan id'
salt.modules.boto_apigateway.detach_usage_plan_from_apis(plan_id, apis, region=None, key=None, keyid=None, profile=None) Detaches given usage plan from each of the apis provided in a list of apiId and stage value
salt myminion boto_apigateway.detach_usage_plan_to_apis plan_id='usage plan id' apis='[{"apiId": "some id 1", "stage": "some stage 1"}]'
salt.modules.boto_apigateway.disable_api_key(apiKey, region=None, key=None, keyid=None, profile=None) disable the given apiKey.
salt myminion boto_apigateway.enable_api_key api_key
salt.modules.boto_apigateway.disassociate_api_key_stagekeys(apiKey, stagekeyslist, region=None, key=None, keyid=None, profile=None) disassociate the given stagekeyslist to the given apiKey.
salt myminion boto_apigateway.disassociate_stagekeys_api_key \ api_key '["restapi id/stage name", ...]'
salt.modules.boto_apigateway.enable_api_key(apiKey, region=None, key=None, keyid=None, profile=None) enable the given apiKey.
salt.modules.boto_apigateway.flush_api_stage_cache(restApiId, stageName, region=None, key=None, keyid=None, profile=None) Flushes cache for the stage identified by stageName from API identified by restApiId
salt myminion boto_apigateway.flush_api_stage_cache restApiId stageName
salt.modules.boto_apigateway.overwrite_api_stage_variables(restApiId, stageName, variables, region=None, key=None, keyid=None, profile=None) Overwrite the stage variables for the given restApiId and stage name with the given variables, variables must be in the form of a dictionary.  Overwrite will always remove all the existing stage variables associated with the given restApiId and stage name, follow by the adding of all the variables specified in the variables dictionary
salt myminion boto_apigateway.overwrite_api_stage_variables restApiId stageName variables='{"name": "value"}'
salt.modules.boto_apigateway.update_api_key_description(apiKey, description, region=None, key=None, keyid=None, profile=None) update the given apiKey with the given description.
salt myminion boto_apigateway.update_api_key_description api_key description
salt.modules.boto_apigateway.update_api_model_schema(restApiId, modelName, schema, region=None, key=None, keyid=None, profile=None) update the schema (in python dictionary format) for the given model in the given restApiId
salt myminion boto_apigateway.update_api_model_schema restApiId modelName schema
salt.modules.boto_apigateway.update_usage_plan(plan_id, throttle=None, quota=None, region=None, key=None, keyid=None, profile=None) Updates an existing usage plan with throttling and quotas
plan_id Id of the created usage plan
salt myminion boto_apigateway.update_usage_plan plan_id='usage plan id' throttle='{"rateLimit": 10.0, "burstLimit": 10}'
salt.modules.boto_asg Connection module for Amazon Autoscale Groups
configuration This module accepts explicit autoscale 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:
asg.keyid: GKTADJGHEIQSXMKKRBJ08H asg.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
asg.region: us-east-1
salt.modules.boto_asg.create(name, launch_config_name, availability_zones, min_size, max_size, desired_capacity=None, load_balancers=None, default_cooldown=None, health_check_type=None, health_check_period=None, placement_group=None, vpc_zone_identifier=None, tags=None, termination_policies=None, suspended_processes=None, scaling_policies=None, scheduled_actions=None, region=None, notification_arn=None, notification_types=None, key=None, keyid=None, profile=None) Create an autoscale group.
salt myminion boto_asg.create myasg mylc '["us-east-1a", "us-east-1e"]' 1 10 load_balancers='["myelb", "myelb2"]' tags='[{"key": "Name", value="myasg", "propagate_at_launch": True}]'
salt.modules.boto_asg.create_launch_configuration(name, image_id, key_name=None, vpc_id=None, vpc_name=None, security_groups=None, user_data=None, instance_type='m1.small', kernel_id=None, ramdisk_id=None, block_device_mappings=None, instance_monitoring=False, spot_price=None, instance_profile_name=None, ebs_optimized=False, associate_public_ip_address=None, volume_type=None, delete_on_termination=True, iops=None, use_block_device_types=False, region=None, key=None, keyid=None, profile=None) Create a launch configuration.
salt myminion boto_asg.create_launch_configuration mylc image_id=ami-0b9c9f62 key_name='mykey' security_groups='["mygroup"]' instance_type='c3.2xlarge'
salt.modules.boto_asg.delete(name, force=False, region=None, key=None, keyid=None, profile=None) Delete an autoscale group.
salt myminion boto_asg.delete myasg region=us-east-1
salt.modules.boto_asg.delete_launch_configuration(name, region=None, key=None, keyid=None, profile=None) Delete a launch configuration.
salt myminion boto_asg.delete_launch_configuration mylc
salt.modules.boto_asg.describe_launch_configuration(name, region=None, key=None, keyid=None, profile=None) Dump details of a given launch configuration.
salt myminion boto_asg.describe_launch_configuration mylc
salt.modules.boto_asg.enter_standby(name, instance_ids, should_decrement_desired_capacity=False, region=None, key=None, keyid=None, profile=None) Switch desired instances to StandBy mode
salt-call boto_asg.enter_standby my_autoscale_group_name '["i-xxxxxx"]'
salt.modules.boto_asg.exists(name, region=None, key=None, keyid=None, profile=None) Check to see if an autoscale group exists.
salt myminion boto_asg.exists myasg region=us-east-1
salt.modules.boto_asg.exit_standby(name, instance_ids, should_decrement_desired_capacity=False, region=None, key=None, keyid=None, profile=None) Exit desired instances from StandBy mode
salt-call boto_asg.exit_standby my_autoscale_group_name '["i-xxxxxx"]'
salt.modules.boto_asg.get_all_groups(region=None, key=None, keyid=None, profile=None) Return all AutoScale Groups visible in the account (as a list of boto.ec2.autoscale.group.AutoScalingGroup).
salt-call boto_asg.get_all_groups region=us-east-1 --output yaml
salt.modules.boto_asg.get_all_launch_configurations(region=None, key=None, keyid=None, profile=None) Fetch and return all Launch Configuration with details.
salt myminion boto_asg.get_all_launch_configurations
salt.modules.boto_asg.get_cloud_init_mime(cloud_init) Get a mime multipart encoded string from a cloud-init dict. Currently supports boothooks, scripts and cloud-config.
salt myminion boto.get_cloud_init_mime <cloud init>
salt.modules.boto_asg.get_config(name, region=None, key=None, keyid=None, profile=None) Get the configuration for an autoscale group.
salt myminion boto_asg.get_config myasg region=us-east-1
salt.modules.boto_asg.get_instances(name, lifecycle_state='InService', health_status='Healthy', attribute='private_ip_address', attributes=None, region=None, key=None, keyid=None, profile=None) return attribute of all instances in the named autoscale group.
salt-call boto_asg.get_instances my_autoscale_group_name
salt.modules.boto_asg.get_scaling_policy_arn(as_group, scaling_policy_name, region=None, key=None, keyid=None, profile=None) Return the arn for a scaling policy in a specific autoscale group or None if not found. Mainly used as a helper method for boto_cloudwatch_alarm, for linking alarms to scaling policies.
salt '*' boto_asg.get_scaling_policy_arn mygroup mypolicy
salt.modules.boto_asg.launch_configuration_exists(name, region=None, key=None, keyid=None, profile=None) Check for a launch configuration's existence.
salt myminion boto_asg.launch_configuration_exists mylc
salt.modules.boto_asg.list_groups(region=None, key=None, keyid=None, profile=None) Return all AutoScale Groups visible in the account (as a list of names).
salt-call boto_asg.list_groups region=us-east-1
salt.modules.boto_asg.list_launch_configurations(region=None, key=None, keyid=None, profile=None) List all Launch Configurations.
salt myminion boto_asg.list_launch_configurations
salt.modules.boto_asg.update(name, launch_config_name, availability_zones, min_size, max_size, desired_capacity=None, load_balancers=None, default_cooldown=None, health_check_type=None, health_check_period=None, placement_group=None, vpc_zone_identifier=None, tags=None, termination_policies=None, suspended_processes=None, scaling_policies=None, scheduled_actions=None, notification_arn=None, notification_types=None, region=None, key=None, keyid=None, profile=None) Update an autoscale group.
salt myminion boto_asg.update myasg mylc '["us-east-1a", "us-east-1e"]' 1 10 load_balancers='["myelb", "myelb2"]' tags='[{"key": "Name", value="myasg", "propagate_at_launch": True}]'
salt.modules.boto_cfn Connection module for Amazon Cloud Formation
configuration This module accepts explicit AWS 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:
cfn.keyid: GKTADJGHEIQSXMKKRBJ08H cfn.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
cfn.region: us-east-1
salt.modules.boto_cfn.create(name, template_body=None, template_url=None, parameters=None, notification_arns=None, disable_rollback=None, timeout_in_minutes=None, capabilities=None, tags=None, on_failure=None, stack_policy_body=None, stack_policy_url=None, region=None, key=None, keyid=None, profile=None) Create a CFN stack.
salt myminion boto_cfn.create mystack template_url='https://s3.amazonaws.com/bucket/template.cft'         region=us-east-1
salt.modules.boto_cfn.delete(name, region=None, key=None, keyid=None, profile=None) Delete a CFN stack.
salt myminion boto_cfn.delete mystack region=us-east-1
salt.modules.boto_cfn.describe(name, region=None, key=None, keyid=None, profile=None) Describe a stack.
salt myminion boto_cfn.describe mystack region=us-east-1
salt.modules.boto_cfn.exists(name, region=None, key=None, keyid=None, profile=None) Check to see if a stack exists.
salt myminion boto_cfn.exists mystack region=us-east-1
salt.modules.boto_cfn.get_template(name, region=None, key=None, keyid=None, profile=None) Check to see if attributes are set on a CFN stack.
salt myminion boto_cfn.get_template mystack
salt.modules.boto_cfn.update_stack(name, template_body=None, template_url=None, parameters=None, notification_arns=None, disable_rollback=False, timeout_in_minutes=None, capabilities=None, tags=None, use_previous_template=None, stack_policy_during_update_body=None, stack_policy_during_update_url=None, stack_policy_body=None, stack_policy_url=None, region=None, key=None, keyid=None, profile=None) Update a CFN stack.
salt myminion boto_cfn.update_stack mystack template_url='https://s3.amazonaws.com/bucket/template.cft'         region=us-east-1
salt.modules.boto_cfn.validate_template(template_body=None, template_url=None, region=None, key=None, keyid=None, profile=None) Validate cloudformation template
salt myminion boto_cfn.validate_template mystack-template
salt.modules.boto_cloudfront Connection module for Amazon CloudFront
configuration This module accepts explicit AWS 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/AWSEC2/latest/UserGuide/ iam-roles-for-amazon-ec2.html
http://boto3.readthedocs.io/en/latest/guide/ configuration.html#guide-configuration
cloudfront.keyid: GKTADJGHEIQSXMKKRBJ08H cloudfront.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
cloudfront.region: us-east-1
salt.modules.boto_cloudfront.create_distribution(name, config, tags=None, region=None, key=None, keyid=None, profile=None) Create a CloudFront distribution with the given name, config, and (optionally) tags.
name   Name for the CloudFront distribution
config Configuration for the distribution
tags   Tags to associate with the distribution
region Region to connect to
key    Secret key to use
keyid  Access key to use
profile A dict with region, key, and keyid, or a pillar key (string) that contains such a dict.
salt myminion boto_cloudfront.create_distribution name=mydistribution profile=awsprofile             config='{"Comment":"partial configuration","Enabled":true}'
salt.modules.boto_cloudfront.export_distributions(region=None, key=None, keyid=None, profile=None) Get details of all CloudFront distributions.  Produces results that can be used to create an SLS file.
salt-call boto_cloudfront.export_distributions --out=txt |            sed "s/local: //" > cloudfront_distributions.sls
salt.modules.boto_cloudfront.get_distribution(name, region=None, key=None, keyid=None, profile=None) Get information about a CloudFront distribution (configuration, tags) with a given name.
name   Name of the CloudFront distribution
salt myminion boto_cloudfront.get_distribution name=mydistribution profile=awsprofile
salt.modules.boto_cloudfront.update_distribution(name, config, tags=None, region=None, key=None, keyid=None, profile=None) Update the config (and optionally tags) for the CloudFront distribution with the given name.
salt myminion boto_cloudfront.update_distribution name=mydistribution profile=awsprofile             config='{"Comment":"partial configuration","Enabled":true}'
salt.modules.boto_cloudtrail Connection module for Amazon CloudTrail
• boto
• boto3
The dependencies listed above can be installed via package or pip.
configuration This module accepts explicit Lambda 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:
cloudtrail.keyid: GKTADJGHEIQSXMKKRBJ08H cloudtrail.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
cloudtrail.region: us-east-1
salt.modules.boto_cloudtrail.add_tags(Name, region=None, key=None, keyid=None, profile=None, **kwargs) Add tags to a trail
Returns {tagged: true} if the trail was tagged and returns {tagged: False} if the trail was not tagged.
salt myminion boto_cloudtrail.add_tags my_trail tag_a=tag_value tag_b=tag_value
salt.modules.boto_cloudtrail.create(Name, S3BucketName, S3KeyPrefix=None, SnsTopicName=None, IncludeGlobalServiceEvents=None, IsMultiRegionTrail=None, EnableLogFileValidation=None, CloudWatchLogsLogGroupArn=None, CloudWatchLogsRoleArn=None, KmsKeyId=None, region=None, key=None, keyid=None, profile=None) Given a valid config, create a trail.
Returns {created: true} if the trail was created and returns {created: False} if the trail was not created.
salt myminion boto_cloudtrail.create my_trail my_bucket
salt.modules.boto_cloudtrail.delete(Name, region=None, key=None, keyid=None, profile=None) Given a trail name, delete it.
Returns {deleted: true} if the trail was deleted and returns {deleted: false} if the trail was not deleted.
salt myminion boto_cloudtrail.delete mytrail
salt.modules.boto_cloudtrail.describe(Name, region=None, key=None, keyid=None, profile=None) Given a trail name describe its properties.
Returns a dictionary of interesting properties.
salt myminion boto_cloudtrail.describe mytrail
salt.modules.boto_cloudtrail.exists(Name, region=None, key=None, keyid=None, profile=None) Given a trail name, check to see if the given trail exists.
Returns True if the given trail exists and returns False if the given trail does not exist.
salt myminion boto_cloudtrail.exists mytrail
salt.modules.boto_cloudtrail.list(region=None, key=None, keyid=None, profile=None) List all trails
Returns list of trails
policies: - {...} - {...}
salt.modules.boto_cloudtrail.list_tags(Name, region=None, key=None, keyid=None, profile=None) List tags of a trail
• {...}
Return type tags
salt myminion boto_cloudtrail.list_tags my_trail
salt.modules.boto_cloudtrail.remove_tags(Name, region=None, key=None, keyid=None, profile=None, **kwargs) Remove tags from a trail
salt myminion boto_cloudtrail.remove_tags my_trail tag_a=tag_value tag_b=tag_value
salt.modules.boto_cloudtrail.start_logging(Name, region=None, key=None, keyid=None, profile=None) Start logging for a trail
Returns {started: true} if the trail was started and returns {started: False} if the trail was not started.
salt myminion boto_cloudtrail.start_logging my_trail
salt.modules.boto_cloudtrail.status(Name, region=None, key=None, keyid=None, profile=None) Given a trail name describe its properties.
salt.modules.boto_cloudtrail.stop_logging(Name, region=None, key=None, keyid=None, profile=None) Stop logging for a trail
Returns {stopped: true} if the trail was stopped and returns {stopped: False} if the trail was not stopped.
salt myminion boto_cloudtrail.stop_logging my_trail
salt.modules.boto_cloudtrail.update(Name, S3BucketName, S3KeyPrefix=None, SnsTopicName=None, IncludeGlobalServiceEvents=None, IsMultiRegionTrail=None, EnableLogFileValidation=None, CloudWatchLogsLogGroupArn=None, CloudWatchLogsRoleArn=None, KmsKeyId=None, region=None, key=None, keyid=None, profile=None) Given a valid config, update a trail.
salt myminion boto_cloudtrail.update my_trail my_bucket
salt.modules.boto_cloudwatch Connection module for Amazon CloudWatch
configuration This module accepts explicit 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:
cloudwatch.keyid: GKTADJGHEIQSXMKKRBJ08H cloudwatch.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
cloudwatch.region: us-east-1
salt.modules.boto_cloudwatch.convert_to_arn(arns, region=None, key=None, keyid=None, profile=None) Convert a list of strings into actual arns. Converts convenience names such as 'scaling_policy:...'
salt '*' convert_to_arn 'scaling_policy:'
salt.modules.boto_cloudwatch.create_or_update_alarm(connection=None, name=None, metric=None, namespace=None, statistic=None, comparison=None, threshold=None, period=None, evaluation_periods=None, unit=None, description='', dimensions=None, alarm_actions=None, insufficient_data_actions=None, ok_actions=None, region=None, key=None, keyid=None, profile=None) Create or update a cloudwatch alarm.
Params are the same as: https://boto.readthedocs.io/en/latest/ref/cloudwatch.html#boto.ec2.cloudwatch.alarm.MetricAlarm.
Dimensions must be a dict. If the value of Dimensions is a string, it will be json decoded to produce a dict. alarm_actions, insufficient_data_actions, and ok_actions must be lists of string. If the passed-in value is a string, it will be split on "," to produce a list. The strings themselves for alarm_actions, insufficient_data_actions, and ok_actions must be Amazon resource names (ARN's); however, this method also supports an arn lookup notation, as follows: arn:aws:....                                    ARN as per http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html scaling_policy:<as_name>:<scaling_policy_name>  The named autoscale group scaling policy, for the named group (e.g. scaling_policy:my-asg:ScaleDown)
This is convenient for setting up autoscaling as follows.  First specify a boto_asg.present state for an ASG with scaling_policies, and then set up boto_cloudwatch_alarm.present states which have alarm_actions that reference the scaling_policy.
salt myminion boto_cloudwatch.create_alarm name=myalarm ... region=us-east-1
salt.modules.boto_cloudwatch.delete_alarm(name, region=None, key=None, keyid=None, profile=None) Delete a cloudwatch alarm
CLI example to delete a queue:
salt myminion boto_cloudwatch.delete_alarm myalarm region=us-east-1
salt.modules.boto_cloudwatch.get_alarm(name, region=None, key=None, keyid=None, profile=None) Get alarm details. Also can be used to check to see if an alarm exists.
salt myminion boto_cloudwatch.get_alarm myalarm region=us-east-1
salt.modules.boto_cloudwatch.get_all_alarms(region=None, prefix=None, key=None, keyid=None, profile=None) Get all alarm details.  Produces results that can be used to create an sls file.
If prefix parameter is given, alarm names in the output will be prepended with the prefix; alarms that have the prefix will be skipped.  This can be used to convert existing alarms to be managed by salt, as follows:
Make a backup of all existing alarms $ salt-call boto_cloudwatch.get_all_alarms --out=txt | sed "s/local: //" > legacy_alarms.sls
Get all alarms with new prefixed names $ salt-call boto_cloudwatch.get_all_alarms "prefix=**MANAGED BY SALT** " --out=txt | sed "s/local: //" > managed_alarms.sls
Insert the managed alarms into cloudwatch $ salt-call state.template managed_alarms.sls
4. Manually verify that the new alarms look right
5. Delete the original alarms $ sed s/present/absent/ legacy_alarms.sls > remove_legacy_alarms.sls $ salt-call state.template remove_legacy_alarms.sls
6. Get all alarms again, verify no changes $ salt-call boto_cloudwatch.get_all_alarms --out=txt | sed "s/local: //" > final_alarms.sls $ diff final_alarms.sls managed_alarms.sls
salt myminion boto_cloudwatch.get_all_alarms region=us-east-1 --out=txt
salt.modules.boto_cloudwatch_event Connection module for Amazon CloudWatch Events
cloudwatch_event.keyid: GKTADJGHEIQSXMKKRBJ08H cloudwatch_event.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
cloudwatch_event.region: us-east-1
salt.modules.boto_cloudwatch_event.create_or_update(Name, ScheduleExpression=None, EventPattern=None, Description=None, RoleArn=None, State=None, region=None, key=None, keyid=None, profile=None) Given a valid config, create an event rule.
Returns {created: true} if the rule was created and returns {created: False} if the rule was not created.
salt myminion boto_cloudwatch_event.create_or_update my_rule
salt.modules.boto_cloudwatch_event.delete(Name, region=None, key=None, keyid=None, profile=None) Given a rule name, delete it.
Returns {deleted: true} if the rule was deleted and returns {deleted: false} if the rule was not deleted.
salt myminion boto_cloudwatch_event.delete myrule
salt.modules.boto_cloudwatch_event.describe(Name, region=None, key=None, keyid=None, profile=None) Given a rule name describe its properties.
salt myminion boto_cloudwatch_event.describe myrule
salt.modules.boto_cloudwatch_event.exists(Name, region=None, key=None, keyid=None, profile=None) Given a rule name, check to see if the given rule exists.
Returns True if the given rule exists and returns False if the given rule does not exist.
salt myminion boto_cloudwatch_event.exists myevent region=us-east-1
salt.modules.boto_cloudwatch_event.list_rules(region=None, key=None, keyid=None, profile=None) List, with details, all Cloudwatch Event rules visible in the current scope.