neulab/tldr huggingface dataset:
salt.modules.boto_elasticache.list_cache_subnet_groups(name=None, region=None, key=None, keyid=None, profile=None) Return a list of all cache subnet group names
salt myminion boto_elasticache.list_subnet_groups region=us-east-1
salt.modules.boto_elasticache.revoke_cache_security_group_ingress(name, ec2_security_group_name, ec2_security_group_owner_id, region=None, key=None, keyid=None, profile=None) Revoke network ingress from an ec2 security group to a cache security group.
salt myminion boto_elasticache.revoke_cache_security_group_ingress myelasticachesg myec2sg 879879
salt.modules.boto_elasticache.subnet_group_exists(name, tags=None, region=None, key=None, keyid=None, profile=None) Check to see if an ElastiCache subnet group exists.
salt myminion boto_elasticache.subnet_group_exists my-param-group                 region=us-east-1
salt.modules.boto_elasticsearch_domain Connection module for Amazon Elasticsearch Service
configuration This module accepts explicit AWS 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:
lambda.keyid: GKTADJGHEIQSXMKKRBJ08H lambda.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
lambda.region: us-east-1
Create and delete methods return:
Request methods (e.g., describe_function) return:
domain: - {...} - {...}
salt.modules.boto_elasticsearch_domain.add_tags(DomainName=None, ARN=None, region=None, key=None, keyid=None, profile=None, **kwargs) Add tags to a domain
Returns {tagged: true} if the domain was tagged and returns {tagged: False} if the domain was not tagged.
salt myminion boto_elasticsearch_domain.add_tags mydomain tag_a=tag_value tag_b=tag_value
salt.modules.boto_elasticsearch_domain.create(DomainName, ElasticsearchClusterConfig=None, EBSOptions=None, AccessPolicies=None, SnapshotOptions=None, AdvancedOptions=None, region=None, key=None, keyid=None, profile=None, ElasticsearchVersion=None) Given a valid config, create a domain.
Returns {created: true} if the domain was created and returns {created: False} if the domain was not created.
salt myminion boto_elasticsearch_domain.create mydomain \ {'InstanceType': 't2.micro.elasticsearch', 'InstanceCount': 1, \ 'DedicatedMasterEnabled': false, 'ZoneAwarenessEnabled': false} \ {'EBSEnabled': true, 'VolumeType': 'gp2', 'VolumeSize': 10, \ 'Iops': 0} \ {"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"AWS": "*"}, "Action": "es:*", \ "Resource": "arn:aws:es:us-east-1:111111111111:domain/mydomain/*", \ "Condition": {"IpAddress": {"aws:SourceIp": ["127.0.0.1"]}}}]} \ {"AutomatedSnapshotStartHour": 0} \ {"rest.action.multi.allow_explicit_index": "true"}
salt.modules.boto_elasticsearch_domain.delete(DomainName, region=None, key=None, keyid=None, profile=None) Given a domain name, delete it.
Returns {deleted: true} if the domain was deleted and returns {deleted: false} if the domain was not deleted.
salt myminion boto_elasticsearch_domain.delete mydomain
salt.modules.boto_elasticsearch_domain.describe(DomainName, region=None, key=None, keyid=None, profile=None) Given a domain name describe its properties.
salt myminion boto_elasticsearch_domain.describe mydomain
salt.modules.boto_elasticsearch_domain.exists(DomainName, region=None, key=None, keyid=None, profile=None) Given a domain name, check to see if the given domain exists.
Returns True if the given domain exists and returns False if the given function does not exist.
salt myminion boto_elasticsearch_domain.exists mydomain
salt.modules.boto_elasticsearch_domain.list_tags(DomainName=None, ARN=None, region=None, key=None, keyid=None, profile=None) List tags of a trail
salt.modules.boto_elasticsearch_domain.remove_tags(TagKeys, DomainName=None, ARN=None, region=None, key=None, keyid=None, profile=None) Remove tags from a trail
salt.modules.boto_elasticsearch_domain.status(DomainName, region=None, key=None, keyid=None, profile=None) Given a domain name describe its status.
salt myminion boto_elasticsearch_domain.status mydomain
salt.modules.boto_elasticsearch_domain.update(DomainName, ElasticsearchClusterConfig=None, EBSOptions=None, AccessPolicies=None, SnapshotOptions=None, AdvancedOptions=None, region=None, key=None, keyid=None, profile=None) Update the named domain to the configuration.
Returns {updated: true} if the domain was updated and returns {updated: False} if the domain was not updated.
salt myminion boto_elasticsearch_domain.update mydomain \ {'InstanceType': 't2.micro.elasticsearch', 'InstanceCount': 1, \ 'DedicatedMasterEnabled': false, 'ZoneAwarenessEnabled': false} \ {'EBSEnabled': true, 'VolumeType': 'gp2', 'VolumeSize': 10, \ 'Iops': 0} \ {"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"AWS": "*"}, "Action": "es:*", \ "Resource": "arn:aws:es:us-east-1:111111111111:domain/mydomain/*", \ "Condition": {"IpAddress": {"aws:SourceIp": ["127.0.0.1"]}}}]} \ {"AutomatedSnapshotStartHour": 0} \ {"rest.action.multi.allow_explicit_index": "true"}
salt.modules.boto_elb Connection module for Amazon ELB
configuration This module accepts explicit elb 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:
elb.keyid: GKTADJGHEIQSXMKKRBJ08H elb.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
elb.region: us-east-1
depends boto >= 2.33.0
salt.modules.boto_elb.apply_security_groups(name, security_groups, region=None, key=None, keyid=None, profile=None) Apply security groups to ELB.
salt myminion boto_elb.apply_security_groups myelb '["mysecgroup1"]'
salt.modules.boto_elb.attach_subnets(name, subnets, region=None, key=None, keyid=None, profile=None) Attach ELB to subnets.
salt myminion boto_elb.attach_subnets myelb '["mysubnet"]'
salt.modules.boto_elb.create(name, availability_zones, listeners, subnets=None, security_groups=None, scheme='internet-facing', region=None, key=None, keyid=None, profile=None) Create an ELB
CLI example to create an ELB:
salt myminion boto_elb.create myelb '["us-east-1a", "us-east-1e"]' '{"elb_port": 443, "elb_protocol": "HTTPS", ...}' region=us-east-1
salt.modules.boto_elb.create_listeners(name, listeners, region=None, key=None, keyid=None, profile=None) Create listeners on an ELB.
salt myminion boto_elb.create_listeners myelb '[["HTTPS", "HTTP", 443, 80, "arn:aws:iam::11  11111:server-certificate/mycert"]]'
salt.modules.boto_elb.create_policy(name, policy_name, policy_type, policy, region=None, key=None, keyid=None, profile=None) Create an ELB policy.
salt myminion boto_elb.create_policy myelb mypolicy LBCookieStickinessPolicyType '{"CookieExpirationPeriod": 3600}'
salt.modules.boto_elb.delete(name, region=None, key=None, keyid=None, profile=None) Delete an ELB.
CLI example to delete an ELB:
salt myminion boto_elb.delete myelb region=us-east-1
salt.modules.boto_elb.delete_listeners(name, ports, region=None, key=None, keyid=None, profile=None) Delete listeners on an ELB.
salt myminion boto_elb.delete_listeners myelb '[80,443]'
salt.modules.boto_elb.delete_policy(name, policy_name, region=None, key=None, keyid=None, profile=None) Delete an ELB policy.
salt myminion boto_elb.delete_policy myelb mypolicy
salt.modules.boto_elb.delete_tags(name, tags, region=None, key=None, keyid=None, profile=None) Add the tags on an ELB
name   name of the ELB
tags   list of tags to remove
salt myminion boto_elb.delete_tags my-elb-name ['TagToRemove1', 'TagToRemove2']
salt.modules.boto_elb.deregister_instances(name, instances, region=None, key=None, keyid=None, profile=None) Deregister instances with an ELB.  Instances is either a string instance id or a list of string instance id's.
• True: instance(s) deregistered successfully
• False: instance(s) failed to be deregistered
• None: instance(s) not valid or not registered, no action taken
salt myminion boto_elb.deregister_instances myelb instance_id salt myminion boto_elb.deregister_instances myelb "[instance_id, instance_id]"
salt.modules.boto_elb.detach_subnets(name, subnets, region=None, key=None, keyid=None, profile=None) Detach ELB from subnets.
salt myminion boto_elb.detach_subnets myelb '["mysubnet"]'
salt.modules.boto_elb.disable_availability_zones(name, availability_zones, region=None, key=None, keyid=None, profile=None) Disable availability zones for ELB.
salt myminion boto_elb.disable_availability_zones myelb '["us-east-1a"]'
salt.modules.boto_elb.enable_availability_zones(name, availability_zones, region=None, key=None, keyid=None, profile=None) Enable availability zones for ELB.
salt myminion boto_elb.enable_availability_zones myelb '["us-east-1a"]'
salt.modules.boto_elb.exists(name, region=None, key=None, keyid=None, profile=None) Check to see if an ELB exists.
salt myminion boto_elb.exists myelb region=us-east-1
salt.modules.boto_elb.get_all_elbs(region=None, key=None, keyid=None, profile=None) Return all load balancers associated with an account
salt myminion boto_elb.get_all_elbs region=us-east-1
salt.modules.boto_elb.get_attributes(name, region=None, key=None, keyid=None, profile=None) Check to see if attributes are set on an ELB.
salt myminion boto_elb.get_attributes myelb
salt.modules.boto_elb.get_elb_config(name, region=None, key=None, keyid=None, profile=None) Get an ELB configuration.
salt.modules.boto_elb.get_health_check(name, region=None, key=None, keyid=None, profile=None) Get the health check configured for this ELB.
salt myminion boto_elb.get_health_check myelb
salt.modules.boto_elb.get_instance_health(name, region=None, key=None, keyid=None, profile=None, instances=None) Get a list of instances and their health state
salt myminion boto_elb.get_instance_health myelb salt myminion boto_elb.get_instance_health myelb region=us-east-1 instances="[instance_id,instance_id]"
salt.modules.boto_elb.list_elbs(region=None, key=None, keyid=None, profile=None) Return names of all load balancers associated with an account
salt myminion boto_elb.list_elbs region=us-east-1
salt.modules.boto_elb.listener_dict_to_tuple(listener) Convert an ELB listener dict into a listener tuple used by certain parts of the AWS ELB API.
salt myminion boto_elb.listener_dict_to_tuple '{"elb_port":80,"instance_port":80,"elb_protocol":"HTTP"}'
salt.modules.boto_elb.register_instances(name, instances, region=None, key=None, keyid=None, profile=None) Register instances with an ELB.  Instances is either a string instance id or a list of string instance id's.
• True: instance(s) registered successfully
• False: instance(s) failed to be registered
salt myminion boto_elb.register_instances myelb instance_id salt myminion boto_elb.register_instances myelb "[instance_id,instance_id]"
salt.modules.boto_elb.set_attributes(name, attributes, region=None, key=None, keyid=None, profile=None) Set attributes on an ELB.
name (string) Name of the ELB instance to set attributes for
attributes A dict of attributes to set.
Valid attributes are:
access_log (dict)
enabled (bool) Enable storage of access logs.
s3_bucket_name (string) The name of the S3 bucket to place logs.
s3_bucket_prefix (string) Prefix for the log file name.
emit_interval (int) Interval for storing logs in S3 in minutes. Valid values are 5 and 60.
connection_draining (dict)
enabled (bool) Enable connection draining.
timeout (int) Maximum allowed time in seconds for sending existing connections to an instance that is deregistering or unhealthy.  Default is 300.
cross_zone_load_balancing (dict)
enabled (bool) Enable cross-zone load balancing.
CLI example to set attributes on an ELB:
salt myminion boto_elb.set_attributes myelb '{"access_log": {"enabled": "true", "s3_bucket_name": "mybucket", "s3_bucket_prefix": "mylogs/", "emit_interval": "5"}}' region=us-east-1
salt.modules.boto_elb.set_backend_policy(name, port, policies=None, region=None, key=None, keyid=None, profile=None) Set the policies of an ELB backend server.
salt myminion boto_elb.set_backend_policy myelb 443 "[policy1,policy2]"
salt.modules.boto_elb.set_health_check(name, health_check, region=None, key=None, keyid=None, profile=None) Set attributes on an ELB.
salt myminion boto_elb.set_health_check myelb '{"target": "HTTP:80/"}'
salt.modules.boto_elb.set_instances(name, instances, test=False, region=None, key=None, keyid=None, profile=None) Set the instances assigned to an ELB to exactly the list given
salt myminion boto_elb.set_instances myelb region=us-east-1 instances="[instance_id,instance_id]"
salt.modules.boto_elb.set_listener_policy(name, port, policies=None, region=None, key=None, keyid=None, profile=None) Set the policies of an ELB listener.
salt myminion boto_elb.set_listener_policy myelb 443 "[policy1,policy2]"
salt.modules.boto_elb.set_tags(name, tags, region=None, key=None, keyid=None, profile=None) Add the tags on an ELB
tags   dict of name/value pair tags
salt myminion boto_elb.set_tags my-elb-name "{'Tag1': 'Value', 'Tag2': 'Another Value'}"
salt.modules.boto_elbv2 Connection module for Amazon ALB
elbv2.keyid: GKTADJGHEIQSXMKKRBJ08H elbv2.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs elbv2.region: us-west-2
salt.modules.boto_elbv2.create_target_group(name, protocol, port, vpc_id, region=None, key=None, keyid=None, profile=None, health_check_protocol='HTTP', health_check_port='traffic-port', health_check_path='/', health_check_interval_seconds=30, health_check_timeout_seconds=5, healthy_threshold_count=5, unhealthy_threshold_count=2) Create target group if not present.
name   (string) - The name of the target group.
protocol (string) - The protocol to use for routing traffic to the targets
port   (int) - The port on which the targets receive traffic. This port is used unless you specify a port override when registering the traffic.
vpc_id (string) - The identifier of the virtual private cloud (VPC).
health_check_protocol (string) - The protocol the load balancer uses when performing health check on targets. The default is the HTTP protocol.
health_check_port (string) - The port the load balancer uses when performing health checks on targets. The default is 'traffic-port', which indicates the port on which each target receives traffic from the load balancer.
health_check_path (string) - The ping path that is the destination on the targets for health checks. The default is /.
health_check_interval_seconds (integer) - The approximate amount of time, in seconds, between health checks of an individual target. The default is 30 seconds.
health_check_timeout_seconds (integer) - The amount of time, in seconds, during which no response from a target means a failed health check. The default is 5 seconds.
healthy_threshold_count (integer) - The number of consecutive health checks successes required before considering an unhealthy target healthy. The default is 5.
unhealthy_threshold_count (integer) - The number of consecutive health check failures required before considering a target unhealthy. The default is 2.
salt myminion boto_elbv2.create_target_group learn1give1 protocol=HTTP port=54006 vpc_id=vpc-deadbeef
salt.modules.boto_elbv2.delete_target_group(name, region=None, key=None, keyid=None, profile=None) Delete target group.
name   (string) - Target Group Name or Amazon Resource Name (ARN).
salt myminion boto_elbv2.delete_target_group arn:aws:elasticloadbalancing:us-west-2:644138682826:targetgroup/learn1give1-api/414788a16b5cf163
salt.modules.boto_elbv2.deregister_targets(name, targets, region=None, key=None, keyid=None, profile=None) Deregister targets to a target froup of an ALB. targets is either a instance id string or a list of instance id's.
salt myminion boto_elbv2.deregister_targets myelb instance_id salt myminion boto_elbv2.deregister_targets myelb "[instance_id,instance_id]"
salt.modules.boto_elbv2.describe_target_health(name, targets=None, region=None, key=None, keyid=None, profile=None) Get the curret health check status for targets in a target group.
salt myminion boto_elbv2.describe_target_health arn:aws:elasticloadbalancing:us-west-2:644138682826:targetgroup/learn1give1-api/414788a16b5cf163 targets=["i-isdf23ifjf"]
salt.modules.boto_elbv2.register_targets(name, targets, region=None, key=None, keyid=None, profile=None) Register targets to a target froup of an ALB. targets is either a instance id string or a list of instance id's.
salt myminion boto_elbv2.register_targets myelb instance_id salt myminion boto_elbv2.register_targets myelb "[instance_id,instance_id]"
salt.modules.boto_elbv2.target_group_exists(name, region=None, key=None, keyid=None, profile=None) Check to see if an target group exists.
salt myminion boto_elbv2.target_group_exists arn:aws:elasticloadbalancing:us-west-2:644138682826:targetgroup/learn1give1-api/414788a16b5cf163
salt.modules.boto_iam Connection module for Amazon IAM
configuration This module accepts explicit iam 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:
iam.keyid: GKTADJGHEIQSXMKKRBJ08H iam.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs iam.region: us-east-1
salt.modules.boto_iam.add_user_to_group(user_name, group_name, region=None, key=None, keyid=None, profile=None) Add user to group.
salt myminion boto_iam.add_user_to_group myuser mygroup
salt.modules.boto_iam.associate_profile_to_role(profile_name, role_name, region=None, key=None, keyid=None, profile=None) Associate an instance profile with an IAM role.
salt myminion boto_iam.associate_profile_to_role myirole myiprofile
salt.modules.boto_iam.attach_group_policy(policy_name, group_name, region=None, key=None, keyid=None, profile=None) Attach a managed policy to a group.
salt myminion boto_iam.attach_group_policy mypolicy mygroup
salt.modules.boto_iam.attach_role_policy(policy_name, role_name, region=None, key=None, keyid=None, profile=None) Attach a managed policy to a role.
salt myminion boto_iam.attach_role_policy mypolicy myrole
salt.modules.boto_iam.attach_user_policy(policy_name, user_name, region=None, key=None, keyid=None, profile=None) Attach a managed policy to a user.
salt myminion boto_iam.attach_user_policy mypolicy myuser
salt.modules.boto_iam.build_policy(region=None, key=None, keyid=None, profile=None) Build a default assume role policy.
salt myminion boto_iam.build_policy
salt.modules.boto_iam.create_access_key(user_name, region=None, key=None, keyid=None, profile=None) Create access key id for a user.
salt myminion boto_iam.create_access_key myuser
salt.modules.boto_iam.create_group(group_name, path=None, region=None, key=None, keyid=None, profile=None) Create a group.
salt myminion boto_iam.create_group group
salt.modules.boto_iam.create_instance_profile(name, region=None, key=None, keyid=None, profile=None) Create an instance profile.
salt myminion boto_iam.create_instance_profile myiprofile
salt.modules.boto_iam.create_login_profile(user_name, password, region=None, key=None, keyid=None, profile=None) Creates a login profile for the specified user, give the user the ability to access AWS services and the AWS Management Console.
salt myminion boto_iam.create_login_profile user_name password
salt.modules.boto_iam.create_policy(policy_name, policy_document, path=None, description=None, region=None, key=None, keyid=None, profile=None) Create a policy.
salt myminios boto_iam.create_policy mypolicy '{"Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": ["s3:Get*", "s3:List*"], "Resource": ["arn:aws:s3:::my-bucket/shared/*"]},]}'
salt.modules.boto_iam.create_policy_version(policy_name, policy_document, set_as_default=None, region=None, key=None, keyid=None, profile=None) Create a policy version.
salt myminios boto_iam.create_policy_version mypolicy '{"Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": ["s3:Get*", "s3:List*"], "Resource": ["arn:aws:s3:::my-bucket/shared/*"]},]}'
salt.modules.boto_iam.create_role(name, policy_document=None, path=None, region=None, key=None, keyid=None, profile=None) Create an instance role.
salt myminion boto_iam.create_role myrole
salt.modules.boto_iam.create_role_policy(role_name, policy_name, policy, region=None, key=None, keyid=None, profile=None) Create or modify a role policy.
salt myminion boto_iam.create_role_policy myirole mypolicy '{"MyPolicy": "Statement": [{"Action": ["sqs:*"], "Effect": "Allow", "Resource": ["arn:aws:sqs:*:*:*"], "Sid": "MyPolicySqs1"}]}'
salt.modules.boto_iam.create_saml_provider(name, saml_metadata_document, region=None, key=None, keyid=None, profile=None) Create SAML provider
salt myminion boto_iam.create_saml_provider my_saml_provider_name saml_metadata_document
salt.modules.boto_iam.create_user(user_name, path=None, region=None, key=None, keyid=None, profile=None) Create a user.
salt myminion boto_iam.create_user myuser
salt.modules.boto_iam.deactivate_mfa_device(user_name, serial, region=None, key=None, keyid=None, profile=None) Deactivates the specified MFA device and removes it from association with the user.
salt myminion boto_iam.deactivate_mfa_device user_name serial_num
salt.modules.boto_iam.delete_access_key(access_key_id, user_name=None, region=None, key=None, keyid=None, profile=None) Delete access key id from a user.
salt myminion boto_iam.delete_access_key myuser
salt.modules.boto_iam.delete_group(group_name, region=None, key=None, keyid=None, profile=None) Delete a group policy.
salt myminion boto_iam.delete_group mygroup
salt.modules.boto_iam.delete_group_policy(group_name, policy_name, region=None, key=None, keyid=None, profile=None) Delete a group policy.
salt myminion boto_iam.delete_group_policy mygroup mypolicy
salt.modules.boto_iam.delete_instance_profile(name, region=None, key=None, keyid=None, profile=None) Delete an instance profile.
salt myminion boto_iam.delete_instance_profile myiprofile
salt.modules.boto_iam.delete_login_profile(user_name, region=None, key=None, keyid=None, profile=None) Deletes a login profile for the specified user.
salt myminion boto_iam.delete_login_profile user_name
salt.modules.boto_iam.delete_policy(policy_name, region=None, key=None, keyid=None, profile=None) Delete a policy.
salt myminion boto_iam.delete_policy mypolicy
salt.modules.boto_iam.delete_policy_version(policy_name, version_id, region=None, key=None, keyid=None, profile=None) Delete a policy version.
salt myminion boto_iam.delete_policy_version mypolicy v1
salt.modules.boto_iam.delete_role(name, region=None, key=None, keyid=None, profile=None) Delete an IAM role.
salt myminion boto_iam.delete_role myirole
salt.modules.boto_iam.delete_role_policy(role_name, policy_name, region=None, key=None, keyid=None, profile=None) Delete a role policy.
salt myminion boto_iam.delete_role_policy myirole mypolicy
salt.modules.boto_iam.delete_saml_provider(name, region=None, key=None, keyid=None, profile=None) Delete SAML provider
salt myminion boto_iam.delete_saml_provider my_saml_provider_name
salt.modules.boto_iam.delete_server_cert(cert_name, region=None, key=None, keyid=None, profile=None) Deletes a certificate from Amazon.
salt myminion boto_iam.delete_server_cert mycert_name
salt.modules.boto_iam.delete_user(user_name, region=None, key=None, keyid=None, profile=None) Delete a user.
salt myminion boto_iam.delete_user myuser
salt.modules.boto_iam.delete_user_policy(user_name, policy_name, region=None, key=None, keyid=None, profile=None) Delete a user policy.
salt myminion boto_iam.delete_user_policy myuser mypolicy
salt.modules.boto_iam.delete_virtual_mfa_device(serial, region=None, key=None, keyid=None, profile=None) Deletes the specified virtual MFA device.
salt myminion boto_iam.delete_virtual_mfa_device serial_num
salt.modules.boto_iam.describe_role(name, region=None, key=None, keyid=None, profile=None) Get information for a role.
salt myminion boto_iam.describe_role myirole
salt.modules.boto_iam.detach_group_policy(policy_name, group_name, region=None, key=None, keyid=None, profile=None) Detach a managed policy to a group.
salt myminion boto_iam.detach_group_policy mypolicy mygroup
salt.modules.boto_iam.detach_role_policy(policy_name, role_name, region=None, key=None, keyid=None, profile=None) Detach a managed policy to a role.
salt myminion boto_iam.detach_role_policy mypolicy myrole
salt.modules.boto_iam.detach_user_policy(policy_name, user_name, region=None, key=None, keyid=None, profile=None) Detach a managed policy to a user.
salt myminion boto_iam.detach_user_policy mypolicy myuser
salt.modules.boto_iam.disassociate_profile_from_role(profile_name, role_name, region=None, key=None, keyid=None, profile=None) Disassociate an instance profile from an IAM role.
salt myminion boto_iam.disassociate_profile_from_role myirole myiprofile
salt.modules.boto_iam.export_roles(path_prefix='/', region=None, key=None, keyid=None, profile=None) Get all IAM role details. Produces results that can be used to create an sls file.
salt-call boto_iam.export_roles --out=txt | sed "s/local: //" > iam_roles.sls
salt.modules.boto_iam.export_users(path_prefix='/', region=None, key=None, keyid=None, profile=None) Get all IAM user details. Produces results that can be used to create an sls file.
salt-call boto_iam.export_users --out=txt | sed "s/local: //" > iam_users.sls
salt.modules.boto_iam.get_account_id(region=None, key=None, keyid=None, profile=None) Get a the AWS account id associated with the used credentials.
salt myminion boto_iam.get_account_id
salt.modules.boto_iam.get_account_policy(region=None, key=None, keyid=None, profile=None) Get account policy for the AWS account.
salt myminion boto_iam.get_account_policy
salt.modules.boto_iam.get_all_access_keys(user_name, marker=None, max_items=None, region=None, key=None, keyid=None, profile=None) Get all access keys from a user.
salt myminion boto_iam.get_all_access_keys myuser
salt.modules.boto_iam.get_all_group_policies(group_name, region=None, key=None, keyid=None, profile=None) Get a list of policy names from a group.
salt myminion boto_iam.get_all_group_policies mygroup
salt.modules.boto_iam.get_all_groups(path_prefix='/', region=None, key=None, keyid=None, profile=None) Get and return all IAM group details, starting at the optional path.
salt-call boto_iam.get_all_groups
salt.modules.boto_iam.get_all_instance_profiles(path_prefix='/', region=None, key=None, keyid=None, profile=None) Get and return all IAM instance profiles, starting at the optional path.
salt-call boto_iam.get_all_instance_profiles
salt.modules.boto_iam.get_all_mfa_devices(user_name, region=None, key=None, keyid=None, profile=None) Get all MFA devices associated with an IAM user.
salt myminion boto_iam.get_all_mfa_devices user_name
salt.modules.boto_iam.get_all_roles(path_prefix=None, region=None, key=None, keyid=None, profile=None) Get and return all IAM role details, starting at the optional path.
salt-call boto_iam.get_all_roles
salt.modules.boto_iam.get_all_user_policies(user_name, marker=None, max_items=None, region=None, key=None, keyid=None, profile=None) Get all user policies.
salt myminion boto_iam.get_all_user_policies myuser
salt.modules.boto_iam.get_all_users(path_prefix='/', region=None, key=None, keyid=None, profile=None) Get and return all IAM user details, starting at the optional path.
salt-call boto_iam.get_all_users
salt.modules.boto_iam.get_group(group_name, region=None, key=None, keyid=None, profile=None) Get group information.
salt myminion boto_iam.get_group mygroup
salt.modules.boto_iam.get_group_members(group_name, region=None, key=None, keyid=None, profile=None) Get group information.
salt.modules.boto_iam.get_group_policy(group_name, policy_name, region=None, key=None, keyid=None, profile=None) Retrieves the specified policy document for the specified group.
salt myminion boto_iam.get_group_policy mygroup policyname
salt.modules.boto_iam.get_policy(policy_name, region=None, key=None, keyid=None, profile=None) Check to see if policy exists.
salt myminion boto_iam.instance_profile_exists myiprofile
salt.modules.boto_iam.get_policy_version(policy_name, version_id, region=None, key=None, keyid=None, profile=None) Check to see if policy exists.
salt.modules.boto_iam.get_role_policy(role_name, policy_name, region=None, key=None, keyid=None, profile=None) Get a role policy.
salt myminion boto_iam.get_role_policy myirole mypolicy
salt.modules.boto_iam.get_saml_provider(name, region=None, key=None, keyid=None, profile=None) Get SAML provider document.
salt myminion boto_iam.get_saml_provider arn
salt.modules.boto_iam.get_saml_provider_arn(name, region=None, key=None, keyid=None, profile=None) Get SAML provider
salt myminion boto_iam.get_saml_provider_arn my_saml_provider_name
salt.modules.boto_iam.get_server_certificate(cert_name, region=None, key=None, keyid=None, profile=None) Returns certificate information from Amazon
salt myminion boto_iam.get_server_certificate mycert_name
salt.modules.boto_iam.get_user(user_name=None, region=None, key=None, keyid=None, profile=None) Get user information.
salt myminion boto_iam.get_user myuser
salt.modules.boto_iam.get_user_policy(user_name, policy_name, region=None, key=None, keyid=None, profile=None) Retrieves the specified policy document for the specified user.
salt myminion boto_iam.get_user_policy myuser mypolicyname
salt.modules.boto_iam.instance_profile_exists(name, region=None, key=None, keyid=None, profile=None) Check to see if an instance profile exists.
salt.modules.boto_iam.list_attached_group_policies(group_name, path_prefix=None, entity_filter=None, region=None, key=None, keyid=None, profile=None) List entities attached to the given group.
salt myminion boto_iam.list_entities_for_policy mypolicy
salt.modules.boto_iam.list_attached_role_policies(role_name, path_prefix=None, entity_filter=None, region=None, key=None, keyid=None, profile=None) List entities attached to the given role.
salt.modules.boto_iam.list_attached_user_policies(user_name, path_prefix=None, entity_filter=None, region=None, key=None, keyid=None, profile=None) List entities attached to the given user.
salt.modules.boto_iam.list_entities_for_policy(policy_name, path_prefix=None, entity_filter=None, region=None, key=None, keyid=None, profile=None) List entities that a policy is attached to.
salt.modules.boto_iam.list_instance_profiles(path_prefix='/', region=None, key=None, keyid=None, profile=None) List all IAM instance profiles, starting at the optional path.
salt-call boto_iam.list_instance_profiles
salt.modules.boto_iam.list_policies(region=None, key=None, keyid=None, profile=None) List policies.
salt myminion boto_iam.list_policies
salt.modules.boto_iam.list_policy_versions(policy_name, region=None, key=None, keyid=None, profile=None) List versions of a policy.
salt myminion boto_iam.list_policy_versions mypolicy
salt.modules.boto_iam.list_role_policies(role_name, region=None, key=None, keyid=None, profile=None) Get a list of policy names from a role.
salt myminion boto_iam.list_role_policies myirole
salt.modules.boto_iam.list_saml_providers(region=None, key=None, keyid=None, profile=None) List SAML providers.
salt myminion boto_iam.list_saml_providers
salt.modules.boto_iam.policy_exists(policy_name, region=None, key=None, keyid=None, profile=None) Check to see if policy exists.
salt.modules.boto_iam.policy_version_exists(policy_name, version_id, region=None, key=None, keyid=None, profile=None) Check to see if policy exists.
salt.modules.boto_iam.profile_associated(role_name, profile_name, region, key, keyid, profile) Check to see if an instance profile is associated with an IAM role.
salt myminion boto_iam.profile_associated myirole myiprofile
salt.modules.boto_iam.put_group_policy(group_name, policy_name, policy_json, region=None, key=None, keyid=None, profile=None) Adds or updates the specified policy document for the specified group.
salt myminion boto_iam.put_group_policy mygroup policyname policyrules
salt.modules.boto_iam.put_user_policy(user_name, policy_name, policy_json, region=None, key=None, keyid=None, profile=None) Adds or updates the specified policy document for the specified user.
salt myminion boto_iam.put_user_policy myuser policyname policyrules
salt.modules.boto_iam.remove_user_from_group(group_name, user_name, region=None, key=None, keyid=None, profile=None) Remove user from group.
salt myminion boto_iam.remove_user_from_group mygroup myuser
salt.modules.boto_iam.role_exists(name, region=None, key=None, keyid=None, profile=None) Check to see if an IAM role exists.
salt myminion boto_iam.role_exists myirole
salt.modules.boto_iam.set_default_policy_version(policy_name, version_id, region=None, key=None, keyid=None, profile=None) Set the default version of  a policy.
salt myminion boto_iam.set_default_policy_version mypolicy v1
salt.modules.boto_iam.update_account_password_policy(allow_users_to_change_password=None, hard_expiry=None, max_password_age=None, minimum_password_length=None, password_reuse_prevention=None, require_lowercase_characters=None, require_numbers=None, require_symbols=None, require_uppercase_characters=None, region=None, key=None, keyid=None, profile=None) Update the password policy for the AWS account.
salt myminion boto_iam.update_account_password_policy True
salt.modules.boto_iam.update_assume_role_policy(role_name, policy_document, region=None, key=None, keyid=None, profile=None) Update an assume role policy for a role.
salt myminion boto_iam.update_assume_role_policy myrole '{"Statement":"..."}'
salt.modules.boto_iam.update_saml_provider(name, saml_metadata_document, region=None, key=None, keyid=None, profile=None) Update SAML provider.
salt myminion boto_iam.update_saml_provider my_saml_provider_name saml_metadata_document
salt.modules.boto_iam.upload_server_cert(cert_name, cert_body, private_key, cert_chain=None, path=None, region=None, key=None, keyid=None, profile=None) Upload a certificate to Amazon.
salt myminion boto_iam.upload_server_cert mycert_name crt priv_key
• cert_name -- The name for the server certificate. Do not include the path in this value.
• cert_body -- The contents of the public key certificate in PEM-encoded format.
• private_key -- The contents of the private key in PEM-encoded format.
• cert_chain -- The contents of the certificate chain. This is typically a concatenation of the PEM-encoded public key certificates of the chain.
• path -- The path for the server certificate.
• region -- The name of the region to connect to.
• key -- The key to be used in order to connect
• keyid -- The keyid to be used in order to connect
• profile -- The profile that contains a dict of region, key, keyid
Returns True / False
salt.modules.boto_iam.user_exists_in_group(user_name, group_name, region=None, key=None, keyid=None, profile=None) Check if user exists in group.
salt myminion boto_iam.user_exists_in_group myuser mygroup
salt.modules.boto_iot Connection module for Amazon IoT
iot.keyid: GKTADJGHEIQSXMKKRBJ08H iot.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
iot.region: us-east-1
salt.modules.boto_iot.attach_principal_policy(policyName, principal, region=None, key=None, keyid=None, profile=None) Attach the specified policy to the specified principal (certificate or other credential.)
Returns {attached: true} if the policy was attached {attached: False} if the policy was not attached.
salt myminion boto_iot.attach_principal_policy mypolicy mycognitoID
salt.modules.boto_iot.create_policy(policyName, policyDocument, region=None, key=None, keyid=None, profile=None) Given a valid config, create a policy.
Returns {created: true} if the policy was created and returns {created: False} if the policy was not created.
salt myminion boto_iot.create_policy my_policy \ '{"Version":"2015-12-12",\ "Statement":[{"Effect":"Allow",\ "Action":["iot:Publish"],\ "Resource":["arn:::::topic/foo/bar"]}]}'
salt.modules.boto_iot.create_policy_version(policyName, policyDocument, setAsDefault=False, region=None, key=None, keyid=None, profile=None) Given a valid config, create a new version of a policy.
Returns {created: true} if the policy version was created and returns {created: False} if the policy version was not created.
salt myminion boto_iot.create_policy_version my_policy \ '{"Statement":[{"Effect":"Allow","Action":["iot:Publish"],"Resource":["arn:::::topic/foo/bar"]}]}'
salt.modules.boto_iot.create_thing_type(thingTypeName, thingTypeDescription, searchableAttributesList, region=None, key=None, keyid=None, profile=None) Given a valid config, create a thing type.
Returns {created: true} if the thing type was created and returns {created: False} if the thing type was not created.
salt myminion boto_iot.create_thing_type mythingtype \ thingtype_description_string '["searchable_attr_1", "searchable_attr_2"]'
salt.modules.boto_iot.create_topic_rule(ruleName, sql, actions, description, ruleDisabled=False, region=None, key=None, keyid=None, profile=None) Given a valid config, create a topic rule.
salt myminion boto_iot.create_topic_rule my_rule "SELECT * FROM 'some/thing'" \ '[{"lambda":{"functionArn":"arn:::::something"}},{"sns":{\ "targetArn":"arn:::::something","roleArn":"arn:::::something"}}]'
salt.modules.boto_iot.delete_policy(policyName, region=None, key=None, keyid=None, profile=None) Given a policy name, delete it.
Returns {deleted: true} if the policy was deleted and returns {deleted: false} if the policy was not deleted.
salt myminion boto_iot.delete_policy mypolicy
salt.modules.boto_iot.delete_policy_version(policyName, policyVersionId, region=None, key=None, keyid=None, profile=None) Given a policy name and version, delete it.
Returns {deleted: true} if the policy version was deleted and returns {deleted: false} if the policy version was not deleted.
salt myminion boto_iot.delete_policy_version mypolicy version
salt.modules.boto_iot.delete_thing_type(thingTypeName, region=None, key=None, keyid=None, profile=None) Given a thing type name, delete it.
Returns {deleted: true} if the thing type was deleted and returns {deleted: false} if the thing type was not deleted.
salt myminion boto_iot.delete_thing_type mythingtype
salt.modules.boto_iot.delete_topic_rule(ruleName, region=None, key=None, keyid=None, profile=None) Given a rule name, delete it.
salt myminion boto_iot.delete_rule myrule
salt.modules.boto_iot.deprecate_thing_type(thingTypeName, undoDeprecate=False, region=None, key=None, keyid=None, profile=None) Given a thing type name, deprecate it when undoDeprecate is False and undeprecate it when undoDeprecate is True.
Returns {deprecated: true} if the thing type was deprecated and returns {deprecated: false} if the thing type was not deprecated.
salt myminion boto_iot.deprecate_thing_type mythingtype
salt.modules.boto_iot.describe_policy(policyName, region=None, key=None, keyid=None, profile=None) Given a policy name describe its properties.
salt myminion boto_iot.describe_policy mypolicy
salt.modules.boto_iot.describe_policy_version(policyName, policyVersionId, region=None, key=None, keyid=None, profile=None) Given a policy name and version describe its properties.
salt myminion boto_iot.describe_policy_version mypolicy version
salt.modules.boto_iot.describe_thing_type(thingTypeName, region=None, key=None, keyid=None, profile=None) Given a thing type name describe its properties.
salt myminion boto_iot.describe_thing_type mythingtype
salt.modules.boto_iot.describe_topic_rule(ruleName, region=None, key=None, keyid=None, profile=None) Given a topic rule name describe its properties.
salt myminion boto_iot.describe_topic_rule myrule
salt.modules.boto_iot.detach_principal_policy(policyName, principal, region=None, key=None, keyid=None, profile=None) Detach the specified policy from the specified principal (certificate or other credential.)
Returns {detached: true} if the policy was detached {detached: False} if the policy was not detached.
salt myminion boto_iot.detach_principal_policy mypolicy mycognitoID
salt.modules.boto_iot.list_policies(region=None, key=None, keyid=None, profile=None) List all policies
Returns list of policies
salt myminion boto_iot.list_policies
Example Return:
salt.modules.boto_iot.list_policy_versions(policyName, region=None, key=None, keyid=None, profile=None) List the versions available for the given policy.
salt myminion boto_iot.list_policy_versions mypolicy
policyVersions: - {...} - {...}
salt.modules.boto_iot.list_principal_policies(principal, region=None, key=None, keyid=None, profile=None) List the policies attached to the given principal.
salt myminion boto_iot.list_principal_policies myprincipal
salt.modules.boto_iot.list_topic_rules(topic=None, ruleDisabled=None, region=None, key=None, keyid=None, profile=None) List all rules (for a given topic, if specified)
Returns list of rules
salt myminion boto_iot.list_topic_rules
rules: - {...} - {...}
salt.modules.boto_iot.policy_exists(policyName, region=None, key=None, keyid=None, profile=None) Given a policy name, check to see if the given policy exists.
Returns True if the given policy exists and returns False if the given policy does not exist.
salt myminion boto_iot.policy_exists mypolicy
salt.modules.boto_iot.policy_version_exists(policyName, policyVersionId, region=None, key=None, keyid=None, profile=None) Given a policy name and version ID, check to see if the given policy version exists.
Returns True if the given policy version exists and returns False if the given policy version does not exist.
salt myminion boto_iot.policy_version_exists mypolicy versionid
salt.modules.boto_iot.replace_topic_rule(ruleName, sql, actions, description, ruleDisabled=False, region=None, key=None, keyid=None, profile=None) Given a valid config, replace a topic rule with the new values.
salt myminion boto_iot.replace_topic_rule my_rule 'SELECT * FROM some.thing' \ '[{"lambda":{"functionArn":"arn:::::something"}},{"sns":{\ "targetArn":"arn:::::something","roleArn":"arn:::::something"}}]'
salt.modules.boto_iot.set_default_policy_version(policyName, policyVersionId, region=None, key=None, keyid=None, profile=None) Sets the specified version of the specified policy as the policy's default (operative) version. This action affects all certificates that the policy is attached to.
Returns {changed: true} if the policy version was set {changed: False} if the policy version was not set.
salt myminion boto_iot.set_default_policy_version mypolicy versionid
salt.modules.boto_iot.thing_type_exists(thingTypeName, region=None, key=None, keyid=None, profile=None) Given a thing type name, check to see if the given thing type exists
Returns True if the given thing type exists and returns False if the given thing type does not exist.
salt myminion boto_iot.thing_type_exists mythingtype
salt.modules.boto_iot.topic_rule_exists(ruleName, region=None, key=None, keyid=None, profile=None) Given a rule name, check to see if the given rule exists.
salt myminion boto_iot.topic_rule_exists myrule
salt.modules.boto_kinesis Connection module for Amazon Kinesis
configuration This module accepts explicit Kinesis 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:
kinesis.keyid: GKTADJGHEIQSXMKKRBJ08H kinesis.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
kinesis.region: us-east-1
salt.modules.boto_kinesis.create_stream(stream_name, num_shards, region=None, key=None, keyid=None, profile=None) Create a stream with name stream_name and initial number of shards num_shards.
salt myminion boto_kinesis.create_stream my_stream N region=us-east-1
salt.modules.boto_kinesis.decrease_stream_retention_period(stream_name, retention_hours, region=None, key=None, keyid=None, profile=None) Decrease stream retention period to retention_hours
salt myminion boto_kinesis.decrease_stream_retention_period my_stream N region=us-east-1
salt.modules.boto_kinesis.delete_stream(stream_name, region=None, key=None, keyid=None, profile=None) Delete the stream with name stream_name. This cannot be undone! All data will be lost!!
salt myminion boto_kinesis.delete_stream my_stream region=us-east-1
salt.modules.boto_kinesis.disable_enhanced_monitoring(stream_name, metrics, region=None, key=None, keyid=None, profile=None) Disable enhanced monitoring for the specified shard-level metrics on stream stream_name
salt myminion boto_kinesis.disable_enhanced_monitoring my_stream ["metrics", "to", "disable"] region=us-east-1
salt.modules.boto_kinesis.enable_enhanced_monitoring(stream_name, metrics, region=None, key=None, keyid=None, profile=None) Enable enhanced monitoring for the specified shard-level metrics on stream stream_name
salt myminion boto_kinesis.enable_enhanced_monitoring my_stream ["metrics", "to", "enable"] region=us-east-1
salt.modules.boto_kinesis.exists(stream_name, region=None, key=None, keyid=None, profile=None) Check if the stream exists. Returns False and the error if it does not.
salt myminion boto_kinesis.exists my_stream region=us-east-1
salt.modules.boto_kinesis.get_info_for_reshard(stream_details) Collect some data: number of open shards, key range, etc. Modifies stream_details to add a sorted list of OpenShards. Returns (min_hash_key, max_hash_key, stream_details)
salt myminion boto_kinesis.get_info_for_reshard existing_stream_details
salt.modules.boto_kinesis.get_stream_when_active(stream_name, region=None, key=None, keyid=None, profile=None) Get complete stream info from AWS, returning only when the stream is in the ACTIVE state.  Continues to retry when stream is updating or creating.  If the stream is deleted during retries, the loop will catch the error and break.
salt myminion boto_kinesis.get_stream_when_active my_stream region=us-east-1
salt.modules.boto_kinesis.increase_stream_retention_period(stream_name, retention_hours, region=None, key=None, keyid=None, profile=None) Increase stream retention period to retention_hours
salt myminion boto_kinesis.increase_stream_retention_period my_stream N region=us-east-1
salt.modules.boto_kinesis.list_streams(region=None, key=None, keyid=None, profile=None) Return a list of all streams visible to the current account
salt myminion boto_kinesis.list_streams
salt.modules.boto_kinesis.long_int(hash_key) The hash key is a 128-bit int, sent as a string.  It's necessary to convert to int/long for comparison operations.  This helper method handles python 2/3 incompatibility
salt myminion boto_kinesis.long_int some_MD5_hash_as_string
Returns long object if python 2.X, int object if python 3.X
salt.modules.boto_kinesis.reshard(stream_name, desired_size, force=False, region=None, key=None, keyid=None, profile=None) Reshard a kinesis stream.  Each call to this function will wait until the stream is ACTIVE, then make a single split or merge operation. This function decides where to split or merge with the assumption that the ultimate goal is a balanced partition space.
For safety, user must past in force=True; otherwise, the function will dry run.
salt myminion boto_kinesis.reshard my_stream N True region=us-east-1
Returns True if a split or merge was found/performed, False if nothing is needed
salt.modules.boto_kms Connection module for Amazon KMS
configuration This module accepts explicit kms 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:
kms.keyid: GKTADJGHEIQSXMKKRBJ08H kms.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
kms.region: us-east-1
salt.modules.boto_kms.create_alias(alias_name, target_key_id, region=None, key=None, keyid=None, profile=None) Create a display name for a key.
salt myminion boto_kms.create_alias 'alias/mykey' key_id
salt.modules.boto_kms.create_grant(key_id, grantee_principal, retiring_principal=None, operations=None, constraints=None, grant_tokens=None, region=None, key=None, keyid=None, profile=None) Adds a grant to a key to specify who can access the key and under what conditions.
salt myminion boto_kms.create_grant 'alias/mykey' 'arn:aws:iam::1111111:/role/myrole' operations='["Encrypt","Decrypt"]'
salt.modules.boto_kms.create_key(policy=None, description=None, key_usage=None, region=None, key=None, keyid=None, profile=None) Creates a master key.
salt myminion boto_kms.create_key '{"Statement":...}' "My master key"
salt.modules.boto_kms.decrypt(ciphertext_blob, encryption_context=None, grant_tokens=None, region=None, key=None, keyid=None, profile=None) Decrypt ciphertext.
salt myminion boto_kms.decrypt encrypted_ciphertext
salt.modules.boto_kms.describe_key(key_id, region=None, key=None, keyid=None, profile=None) Get detailed information about a key.
salt myminion boto_kms.describe_key 'alias/mykey'