def init_services(self):
"""Delay imports and activation of Azure RM services until needed."""
from azure.common.credentials import ServicePrincipalCredentials
from azure.mgmt.resource.resources import (
ResourceManagementClient,
ResourceManagementClientConfiguration,
)
from azure.mgmt.storage import (
StorageManagementClient,
StorageManagementClientConfiguration,
)
from azure.mgmt.compute import (
ComputeManagementClient,
ComputeManagementClientConfiguration,
)
from azure.mgmt.network import (
NetworkManagementClient,
NetworkManagementClientConfiguration,
)
self.credentials = ServicePrincipalCredentials(
client_id=self.client_id, secret=self.secret, tenant=self.tenant)
self.storage = StorageManagementClient(
StorageManagementClientConfiguration(self.credentials,
self.subscription_id))
self.resource = ResourceManagementClient(
ResourceManagementClientConfiguration(self.credentials,
self.subscription_id))
self.compute = ComputeManagementClient(
ComputeManagementClientConfiguration(self.credentials,
self.subscription_id))
self.network = NetworkManagementClient(
NetworkManagementClientConfiguration(self.credentials,
self.subscription_id))
def prepare_network_security_group(settings, static_ip, nsg_name, rules):
credentials = ServicePrincipalCredentials(client_id=settings["CLIENT_ID"],
secret=settings["CLIENT_SECRET"],
tenant=settings["TENANT_ID"])
network_client = NetworkManagementClient(
NetworkManagementClientConfiguration(credentials,
settings["SUBSCRIPTION_ID"]))
priority = 200
for protocol in rules:
for name, port in rules[protocol].items():
params = azure.mgmt.network.models.SecurityRule(
protocol,
'*',
static_ip + "/32",
'Allow',
'Inbound',
source_port_range='*',
destination_port_range=port,
priority=priority,
name=name)
priority += 1
ret = network_client.security_rules.create_or_update(
settings["RESOURCE_GROUP_NAME"], nsg_name, name, params)
ret.wait()
def network_client(self):
from azure.mgmt.network import (NetworkManagementClient,
NetworkManagementClientConfiguration)
return NetworkManagementClient(
NetworkManagementClientConfiguration(self.azure_credentials,
self.env.subscription_id))
def get_virtual_network_details(subscription_id, creds, resource_group_name, network_name):
network_client = NetworkManagementClient(NetworkManagementClientConfiguration(creds, subscription_id))
model = VirtualNetworkDetails(
name=network_name,
network=network_client.virtual_networks.get(resource_group_name, network_name),
)
return model
def get_resource_group_details(subscription_id, creds, resource_group_name):
storage_client = StorageManagementClient(StorageManagementClientConfiguration(creds, subscription_id))
resource_client = ResourceManagementClient(ResourceManagementClientConfiguration(creds, subscription_id))
compute_client = ComputeManagementClient(ComputeManagementClientConfiguration(creds, subscription_id))
network_client = NetworkManagementClient(NetworkManagementClientConfiguration(creds, subscription_id))
model = ResourceGroupDetails()
model.storage_accounts = list(storage_client.storage_accounts.list_by_resource_group(resource_group_name))
provider = resource_client.providers.get('Microsoft.Storage')
resource_type = [r for r in provider.resource_types if r.resource_type == 'storageAccounts'][0]
model.storage_accounts_locations = resource_type.locations
# TODO: make an iterate function
model.vms = list(compute_client.virtual_machines.list(resource_group_name))
model.public_ip_addresses = list(network_client.public_ip_addresses.list(resource_group_name))
model.virtual_networks = list(network_client.virtual_networks.list(resource_group_name))
return model
def main():
argument_spec = dict(azure_url=dict(default=AZURE_URL),
subscription_id=dict(required=False),
client_secret=dict(no_log=True),
client_id=dict(),
tenant_or_domain=dict(),
security_token=dict(aliases=['access_token'],
no_log=True),
resource_group_name=dict(required=True),
state=dict(default='present',
choices=['present', 'absent']),
template=dict(default=None, type='dict'),
parameters=dict(default=None, type='dict'),
template_link=dict(default=None),
parameters_link=dict(default=None),
location=dict(default="West US"))
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=[['template_link', 'template'],
['parameters_link', 'parameters']],
)
if not HAS_DEPS:
module.fail_json(msg='requests and azure are required for this module')
conn_info = get_azure_connection_info(module)
if conn_info['security_token'] is None and \
(conn_info['client_id'] is None or conn_info['client_secret'] is None or conn_info[
'tenant_or_domain'] is None):
module.fail_json(
msg=
'security token or client_id, client_secret and tenant_or_domain is required'
)
if conn_info['security_token'] is None:
conn_info['security_token'] = get_token(conn_info['tenant_or_domain'],
conn_info['client_id'],
conn_info['client_secret'])
if conn_info['security_token'] is None:
module.fail_json(
msg=
'failed to retrieve a security token from Azure Active Directory')
credentials = BasicTokenAuthentication(
token={'access_token': conn_info['security_token']})
subscription_id = module.params.get('subscription_id')
resource_client = ResourceManagementClient(
ResourceManagementClientConfiguration(credentials, subscription_id))
network_client = NetworkManagementClient(
NetworkManagementClientConfiguration(credentials, subscription_id))
conn_info['deployment_name'] = 'ansible-arm'
if module.params.get('state') == 'present':
deployment = deploy_template(module, resource_client, conn_info)
data = dict(name=deployment.name,
group_name=conn_info['resource_group_name'],
id=deployment.id,
outputs=deployment.properties.outputs,
instances=get_instances(network_client,
conn_info['resource_group_name'],
deployment),
changed=True,
msg='deployment created')
dir(data)
module.exit_json(**data)
else:
destroy_resource_group(module, resource_client, conn_info)
module.exit_json(changed=True, msg='deployment deleted')
def main():
argument_spec = dict(azure_url=dict(default=AZURE_URL),
subscription_id=dict(),
client_secret=dict(no_log=True),
client_id=dict(required=True),
tenant_id=dict(required=True),
resource_group_name=dict(required=True),
state=dict(default='present',
choices=['present', 'absent']),
template=dict(default=None, type='dict'),
parameters=dict(default=None, type='dict'),
template_link=dict(default=None),
parameters_link=dict(default=None),
location=dict(default="West US"),
deployment_mode=dict(
default='Complete',
choices=['Complete', 'Incremental']),
deployment_name=dict(default="ansible-arm"),
wait_for_deployment_completion=dict(default=True),
wait_for_deployment_polling_period=dict(default=30))
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=[['template_link', 'template'],
['parameters_link', 'parameters']],
)
if not HAS_DEPS:
module.fail_json(msg='requests and azure are required for this module')
conn_info = get_azure_connection_info(module)
credentials = ServicePrincipalCredentials(
client_id=conn_info['client_id'],
secret=conn_info['client_secret'],
tenant=conn_info['tenant_id'])
subscription_id = conn_info['subscription_id']
resource_configuration = ResourceManagementClientConfiguration(
credentials, subscription_id)
resource_configuration.add_user_agent('Ansible-Deploy')
resource_client = ResourceManagementClient(resource_configuration)
network_configuration = NetworkManagementClientConfiguration(
credentials, subscription_id)
network_configuration.add_user_agent('Ansible-Deploy')
network_client = NetworkManagementClient(network_configuration)
conn_info['deployment_name'] = module.params.get('deployment_name')
if module.params.get('state') == 'present':
deployment = deploy_template(module, resource_client, conn_info)
data = dict(name=deployment.name,
group_name=conn_info['resource_group_name'],
id=deployment.id,
outputs=deployment.properties.outputs,
instances=get_instances(network_client,
conn_info['resource_group_name'],
deployment),
changed=True,
msg='deployment created')
module.exit_json(**data)
else:
destroy_resource_group(module, resource_client, conn_info)
module.exit_json(changed=True, msg='deployment deleted')
__author__ = 'rafael'
# TODO: Install library
from azure.mgmt.compute import ComputeManagementClient, ComputeManagementClientConfiguration
from azure.mgmt.network import NetworkManagementClient, NetworkManagementClientConfiguration
# TODO: Replace this with your subscription id
subscription_id = '33333333-3333-3333-3333-333333333333'
# TODO: See above how to get a Credentials instance
credentials = ...
compute_client = ComputeManagementClient(
ComputeManagementClientConfiguration(credentials, subscription_id))
network_client = NetworkManagementClient(
NetworkManagementClientConfiguration(credentials, subscription_id))