| # Copyright (c) 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved |
| # |
| # Permission is hereby granted, free of charge, to any person obtaining a |
| # copy of this software and associated documentation files (the |
| # "Software"), to deal in the Software without restriction, including |
| # without limitation the rights to use, copy, modify, merge, publish, dis- |
| # tribute, sublicense, and/or sell copies of the Software, and to permit |
| # persons to whom the Software is furnished to do so, subject to the fol- |
| # lowing conditions: |
| # |
| # The above copyright notice and this permission notice shall be included |
| # in all copies or substantial portions of the Software. |
| # |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL- |
| # ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT |
| # SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| # IN THE SOFTWARE. |
| # |
| |
| import boto |
| from boto.compat import json |
| from boto.connection import AWSQueryConnection |
| from boto.regioninfo import RegionInfo |
| from boto.exception import JSONResponseError |
| from boto.opsworks import exceptions |
| |
| |
| class OpsWorksConnection(AWSQueryConnection): |
| """ |
| AWS OpsWorks |
| Welcome to the AWS OpsWorks API Reference . This guide provides |
| descriptions, syntax, and usage examples about AWS OpsWorks |
| actions and data types, including common parameters and error |
| codes. |
| |
| AWS OpsWorks is an application management service that provides an |
| integrated experience for overseeing the complete application |
| lifecycle. For information about this product, go to the `AWS |
| OpsWorks`_ details page. |
| |
| **SDKs and CLI** |
| |
| The most common way to use the AWS OpsWorks API is by using the |
| AWS Command Line Interface (CLI) or by using one of the AWS SDKs |
| to implement applications in your preferred language. For more |
| information, see: |
| |
| |
| + `AWS CLI`_ |
| + `AWS SDK for Java`_ |
| + `AWS SDK for .NET`_ |
| + `AWS SDK for PHP 2`_ |
| + `AWS SDK for Ruby`_ |
| + `AWS SDK for Node.js`_ |
| + `AWS SDK for Python(Boto)`_ |
| |
| |
| **Endpoints** |
| |
| AWS OpsWorks supports only one endpoint, opsworks.us- |
| east-1.amazonaws.com (HTTPS), so you must connect to that |
| endpoint. You can then use the API to direct AWS OpsWorks to |
| create stacks in any AWS Region. |
| |
| **Chef Versions** |
| |
| When you call CreateStack, CloneStack, or UpdateStack we recommend |
| you use the `ConfigurationManager` parameter to specify the Chef |
| version, 0.9, 11.4, or 11.10. The default value is currently |
| 11.10. For more information, see `Chef Versions`_. |
| |
| You can still specify Chef 0.9 for your stack, but new features |
| are not available for Chef 0.9 stacks, and support is scheduled to |
| end on July 24, 2014. We do not recommend using Chef 0.9 for new |
| stacks, and we recommend migrating your existing Chef 0.9 stacks |
| to Chef 11.10 as soon as possible. |
| """ |
| APIVersion = "2013-02-18" |
| DefaultRegionName = "us-east-1" |
| DefaultRegionEndpoint = "opsworks.us-east-1.amazonaws.com" |
| ServiceName = "OpsWorks" |
| TargetPrefix = "OpsWorks_20130218" |
| ResponseError = JSONResponseError |
| |
| _faults = { |
| "ResourceNotFoundException": exceptions.ResourceNotFoundException, |
| "ValidationException": exceptions.ValidationException, |
| } |
| |
| |
| def __init__(self, **kwargs): |
| region = kwargs.pop('region', None) |
| if not region: |
| region = RegionInfo(self, self.DefaultRegionName, |
| self.DefaultRegionEndpoint) |
| |
| if 'host' not in kwargs or kwargs['host'] is None: |
| kwargs['host'] = region.endpoint |
| |
| super(OpsWorksConnection, self).__init__(**kwargs) |
| self.region = region |
| |
| def _required_auth_capability(self): |
| return ['hmac-v4'] |
| |
| def assign_instance(self, instance_id, layer_ids): |
| """ |
| Assign a registered instance to a custom layer. You cannot use |
| this action with instances that were created with AWS |
| OpsWorks. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| :type layer_ids: list |
| :param layer_ids: The layer ID, which must correspond to a custom |
| layer. You cannot assign a registered instance to a built-in layer. |
| |
| """ |
| params = { |
| 'InstanceId': instance_id, |
| 'LayerIds': layer_ids, |
| } |
| return self.make_request(action='AssignInstance', |
| body=json.dumps(params)) |
| |
| def assign_volume(self, volume_id, instance_id=None): |
| """ |
| Assigns one of the stack's registered Amazon EBS volumes to a |
| specified instance. The volume must first be registered with |
| the stack by calling RegisterVolume. For more information, see |
| `Resource Management`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type volume_id: string |
| :param volume_id: The volume ID. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| """ |
| params = {'VolumeId': volume_id, } |
| if instance_id is not None: |
| params['InstanceId'] = instance_id |
| return self.make_request(action='AssignVolume', |
| body=json.dumps(params)) |
| |
| def associate_elastic_ip(self, elastic_ip, instance_id=None): |
| """ |
| Associates one of the stack's registered Elastic IP addresses |
| with a specified instance. The address must first be |
| registered with the stack by calling RegisterElasticIp. For |
| more information, see `Resource Management`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type elastic_ip: string |
| :param elastic_ip: The Elastic IP address. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| """ |
| params = {'ElasticIp': elastic_ip, } |
| if instance_id is not None: |
| params['InstanceId'] = instance_id |
| return self.make_request(action='AssociateElasticIp', |
| body=json.dumps(params)) |
| |
| def attach_elastic_load_balancer(self, elastic_load_balancer_name, |
| layer_id): |
| """ |
| Attaches an Elastic Load Balancing load balancer to a |
| specified layer. For more information, see `Elastic Load |
| Balancing`_. |
| |
| |
| You must create the Elastic Load Balancing instance |
| separately, by using the Elastic Load Balancing console, API, |
| or CLI. For more information, see ` Elastic Load Balancing |
| Developer Guide`_. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type elastic_load_balancer_name: string |
| :param elastic_load_balancer_name: The Elastic Load Balancing |
| instance's name. |
| |
| :type layer_id: string |
| :param layer_id: The ID of the layer that the Elastic Load Balancing |
| instance is to be attached to. |
| |
| """ |
| params = { |
| 'ElasticLoadBalancerName': elastic_load_balancer_name, |
| 'LayerId': layer_id, |
| } |
| return self.make_request(action='AttachElasticLoadBalancer', |
| body=json.dumps(params)) |
| |
| def clone_stack(self, source_stack_id, service_role_arn, name=None, |
| region=None, vpc_id=None, attributes=None, |
| default_instance_profile_arn=None, default_os=None, |
| hostname_theme=None, default_availability_zone=None, |
| default_subnet_id=None, custom_json=None, |
| configuration_manager=None, chef_configuration=None, |
| use_custom_cookbooks=None, |
| use_opsworks_security_groups=None, |
| custom_cookbooks_source=None, default_ssh_key_name=None, |
| clone_permissions=None, clone_app_ids=None, |
| default_root_device_type=None): |
| """ |
| Creates a clone of a specified stack. For more information, |
| see `Clone a Stack`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have an attached policy that explicitly grants permissions. |
| For more information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type source_stack_id: string |
| :param source_stack_id: The source stack ID. |
| |
| :type name: string |
| :param name: The cloned stack name. |
| |
| :type region: string |
| :param region: The cloned stack AWS region, such as "us-east-1". For |
| more information about AWS regions, see `Regions and Endpoints`_. |
| |
| :type vpc_id: string |
| :param vpc_id: The ID of the VPC that the cloned stack is to be |
| launched into. It must be in the specified region. All instances |
| are launched into this VPC, and you cannot change the ID later. |
| |
| + If your account supports EC2 Classic, the default value is no VPC. |
| + If your account does not support EC2 Classic, the default value is |
| the default VPC for the specified region. |
| |
| |
| If the VPC ID corresponds to a default VPC and you have specified |
| either the `DefaultAvailabilityZone` or the `DefaultSubnetId` |
| parameter only, AWS OpsWorks infers the value of the other |
| parameter. If you specify neither parameter, AWS OpsWorks sets |
| these parameters to the first valid Availability Zone for the |
| specified region and the corresponding default VPC subnet ID, |
| respectively. |
| |
| If you specify a nondefault VPC ID, note the following: |
| |
| |
| + It must belong to a VPC in your account that is in the specified |
| region. |
| + You must specify a value for `DefaultSubnetId`. |
| |
| |
| For more information on how to use AWS OpsWorks with a VPC, see |
| `Running a Stack in a VPC`_. For more information on default VPC |
| and EC2 Classic, see `Supported Platforms`_. |
| |
| :type attributes: map |
| :param attributes: A list of stack attributes and values as key/value |
| pairs to be added to the cloned stack. |
| |
| :type service_role_arn: string |
| :param service_role_arn: |
| The stack AWS Identity and Access Management (IAM) role, which allows |
| AWS OpsWorks to work with AWS resources on your behalf. You must |
| set this parameter to the Amazon Resource Name (ARN) for an |
| existing IAM role. If you create a stack by using the AWS OpsWorks |
| console, it creates the role for you. You can obtain an existing |
| stack's IAM ARN programmatically by calling DescribePermissions. |
| For more information about IAM ARNs, see `Using Identifiers`_. |
| |
| |
| You must set this parameter to a valid service role ARN or the action |
| will fail; there is no default value. You can specify the source |
| stack's service role ARN, if you prefer, but you must do so |
| explicitly. |
| |
| :type default_instance_profile_arn: string |
| :param default_instance_profile_arn: The ARN of an IAM profile that is |
| the default profile for all of the stack's EC2 instances. For more |
| information about IAM ARNs, see `Using Identifiers`_. |
| |
| :type default_os: string |
| :param default_os: The stacks's operating system, which must be set to |
| one of the following. |
| |
| + Standard operating systems: an Amazon Linux version such as `Amazon |
| Linux 2014.09`, `Ubuntu 12.04 LTS`, or `Ubuntu 14.04 LTS`. |
| + Custom AMIs: `Custom`. You specify the custom AMI you want to use |
| when you create instances. |
| |
| |
| The default option is the current Amazon Linux version. |
| |
| :type hostname_theme: string |
| :param hostname_theme: The stack's host name theme, with spaces are |
| replaced by underscores. The theme is used to generate host names |
| for the stack's instances. By default, `HostnameTheme` is set to |
| `Layer_Dependent`, which creates host names by appending integers |
| to the layer's short name. The other themes are: |
| |
| + `Baked_Goods` |
| + `Clouds` |
| + `European_Cities` |
| + `Fruits` |
| + `Greek_Deities` |
| + `Legendary_Creatures_from_Japan` |
| + `Planets_and_Moons` |
| + `Roman_Deities` |
| + `Scottish_Islands` |
| + `US_Cities` |
| + `Wild_Cats` |
| |
| |
| To obtain a generated host name, call `GetHostNameSuggestion`, which |
| returns a host name based on the current theme. |
| |
| :type default_availability_zone: string |
| :param default_availability_zone: The cloned stack's default |
| Availability Zone, which must be in the specified region. For more |
| information, see `Regions and Endpoints`_. If you also specify a |
| value for `DefaultSubnetId`, the subnet must be in the same zone. |
| For more information, see the `VpcId` parameter description. |
| |
| :type default_subnet_id: string |
| :param default_subnet_id: The stack's default VPC subnet ID. This |
| parameter is required if you specify a value for the `VpcId` |
| parameter. All instances are launched into this subnet unless you |
| specify otherwise when you create the instance. If you also specify |
| a value for `DefaultAvailabilityZone`, the subnet must be in that |
| zone. For information on default values and when this parameter is |
| required, see the `VpcId` parameter description. |
| |
| :type custom_json: string |
| :param custom_json: A string that contains user-defined, custom JSON. |
| It is used to override the corresponding default stack |
| configuration JSON values. The string should be in the following |
| format and must escape characters such as '"'.: |
| `"{\"key1\": \"value1\", \"key2\": \"value2\",...}"` |
| |
| For more information on custom JSON, see `Use Custom JSON to Modify the |
| Stack Configuration JSON`_ |
| |
| :type configuration_manager: dict |
| :param configuration_manager: The configuration manager. When you clone |
| a stack we recommend that you use the configuration manager to |
| specify the Chef version, 0.9, 11.4, or 11.10. The default value is |
| currently 11.4. |
| |
| :type chef_configuration: dict |
| :param chef_configuration: A `ChefConfiguration` object that specifies |
| whether to enable Berkshelf and the Berkshelf version on Chef 11.10 |
| stacks. For more information, see `Create a New Stack`_. |
| |
| :type use_custom_cookbooks: boolean |
| :param use_custom_cookbooks: Whether to use custom cookbooks. |
| |
| :type use_opsworks_security_groups: boolean |
| :param use_opsworks_security_groups: Whether to associate the AWS |
| OpsWorks built-in security groups with the stack's layers. |
| AWS OpsWorks provides a standard set of built-in security groups, one |
| for each layer, which are associated with layers by default. With |
| `UseOpsworksSecurityGroups` you can instead provide your own custom |
| security groups. `UseOpsworksSecurityGroups` has the following |
| settings: |
| |
| |
| + True - AWS OpsWorks automatically associates the appropriate built-in |
| security group with each layer (default setting). You can associate |
| additional security groups with a layer after you create it but you |
| cannot delete the built-in security group. |
| + False - AWS OpsWorks does not associate built-in security groups with |
| layers. You must create appropriate EC2 security groups and |
| associate a security group with each layer that you create. |
| However, you can still manually associate a built-in security group |
| with a layer on creation; custom security groups are required only |
| for those layers that need custom settings. |
| |
| |
| For more information, see `Create a New Stack`_. |
| |
| :type custom_cookbooks_source: dict |
| :param custom_cookbooks_source: Contains the information required to |
| retrieve an app or cookbook from a repository. For more |
| information, see `Creating Apps`_ or `Custom Recipes and |
| Cookbooks`_. |
| |
| :type default_ssh_key_name: string |
| :param default_ssh_key_name: A default SSH key for the stack instances. |
| You can override this value when you create or update an instance. |
| |
| :type clone_permissions: boolean |
| :param clone_permissions: Whether to clone the source stack's |
| permissions. |
| |
| :type clone_app_ids: list |
| :param clone_app_ids: A list of source stack app IDs to be included in |
| the cloned stack. |
| |
| :type default_root_device_type: string |
| :param default_root_device_type: The default root device type. This |
| value is used by default for all instances in the cloned stack, but |
| you can override it when you create an instance. For more |
| information, see `Storage for the Root Device`_. |
| |
| """ |
| params = { |
| 'SourceStackId': source_stack_id, |
| 'ServiceRoleArn': service_role_arn, |
| } |
| if name is not None: |
| params['Name'] = name |
| if region is not None: |
| params['Region'] = region |
| if vpc_id is not None: |
| params['VpcId'] = vpc_id |
| if attributes is not None: |
| params['Attributes'] = attributes |
| if default_instance_profile_arn is not None: |
| params['DefaultInstanceProfileArn'] = default_instance_profile_arn |
| if default_os is not None: |
| params['DefaultOs'] = default_os |
| if hostname_theme is not None: |
| params['HostnameTheme'] = hostname_theme |
| if default_availability_zone is not None: |
| params['DefaultAvailabilityZone'] = default_availability_zone |
| if default_subnet_id is not None: |
| params['DefaultSubnetId'] = default_subnet_id |
| if custom_json is not None: |
| params['CustomJson'] = custom_json |
| if configuration_manager is not None: |
| params['ConfigurationManager'] = configuration_manager |
| if chef_configuration is not None: |
| params['ChefConfiguration'] = chef_configuration |
| if use_custom_cookbooks is not None: |
| params['UseCustomCookbooks'] = use_custom_cookbooks |
| if use_opsworks_security_groups is not None: |
| params['UseOpsworksSecurityGroups'] = use_opsworks_security_groups |
| if custom_cookbooks_source is not None: |
| params['CustomCookbooksSource'] = custom_cookbooks_source |
| if default_ssh_key_name is not None: |
| params['DefaultSshKeyName'] = default_ssh_key_name |
| if clone_permissions is not None: |
| params['ClonePermissions'] = clone_permissions |
| if clone_app_ids is not None: |
| params['CloneAppIds'] = clone_app_ids |
| if default_root_device_type is not None: |
| params['DefaultRootDeviceType'] = default_root_device_type |
| return self.make_request(action='CloneStack', |
| body=json.dumps(params)) |
| |
| def create_app(self, stack_id, name, type, shortname=None, |
| description=None, data_sources=None, app_source=None, |
| domains=None, enable_ssl=None, ssl_configuration=None, |
| attributes=None, environment=None): |
| """ |
| Creates an app for a specified stack. For more information, |
| see `Creating Apps`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| :type shortname: string |
| :param shortname: The app's short name. |
| |
| :type name: string |
| :param name: The app name. |
| |
| :type description: string |
| :param description: A description of the app. |
| |
| :type data_sources: list |
| :param data_sources: The app's data source. |
| |
| :type type: string |
| :param type: The app type. Each supported type is associated with a |
| particular layer. For example, PHP applications are associated with |
| a PHP layer. AWS OpsWorks deploys an application to those instances |
| that are members of the corresponding layer. |
| |
| :type app_source: dict |
| :param app_source: A `Source` object that specifies the app repository. |
| |
| :type domains: list |
| :param domains: The app virtual host settings, with multiple domains |
| separated by commas. For example: `'www.example.com, example.com'` |
| |
| :type enable_ssl: boolean |
| :param enable_ssl: Whether to enable SSL for the app. |
| |
| :type ssl_configuration: dict |
| :param ssl_configuration: An `SslConfiguration` object with the SSL |
| configuration. |
| |
| :type attributes: map |
| :param attributes: One or more user-defined key/value pairs to be added |
| to the stack attributes. |
| |
| :type environment: list |
| :param environment: |
| An array of `EnvironmentVariable` objects that specify environment |
| variables to be associated with the app. You can specify up to ten |
| environment variables. After you deploy the app, these variables |
| are defined on the associated app server instance. |
| |
| This parameter is supported only by Chef 11.10 stacks. If you have |
| specified one or more environment variables, you cannot modify the |
| stack's Chef version. |
| |
| """ |
| params = {'StackId': stack_id, 'Name': name, 'Type': type, } |
| if shortname is not None: |
| params['Shortname'] = shortname |
| if description is not None: |
| params['Description'] = description |
| if data_sources is not None: |
| params['DataSources'] = data_sources |
| if app_source is not None: |
| params['AppSource'] = app_source |
| if domains is not None: |
| params['Domains'] = domains |
| if enable_ssl is not None: |
| params['EnableSsl'] = enable_ssl |
| if ssl_configuration is not None: |
| params['SslConfiguration'] = ssl_configuration |
| if attributes is not None: |
| params['Attributes'] = attributes |
| if environment is not None: |
| params['Environment'] = environment |
| return self.make_request(action='CreateApp', |
| body=json.dumps(params)) |
| |
| def create_deployment(self, stack_id, command, app_id=None, |
| instance_ids=None, comment=None, custom_json=None): |
| """ |
| Runs deployment or stack commands. For more information, see |
| `Deploying Apps`_ and `Run Stack Commands`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Deploy or Manage permissions level for the stack, or an |
| attached policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| :type app_id: string |
| :param app_id: The app ID. This parameter is required for app |
| deployments, but not for other deployment commands. |
| |
| :type instance_ids: list |
| :param instance_ids: The instance IDs for the deployment targets. |
| |
| :type command: dict |
| :param command: A `DeploymentCommand` object that specifies the |
| deployment command and any associated arguments. |
| |
| :type comment: string |
| :param comment: A user-defined comment. |
| |
| :type custom_json: string |
| :param custom_json: A string that contains user-defined, custom JSON. |
| It is used to override the corresponding default stack |
| configuration JSON values. The string should be in the following |
| format and must escape characters such as '"'.: |
| `"{\"key1\": \"value1\", \"key2\": \"value2\",...}"` |
| |
| For more information on custom JSON, see `Use Custom JSON to Modify the |
| Stack Configuration JSON`_. |
| |
| """ |
| params = {'StackId': stack_id, 'Command': command, } |
| if app_id is not None: |
| params['AppId'] = app_id |
| if instance_ids is not None: |
| params['InstanceIds'] = instance_ids |
| if comment is not None: |
| params['Comment'] = comment |
| if custom_json is not None: |
| params['CustomJson'] = custom_json |
| return self.make_request(action='CreateDeployment', |
| body=json.dumps(params)) |
| |
| def create_instance(self, stack_id, layer_ids, instance_type, |
| auto_scaling_type=None, hostname=None, os=None, |
| ami_id=None, ssh_key_name=None, |
| availability_zone=None, virtualization_type=None, |
| subnet_id=None, architecture=None, |
| root_device_type=None, install_updates_on_boot=None, |
| ebs_optimized=None): |
| """ |
| Creates an instance in a specified stack. For more |
| information, see `Adding an Instance to a Layer`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| :type layer_ids: list |
| :param layer_ids: An array that contains the instance layer IDs. |
| |
| :type instance_type: string |
| :param instance_type: The instance type. AWS OpsWorks supports all |
| instance types except Cluster Compute, Cluster GPU, and High Memory |
| Cluster. For more information, see `Instance Families and Types`_. |
| The parameter values that you use to specify the various types are |
| in the API Name column of the Available Instance Types table. |
| |
| :type auto_scaling_type: string |
| :param auto_scaling_type: For load-based or time-based instances, the |
| type. |
| |
| :type hostname: string |
| :param hostname: The instance host name. |
| |
| :type os: string |
| :param os: The instance's operating system, which must be set to one of |
| the following. |
| |
| + Standard operating systems: an Amazon Linux version such as `Amazon |
| Linux 2014.09`, `Ubuntu 12.04 LTS`, or `Ubuntu 14.04 LTS`. |
| + Custom AMIs: `Custom` |
| |
| |
| The default option is the current Amazon Linux version. If you set this |
| parameter to `Custom`, you must use the CreateInstance action's |
| AmiId parameter to specify the custom AMI that you want to use. For |
| more information on the standard operating systems, see `Operating |
| Systems`_For more information on how to use custom AMIs with |
| OpsWorks, see `Using Custom AMIs`_. |
| |
| :type ami_id: string |
| :param ami_id: |
| A custom AMI ID to be used to create the instance. The AMI should be |
| based on one of the standard AWS OpsWorks AMIs: Amazon Linux, |
| Ubuntu 12.04 LTS, or Ubuntu 14.04 LTS. For more information, see |
| `Instances`_. |
| |
| If you specify a custom AMI, you must set `Os` to `Custom`. |
| |
| :type ssh_key_name: string |
| :param ssh_key_name: The instance SSH key name. |
| |
| :type availability_zone: string |
| :param availability_zone: The instance Availability Zone. For more |
| information, see `Regions and Endpoints`_. |
| |
| :type virtualization_type: string |
| :param virtualization_type: The instance's virtualization type, |
| `paravirtual` or `hvm`. |
| |
| :type subnet_id: string |
| :param subnet_id: The ID of the instance's subnet. If the stack is |
| running in a VPC, you can use this parameter to override the |
| stack's default subnet ID value and direct AWS OpsWorks to launch |
| the instance in a different subnet. |
| |
| :type architecture: string |
| :param architecture: The instance architecture. The default option is |
| `x86_64`. Instance types do not necessarily support both |
| architectures. For a list of the architectures that are supported |
| by the different instance types, see `Instance Families and |
| Types`_. |
| |
| :type root_device_type: string |
| :param root_device_type: The instance root device type. For more |
| information, see `Storage for the Root Device`_. |
| |
| :type install_updates_on_boot: boolean |
| :param install_updates_on_boot: |
| Whether to install operating system and package updates when the |
| instance boots. The default value is `True`. To control when |
| updates are installed, set this value to `False`. You must then |
| update your instances manually by using CreateDeployment to run the |
| `update_dependencies` stack command or manually running `yum` |
| (Amazon Linux) or `apt-get` (Ubuntu) on the instances. |
| |
| |
| We strongly recommend using the default value of `True` to ensure that |
| your instances have the latest security updates. |
| |
| :type ebs_optimized: boolean |
| :param ebs_optimized: Whether to create an Amazon EBS-optimized |
| instance. |
| |
| """ |
| params = { |
| 'StackId': stack_id, |
| 'LayerIds': layer_ids, |
| 'InstanceType': instance_type, |
| } |
| if auto_scaling_type is not None: |
| params['AutoScalingType'] = auto_scaling_type |
| if hostname is not None: |
| params['Hostname'] = hostname |
| if os is not None: |
| params['Os'] = os |
| if ami_id is not None: |
| params['AmiId'] = ami_id |
| if ssh_key_name is not None: |
| params['SshKeyName'] = ssh_key_name |
| if availability_zone is not None: |
| params['AvailabilityZone'] = availability_zone |
| if virtualization_type is not None: |
| params['VirtualizationType'] = virtualization_type |
| if subnet_id is not None: |
| params['SubnetId'] = subnet_id |
| if architecture is not None: |
| params['Architecture'] = architecture |
| if root_device_type is not None: |
| params['RootDeviceType'] = root_device_type |
| if install_updates_on_boot is not None: |
| params['InstallUpdatesOnBoot'] = install_updates_on_boot |
| if ebs_optimized is not None: |
| params['EbsOptimized'] = ebs_optimized |
| return self.make_request(action='CreateInstance', |
| body=json.dumps(params)) |
| |
| def create_layer(self, stack_id, type, name, shortname, attributes=None, |
| custom_instance_profile_arn=None, |
| custom_security_group_ids=None, packages=None, |
| volume_configurations=None, enable_auto_healing=None, |
| auto_assign_elastic_ips=None, |
| auto_assign_public_ips=None, custom_recipes=None, |
| install_updates_on_boot=None, |
| use_ebs_optimized_instances=None, |
| lifecycle_event_configuration=None): |
| """ |
| Creates a layer. For more information, see `How to Create a |
| Layer`_. |
| |
| |
| You should use **CreateLayer** for noncustom layer types such |
| as PHP App Server only if the stack does not have an existing |
| layer of that type. A stack can have at most one instance of |
| each noncustom layer; if you attempt to create a second |
| instance, **CreateLayer** fails. A stack can have an arbitrary |
| number of custom layers, so you can call **CreateLayer** as |
| many times as you like for that layer type. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The layer stack ID. |
| |
| :type type: string |
| :param type: The layer type. A stack cannot have more than one built-in |
| layer of the same type. It can have any number of custom layers. |
| |
| :type name: string |
| :param name: The layer name, which is used by the console. |
| |
| :type shortname: string |
| :param shortname: The layer short name, which is used internally by AWS |
| OpsWorks and by Chef recipes. The short name is also used as the |
| name for the directory where your app files are installed. It can |
| have a maximum of 200 characters, which are limited to the |
| alphanumeric characters, '-', '_', and '.'. |
| |
| :type attributes: map |
| :param attributes: One or more user-defined key/value pairs to be added |
| to the stack attributes. |
| |
| :type custom_instance_profile_arn: string |
| :param custom_instance_profile_arn: The ARN of an IAM profile that to |
| be used for the layer's EC2 instances. For more information about |
| IAM ARNs, see `Using Identifiers`_. |
| |
| :type custom_security_group_ids: list |
| :param custom_security_group_ids: An array containing the layer custom |
| security group IDs. |
| |
| :type packages: list |
| :param packages: An array of `Package` objects that describe the layer |
| packages. |
| |
| :type volume_configurations: list |
| :param volume_configurations: A `VolumeConfigurations` object that |
| describes the layer's Amazon EBS volumes. |
| |
| :type enable_auto_healing: boolean |
| :param enable_auto_healing: Whether to disable auto healing for the |
| layer. |
| |
| :type auto_assign_elastic_ips: boolean |
| :param auto_assign_elastic_ips: Whether to automatically assign an |
| `Elastic IP address`_ to the layer's instances. For more |
| information, see `How to Edit a Layer`_. |
| |
| :type auto_assign_public_ips: boolean |
| :param auto_assign_public_ips: For stacks that are running in a VPC, |
| whether to automatically assign a public IP address to the layer's |
| instances. For more information, see `How to Edit a Layer`_. |
| |
| :type custom_recipes: dict |
| :param custom_recipes: A `LayerCustomRecipes` object that specifies the |
| layer custom recipes. |
| |
| :type install_updates_on_boot: boolean |
| :param install_updates_on_boot: |
| Whether to install operating system and package updates when the |
| instance boots. The default value is `True`. To control when |
| updates are installed, set this value to `False`. You must then |
| update your instances manually by using CreateDeployment to run the |
| `update_dependencies` stack command or manually running `yum` |
| (Amazon Linux) or `apt-get` (Ubuntu) on the instances. |
| |
| |
| We strongly recommend using the default value of `True`, to ensure that |
| your instances have the latest security updates. |
| |
| :type use_ebs_optimized_instances: boolean |
| :param use_ebs_optimized_instances: Whether to use Amazon EBS-optimized |
| instances. |
| |
| :type lifecycle_event_configuration: dict |
| :param lifecycle_event_configuration: A LifeCycleEventConfiguration |
| object that you can use to configure the Shutdown event to specify |
| an execution timeout and enable or disable Elastic Load Balancer |
| connection draining. |
| |
| """ |
| params = { |
| 'StackId': stack_id, |
| 'Type': type, |
| 'Name': name, |
| 'Shortname': shortname, |
| } |
| if attributes is not None: |
| params['Attributes'] = attributes |
| if custom_instance_profile_arn is not None: |
| params['CustomInstanceProfileArn'] = custom_instance_profile_arn |
| if custom_security_group_ids is not None: |
| params['CustomSecurityGroupIds'] = custom_security_group_ids |
| if packages is not None: |
| params['Packages'] = packages |
| if volume_configurations is not None: |
| params['VolumeConfigurations'] = volume_configurations |
| if enable_auto_healing is not None: |
| params['EnableAutoHealing'] = enable_auto_healing |
| if auto_assign_elastic_ips is not None: |
| params['AutoAssignElasticIps'] = auto_assign_elastic_ips |
| if auto_assign_public_ips is not None: |
| params['AutoAssignPublicIps'] = auto_assign_public_ips |
| if custom_recipes is not None: |
| params['CustomRecipes'] = custom_recipes |
| if install_updates_on_boot is not None: |
| params['InstallUpdatesOnBoot'] = install_updates_on_boot |
| if use_ebs_optimized_instances is not None: |
| params['UseEbsOptimizedInstances'] = use_ebs_optimized_instances |
| if lifecycle_event_configuration is not None: |
| params['LifecycleEventConfiguration'] = lifecycle_event_configuration |
| return self.make_request(action='CreateLayer', |
| body=json.dumps(params)) |
| |
| def create_stack(self, name, region, service_role_arn, |
| default_instance_profile_arn, vpc_id=None, |
| attributes=None, default_os=None, hostname_theme=None, |
| default_availability_zone=None, default_subnet_id=None, |
| custom_json=None, configuration_manager=None, |
| chef_configuration=None, use_custom_cookbooks=None, |
| use_opsworks_security_groups=None, |
| custom_cookbooks_source=None, default_ssh_key_name=None, |
| default_root_device_type=None): |
| """ |
| Creates a new stack. For more information, see `Create a New |
| Stack`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have an attached policy that explicitly grants permissions. |
| For more information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type name: string |
| :param name: The stack name. |
| |
| :type region: string |
| :param region: The stack AWS region, such as "us-east-1". For more |
| information about Amazon regions, see `Regions and Endpoints`_. |
| |
| :type vpc_id: string |
| :param vpc_id: The ID of the VPC that the stack is to be launched into. |
| It must be in the specified region. All instances are launched into |
| this VPC, and you cannot change the ID later. |
| |
| + If your account supports EC2 Classic, the default value is no VPC. |
| + If your account does not support EC2 Classic, the default value is |
| the default VPC for the specified region. |
| |
| |
| If the VPC ID corresponds to a default VPC and you have specified |
| either the `DefaultAvailabilityZone` or the `DefaultSubnetId` |
| parameter only, AWS OpsWorks infers the value of the other |
| parameter. If you specify neither parameter, AWS OpsWorks sets |
| these parameters to the first valid Availability Zone for the |
| specified region and the corresponding default VPC subnet ID, |
| respectively. |
| |
| If you specify a nondefault VPC ID, note the following: |
| |
| |
| + It must belong to a VPC in your account that is in the specified |
| region. |
| + You must specify a value for `DefaultSubnetId`. |
| |
| |
| For more information on how to use AWS OpsWorks with a VPC, see |
| `Running a Stack in a VPC`_. For more information on default VPC |
| and EC2 Classic, see `Supported Platforms`_. |
| |
| :type attributes: map |
| :param attributes: One or more user-defined key/value pairs to be added |
| to the stack attributes. |
| |
| :type service_role_arn: string |
| :param service_role_arn: The stack AWS Identity and Access Management |
| (IAM) role, which allows AWS OpsWorks to work with AWS resources on |
| your behalf. You must set this parameter to the Amazon Resource |
| Name (ARN) for an existing IAM role. For more information about IAM |
| ARNs, see `Using Identifiers`_. |
| |
| :type default_instance_profile_arn: string |
| :param default_instance_profile_arn: The ARN of an IAM profile that is |
| the default profile for all of the stack's EC2 instances. For more |
| information about IAM ARNs, see `Using Identifiers`_. |
| |
| :type default_os: string |
| :param default_os: The stack's operating system, which must be set to |
| one of the following. |
| |
| + Standard operating systems: an Amazon Linux version such as `Amazon |
| Linux 2014.09`, `Ubuntu 12.04 LTS`, or `Ubuntu 14.04 LTS`. |
| + Custom AMIs: `Custom`. You specify the custom AMI you want to use |
| when you create instances. |
| |
| |
| The default option is the current Amazon Linux version. |
| |
| :type hostname_theme: string |
| :param hostname_theme: The stack's host name theme, with spaces are |
| replaced by underscores. The theme is used to generate host names |
| for the stack's instances. By default, `HostnameTheme` is set to |
| `Layer_Dependent`, which creates host names by appending integers |
| to the layer's short name. The other themes are: |
| |
| + `Baked_Goods` |
| + `Clouds` |
| + `European_Cities` |
| + `Fruits` |
| + `Greek_Deities` |
| + `Legendary_Creatures_from_Japan` |
| + `Planets_and_Moons` |
| + `Roman_Deities` |
| + `Scottish_Islands` |
| + `US_Cities` |
| + `Wild_Cats` |
| |
| |
| To obtain a generated host name, call `GetHostNameSuggestion`, which |
| returns a host name based on the current theme. |
| |
| :type default_availability_zone: string |
| :param default_availability_zone: The stack's default Availability |
| Zone, which must be in the specified region. For more information, |
| see `Regions and Endpoints`_. If you also specify a value for |
| `DefaultSubnetId`, the subnet must be in the same zone. For more |
| information, see the `VpcId` parameter description. |
| |
| :type default_subnet_id: string |
| :param default_subnet_id: The stack's default VPC subnet ID. This |
| parameter is required if you specify a value for the `VpcId` |
| parameter. All instances are launched into this subnet unless you |
| specify otherwise when you create the instance. If you also specify |
| a value for `DefaultAvailabilityZone`, the subnet must be in that |
| zone. For information on default values and when this parameter is |
| required, see the `VpcId` parameter description. |
| |
| :type custom_json: string |
| :param custom_json: A string that contains user-defined, custom JSON. |
| It is used to override the corresponding default stack |
| configuration JSON values. The string should be in the following |
| format and must escape characters such as '"'.: |
| `"{\"key1\": \"value1\", \"key2\": \"value2\",...}"` |
| |
| For more information on custom JSON, see `Use Custom JSON to Modify the |
| Stack Configuration JSON`_. |
| |
| :type configuration_manager: dict |
| :param configuration_manager: The configuration manager. When you clone |
| a stack we recommend that you use the configuration manager to |
| specify the Chef version, 0.9, 11.4, or 11.10. The default value is |
| currently 11.4. |
| |
| :type chef_configuration: dict |
| :param chef_configuration: A `ChefConfiguration` object that specifies |
| whether to enable Berkshelf and the Berkshelf version on Chef 11.10 |
| stacks. For more information, see `Create a New Stack`_. |
| |
| :type use_custom_cookbooks: boolean |
| :param use_custom_cookbooks: Whether the stack uses custom cookbooks. |
| |
| :type use_opsworks_security_groups: boolean |
| :param use_opsworks_security_groups: Whether to associate the AWS |
| OpsWorks built-in security groups with the stack's layers. |
| AWS OpsWorks provides a standard set of built-in security groups, one |
| for each layer, which are associated with layers by default. With |
| `UseOpsworksSecurityGroups` you can instead provide your own custom |
| security groups. `UseOpsworksSecurityGroups` has the following |
| settings: |
| |
| |
| + True - AWS OpsWorks automatically associates the appropriate built-in |
| security group with each layer (default setting). You can associate |
| additional security groups with a layer after you create it but you |
| cannot delete the built-in security group. |
| + False - AWS OpsWorks does not associate built-in security groups with |
| layers. You must create appropriate EC2 security groups and |
| associate a security group with each layer that you create. |
| However, you can still manually associate a built-in security group |
| with a layer on creation; custom security groups are required only |
| for those layers that need custom settings. |
| |
| |
| For more information, see `Create a New Stack`_. |
| |
| :type custom_cookbooks_source: dict |
| :param custom_cookbooks_source: Contains the information required to |
| retrieve an app or cookbook from a repository. For more |
| information, see `Creating Apps`_ or `Custom Recipes and |
| Cookbooks`_. |
| |
| :type default_ssh_key_name: string |
| :param default_ssh_key_name: A default SSH key for the stack instances. |
| You can override this value when you create or update an instance. |
| |
| :type default_root_device_type: string |
| :param default_root_device_type: The default root device type. This |
| value is used by default for all instances in the stack, but you |
| can override it when you create an instance. The default option is |
| `instance-store`. For more information, see `Storage for the Root |
| Device`_. |
| |
| """ |
| params = { |
| 'Name': name, |
| 'Region': region, |
| 'ServiceRoleArn': service_role_arn, |
| 'DefaultInstanceProfileArn': default_instance_profile_arn, |
| } |
| if vpc_id is not None: |
| params['VpcId'] = vpc_id |
| if attributes is not None: |
| params['Attributes'] = attributes |
| if default_os is not None: |
| params['DefaultOs'] = default_os |
| if hostname_theme is not None: |
| params['HostnameTheme'] = hostname_theme |
| if default_availability_zone is not None: |
| params['DefaultAvailabilityZone'] = default_availability_zone |
| if default_subnet_id is not None: |
| params['DefaultSubnetId'] = default_subnet_id |
| if custom_json is not None: |
| params['CustomJson'] = custom_json |
| if configuration_manager is not None: |
| params['ConfigurationManager'] = configuration_manager |
| if chef_configuration is not None: |
| params['ChefConfiguration'] = chef_configuration |
| if use_custom_cookbooks is not None: |
| params['UseCustomCookbooks'] = use_custom_cookbooks |
| if use_opsworks_security_groups is not None: |
| params['UseOpsworksSecurityGroups'] = use_opsworks_security_groups |
| if custom_cookbooks_source is not None: |
| params['CustomCookbooksSource'] = custom_cookbooks_source |
| if default_ssh_key_name is not None: |
| params['DefaultSshKeyName'] = default_ssh_key_name |
| if default_root_device_type is not None: |
| params['DefaultRootDeviceType'] = default_root_device_type |
| return self.make_request(action='CreateStack', |
| body=json.dumps(params)) |
| |
| def create_user_profile(self, iam_user_arn, ssh_username=None, |
| ssh_public_key=None, allow_self_management=None): |
| """ |
| Creates a new user profile. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have an attached policy that explicitly grants permissions. |
| For more information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type iam_user_arn: string |
| :param iam_user_arn: The user's IAM ARN. |
| |
| :type ssh_username: string |
| :param ssh_username: The user's SSH user name. The allowable characters |
| are [a-z], [A-Z], [0-9], '-', and '_'. If the specified name |
| includes other punctuation marks, AWS OpsWorks removes them. For |
| example, `my.name` will be changed to `myname`. If you do not |
| specify an SSH user name, AWS OpsWorks generates one from the IAM |
| user name. |
| |
| :type ssh_public_key: string |
| :param ssh_public_key: The user's public SSH key. |
| |
| :type allow_self_management: boolean |
| :param allow_self_management: Whether users can specify their own SSH |
| public key through the My Settings page. For more information, see |
| `Setting an IAM User's Public SSH Key`_. |
| |
| """ |
| params = {'IamUserArn': iam_user_arn, } |
| if ssh_username is not None: |
| params['SshUsername'] = ssh_username |
| if ssh_public_key is not None: |
| params['SshPublicKey'] = ssh_public_key |
| if allow_self_management is not None: |
| params['AllowSelfManagement'] = allow_self_management |
| return self.make_request(action='CreateUserProfile', |
| body=json.dumps(params)) |
| |
| def delete_app(self, app_id): |
| """ |
| Deletes a specified app. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type app_id: string |
| :param app_id: The app ID. |
| |
| """ |
| params = {'AppId': app_id, } |
| return self.make_request(action='DeleteApp', |
| body=json.dumps(params)) |
| |
| def delete_instance(self, instance_id, delete_elastic_ip=None, |
| delete_volumes=None): |
| """ |
| Deletes a specified instance, which terminates the associated |
| Amazon EC2 instance. You must stop an instance before you can |
| delete it. |
| |
| For more information, see `Deleting Instances`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| :type delete_elastic_ip: boolean |
| :param delete_elastic_ip: Whether to delete the instance Elastic IP |
| address. |
| |
| :type delete_volumes: boolean |
| :param delete_volumes: Whether to delete the instance's Amazon EBS |
| volumes. |
| |
| """ |
| params = {'InstanceId': instance_id, } |
| if delete_elastic_ip is not None: |
| params['DeleteElasticIp'] = delete_elastic_ip |
| if delete_volumes is not None: |
| params['DeleteVolumes'] = delete_volumes |
| return self.make_request(action='DeleteInstance', |
| body=json.dumps(params)) |
| |
| def delete_layer(self, layer_id): |
| """ |
| Deletes a specified layer. You must first stop and then delete |
| all associated instances or unassign registered instances. For |
| more information, see `How to Delete a Layer`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type layer_id: string |
| :param layer_id: The layer ID. |
| |
| """ |
| params = {'LayerId': layer_id, } |
| return self.make_request(action='DeleteLayer', |
| body=json.dumps(params)) |
| |
| def delete_stack(self, stack_id): |
| """ |
| Deletes a specified stack. You must first delete all |
| instances, layers, and apps or deregister registered |
| instances. For more information, see `Shut Down a Stack`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| """ |
| params = {'StackId': stack_id, } |
| return self.make_request(action='DeleteStack', |
| body=json.dumps(params)) |
| |
| def delete_user_profile(self, iam_user_arn): |
| """ |
| Deletes a user profile. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have an attached policy that explicitly grants permissions. |
| For more information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type iam_user_arn: string |
| :param iam_user_arn: The user's IAM ARN. |
| |
| """ |
| params = {'IamUserArn': iam_user_arn, } |
| return self.make_request(action='DeleteUserProfile', |
| body=json.dumps(params)) |
| |
| def deregister_elastic_ip(self, elastic_ip): |
| """ |
| Deregisters a specified Elastic IP address. The address can |
| then be registered by another stack. For more information, see |
| `Resource Management`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type elastic_ip: string |
| :param elastic_ip: The Elastic IP address. |
| |
| """ |
| params = {'ElasticIp': elastic_ip, } |
| return self.make_request(action='DeregisterElasticIp', |
| body=json.dumps(params)) |
| |
| def deregister_instance(self, instance_id): |
| """ |
| Deregister a registered Amazon EC2 or on-premises instance. |
| This action removes the instance from the stack and returns it |
| to your control. This action can not be used with instances |
| that were created with AWS OpsWorks. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| """ |
| params = {'InstanceId': instance_id, } |
| return self.make_request(action='DeregisterInstance', |
| body=json.dumps(params)) |
| |
| def deregister_rds_db_instance(self, rds_db_instance_arn): |
| """ |
| Deregisters an Amazon RDS instance. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type rds_db_instance_arn: string |
| :param rds_db_instance_arn: The Amazon RDS instance's ARN. |
| |
| """ |
| params = {'RdsDbInstanceArn': rds_db_instance_arn, } |
| return self.make_request(action='DeregisterRdsDbInstance', |
| body=json.dumps(params)) |
| |
| def deregister_volume(self, volume_id): |
| """ |
| Deregisters an Amazon EBS volume. The volume can then be |
| registered by another stack. For more information, see |
| `Resource Management`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type volume_id: string |
| :param volume_id: The volume ID. |
| |
| """ |
| params = {'VolumeId': volume_id, } |
| return self.make_request(action='DeregisterVolume', |
| body=json.dumps(params)) |
| |
| def describe_apps(self, stack_id=None, app_ids=None): |
| """ |
| Requests a description of a specified set of apps. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The app stack ID. If you use this parameter, |
| `DescribeApps` returns a description of the apps in the specified |
| stack. |
| |
| :type app_ids: list |
| :param app_ids: An array of app IDs for the apps to be described. If |
| you use this parameter, `DescribeApps` returns a description of the |
| specified apps. Otherwise, it returns a description of every app. |
| |
| """ |
| params = {} |
| if stack_id is not None: |
| params['StackId'] = stack_id |
| if app_ids is not None: |
| params['AppIds'] = app_ids |
| return self.make_request(action='DescribeApps', |
| body=json.dumps(params)) |
| |
| def describe_commands(self, deployment_id=None, instance_id=None, |
| command_ids=None): |
| """ |
| Describes the results of specified commands. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type deployment_id: string |
| :param deployment_id: The deployment ID. If you include this parameter, |
| `DescribeCommands` returns a description of the commands associated |
| with the specified deployment. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. If you include this parameter, |
| `DescribeCommands` returns a description of the commands associated |
| with the specified instance. |
| |
| :type command_ids: list |
| :param command_ids: An array of command IDs. If you include this |
| parameter, `DescribeCommands` returns a description of the |
| specified commands. Otherwise, it returns a description of every |
| command. |
| |
| """ |
| params = {} |
| if deployment_id is not None: |
| params['DeploymentId'] = deployment_id |
| if instance_id is not None: |
| params['InstanceId'] = instance_id |
| if command_ids is not None: |
| params['CommandIds'] = command_ids |
| return self.make_request(action='DescribeCommands', |
| body=json.dumps(params)) |
| |
| def describe_deployments(self, stack_id=None, app_id=None, |
| deployment_ids=None): |
| """ |
| Requests a description of a specified set of deployments. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. If you include this parameter, |
| `DescribeDeployments` returns a description of the commands |
| associated with the specified stack. |
| |
| :type app_id: string |
| :param app_id: The app ID. If you include this parameter, |
| `DescribeDeployments` returns a description of the commands |
| associated with the specified app. |
| |
| :type deployment_ids: list |
| :param deployment_ids: An array of deployment IDs to be described. If |
| you include this parameter, `DescribeDeployments` returns a |
| description of the specified deployments. Otherwise, it returns a |
| description of every deployment. |
| |
| """ |
| params = {} |
| if stack_id is not None: |
| params['StackId'] = stack_id |
| if app_id is not None: |
| params['AppId'] = app_id |
| if deployment_ids is not None: |
| params['DeploymentIds'] = deployment_ids |
| return self.make_request(action='DescribeDeployments', |
| body=json.dumps(params)) |
| |
| def describe_elastic_ips(self, instance_id=None, stack_id=None, ips=None): |
| """ |
| Describes `Elastic IP addresses`_. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. If you include this parameter, |
| `DescribeElasticIps` returns a description of the Elastic IP |
| addresses associated with the specified instance. |
| |
| :type stack_id: string |
| :param stack_id: A stack ID. If you include this parameter, |
| `DescribeElasticIps` returns a description of the Elastic IP |
| addresses that are registered with the specified stack. |
| |
| :type ips: list |
| :param ips: An array of Elastic IP addresses to be described. If you |
| include this parameter, `DescribeElasticIps` returns a description |
| of the specified Elastic IP addresses. Otherwise, it returns a |
| description of every Elastic IP address. |
| |
| """ |
| params = {} |
| if instance_id is not None: |
| params['InstanceId'] = instance_id |
| if stack_id is not None: |
| params['StackId'] = stack_id |
| if ips is not None: |
| params['Ips'] = ips |
| return self.make_request(action='DescribeElasticIps', |
| body=json.dumps(params)) |
| |
| def describe_elastic_load_balancers(self, stack_id=None, layer_ids=None): |
| """ |
| Describes a stack's Elastic Load Balancing instances. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: A stack ID. The action describes the stack's Elastic |
| Load Balancing instances. |
| |
| :type layer_ids: list |
| :param layer_ids: A list of layer IDs. The action describes the Elastic |
| Load Balancing instances for the specified layers. |
| |
| """ |
| params = {} |
| if stack_id is not None: |
| params['StackId'] = stack_id |
| if layer_ids is not None: |
| params['LayerIds'] = layer_ids |
| return self.make_request(action='DescribeElasticLoadBalancers', |
| body=json.dumps(params)) |
| |
| def describe_instances(self, stack_id=None, layer_id=None, |
| instance_ids=None): |
| """ |
| Requests a description of a set of instances. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: A stack ID. If you use this parameter, |
| `DescribeInstances` returns descriptions of the instances |
| associated with the specified stack. |
| |
| :type layer_id: string |
| :param layer_id: A layer ID. If you use this parameter, |
| `DescribeInstances` returns descriptions of the instances |
| associated with the specified layer. |
| |
| :type instance_ids: list |
| :param instance_ids: An array of instance IDs to be described. If you |
| use this parameter, `DescribeInstances` returns a description of |
| the specified instances. Otherwise, it returns a description of |
| every instance. |
| |
| """ |
| params = {} |
| if stack_id is not None: |
| params['StackId'] = stack_id |
| if layer_id is not None: |
| params['LayerId'] = layer_id |
| if instance_ids is not None: |
| params['InstanceIds'] = instance_ids |
| return self.make_request(action='DescribeInstances', |
| body=json.dumps(params)) |
| |
| def describe_layers(self, stack_id=None, layer_ids=None): |
| """ |
| Requests a description of one or more layers in a specified |
| stack. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| :type layer_ids: list |
| :param layer_ids: An array of layer IDs that specify the layers to be |
| described. If you omit this parameter, `DescribeLayers` returns a |
| description of every layer in the specified stack. |
| |
| """ |
| params = {} |
| if stack_id is not None: |
| params['StackId'] = stack_id |
| if layer_ids is not None: |
| params['LayerIds'] = layer_ids |
| return self.make_request(action='DescribeLayers', |
| body=json.dumps(params)) |
| |
| def describe_load_based_auto_scaling(self, layer_ids): |
| """ |
| Describes load-based auto scaling configurations for specified |
| layers. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type layer_ids: list |
| :param layer_ids: An array of layer IDs. |
| |
| """ |
| params = {'LayerIds': layer_ids, } |
| return self.make_request(action='DescribeLoadBasedAutoScaling', |
| body=json.dumps(params)) |
| |
| def describe_my_user_profile(self): |
| """ |
| Describes a user's SSH information. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have self-management enabled or an attached policy that |
| explicitly grants permissions. For more information on user |
| permissions, see `Managing User Permissions`_. |
| |
| |
| """ |
| params = {} |
| return self.make_request(action='DescribeMyUserProfile', |
| body=json.dumps(params)) |
| |
| def describe_permissions(self, iam_user_arn=None, stack_id=None): |
| """ |
| Describes the permissions for a specified stack. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type iam_user_arn: string |
| :param iam_user_arn: The user's IAM ARN. For more information about IAM |
| ARNs, see `Using Identifiers`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| """ |
| params = {} |
| if iam_user_arn is not None: |
| params['IamUserArn'] = iam_user_arn |
| if stack_id is not None: |
| params['StackId'] = stack_id |
| return self.make_request(action='DescribePermissions', |
| body=json.dumps(params)) |
| |
| def describe_raid_arrays(self, instance_id=None, stack_id=None, |
| raid_array_ids=None): |
| """ |
| Describe an instance's RAID arrays. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. If you use this parameter, |
| `DescribeRaidArrays` returns descriptions of the RAID arrays |
| associated with the specified instance. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| :type raid_array_ids: list |
| :param raid_array_ids: An array of RAID array IDs. If you use this |
| parameter, `DescribeRaidArrays` returns descriptions of the |
| specified arrays. Otherwise, it returns a description of every |
| array. |
| |
| """ |
| params = {} |
| if instance_id is not None: |
| params['InstanceId'] = instance_id |
| if stack_id is not None: |
| params['StackId'] = stack_id |
| if raid_array_ids is not None: |
| params['RaidArrayIds'] = raid_array_ids |
| return self.make_request(action='DescribeRaidArrays', |
| body=json.dumps(params)) |
| |
| def describe_rds_db_instances(self, stack_id, rds_db_instance_arns=None): |
| """ |
| Describes Amazon RDS instances. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID that the instances are registered with. |
| The operation returns descriptions of all registered Amazon RDS |
| instances. |
| |
| :type rds_db_instance_arns: list |
| :param rds_db_instance_arns: An array containing the ARNs of the |
| instances to be described. |
| |
| """ |
| params = {'StackId': stack_id, } |
| if rds_db_instance_arns is not None: |
| params['RdsDbInstanceArns'] = rds_db_instance_arns |
| return self.make_request(action='DescribeRdsDbInstances', |
| body=json.dumps(params)) |
| |
| def describe_service_errors(self, stack_id=None, instance_id=None, |
| service_error_ids=None): |
| """ |
| Describes AWS OpsWorks service errors. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. If you use this parameter, |
| `DescribeServiceErrors` returns descriptions of the errors |
| associated with the specified stack. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. If you use this parameter, |
| `DescribeServiceErrors` returns descriptions of the errors |
| associated with the specified instance. |
| |
| :type service_error_ids: list |
| :param service_error_ids: An array of service error IDs. If you use |
| this parameter, `DescribeServiceErrors` returns descriptions of the |
| specified errors. Otherwise, it returns a description of every |
| error. |
| |
| """ |
| params = {} |
| if stack_id is not None: |
| params['StackId'] = stack_id |
| if instance_id is not None: |
| params['InstanceId'] = instance_id |
| if service_error_ids is not None: |
| params['ServiceErrorIds'] = service_error_ids |
| return self.make_request(action='DescribeServiceErrors', |
| body=json.dumps(params)) |
| |
| def describe_stack_provisioning_parameters(self, stack_id): |
| """ |
| Requests a description of a stack's provisioning parameters. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the stack |
| or an attached policy that explicitly grants permissions. For |
| more information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID |
| |
| """ |
| params = {'StackId': stack_id, } |
| return self.make_request(action='DescribeStackProvisioningParameters', |
| body=json.dumps(params)) |
| |
| def describe_stack_summary(self, stack_id): |
| """ |
| Describes the number of layers and apps in a specified stack, |
| and the number of instances in each state, such as |
| `running_setup` or `online`. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| """ |
| params = {'StackId': stack_id, } |
| return self.make_request(action='DescribeStackSummary', |
| body=json.dumps(params)) |
| |
| def describe_stacks(self, stack_ids=None): |
| """ |
| Requests a description of one or more stacks. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type stack_ids: list |
| :param stack_ids: An array of stack IDs that specify the stacks to be |
| described. If you omit this parameter, `DescribeStacks` returns a |
| description of every stack. |
| |
| """ |
| params = {} |
| if stack_ids is not None: |
| params['StackIds'] = stack_ids |
| return self.make_request(action='DescribeStacks', |
| body=json.dumps(params)) |
| |
| def describe_time_based_auto_scaling(self, instance_ids): |
| """ |
| Describes time-based auto scaling configurations for specified |
| instances. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type instance_ids: list |
| :param instance_ids: An array of instance IDs. |
| |
| """ |
| params = {'InstanceIds': instance_ids, } |
| return self.make_request(action='DescribeTimeBasedAutoScaling', |
| body=json.dumps(params)) |
| |
| def describe_user_profiles(self, iam_user_arns=None): |
| """ |
| Describe specified users. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have an attached policy that explicitly grants permissions. |
| For more information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type iam_user_arns: list |
| :param iam_user_arns: An array of IAM user ARNs that identify the users |
| to be described. |
| |
| """ |
| params = {} |
| if iam_user_arns is not None: |
| params['IamUserArns'] = iam_user_arns |
| return self.make_request(action='DescribeUserProfiles', |
| body=json.dumps(params)) |
| |
| def describe_volumes(self, instance_id=None, stack_id=None, |
| raid_array_id=None, volume_ids=None): |
| """ |
| Describes an instance's Amazon EBS volumes. |
| |
| |
| You must specify at least one of the parameters. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Show, Deploy, or Manage permissions level for the |
| stack, or an attached policy that explicitly grants |
| permissions. For more information on user permissions, see |
| `Managing User Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. If you use this parameter, |
| `DescribeVolumes` returns descriptions of the volumes associated |
| with the specified instance. |
| |
| :type stack_id: string |
| :param stack_id: A stack ID. The action describes the stack's |
| registered Amazon EBS volumes. |
| |
| :type raid_array_id: string |
| :param raid_array_id: The RAID array ID. If you use this parameter, |
| `DescribeVolumes` returns descriptions of the volumes associated |
| with the specified RAID array. |
| |
| :type volume_ids: list |
| :param volume_ids: Am array of volume IDs. If you use this parameter, |
| `DescribeVolumes` returns descriptions of the specified volumes. |
| Otherwise, it returns a description of every volume. |
| |
| """ |
| params = {} |
| if instance_id is not None: |
| params['InstanceId'] = instance_id |
| if stack_id is not None: |
| params['StackId'] = stack_id |
| if raid_array_id is not None: |
| params['RaidArrayId'] = raid_array_id |
| if volume_ids is not None: |
| params['VolumeIds'] = volume_ids |
| return self.make_request(action='DescribeVolumes', |
| body=json.dumps(params)) |
| |
| def detach_elastic_load_balancer(self, elastic_load_balancer_name, |
| layer_id): |
| """ |
| Detaches a specified Elastic Load Balancing instance from its |
| layer. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type elastic_load_balancer_name: string |
| :param elastic_load_balancer_name: The Elastic Load Balancing |
| instance's name. |
| |
| :type layer_id: string |
| :param layer_id: The ID of the layer that the Elastic Load Balancing |
| instance is attached to. |
| |
| """ |
| params = { |
| 'ElasticLoadBalancerName': elastic_load_balancer_name, |
| 'LayerId': layer_id, |
| } |
| return self.make_request(action='DetachElasticLoadBalancer', |
| body=json.dumps(params)) |
| |
| def disassociate_elastic_ip(self, elastic_ip): |
| """ |
| Disassociates an Elastic IP address from its instance. The |
| address remains registered with the stack. For more |
| information, see `Resource Management`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type elastic_ip: string |
| :param elastic_ip: The Elastic IP address. |
| |
| """ |
| params = {'ElasticIp': elastic_ip, } |
| return self.make_request(action='DisassociateElasticIp', |
| body=json.dumps(params)) |
| |
| def get_hostname_suggestion(self, layer_id): |
| """ |
| Gets a generated host name for the specified layer, based on |
| the current host name theme. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type layer_id: string |
| :param layer_id: The layer ID. |
| |
| """ |
| params = {'LayerId': layer_id, } |
| return self.make_request(action='GetHostnameSuggestion', |
| body=json.dumps(params)) |
| |
| def reboot_instance(self, instance_id): |
| """ |
| Reboots a specified instance. For more information, see |
| `Starting, Stopping, and Rebooting Instances`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| """ |
| params = {'InstanceId': instance_id, } |
| return self.make_request(action='RebootInstance', |
| body=json.dumps(params)) |
| |
| def register_elastic_ip(self, elastic_ip, stack_id): |
| """ |
| Registers an Elastic IP address with a specified stack. An |
| address can be registered with only one stack at a time. If |
| the address is already registered, you must first deregister |
| it by calling DeregisterElasticIp. For more information, see |
| `Resource Management`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type elastic_ip: string |
| :param elastic_ip: The Elastic IP address. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| """ |
| params = {'ElasticIp': elastic_ip, 'StackId': stack_id, } |
| return self.make_request(action='RegisterElasticIp', |
| body=json.dumps(params)) |
| |
| def register_instance(self, stack_id, hostname=None, public_ip=None, |
| private_ip=None, rsa_public_key=None, |
| rsa_public_key_fingerprint=None, |
| instance_identity=None): |
| """ |
| Registers instances with a specified stack that were created |
| outside of AWS OpsWorks. |
| |
| We do not recommend using this action to register instances. |
| The complete registration operation has two primary steps, |
| installing the AWS OpsWorks agent on the instance and |
| registering the instance with the stack. `RegisterInstance` |
| handles only the second step. You should instead use the AWS |
| CLI `register` command, which performs the entire registration |
| operation. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The ID of the stack that the instance is to be |
| registered with. |
| |
| :type hostname: string |
| :param hostname: The instance's hostname. |
| |
| :type public_ip: string |
| :param public_ip: The instance's public IP address. |
| |
| :type private_ip: string |
| :param private_ip: The instance's private IP address. |
| |
| :type rsa_public_key: string |
| :param rsa_public_key: The instances public RSA key. This key is used |
| to encrypt communication between the instance and the service. |
| |
| :type rsa_public_key_fingerprint: string |
| :param rsa_public_key_fingerprint: The instances public RSA key |
| fingerprint. |
| |
| :type instance_identity: dict |
| :param instance_identity: An InstanceIdentity object that contains the |
| instance's identity. |
| |
| """ |
| params = {'StackId': stack_id, } |
| if hostname is not None: |
| params['Hostname'] = hostname |
| if public_ip is not None: |
| params['PublicIp'] = public_ip |
| if private_ip is not None: |
| params['PrivateIp'] = private_ip |
| if rsa_public_key is not None: |
| params['RsaPublicKey'] = rsa_public_key |
| if rsa_public_key_fingerprint is not None: |
| params['RsaPublicKeyFingerprint'] = rsa_public_key_fingerprint |
| if instance_identity is not None: |
| params['InstanceIdentity'] = instance_identity |
| return self.make_request(action='RegisterInstance', |
| body=json.dumps(params)) |
| |
| def register_rds_db_instance(self, stack_id, rds_db_instance_arn, |
| db_user, db_password): |
| """ |
| Registers an Amazon RDS instance with a stack. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| :type rds_db_instance_arn: string |
| :param rds_db_instance_arn: The Amazon RDS instance's ARN. |
| |
| :type db_user: string |
| :param db_user: The database's master user name. |
| |
| :type db_password: string |
| :param db_password: The database password. |
| |
| """ |
| params = { |
| 'StackId': stack_id, |
| 'RdsDbInstanceArn': rds_db_instance_arn, |
| 'DbUser': db_user, |
| 'DbPassword': db_password, |
| } |
| return self.make_request(action='RegisterRdsDbInstance', |
| body=json.dumps(params)) |
| |
| def register_volume(self, stack_id, ec_2_volume_id=None): |
| """ |
| Registers an Amazon EBS volume with a specified stack. A |
| volume can be registered with only one stack at a time. If the |
| volume is already registered, you must first deregister it by |
| calling DeregisterVolume. For more information, see `Resource |
| Management`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type ec_2_volume_id: string |
| :param ec_2_volume_id: The Amazon EBS volume ID. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| """ |
| params = {'StackId': stack_id, } |
| if ec_2_volume_id is not None: |
| params['Ec2VolumeId'] = ec_2_volume_id |
| return self.make_request(action='RegisterVolume', |
| body=json.dumps(params)) |
| |
| def set_load_based_auto_scaling(self, layer_id, enable=None, |
| up_scaling=None, down_scaling=None): |
| """ |
| Specify the load-based auto scaling configuration for a |
| specified layer. For more information, see `Managing Load with |
| Time-based and Load-based Instances`_. |
| |
| |
| To use load-based auto scaling, you must create a set of load- |
| based auto scaling instances. Load-based auto scaling operates |
| only on the instances from that set, so you must ensure that |
| you have created enough instances to handle the maximum |
| anticipated load. |
| |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type layer_id: string |
| :param layer_id: The layer ID. |
| |
| :type enable: boolean |
| :param enable: Enables load-based auto scaling for the layer. |
| |
| :type up_scaling: dict |
| :param up_scaling: An `AutoScalingThresholds` object with the upscaling |
| threshold configuration. If the load exceeds these thresholds for a |
| specified amount of time, AWS OpsWorks starts a specified number of |
| instances. |
| |
| :type down_scaling: dict |
| :param down_scaling: An `AutoScalingThresholds` object with the |
| downscaling threshold configuration. If the load falls below these |
| thresholds for a specified amount of time, AWS OpsWorks stops a |
| specified number of instances. |
| |
| """ |
| params = {'LayerId': layer_id, } |
| if enable is not None: |
| params['Enable'] = enable |
| if up_scaling is not None: |
| params['UpScaling'] = up_scaling |
| if down_scaling is not None: |
| params['DownScaling'] = down_scaling |
| return self.make_request(action='SetLoadBasedAutoScaling', |
| body=json.dumps(params)) |
| |
| def set_permission(self, stack_id, iam_user_arn, allow_ssh=None, |
| allow_sudo=None, level=None): |
| """ |
| Specifies a user's permissions. For more information, see |
| `Security and Permissions`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| :type iam_user_arn: string |
| :param iam_user_arn: The user's IAM ARN. |
| |
| :type allow_ssh: boolean |
| :param allow_ssh: The user is allowed to use SSH to communicate with |
| the instance. |
| |
| :type allow_sudo: boolean |
| :param allow_sudo: The user is allowed to use **sudo** to elevate |
| privileges. |
| |
| :type level: string |
| :param level: The user's permission level, which must be set to one of |
| the following strings. You cannot set your own permissions level. |
| |
| + `deny` |
| + `show` |
| + `deploy` |
| + `manage` |
| + `iam_only` |
| |
| |
| For more information on the permissions associated with these levels, |
| see `Managing User Permissions`_ |
| |
| """ |
| params = {'StackId': stack_id, 'IamUserArn': iam_user_arn, } |
| if allow_ssh is not None: |
| params['AllowSsh'] = allow_ssh |
| if allow_sudo is not None: |
| params['AllowSudo'] = allow_sudo |
| if level is not None: |
| params['Level'] = level |
| return self.make_request(action='SetPermission', |
| body=json.dumps(params)) |
| |
| def set_time_based_auto_scaling(self, instance_id, |
| auto_scaling_schedule=None): |
| """ |
| Specify the time-based auto scaling configuration for a |
| specified instance. For more information, see `Managing Load |
| with Time-based and Load-based Instances`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| :type auto_scaling_schedule: dict |
| :param auto_scaling_schedule: An `AutoScalingSchedule` with the |
| instance schedule. |
| |
| """ |
| params = {'InstanceId': instance_id, } |
| if auto_scaling_schedule is not None: |
| params['AutoScalingSchedule'] = auto_scaling_schedule |
| return self.make_request(action='SetTimeBasedAutoScaling', |
| body=json.dumps(params)) |
| |
| def start_instance(self, instance_id): |
| """ |
| Starts a specified instance. For more information, see |
| `Starting, Stopping, and Rebooting Instances`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| """ |
| params = {'InstanceId': instance_id, } |
| return self.make_request(action='StartInstance', |
| body=json.dumps(params)) |
| |
| def start_stack(self, stack_id): |
| """ |
| Starts a stack's instances. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| """ |
| params = {'StackId': stack_id, } |
| return self.make_request(action='StartStack', |
| body=json.dumps(params)) |
| |
| def stop_instance(self, instance_id): |
| """ |
| Stops a specified instance. When you stop a standard instance, |
| the data disappears and must be reinstalled when you restart |
| the instance. You can stop an Amazon EBS-backed instance |
| without losing data. For more information, see `Starting, |
| Stopping, and Rebooting Instances`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| """ |
| params = {'InstanceId': instance_id, } |
| return self.make_request(action='StopInstance', |
| body=json.dumps(params)) |
| |
| def stop_stack(self, stack_id): |
| """ |
| Stops a specified stack. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| """ |
| params = {'StackId': stack_id, } |
| return self.make_request(action='StopStack', |
| body=json.dumps(params)) |
| |
| def unassign_instance(self, instance_id): |
| """ |
| Unassigns a registered instance from all of it's layers. The |
| instance remains in the stack as an unassigned instance and |
| can be assigned to another layer, as needed. You cannot use |
| this action with instances that were created with AWS |
| OpsWorks. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| """ |
| params = {'InstanceId': instance_id, } |
| return self.make_request(action='UnassignInstance', |
| body=json.dumps(params)) |
| |
| def unassign_volume(self, volume_id): |
| """ |
| Unassigns an assigned Amazon EBS volume. The volume remains |
| registered with the stack. For more information, see `Resource |
| Management`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type volume_id: string |
| :param volume_id: The volume ID. |
| |
| """ |
| params = {'VolumeId': volume_id, } |
| return self.make_request(action='UnassignVolume', |
| body=json.dumps(params)) |
| |
| def update_app(self, app_id, name=None, description=None, |
| data_sources=None, type=None, app_source=None, |
| domains=None, enable_ssl=None, ssl_configuration=None, |
| attributes=None, environment=None): |
| """ |
| Updates a specified app. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Deploy or Manage permissions level for the stack, or an |
| attached policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type app_id: string |
| :param app_id: The app ID. |
| |
| :type name: string |
| :param name: The app name. |
| |
| :type description: string |
| :param description: A description of the app. |
| |
| :type data_sources: list |
| :param data_sources: The app's data sources. |
| |
| :type type: string |
| :param type: The app type. |
| |
| :type app_source: dict |
| :param app_source: A `Source` object that specifies the app repository. |
| |
| :type domains: list |
| :param domains: The app's virtual host settings, with multiple domains |
| separated by commas. For example: `'www.example.com, example.com'` |
| |
| :type enable_ssl: boolean |
| :param enable_ssl: Whether SSL is enabled for the app. |
| |
| :type ssl_configuration: dict |
| :param ssl_configuration: An `SslConfiguration` object with the SSL |
| configuration. |
| |
| :type attributes: map |
| :param attributes: One or more user-defined key/value pairs to be added |
| to the stack attributes. |
| |
| :type environment: list |
| :param environment: |
| An array of `EnvironmentVariable` objects that specify environment |
| variables to be associated with the app. You can specify up to ten |
| environment variables. After you deploy the app, these variables |
| are defined on the associated app server instances. |
| |
| This parameter is supported only by Chef 11.10 stacks. If you have |
| specified one or more environment variables, you cannot modify the |
| stack's Chef version. |
| |
| """ |
| params = {'AppId': app_id, } |
| if name is not None: |
| params['Name'] = name |
| if description is not None: |
| params['Description'] = description |
| if data_sources is not None: |
| params['DataSources'] = data_sources |
| if type is not None: |
| params['Type'] = type |
| if app_source is not None: |
| params['AppSource'] = app_source |
| if domains is not None: |
| params['Domains'] = domains |
| if enable_ssl is not None: |
| params['EnableSsl'] = enable_ssl |
| if ssl_configuration is not None: |
| params['SslConfiguration'] = ssl_configuration |
| if attributes is not None: |
| params['Attributes'] = attributes |
| if environment is not None: |
| params['Environment'] = environment |
| return self.make_request(action='UpdateApp', |
| body=json.dumps(params)) |
| |
| def update_elastic_ip(self, elastic_ip, name=None): |
| """ |
| Updates a registered Elastic IP address's name. For more |
| information, see `Resource Management`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type elastic_ip: string |
| :param elastic_ip: The address. |
| |
| :type name: string |
| :param name: The new name. |
| |
| """ |
| params = {'ElasticIp': elastic_ip, } |
| if name is not None: |
| params['Name'] = name |
| return self.make_request(action='UpdateElasticIp', |
| body=json.dumps(params)) |
| |
| def update_instance(self, instance_id, layer_ids=None, |
| instance_type=None, auto_scaling_type=None, |
| hostname=None, os=None, ami_id=None, |
| ssh_key_name=None, architecture=None, |
| install_updates_on_boot=None, ebs_optimized=None): |
| """ |
| Updates a specified instance. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type instance_id: string |
| :param instance_id: The instance ID. |
| |
| :type layer_ids: list |
| :param layer_ids: The instance's layer IDs. |
| |
| :type instance_type: string |
| :param instance_type: The instance type. AWS OpsWorks supports all |
| instance types except Cluster Compute, Cluster GPU, and High Memory |
| Cluster. For more information, see `Instance Families and Types`_. |
| The parameter values that you use to specify the various types are |
| in the API Name column of the Available Instance Types table. |
| |
| :type auto_scaling_type: string |
| :param auto_scaling_type: For load-based or time-based instances, the |
| type. |
| |
| :type hostname: string |
| :param hostname: The instance host name. |
| |
| :type os: string |
| :param os: The instance's operating system, which must be set to one of |
| the following. |
| |
| + Standard operating systems: An Amazon Linux version such as `Amazon |
| Linux 2014.09`, `Ubuntu 12.04 LTS`, or `Ubuntu 14.04 LTS`. |
| + Custom AMIs: `Custom` |
| |
| |
| The default option is the current Amazon Linux version, such as `Amazon |
| Linux 2014.09`. If you set this parameter to `Custom`, you must use |
| the CreateInstance action's AmiId parameter to specify the custom |
| AMI that you want to use. For more information on the standard |
| operating systems, see `Operating Systems`_For more information on |
| how to use custom AMIs with OpsWorks, see `Using Custom AMIs`_. |
| |
| :type ami_id: string |
| :param ami_id: |
| A custom AMI ID to be used to create the instance. The AMI should be |
| based on one of the standard AWS OpsWorks AMIs: Amazon Linux, |
| Ubuntu 12.04 LTS, or Ubuntu 14.04 LTS. For more information, see |
| `Instances`_ |
| |
| If you specify a custom AMI, you must set `Os` to `Custom`. |
| |
| :type ssh_key_name: string |
| :param ssh_key_name: The instance SSH key name. |
| |
| :type architecture: string |
| :param architecture: The instance architecture. Instance types do not |
| necessarily support both architectures. For a list of the |
| architectures that are supported by the different instance types, |
| see `Instance Families and Types`_. |
| |
| :type install_updates_on_boot: boolean |
| :param install_updates_on_boot: |
| Whether to install operating system and package updates when the |
| instance boots. The default value is `True`. To control when |
| updates are installed, set this value to `False`. You must then |
| update your instances manually by using CreateDeployment to run the |
| `update_dependencies` stack command or manually running `yum` |
| (Amazon Linux) or `apt-get` (Ubuntu) on the instances. |
| |
| |
| We strongly recommend using the default value of `True`, to ensure that |
| your instances have the latest security updates. |
| |
| :type ebs_optimized: boolean |
| :param ebs_optimized: Whether this is an Amazon EBS-optimized instance. |
| |
| """ |
| params = {'InstanceId': instance_id, } |
| if layer_ids is not None: |
| params['LayerIds'] = layer_ids |
| if instance_type is not None: |
| params['InstanceType'] = instance_type |
| if auto_scaling_type is not None: |
| params['AutoScalingType'] = auto_scaling_type |
| if hostname is not None: |
| params['Hostname'] = hostname |
| if os is not None: |
| params['Os'] = os |
| if ami_id is not None: |
| params['AmiId'] = ami_id |
| if ssh_key_name is not None: |
| params['SshKeyName'] = ssh_key_name |
| if architecture is not None: |
| params['Architecture'] = architecture |
| if install_updates_on_boot is not None: |
| params['InstallUpdatesOnBoot'] = install_updates_on_boot |
| if ebs_optimized is not None: |
| params['EbsOptimized'] = ebs_optimized |
| return self.make_request(action='UpdateInstance', |
| body=json.dumps(params)) |
| |
| def update_layer(self, layer_id, name=None, shortname=None, |
| attributes=None, custom_instance_profile_arn=None, |
| custom_security_group_ids=None, packages=None, |
| volume_configurations=None, enable_auto_healing=None, |
| auto_assign_elastic_ips=None, |
| auto_assign_public_ips=None, custom_recipes=None, |
| install_updates_on_boot=None, |
| use_ebs_optimized_instances=None, |
| lifecycle_event_configuration=None): |
| """ |
| Updates a specified layer. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type layer_id: string |
| :param layer_id: The layer ID. |
| |
| :type name: string |
| :param name: The layer name, which is used by the console. |
| |
| :type shortname: string |
| :param shortname: The layer short name, which is used internally by AWS |
| OpsWorksand by Chef. The short name is also used as the name for |
| the directory where your app files are installed. It can have a |
| maximum of 200 characters and must be in the following format: |
| /\A[a-z0-9\-\_\.]+\Z/. |
| |
| :type attributes: map |
| :param attributes: One or more user-defined key/value pairs to be added |
| to the stack attributes. |
| |
| :type custom_instance_profile_arn: string |
| :param custom_instance_profile_arn: The ARN of an IAM profile to be |
| used for all of the layer's EC2 instances. For more information |
| about IAM ARNs, see `Using Identifiers`_. |
| |
| :type custom_security_group_ids: list |
| :param custom_security_group_ids: An array containing the layer's |
| custom security group IDs. |
| |
| :type packages: list |
| :param packages: An array of `Package` objects that describe the |
| layer's packages. |
| |
| :type volume_configurations: list |
| :param volume_configurations: A `VolumeConfigurations` object that |
| describes the layer's Amazon EBS volumes. |
| |
| :type enable_auto_healing: boolean |
| :param enable_auto_healing: Whether to disable auto healing for the |
| layer. |
| |
| :type auto_assign_elastic_ips: boolean |
| :param auto_assign_elastic_ips: Whether to automatically assign an |
| `Elastic IP address`_ to the layer's instances. For more |
| information, see `How to Edit a Layer`_. |
| |
| :type auto_assign_public_ips: boolean |
| :param auto_assign_public_ips: For stacks that are running in a VPC, |
| whether to automatically assign a public IP address to the layer's |
| instances. For more information, see `How to Edit a Layer`_. |
| |
| :type custom_recipes: dict |
| :param custom_recipes: A `LayerCustomRecipes` object that specifies the |
| layer's custom recipes. |
| |
| :type install_updates_on_boot: boolean |
| :param install_updates_on_boot: |
| Whether to install operating system and package updates when the |
| instance boots. The default value is `True`. To control when |
| updates are installed, set this value to `False`. You must then |
| update your instances manually by using CreateDeployment to run the |
| `update_dependencies` stack command or manually running `yum` |
| (Amazon Linux) or `apt-get` (Ubuntu) on the instances. |
| |
| |
| We strongly recommend using the default value of `True`, to ensure that |
| your instances have the latest security updates. |
| |
| :type use_ebs_optimized_instances: boolean |
| :param use_ebs_optimized_instances: Whether to use Amazon EBS-optimized |
| instances. |
| |
| :type lifecycle_event_configuration: dict |
| :param lifecycle_event_configuration: |
| |
| """ |
| params = {'LayerId': layer_id, } |
| if name is not None: |
| params['Name'] = name |
| if shortname is not None: |
| params['Shortname'] = shortname |
| if attributes is not None: |
| params['Attributes'] = attributes |
| if custom_instance_profile_arn is not None: |
| params['CustomInstanceProfileArn'] = custom_instance_profile_arn |
| if custom_security_group_ids is not None: |
| params['CustomSecurityGroupIds'] = custom_security_group_ids |
| if packages is not None: |
| params['Packages'] = packages |
| if volume_configurations is not None: |
| params['VolumeConfigurations'] = volume_configurations |
| if enable_auto_healing is not None: |
| params['EnableAutoHealing'] = enable_auto_healing |
| if auto_assign_elastic_ips is not None: |
| params['AutoAssignElasticIps'] = auto_assign_elastic_ips |
| if auto_assign_public_ips is not None: |
| params['AutoAssignPublicIps'] = auto_assign_public_ips |
| if custom_recipes is not None: |
| params['CustomRecipes'] = custom_recipes |
| if install_updates_on_boot is not None: |
| params['InstallUpdatesOnBoot'] = install_updates_on_boot |
| if use_ebs_optimized_instances is not None: |
| params['UseEbsOptimizedInstances'] = use_ebs_optimized_instances |
| if lifecycle_event_configuration is not None: |
| params['LifecycleEventConfiguration'] = lifecycle_event_configuration |
| return self.make_request(action='UpdateLayer', |
| body=json.dumps(params)) |
| |
| def update_my_user_profile(self, ssh_public_key=None): |
| """ |
| Updates a user's SSH public key. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have self-management enabled or an attached policy that |
| explicitly grants permissions. For more information on user |
| permissions, see `Managing User Permissions`_. |
| |
| :type ssh_public_key: string |
| :param ssh_public_key: The user's SSH public key. |
| |
| """ |
| params = {} |
| if ssh_public_key is not None: |
| params['SshPublicKey'] = ssh_public_key |
| return self.make_request(action='UpdateMyUserProfile', |
| body=json.dumps(params)) |
| |
| def update_rds_db_instance(self, rds_db_instance_arn, db_user=None, |
| db_password=None): |
| """ |
| Updates an Amazon RDS instance. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type rds_db_instance_arn: string |
| :param rds_db_instance_arn: The Amazon RDS instance's ARN. |
| |
| :type db_user: string |
| :param db_user: The master user name. |
| |
| :type db_password: string |
| :param db_password: The database password. |
| |
| """ |
| params = {'RdsDbInstanceArn': rds_db_instance_arn, } |
| if db_user is not None: |
| params['DbUser'] = db_user |
| if db_password is not None: |
| params['DbPassword'] = db_password |
| return self.make_request(action='UpdateRdsDbInstance', |
| body=json.dumps(params)) |
| |
| def update_stack(self, stack_id, name=None, attributes=None, |
| service_role_arn=None, |
| default_instance_profile_arn=None, default_os=None, |
| hostname_theme=None, default_availability_zone=None, |
| default_subnet_id=None, custom_json=None, |
| configuration_manager=None, chef_configuration=None, |
| use_custom_cookbooks=None, custom_cookbooks_source=None, |
| default_ssh_key_name=None, |
| default_root_device_type=None, |
| use_opsworks_security_groups=None): |
| """ |
| Updates a specified stack. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type stack_id: string |
| :param stack_id: The stack ID. |
| |
| :type name: string |
| :param name: The stack's new name. |
| |
| :type attributes: map |
| :param attributes: One or more user-defined key/value pairs to be added |
| to the stack attributes. |
| |
| :type service_role_arn: string |
| :param service_role_arn: |
| The stack AWS Identity and Access Management (IAM) role, which allows |
| AWS OpsWorks to work with AWS resources on your behalf. You must |
| set this parameter to the Amazon Resource Name (ARN) for an |
| existing IAM role. For more information about IAM ARNs, see `Using |
| Identifiers`_. |
| |
| |
| You must set this parameter to a valid service role ARN or the action |
| will fail; there is no default value. You can specify the stack's |
| current service role ARN, if you prefer, but you must do so |
| explicitly. |
| |
| :type default_instance_profile_arn: string |
| :param default_instance_profile_arn: The ARN of an IAM profile that is |
| the default profile for all of the stack's EC2 instances. For more |
| information about IAM ARNs, see `Using Identifiers`_. |
| |
| :type default_os: string |
| :param default_os: The stack's operating system, which must be set to |
| one of the following. |
| |
| + Standard operating systems: an Amazon Linux version such as `Amazon |
| Linux 2014.09`, `Ubuntu 12.04 LTS`, or `Ubuntu 14.04 LTS`. |
| + Custom AMIs: `Custom`. You specify the custom AMI you want to use |
| when you create instances. |
| |
| |
| The default option is the current Amazon Linux version. |
| |
| :type hostname_theme: string |
| :param hostname_theme: The stack's new host name theme, with spaces are |
| replaced by underscores. The theme is used to generate host names |
| for the stack's instances. By default, `HostnameTheme` is set to |
| `Layer_Dependent`, which creates host names by appending integers |
| to the layer's short name. The other themes are: |
| |
| + `Baked_Goods` |
| + `Clouds` |
| + `European_Cities` |
| + `Fruits` |
| + `Greek_Deities` |
| + `Legendary_Creatures_from_Japan` |
| + `Planets_and_Moons` |
| + `Roman_Deities` |
| + `Scottish_Islands` |
| + `US_Cities` |
| + `Wild_Cats` |
| |
| |
| To obtain a generated host name, call `GetHostNameSuggestion`, which |
| returns a host name based on the current theme. |
| |
| :type default_availability_zone: string |
| :param default_availability_zone: The stack's default Availability |
| Zone, which must be in the specified region. For more information, |
| see `Regions and Endpoints`_. If you also specify a value for |
| `DefaultSubnetId`, the subnet must be in the same zone. For more |
| information, see CreateStack. |
| |
| :type default_subnet_id: string |
| :param default_subnet_id: The stack's default VPC subnet ID. This |
| parameter is required if you specify a value for the `VpcId` |
| parameter. All instances are launched into this subnet unless you |
| specify otherwise when you create the instance. If you also specify |
| a value for `DefaultAvailabilityZone`, the subnet must be in that |
| zone. For information on default values and when this parameter is |
| required, see the `VpcId` parameter description. |
| |
| :type custom_json: string |
| :param custom_json: A string that contains user-defined, custom JSON. |
| It is used to override the corresponding default stack |
| configuration JSON values. The string should be in the following |
| format and must escape characters such as '"'.: |
| `"{\"key1\": \"value1\", \"key2\": \"value2\",...}"` |
| |
| For more information on custom JSON, see `Use Custom JSON to Modify the |
| Stack Configuration JSON`_. |
| |
| :type configuration_manager: dict |
| :param configuration_manager: The configuration manager. When you clone |
| a stack we recommend that you use the configuration manager to |
| specify the Chef version, 0.9, 11.4, or 11.10. The default value is |
| currently 11.4. |
| |
| :type chef_configuration: dict |
| :param chef_configuration: A `ChefConfiguration` object that specifies |
| whether to enable Berkshelf and the Berkshelf version on Chef 11.10 |
| stacks. For more information, see `Create a New Stack`_. |
| |
| :type use_custom_cookbooks: boolean |
| :param use_custom_cookbooks: Whether the stack uses custom cookbooks. |
| |
| :type custom_cookbooks_source: dict |
| :param custom_cookbooks_source: Contains the information required to |
| retrieve an app or cookbook from a repository. For more |
| information, see `Creating Apps`_ or `Custom Recipes and |
| Cookbooks`_. |
| |
| :type default_ssh_key_name: string |
| :param default_ssh_key_name: A default SSH key for the stack instances. |
| You can override this value when you create or update an instance. |
| |
| :type default_root_device_type: string |
| :param default_root_device_type: The default root device type. This |
| value is used by default for all instances in the stack, but you |
| can override it when you create an instance. For more information, |
| see `Storage for the Root Device`_. |
| |
| :type use_opsworks_security_groups: boolean |
| :param use_opsworks_security_groups: Whether to associate the AWS |
| OpsWorks built-in security groups with the stack's layers. |
| AWS OpsWorks provides a standard set of built-in security groups, one |
| for each layer, which are associated with layers by default. |
| `UseOpsworksSecurityGroups` allows you to instead provide your own |
| custom security groups. `UseOpsworksSecurityGroups` has the |
| following settings: |
| |
| |
| + True - AWS OpsWorks automatically associates the appropriate built-in |
| security group with each layer (default setting). You can associate |
| additional security groups with a layer after you create it but you |
| cannot delete the built-in security group. |
| + False - AWS OpsWorks does not associate built-in security groups with |
| layers. You must create appropriate EC2 security groups and |
| associate a security group with each layer that you create. |
| However, you can still manually associate a built-in security group |
| with a layer on creation; custom security groups are required only |
| for those layers that need custom settings. |
| |
| |
| For more information, see `Create a New Stack`_. |
| |
| """ |
| params = {'StackId': stack_id, } |
| if name is not None: |
| params['Name'] = name |
| if attributes is not None: |
| params['Attributes'] = attributes |
| if service_role_arn is not None: |
| params['ServiceRoleArn'] = service_role_arn |
| if default_instance_profile_arn is not None: |
| params['DefaultInstanceProfileArn'] = default_instance_profile_arn |
| if default_os is not None: |
| params['DefaultOs'] = default_os |
| if hostname_theme is not None: |
| params['HostnameTheme'] = hostname_theme |
| if default_availability_zone is not None: |
| params['DefaultAvailabilityZone'] = default_availability_zone |
| if default_subnet_id is not None: |
| params['DefaultSubnetId'] = default_subnet_id |
| if custom_json is not None: |
| params['CustomJson'] = custom_json |
| if configuration_manager is not None: |
| params['ConfigurationManager'] = configuration_manager |
| if chef_configuration is not None: |
| params['ChefConfiguration'] = chef_configuration |
| if use_custom_cookbooks is not None: |
| params['UseCustomCookbooks'] = use_custom_cookbooks |
| if custom_cookbooks_source is not None: |
| params['CustomCookbooksSource'] = custom_cookbooks_source |
| if default_ssh_key_name is not None: |
| params['DefaultSshKeyName'] = default_ssh_key_name |
| if default_root_device_type is not None: |
| params['DefaultRootDeviceType'] = default_root_device_type |
| if use_opsworks_security_groups is not None: |
| params['UseOpsworksSecurityGroups'] = use_opsworks_security_groups |
| return self.make_request(action='UpdateStack', |
| body=json.dumps(params)) |
| |
| def update_user_profile(self, iam_user_arn, ssh_username=None, |
| ssh_public_key=None, allow_self_management=None): |
| """ |
| Updates a specified user profile. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have an attached policy that explicitly grants permissions. |
| For more information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type iam_user_arn: string |
| :param iam_user_arn: The user IAM ARN. |
| |
| :type ssh_username: string |
| :param ssh_username: The user's SSH user name. The allowable characters |
| are [a-z], [A-Z], [0-9], '-', and '_'. If the specified name |
| includes other punctuation marks, AWS OpsWorks removes them. For |
| example, `my.name` will be changed to `myname`. If you do not |
| specify an SSH user name, AWS OpsWorks generates one from the IAM |
| user name. |
| |
| :type ssh_public_key: string |
| :param ssh_public_key: The user's new SSH public key. |
| |
| :type allow_self_management: boolean |
| :param allow_self_management: Whether users can specify their own SSH |
| public key through the My Settings page. For more information, see |
| `Managing User Permissions`_. |
| |
| """ |
| params = {'IamUserArn': iam_user_arn, } |
| if ssh_username is not None: |
| params['SshUsername'] = ssh_username |
| if ssh_public_key is not None: |
| params['SshPublicKey'] = ssh_public_key |
| if allow_self_management is not None: |
| params['AllowSelfManagement'] = allow_self_management |
| return self.make_request(action='UpdateUserProfile', |
| body=json.dumps(params)) |
| |
| def update_volume(self, volume_id, name=None, mount_point=None): |
| """ |
| Updates an Amazon EBS volume's name or mount point. For more |
| information, see `Resource Management`_. |
| |
| **Required Permissions**: To use this action, an IAM user must |
| have a Manage permissions level for the stack, or an attached |
| policy that explicitly grants permissions. For more |
| information on user permissions, see `Managing User |
| Permissions`_. |
| |
| :type volume_id: string |
| :param volume_id: The volume ID. |
| |
| :type name: string |
| :param name: The new name. |
| |
| :type mount_point: string |
| :param mount_point: The new mount point. |
| |
| """ |
| params = {'VolumeId': volume_id, } |
| if name is not None: |
| params['Name'] = name |
| if mount_point is not None: |
| params['MountPoint'] = mount_point |
| return self.make_request(action='UpdateVolume', |
| body=json.dumps(params)) |
| |
| def make_request(self, action, body): |
| headers = { |
| 'X-Amz-Target': '%s.%s' % (self.TargetPrefix, action), |
| 'Host': self.region.endpoint, |
| 'Content-Type': 'application/x-amz-json-1.1', |
| 'Content-Length': str(len(body)), |
| } |
| http_request = self.build_base_http_request( |
| method='POST', path='/', auth_path='/', params={}, |
| headers=headers, data=body) |
| response = self._mexe(http_request, sender=None, |
| override_num_retries=10) |
| response_body = response.read().decode('utf-8') |
| boto.log.debug(response_body) |
| if response.status == 200: |
| if response_body: |
| return json.loads(response_body) |
| else: |
| json_body = json.loads(response_body) |
| fault_name = json_body.get('__type', None) |
| exception_class = self._faults.get(fault_name, self.ResponseError) |
| raise exception_class(response.status, response.reason, |
| body=json_body) |
| |