def _ex_create_subnet(self, cidr, network_name, name):
"""
Create a subnet
"""
data = {
"properties": {
"addressPrefix": cidr
}
}
subscription = self.provider.connection.subscription_id
resource_group = self.resource_group
action = f"/subscriptions/{subscription}/resourceGroups/" \
f"{resource_group}/providers/" \
f"Microsoft.Network/virtualNetworks/" \
f"{network_name}/subnets/{name}"
r = self.provider.connection.request(
action,
params=self.api_version,
method="PUT",
data=data
)
return AzureSubnet(
id=r.object["id"],
name=r.object["name"],
extra=r.object["properties"]
)
def _ex_create_subnet(self, cidr, network_name, name):
"""
Create a subnet
"""
data = {
"properties": {
"addressPrefix": cidr
}
}
action = "/subscriptions/%s/resourceGroups/%s/providers/" \
"Microsoft.Network/virtualNetworks/%s/subnets/%s" \
% (self.provider.connection.subscription_id, self.resource_group, network_name, name)
r = self.provider.connection.request(
action,
params={"api-version": "2018-08-01"},
method="PUT",
data=data
)
return AzureSubnet(
id=r.object["id"],
name=r.object["name"],
extra=r.object["properties"]
)
def ex_create_subnet(self,
resource_group,
cidr_block,
network_name,
name=None):
data = {"properties": {"addressPrefix": cidr_block}}
action = "/subscriptions/%s/resourceGroups/%s/providers/" \
"Microsoft.Network/virtualNetworks/%s/subnets/%s" \
% (self.connection.subscription_id, resource_group, network_name, name)
r = self.connection.request(action,
params={"api-version": "2017-03-01"},
method="PUT",
data=data)
return AzureSubnet(r.object["id"], r.object["name"],
r.object["properties"])
def create_node(self,
name,
size,
image,
auth,
ex_resource_group,
ex_storage_account,
ex_blob_container="vhds",
location=None,
ex_user_name="azureuser",
ex_network=None,
ex_subnet=None,
ex_nic=None,
ex_tags={},
ex_customdata=""):
"""Create a new node instance. This instance will be started
automatically.
This driver supports the ``ssh_key`` feature flag for ``created_node``
so you can upload a public key into the new instance::
>>> from libcloud.compute.drivers.azure_arm import AzureNodeDriver
>>> driver = AzureNodeDriver(...)
>>> auth = NodeAuthSSHKey('pubkey data here')
>>> node = driver.create_node("test_node", auth=auth)
This driver also supports the ``password`` feature flag for
``create_node``
so you can set a password::
>>> driver = AzureNodeDriver(...)
>>> auth = NodeAuthPassword('mysecretpassword')
>>> node = driver.create_node("test_node", auth=auth, ...)
If you don't provide the ``auth`` argument libcloud will assign
a password::
>>> driver = AzureNodeDriver(...)
>>> node = driver.create_node("test_node", ...)
>>> password = node.extra["properties"] \
["osProfile"]["adminPassword"]
:param name: String with a name for this new node (required)
:type name: ``str``
:param size: The size of resources allocated to this node.
(required)
:type size: :class:`.NodeSize`
:param image: OS Image to boot on node. (required)
:type image: :class:`.AzureImage`
:param location: Which data center to create a node in.
(if None, use default location specified as 'region' in __init__)
:type location: :class:`.NodeLocation`
:param auth: Initial authentication information for the node
(optional)
:type auth: :class:`.NodeAuthSSHKey` or :class:`NodeAuthPassword`
:param ex_resource_group: The resource group in which to create the
node
:type ex_resource_group: ``str``
:param ex_storage_account: The storage account id in which to store
the node's disk image.
Note: when booting from a user image (AzureVhdImage)
the source image and the node image must use the same storage account.
:type ex_storage_account: ``str``
:param ex_blob_container: The name of the blob container on the
storage account in which to store the node's disk image (optional,
default "vhds")
:type ex_blob_container: ``str``
:param ex_user_name: User name for the initial admin user
(optional, default "azureuser")
:type ex_user_name: ``str``
:param ex_network: The virtual network the node will be attached to.
Must provide either `ex_network` (to create a default NIC for the
node on the given network) or `ex_nic` (to supply the NIC explicitly).
:type ex_network: ``str``
:param ex_subnet: If ex_network is provided, the subnet of the
virtual network the node will be attached to. Optional, default
is the "default" subnet.
:type ex_subnet: ``str``
:param ex_nic: A virtual NIC to attach to this Node, from
`ex_create_network_interface` or `ex_get_nic`.
Must provide either `ex_nic` (to supply the NIC explicitly) or
ex_network (to create a default NIC for the node on the
given network).
:type ex_nic: :class:`AzureNic`
:param ex_tags: Optional tags to associate with this node.
:type ex_tags: ``dict``
:param ex_customdata: Custom data that will
be placed in the file /var/lib/waagent/CustomData
https://azure.microsoft.com/en-us/documentation/ \
articles/virtual-machines-how-to-inject-custom-data/
:type ex_customdata: ``str``
:return: The newly created node.
:rtype: :class:`.Node`
"""
if location is None:
location = self.default_location
if ex_nic is None:
if ex_network is None:
raise ValueError("Must provide either ex_network or ex_nic")
if ex_subnet is None:
ex_subnet = "default"
subnet_id = "/subscriptions/%s/resourceGroups/%s/providers" \
"/Microsoft.Network/virtualnetworks/%s/subnets/%s" % \
(self.subscription_id, ex_resource_group,
ex_network, ex_subnet)
subnet = AzureSubnet(subnet_id, ex_subnet, {})
ex_nic = self.ex_create_network_interface(name + "-nic",
subnet,
ex_resource_group,
location)
auth = self._get_and_check_auth(auth)
target = "/subscriptions/%s/resourceGroups/%s/providers" \
"/Microsoft.Compute/virtualMachines/%s" % \
(self.subscription_id, ex_resource_group, name)
instance_vhd = "https://%s.blob.core.windows.net" \
"/%s/%s-os.vhd" \
% (ex_storage_account,
ex_blob_container,
name
)
if isinstance(image, AzureVhdImage):
storageProfile = {
"osDisk": {
"name": "virtualmachine-osDisk",
"osType": "linux",
"caching": "ReadWrite",
"createOption": "FromImage",
"image": {
"uri": image.id
},
"vhd": {
"uri": instance_vhd
}
}
}
elif isinstance(image, AzureImage):
storageProfile = {
"imageReference": {
"publisher": image.publisher,
"offer": image.offer,
"sku": image.sku,
"version": image.version
},
"osDisk": {
"name": "virtualmachine-osDisk",
"vhd": {
"uri": instance_vhd
},
"caching": "ReadWrite",
"createOption": "FromImage"
}
}
else:
raise LibcloudError(
"Unknown image type %s,"
"expected one of AzureImage, AzureVhdImage",
type(image))
data = {
"id": target,
"name": name,
"type": "Microsoft.Compute/virtualMachines",
"location": location.id,
"tags": ex_tags,
"properties": {
"hardwareProfile": {
"vmSize": size.id
},
"storageProfile": storageProfile,
"osProfile": {
"computerName": name
},
"networkProfile": {
"networkInterfaces": [
{
"id": ex_nic.id
}
]
}
}
}
if ex_customdata:
data["properties"]["osProfile"]["customData"] = \
base64.b64encode(ex_customdata)
data["properties"]["osProfile"]["adminUsername"] = ex_user_name
if isinstance(auth, NodeAuthSSHKey):
data["properties"]["osProfile"]["adminPassword"] = \
binascii.hexlify(os.urandom(20)).decode("utf-8")
data["properties"]["osProfile"]["linuxConfiguration"] = {
"disablePasswordAuthentication": "true",
"ssh": {
"publicKeys": [
{
"path": '/home/%s/.ssh/authorized_keys' % (
ex_user_name),
"keyData": auth.pubkey
}
]
}
}
elif isinstance(auth, NodeAuthPassword):
data["properties"]["osProfile"]["linuxConfiguration"] = {
"disablePasswordAuthentication": "false"
}
data["properties"]["osProfile"]["adminPassword"] = auth.password
else:
raise ValueError(
"Must provide NodeAuthSSHKey or NodeAuthPassword in auth")
r = self.connection.request(target,
params={"api-version": "2015-06-15"},
data=data,
method="PUT")
while r.object is None:
time.sleep(1)
node = self._to_node(r.object)
node.size = size
node.image = image
return node