From fe1153c0afa1ffd648147af97454e900560b3532 Mon Sep 17 00:00:00 2001 From: Julien Stroheker Date: Tue, 29 Aug 2017 20:59:38 -0400 Subject: [PATCH] Azure acs module (azure_rm_acs.py) (#28522) * Adding acs module * linter issue * Reduce the VM Size for the int. tests * Short the name of the cluster * Fixing the asserts and title * Fixing VM Scale count in int. tests * Changing the location of the tests * trying eastus2 * disabling acs CI tests until stabilized --- lib/ansible/module_utils/azure_rm_common.py | 13 + .../modules/cloud/azure/azure_rm_acs.py | 719 ++++++++++++++++++ packaging/requirements/requirements-azure.txt | 1 + test/integration/targets/azure_rm_acs/aliases | 2 + .../targets/azure_rm_acs/meta/main.yml | 2 + .../targets/azure_rm_acs/tasks/main.yml | 143 ++++ 6 files changed, 880 insertions(+) create mode 100644 lib/ansible/modules/cloud/azure/azure_rm_acs.py create mode 100644 test/integration/targets/azure_rm_acs/aliases create mode 100644 test/integration/targets/azure_rm_acs/meta/main.yml create mode 100644 test/integration/targets/azure_rm_acs/tasks/main.yml diff --git a/lib/ansible/module_utils/azure_rm_common.py b/lib/ansible/module_utils/azure_rm_common.py index 4e8d84b140..fe00a890d8 100644 --- a/lib/ansible/module_utils/azure_rm_common.py +++ b/lib/ansible/module_utils/azure_rm_common.py @@ -105,6 +105,7 @@ try: from azure.mgmt.storage import StorageManagementClient from azure.mgmt.compute import ComputeManagementClient from azure.mgmt.dns import DnsManagementClient + from azure.mgmt.containerservice import ContainerServiceClient from azure.storage.cloudstorageaccount import CloudStorageAccount except ImportError as exc: HAS_AZURE_EXC = exc @@ -184,6 +185,7 @@ class AzureRMModuleBase(object): self._resource_client = None self._compute_client = None self._dns_client = None + self._containerservice_client = None self.check_mode = self.module.check_mode self.facts_module = facts_module # self.debug = self.module.params.get('debug') @@ -724,3 +726,14 @@ class AzureRMModuleBase(object): ) self._register('Microsoft.Dns') return self._dns_client + + @property + def containerservice_client(self): + self.log('Getting container service client') + if not self._containerservice_client: + self._containerservice_client = ContainerServiceClient( + self.azure_credentials, + self.subscription_id + ) + self._register('Microsoft.ContainerService') + return self._containerservice_client diff --git a/lib/ansible/modules/cloud/azure/azure_rm_acs.py b/lib/ansible/modules/cloud/azure/azure_rm_acs.py new file mode 100644 index 0000000000..444848a3b5 --- /dev/null +++ b/lib/ansible/modules/cloud/azure/azure_rm_acs.py @@ -0,0 +1,719 @@ +#!/usr/bin/python +# +# Copyright (c) 2017 Julien Stroheker, +# +# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) + +from __future__ import absolute_import, division, print_function +__metaclass__ = type + + +ANSIBLE_METADATA = {'metadata_version': '1.1', + 'status': ['preview'], + 'supported_by': 'community'} + + +DOCUMENTATION = ''' +--- +module: azure_rm_acs +version_added: "2.4" +short_description: Manage an Azure Container Service Instance (ACS). +description: + - Create, update and delete an Azure Container Service Instance. + +options: + resource_group: + description: + - Name of a resource group where the Container Services exists or will be created. + required: true + name: + description: + - Name of the Container Services instance. + required: true + default: null + state: + description: + - Assert the state of the ACS. Use 'present' to create or update an ACS and 'absent' to delete it. + default: present + choices: + - absent + - present + required: false + location: + description: + - Valid azure location. Defaults to location of the resource group. + default: resource_group location + required: false + orchestration_platform: + description: + - Specifies the Container Orchestration Platform to use. Currently can be either DCOS, Kubernetes or Swarm. + required: true + master_profile: + description: + - Master profile suboptions. + required: true + default: null + suboptions: + count: + description: + - Number of masters (VMs) in the container service cluster. Allowed values are 1, 3, and 5. + required: true + choices: + - 1 + - 3 + - 5 + dns_prefix: + description: + - The DNS Prefix to use for the Container Service master nodes. + required: true + linux_profile: + description: + - The linux profile suboptions. + required: true + default: null + suboptions: + admin_username: + description: + - The Admin Username for the Cluster. + required: true + default: azureuser + ssh_key: + description: + - The Public SSH Key used to access the cluster. + required: true + agent_pool_profiles: + description: + - The agent pool profile suboptions. + required: true + default: null + suboptions: + name: + description: + - Unique name of the agent pool profile in the context of the subscription and resource group. + required: true + count: + description: + - Number of agents (VMs) to host docker containers. Allowed values must be in the range of 1 to 100 (inclusive). + required: true + default: 1 + dns_prefix: + description: + - The DNS Prefix given to Agents in this Agent Pool. + required: true + vm_size: + description: + - The VM Size of each of the Agent Pool VM's (e.g. Standard_F1 / Standard_D2v2). + required: true + default: Standard_D2v2 + service_principal: + description: + - The service principal suboptions. + required: false + default: null + suboptions: + client_id: + description: + - The ID for the Service Principal. + required: false + client_secret: + description: + - The secret password associated with the service principal. + required: false + diagnostics_profile: + description: + - Should VM Diagnostics be enabled for the Container Service VM's. + required: true + default: false + +extends_documentation_fragment: + - azure + - azure_tags + +author: + - "Julien Stroheker (@julienstroheker)" + +''' + +EXAMPLES = ''' + - name: Create an azure container services instance running Kubernetes + azure_rm_acs: + name: acctestcontservice1 + location: eastus + resource_group: Testing + orchestration_platform: Kubernetes + master_profile: + - count: 3 + dns_prefix: acsk8smasterdns + linux_profile: + - admin_username: azureuser + ssh_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAA... + service_principal: + - client_id: "cf72ca99-f6b9-4004-b0e0-bee10c521948" + client_secret: "mySPNp@ssw0rd!" + agent_pool_profiles: + - name: default + count: 5 + dns_prefix: acsk8sagent + vm_size: Standard_D2_v2 + diagnostics_profile: false + tags: + Environment: Production + + - name: Create an azure container services instance running DCOS + azure_rm_acs: + name: acctestcontservice2 + location: eastus + resource_group: Testing + orchestration_platform: DCOS + master_profile: + - count: 3 + dns_prefix: acsdcosmasterdns + linux_profile: + - admin_username: azureuser + ssh_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAA... + agent_pool_profiles: + - name: default + count: 5 + dns_prefix: acscdcosagent + vm_size: Standard_D2_v2 + diagnostics_profile: false + tags: + Environment: Production + + - name: Create an azure container services instance running Swarm + azure_rm_acs: + name: acctestcontservice3 + location: eastus + resource_group: Testing + orchestration_platform: Swarm + master_profile: + - count: 3 + dns_prefix: acsswarmmasterdns + linux_profile: + - admin_username: azureuser + ssh_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAA... + agent_pool_profiles: + - name: default + count: 5 + dns_prefix: acsswarmagent + vm_size: Standard_D2_v2 + diagnostics_profile: false + tags: + Environment: Production + +# Deletes the specified container service in the specified subscription and resource group. +# The operation does not delete other resources created as part of creating a container service, +# including storage accounts, VMs, and availability sets. All the other resources created with the container +# service are part of the same resource group and can be deleted individually. + - name: Remove an azure container services instance + azure_rm_acs: + name: acctestcontservice3 + location: eastus + resource_group: Testing + state: absent + orchestration_platform: Swarm + master_profile: + - count: 1 + dns_prefix: acstestingmasterdns5 + linux_profile: + - admin_username: azureuser + ssh_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAA... + service_principal: + - client_id: 7fb4173c-3ca3-4d5b-87f8-1daac941207a + client_secret: MPNSuM1auUuITefiLGBrpZZnLMDKBLw2 + agent_pool_profiles: + - name: default + count: 4 + dns_prefix: acctestagent15 + vm_size: Standard_A0 + diagnostics_profile: false + tags: + Ansible: azure_rm_acs +''' +RETURN = ''' +state: + description: Current state of the azure container service + returned: always + type: dict +''' + +from ansible.module_utils.azure_rm_common import AzureRMModuleBase + +try: + from msrestazure.azure_exceptions import CloudError + from azure.mgmt.containerservice.models import ( + ContainerService, ContainerServiceOrchestratorProfile, ContainerServiceCustomProfile, + ContainerServiceServicePrincipalProfile, ContainerServiceMasterProfile, + ContainerServiceAgentPoolProfile, ContainerServiceWindowsProfile, + ContainerServiceLinuxProfile, ContainerServiceSshConfiguration, + ContainerServiceDiagnosticsProfile, ContainerServiceSshPublicKey, + ContainerServiceVMDiagnostics + ) +except ImportError: + # This is handled in azure_rm_common + pass + + +def create_agent_pool_profile_instance(agentpoolprofile): + ''' + Helper method to serialize a dict to a ContainerServiceAgentPoolProfile + :param: agentpoolprofile: dict with the parameters to setup the ContainerServiceAgentPoolProfile + :return: ContainerServiceAgentPoolProfile + ''' + return ContainerServiceAgentPoolProfile( + name=agentpoolprofile['name'], + count=agentpoolprofile['count'], + dns_prefix=agentpoolprofile['dns_prefix'], + vm_size=agentpoolprofile['vm_size'] + ) + + +def create_orch_platform_instance(orchestrator): + ''' + Helper method to serialize a dict to a ContainerServiceOrchestratorProfile + :param: orchestrator: dict with the parameters to setup the ContainerServiceOrchestratorProfile + :return: ContainerServiceOrchestratorProfile + ''' + return ContainerServiceOrchestratorProfile( + orchestrator_type=orchestrator, + ) + + +def create_service_principal_profile_instance(spnprofile): + ''' + Helper method to serialize a dict to a ContainerServiceServicePrincipalProfile + :param: spnprofile: dict with the parameters to setup the ContainerServiceServicePrincipalProfile + :return: ContainerServiceServicePrincipalProfile + ''' + return ContainerServiceServicePrincipalProfile( + client_id=spnprofile[0]['client_id'], + secret=spnprofile[0]['client_secret'] + ) + + +def create_linux_profile_instance(linuxprofile): + ''' + Helper method to serialize a dict to a ContainerServiceLinuxProfile + :param: linuxprofile: dict with the parameters to setup the ContainerServiceLinuxProfile + :return: ContainerServiceLinuxProfile + ''' + return ContainerServiceLinuxProfile( + admin_username=linuxprofile[0]['admin_username'], + ssh=create_ssh_configuration_instance(linuxprofile[0]['ssh_key']) + ) + + +def create_ssh_configuration_instance(sshconf): + ''' + Helper method to serialize a dict to a ContainerServiceSshConfiguration + :param: sshconf: dict with the parameters to setup the ContainerServiceSshConfiguration + :return: ContainerServiceSshConfiguration + ''' + listssh = [] + key = ContainerServiceSshPublicKey(key_data=str(sshconf)) + listssh.append(key) + return ContainerServiceSshConfiguration( + public_keys=listssh + ) + + +def create_master_profile_instance(masterprofile): + ''' + Helper method to serialize a dict to a ContainerServiceMasterProfile + :param: masterprofile: dict with the parameters to setup the ContainerServiceMasterProfile + :return: ContainerServiceMasterProfile + ''' + return ContainerServiceMasterProfile( + count=masterprofile[0]['count'], + dns_prefix=masterprofile[0]['dns_prefix'] + ) + + +def create_diagnostics_profile_instance(diagprofile): + ''' + Helper method to serialize a dict to a ContainerServiceDiagnosticsProfile + :param: diagprofile: dict with the parameters to setup the ContainerServiceDiagnosticsProfile + :return: ContainerServiceDiagnosticsProfile + ''' + return ContainerServiceDiagnosticsProfile( + vm_diagnostics=create_vm_diagnostics_instance(diagprofile) + ) + + +def create_vm_diagnostics_instance(vmdiag): + ''' + Helper method to serialize a dict to a ContainerServiceVMDiagnostics + :param: vmdiag: dict with the parameters to setup the ContainerServiceVMDiagnostics + :return: ContainerServiceVMDiagnostics + ''' + return ContainerServiceVMDiagnostics( + enabled=vmdiag + ) + + +def create_acs_dict(acs): + ''' + Helper method to deserialize a ContainerService to a dict + :param: acs: ContainerService or AzureOperationPoller with the Azure callback object + :return: dict with the state on Azure + ''' + results = dict( + id=acs.id, + name=acs.name, + location=acs.location, + tags=acs.tags, + orchestrator_profile=create_orchestrator_profile_dict(acs.orchestrator_profile), + master_profile=create_master_profile_dict(acs.master_profile), + linux_profile=create_linux_profile_dict(acs.linux_profile), + service_principal_profile=acs.service_principal_profile, + diagnostics_profile=create_diagnotstics_profile_dict(acs.diagnostics_profile), + provisioning_state=acs.provisioning_state, + agent_pool_profiles=create_agent_pool_profiles_dict(acs.agent_pool_profiles), + type=acs.type + ) + return results + + +def create_linux_profile_dict(linuxprofile): + ''' + Helper method to deserialize a ContainerServiceLinuxProfile to a dict + :param: linuxprofile: ContainerServiceLinuxProfile with the Azure callback object + :return: dict with the state on Azure + ''' + results = dict( + ssh_key=linuxprofile.ssh.public_keys[0].key_data, + admin_username=linuxprofile.admin_username + ) + return results + + +def create_master_profile_dict(masterprofile): + ''' + Helper method to deserialize a ContainerServiceMasterProfile to a dict + :param: masterprofile: ContainerServiceMasterProfile with the Azure callback object + :return: dict with the state on Azure + ''' + results = dict( + count=masterprofile.count, + fqdn=masterprofile.fqdn, + dns_prefix=masterprofile.dns_prefix + ) + return results + + +def create_diagnotstics_profile_dict(diagnosticsprofile): + ''' + Helper method to deserialize a ContainerServiceVMDiagnostics to a dict + :param: diagnosticsprofile: ContainerServiceVMDiagnostics with the Azure callback object + :return: dict with the state on Azure + ''' + results = dict( + vm_diagnostics=diagnosticsprofile.vm_diagnostics.enabled + ) + return results + + +def create_orchestrator_profile_dict(orchestratorprofile): + ''' + Helper method to deserialize a ContainerServiceOrchestratorProfile to a dict + :param: orchestratorprofile: ContainerServiceOrchestratorProfile with the Azure callback object + :return: dict with the state on Azure + ''' + results = dict( + orchestrator_type=str(orchestratorprofile.orchestrator_type) + ) + return results + + +def create_agent_pool_profiles_dict(agentpoolprofiles): + ''' + Helper method to deserialize a ContainerServiceAgentPoolProfile to a dict + :param: agentpoolprofiles: ContainerServiceAgentPoolProfile with the Azure callback object + :return: dict with the state on Azure + ''' + results = [] + for profile in agentpoolprofiles: + result = dict( + count=profile.count, + vm_size=profile.vm_size, + name=profile.name, + dns_prefix=profile.dns_prefix, + fqdn=profile.fqdn + ) + results.append(result) + return results + + +class AzureRMContainerService(AzureRMModuleBase): + """Configuration class for an Azure RM container service resource""" + + def __init__(self): + self.module_arg_spec = dict( + resource_group=dict( + type='str', + required=True + ), + name=dict( + type='str', + required=True + ), + state=dict( + type='str', + required=False, + default='present', + choices=['present', 'absent'] + ), + location=dict( + type='str', + required=False + ), + orchestration_platform=dict( + type='str', + required=True, + choices=['DCOS', 'Kubernetes', 'Swarm'] + ), + master_profile=dict( + type='list', + required=True + ), + linux_profile=dict( + type='list', + required=True + ), + agent_pool_profiles=dict( + type='list', + required=True + ), + service_principal=dict( + type='list', + required=False + ), + diagnostics_profile=dict( + type='bool', + required=True + ) + ) + + self.resource_group = None + self.name = None + self.location = None + self.tags = None + self.state = None + self.orchestration_platform = None + self.master_profile = None + self.linux_profile = None + self.agent_pool_profiles = None + self.service_principal = None + self.diagnostics_profile = None + + self.results = dict(changed=False, state=dict()) + + super(AzureRMContainerService, self).__init__(derived_arg_spec=self.module_arg_spec, + supports_check_mode=True, + supports_tags=True) + + def exec_module(self, **kwargs): + """Main module execution method""" + + for key in list(self.module_arg_spec.keys()) + ['tags']: + setattr(self, key, kwargs[key]) + + resource_group = None + response = None + results = dict() + to_be_updated = False + + try: + resource_group = self.get_resource_group(self.resource_group) + except CloudError: + self.fail('resource group {} not found'.format(self.resource_group)) + if not self.location: + self.location = resource_group.location + + # Check if the ACS instance already present in the RG + if self.state == 'present': + + if self.orchestration_platform == 'Kubernetes': + if not self.service_principal: + self.fail('service_principal should be specified when using Kubernetes') + if not self.service_principal[0].get('client_id'): + self.fail('service_principal.client_id should be specified when using Kubernetes') + if not self.service_principal[0].get('client_secret'): + self.fail('service_principal.client_secret should be specified when using Kubernetes') + + mastercount = self.master_profile[0].get('count') + if mastercount != 1 and mastercount != 3 and mastercount != 5: + self.fail('Master Count number wrong : {} / should be 1 3 or 5'.format(mastercount)) + + # For now Agent Pool cannot be more than 1, just remove this part in the future if it change + agentpoolcount = len(self.agent_pool_profiles) + if agentpoolcount > 1: + self.fail('You cannot specify more than agent_pool_profiles') + + response = self.get_acs() + self.results['state'] = response + if not response: + to_be_updated = True + + else: + self.log('Results : {0}'.format(response)) + update_tags, response['tags'] = self.update_tags(response['tags']) + + if response['provisioning_state'] == "Succeeded": + if update_tags: + to_be_updated = True + + # Cannot Update the master count for now // Uncomment this block in the future to support it + if response['master_profile'].get('count') != self.master_profile[0].get('count'): + # self.log(("Master Profile Count Diff, Was {0} / Now {1}" + # .format(response['master_profile'].count, + # self.master_profile[0].get('count')))) + # to_be_updated = True + self.module.warn("master_profile.count cannot be updated") + + # Cannot Update the SSH Key for now // Uncomment this block in the future to support it + if response['linux_profile'].get('ssh_key') != self.linux_profile[0].get('ssh_key'): + # self.log(("Linux Profile Diff SSH, Was {0} / Now {1}" + # .format(response['linux_profile'].ssh.public_keys[0].key_data, + # self.linux_profile[0].get('ssh_key')))) + # to_be_updated = True + self.module.warn("linux_profile.ssh_key cannot be updated") + + # self.log("linux_profile response : {0}".format(response['linux_profile'].get('admin_username'))) + # self.log("linux_profile self : {0}".format(self.linux_profile[0].get('admin_username'))) + # Cannot Update the Username for now // Uncomment this block in the future to support it + if response['linux_profile'].get('admin_username') != self.linux_profile[0].get('admin_username'): + # self.log(("Linux Profile Diff User, Was {0} / Now {1}" + # .format(response['linux_profile'].admin_username, + # self.linux_profile[0].get('admin_username')))) + # to_be_updated = True + self.module.warn("linux_profile.admin_username cannot be updated") + + # Cannot have more that one agent pool profile for now // Uncomment this block in the future to support it + # if len(response['agent_pool_profiles']) != len(self.agent_pool_profiles): + # self.log("Agent Pool count is diff, need to updated") + # to_be_updated = True + + for profile_result in response['agent_pool_profiles']: + matched = False + for profile_self in self.agent_pool_profiles: + if profile_result['name'] == profile_self['name']: + matched = True + if profile_result['count'] != profile_self['count'] or profile_result['vm_size'] != profile_self['vm_size']: + self.log(("Agent Profile Diff - Count was {0} / Now {1} - Vm_size was {2} / Now {3}" + .format(profile_result['count'], profile_self['count'], + profile_result['vm_size'], profile_self['vm_size']))) + to_be_updated = True + if not matched: + self.log("Agent Pool not found") + to_be_updated = True + + if to_be_updated: + self.log("Need to Create / Update the ACS instance") + + if self.check_mode: + return self.results + + self.results['state'] = self.create_update_acs() + self.results['changed'] = True + + self.log("Creation / Update done") + elif self.state == 'absent': + self.delete_acs() + self.log("ACS instance deleted") + + return self.results + + def create_update_acs(self): + ''' + Creates or updates a container service with the specified configuration of orchestrator, masters, and agents. + + :return: deserialized ACS instance state dictionary + ''' + self.log("Creating / Updating the ACS instance {0}".format(self.name)) + + service_principal_profile = None + agentpools = [] + + if self.agent_pool_profiles: + for profile in self.agent_pool_profiles: + self.log("Trying to push the following Profile {0}".format(profile)) + agentpools.append(create_agent_pool_profile_instance(profile)) + + if self.orchestration_platform == 'Kubernetes': + service_principal_profile = create_service_principal_profile_instance(self.service_principal) + + parameters = ContainerService( + location=self.location, + tags=self.tags, + orchestrator_profile=create_orch_platform_instance(self.orchestration_platform), + service_principal_profile=service_principal_profile, + linux_profile=create_linux_profile_instance(self.linux_profile), + master_profile=create_master_profile_instance(self.master_profile), + agent_pool_profiles=agentpools, + diagnostics_profile=create_diagnostics_profile_instance(self.diagnostics_profile) + ) + + # self.log("orchestrator_profile : {0}".format(parameters.orchestrator_profile)) + # self.log("service_principal_profile : {0}".format(parameters.service_principal_profile)) + # self.log("linux_profile : {0}".format(parameters.linux_profile)) + # self.log("ssh from yaml : {0}".format(results.get('linux_profile')[0])) + # self.log("ssh : {0}".format(parameters.linux_profile.ssh)) + # self.log("master_profile : {0}".format(parameters.master_profile)) + # self.log("agent_pool_profiles : {0}".format(parameters.agent_pool_profiles)) + # self.log("vm_diagnostics : {0}".format(parameters.diagnostics_profile.vm_diagnostics)) + + try: + poller = self.containerservice_client.container_services.create_or_update(self.resource_group, self.name, parameters) + response = self.get_poller_result(poller) + except CloudError as exc: + self.log('Error attempting to create the ACS instance.') + self.fail("Error creating the ACS instance: {0}".format(str(exc))) + return create_acs_dict(response) + + def delete_acs(self): + ''' + Deletes the specified container service in the specified subscription and resource group. + The operation does not delete other resources created as part of creating a container service, + including storage accounts, VMs, and availability sets. + All the other resources created with the container service are part of the same resource group and can be deleted individually. + + :return: True + ''' + self.log("Deleting the ACS instance {0}".format(self.name)) + try: + poller = self.containerservice_client.container_services.delete(self.resource_group, self.name) + self.get_poller_result(poller) + except CloudError as e: + self.log('Error attempting to delete the ACS instance.') + self.fail("Error deleting the ACS instance: {0}".format(str(e))) + + return True + + def get_acs(self): + ''' + Gets the properties of the specified container service. + + :return: deserialized ACS instance state dictionary + ''' + self.log("Checking if the ACS instance {0} is present".format(self.name)) + found = False + try: + response = self.containerservice_client.container_services.get(self.resource_group, self.name) + found = True + self.log("Response : {0}".format(response)) + self.log("ACS instance : {0} found".format(response.name)) + except CloudError as e: + self.log('Did not find the ACS instance.') + if found is True: + return create_acs_dict(response) + else: + return False + + +def main(): + """Main execution""" + AzureRMContainerService() + +if __name__ == '__main__': + main() diff --git a/packaging/requirements/requirements-azure.txt b/packaging/requirements/requirements-azure.txt index a586e99f2d..fb2b8a7ab7 100644 --- a/packaging/requirements/requirements-azure.txt +++ b/packaging/requirements/requirements-azure.txt @@ -12,3 +12,4 @@ azure-mgmt-keyvault>=0.40.0,<0.41 azure-mgmt-batch>=4.1.0,<5 azure-mgmt-sql>=0.7.1,<0.8 azure-mgmt-web>=0.32.0,<0.33 +azure-mgmt-containerservice>=1.0.0 \ No newline at end of file diff --git a/test/integration/targets/azure_rm_acs/aliases b/test/integration/targets/azure_rm_acs/aliases new file mode 100644 index 0000000000..b1cd4a5978 --- /dev/null +++ b/test/integration/targets/azure_rm_acs/aliases @@ -0,0 +1,2 @@ +cloud/azure +destructive diff --git a/test/integration/targets/azure_rm_acs/meta/main.yml b/test/integration/targets/azure_rm_acs/meta/main.yml new file mode 100644 index 0000000000..95e1952f98 --- /dev/null +++ b/test/integration/targets/azure_rm_acs/meta/main.yml @@ -0,0 +1,2 @@ +dependencies: + - setup_azure diff --git a/test/integration/targets/azure_rm_acs/tasks/main.yml b/test/integration/targets/azure_rm_acs/tasks/main.yml new file mode 100644 index 0000000000..b59ada099f --- /dev/null +++ b/test/integration/targets/azure_rm_acs/tasks/main.yml @@ -0,0 +1,143 @@ + - name: Create an ACS instance - DCOS + azure_rm_acs: + name: "acsdcos{{ resource_group | hash('md5') | truncate(7, True, '') }}" + resource_group: "{{ resource_group }}" + location: eastus2 + orchestration_platform: DCOS + master_profile: + - count: 1 + dns_prefix: "acsdcos{{ resource_group | hash('md5') | truncate(10, True, '') }}" + linux_profile: + - admin_username: azureuser + ssh_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCqaZoyiz1qbdOQ8xEf6uEu1cCwYowo5FHtsBhqLoDnnp7KUTEBN+io238wdhjkasndq238e2/983289dasjnasey823/YkUCuzxDpsH7DUDhZcwySLKVVe0Qm3+928dfsjsejk298r/+vAnflKebuypNlmocIvakFWoZda18FOmsOoIVXQ8HWFNCuw9ZCunMSN62QGamCe3dL5cXlkgHYv7ekJE15IA9aOJcM7e90oeTqo+dsajda82e78sdja/llas8tsXY85LFqRnr3gJ02bAscjc477+X+j/gkpFoN1QEmt juliens@msft.com + agent_pool_profiles: + - name: default + count: 1 + dns_prefix: "acsdcos{{ resource_group | hash('md5') | truncate(12, True, '') }}" + vm_size: Standard_A0 + diagnostics_profile: false + register: output + + - name: Assert the ACS instance is well created + assert: + that: + - output.changed + - output.state.provisioning_state == 'Succeeded' + + - name: Scale the ACS instance from 1 to 2 - DCOS + azure_rm_acs: + name: "acsdcos{{ resource_group | hash('md5') | truncate(7, True, '') }}" + resource_group: "{{ resource_group }}" + location: eastus2 + orchestration_platform: DCOS + master_profile: + - count: 1 + dns_prefix: "acsdcos{{ resource_group | hash('md5') | truncate(10, True, '') }}" + linux_profile: + - admin_username: azureuser + ssh_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCqaZoyiz1qbdOQ8xEf6uEu1cCwYowo5FHtsBhqLoDnnp7KUTEBN+io238wdhjkasndq238e2/983289dasjnasey823/YkUCuzxDpsH7DUDhZcwySLKVVe0Qm3+928dfsjsejk298r/+vAnflKebuypNlmocIvakFWoZda18FOmsOoIVXQ8HWFNCuw9ZCunMSN62QGamCe3dL5cXlkgHYv7ekJE15IA9aOJcM7e90oeTqo+dsajda82e78sdja/llas8tsXY85LFqRnr3gJ02bAscjc477+X+j/gkpFoN1QEmt juliens@msft.com + agent_pool_profiles: + - name: default + count: 2 + dns_prefix: "acsdcos{{ resource_group | hash('md5') | truncate(12, True, '') }}" + vm_size: Standard_A0 + diagnostics_profile: false + register: output + + - name: Assert the ACS instance is well scaled + assert: + that: + - output.changed + - output.state.agent_pool_profiles[0].count == 2 + + - name: Delete the DCOS ACS instance - DCOS + azure_rm_acs: + name: "acsdcos{{ resource_group | hash('md5') | truncate(7, True, '') }}" + resource_group: "{{ resource_group }}" + location: eastus2 + orchestration_platform: DCOS + state: absent + master_profile: + - count: 1 + dns_prefix: "acsdcos{{ resource_group | hash('md5') | truncate(10, True, '') }}" + linux_profile: + - admin_username: azureuser + ssh_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCqaZoyiz1qbdOQ8xEf6uEu1cCwYowo5FHtsBhqLoDnnp7KUTEBN+io238wdhjkasndq238e2/983289dasjnasey823/YkUCuzxDpsH7DUDhZcwySLKVVe0Qm3+928dfsjsejk298r/+vAnflKebuypNlmocIvakFWoZda18FOmsOoIVXQ8HWFNCuw9ZCunMSN62QGamCe3dL5cXlkgHYv7ekJE15IA9aOJcM7e90oeTqo+dsajda82e78sdja/llas8tsXY85LFqRnr3gJ02bAscjc477+X+j/gkpFoN1QEmt juliens@msft.com + agent_pool_profiles: + - name: default + count: 2 + dns_prefix: "acsdcos{{ resource_group | hash('md5') | truncate(12, True, '') }}" + vm_size: Standard_A0 + diagnostics_profile: false + + - name: Create an ACS instance - Swarm + azure_rm_acs: + name: "acssw{{ resource_group | hash('md5') | truncate(7, True, '') }}" + resource_group: "{{ resource_group }}" + location: eastus2 + orchestration_platform: Swarm + master_profile: + - count: 1 + dns_prefix: "acssw{{ resource_group | hash('md5') | truncate(10, True, '') }}" + linux_profile: + - admin_username: azureuser + ssh_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCqaZoyiz1qbdOQ8xEf6uEu1cCwYowo5FHtsBhqLoDnnp7KUTEBN+io238wdhjkasndq238e2/983289dasjnasey823/YkUCuzxDpsH7DUDhZcwySLKVVe0Qm3+928dfsjsejk298r/+vAnflKebuypNlmocIvakFWoZda18FOmsOoIVXQ8HWFNCuw9ZCunMSN62QGamCe3dL5cXlkgHYv7ekJE15IA9aOJcM7e90oeTqo+dsajda82e78sdja/llas8tsXY85LFqRnr3gJ02bAscjc477+X+j/gkpFoN1QEmt juliens@msft.com + agent_pool_profiles: + - name: default + count: 1 + dns_prefix: "acssw{{ resource_group | hash('md5') | truncate(12, True, '') }}" + vm_size: Standard_A0 + diagnostics_profile: false + register: output + + - name: Assert the ACS instance is well created + assert: + that: + - output.changed + - output.state.provisioning_state == 'Succeeded' + + - name: Scale the ACS instance from 1 to 2 - Swarm + azure_rm_acs: + name: "acssw{{ resource_group | hash('md5') | truncate(7, True, '') }}" + resource_group: "{{ resource_group }}" + location: eastus2 + orchestration_platform: Swarm + master_profile: + - count: 1 + dns_prefix: "acssw{{ resource_group | hash('md5') | truncate(10, True, '') }}" + linux_profile: + - admin_username: azureuser + ssh_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCqaZoyiz1qbdOQ8xEf6uEu1cCwYowo5FHtsBhqLoDnnp7KUTEBN+io238wdhjkasndq238e2/983289dasjnasey823/YkUCuzxDpsH7DUDhZcwySLKVVe0Qm3+928dfsjsejk298r/+vAnflKebuypNlmocIvakFWoZda18FOmsOoIVXQ8HWFNCuw9ZCunMSN62QGamCe3dL5cXlkgHYv7ekJE15IA9aOJcM7e90oeTqo+dsajda82e78sdja/llas8tsXY85LFqRnr3gJ02bAscjc477+X+j/gkpFoN1QEmt juliens@msft.com + agent_pool_profiles: + - name: default + count: 2 + dns_prefix: "acssw{{ resource_group | hash('md5') | truncate(12, True, '') }}" + vm_size: Standard_A0 + diagnostics_profile: false + register: output + + - name: Assert the ACS instance is well scaled + assert: + that: + - output.changed + - output.state.agent_pool_profiles[0].count == 2 + + - name: Delete the ACS instance - Swarm + azure_rm_acs: + name: "acssw{{ resource_group | hash('md5') | truncate(7, True, '') }}" + resource_group: "{{ resource_group }}" + location: eastus2 + orchestration_platform: Swarm + state: absent + master_profile: + - count: 1 + dns_prefix: "acssw{{ resource_group | hash('md5') | truncate(10, True, '') }}" + linux_profile: + - admin_username: azureuser + ssh_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCqaZoyiz1qbdOQ8xEf6uEu1cCwYowo5FHtsBhqLoDnnp7KUTEBN+io238wdhjkasndq238e2/983289dasjnasey823/YkUCuzxDpsH7DUDhZcwySLKVVe0Qm3+928dfsjsejk298r/+vAnflKebuypNlmocIvakFWoZda18FOmsOoIVXQ8HWFNCuw9ZCunMSN62QGamCe3dL5cXlkgHYv7ekJE15IA9aOJcM7e90oeTqo+dsajda82e78sdja/llas8tsXY85LFqRnr3gJ02bAscjc477+X+j/gkpFoN1QEmt juliens@msft.com + agent_pool_profiles: + - name: default + count: 2 + dns_prefix: "acssw{{ resource_group | hash('md5') | truncate(12, True, '') }}" + vm_size: Standard_A0 + diagnostics_profile: false \ No newline at end of file