def _provision_helper_vm(self):
init_script = r"""#!/bin/bash
echo 'net.ipv4.conf.default.rp_filter = 2' >> /etc/sysctl.conf
echo 'net.ipv4.conf.all.rp_filter = 2' >> /etc/sysctl.conf
/usr/sbin/sysctl -p /etc/sysctl.conf
"""
sg = compute.SecGroup(
"helper-vm-sg",
description="allow ssh",
rules=[
compute.SecGroupRuleArgs(
cidr="0.0.0.0/0", from_port=22, to_port=22, ip_protocol="tcp"
)
],
)
external_port = networking.Port(
"helper-vm-external-port",
network_id=self.resources.mgmt_network.id,
fixed_ips=[
networking.PortFixedIpArgs(
subnet_id=self.resources.mgmt_subnet.id,
ip_address=self.props.helper_vm["ip"],
)
],
security_group_ids=[sg.id],
)
helper_vm = compute.Instance(
"helper-vm",
name="helper-vm",
flavor_name=self.props.helper_vm["flavor_name"],
image_name=self.props.helper_vm["image_name"],
networks=[
compute.InstanceNetworkArgs(name=self.resources.deploy_network.name),
],
key_pair=self.resources.keypair.name,
user_data=init_script,
opts=ResourceOptions(
delete_before_replace=True,
ignore_changes=["image_name", "key_pair"],
),
)
attach_external_ip = compute.InterfaceAttach(
"helper-vm-attatch",
instance_id=helper_vm.id,
port_id=external_port.id,
opts=ResourceOptions(delete_before_replace=True, depends_on=[helper_vm]),
)
pulumi.export(
"HelperVM",
Output.all(
helper_vm.name, helper_vm.id, external_port.all_fixed_ips[0]
).apply(lambda args: f"{args[0]} ({args[1]}, {args[2]})"),
)
return helper_vm, attach_external_ip
def _provision_vsanwiteness_helper(self):
props = self.props.helper_vsanwitness
compute.Instance(
"helper-vsanwitness",
name="helper-vsanwitness",
flavor_name=props["flavor_name"],
image_name=props["image_name"],
availability_zone=props["availability_zone"],
networks=[
compute.InstanceNetworkArgs(name=self.resources.deploy_network.name),
compute.InstanceNetworkArgs(name=self.resources.private_networks["vsanwitness"]["network"].name),
],
key_pair=self.resources.keypair.name,
opts=ResourceOptions(
delete_before_replace=True,
ignore_changes=["image_name", "key_pair"],
),
)
def Host(hostname: str, domain: str, spec: dict) -> compute.Instance:
custom_spec = spec.copy()
custom_spec['name'] = hostname
custom_spec['user_data'] = create_ignition_config(
fqdn=f"{hostname}.{domain}",
container_type='containers' # 'containers' for podman, 'docker' for ...
)
# Create an OpenStack resource (Compute Instance)
instance = compute.Instance(hostname, **custom_spec)
pulumi.export(f'{hostname}_ip', instance.access_ip_v4)
volume = blockstorage.Volume(f"{hostname}-data", size=40)
compute.VolumeAttach(f"va-{hostname}-data",
instance_id=instance.id,
volume_id=volume.id,
opts=pulumi.ResourceOptions(parent=instance))
return instance
def _provision_helper_vm(self):
init_script = r"""#!/bin/bash
echo 'net.ipv4.conf.default.rp_filter = 2' >> /etc/sysctl.conf
echo 'net.ipv4.conf.all.rp_filter = 2' >> /etc/sysctl.conf
/usr/sbin/sysctl -p /etc/sysctl.conf
"""
sg = compute.SecGroup(
"helper-vm-sg",
description="allow ssh",
rules=[
compute.SecGroupRuleArgs(
cidr="0.0.0.0/0", from_port=22, to_port=22, ip_protocol="tcp"
)
],
)
external_port = networking.Port(
"helper-vm-external-port",
network_id=self.resources.mgmt_network.id,
fixed_ips=[
networking.PortFixedIpArgs(
subnet_id=self.resources.mgmt_subnet.id,
ip_address=self.props.helper_vm["ip"],
)
],
security_group_ids=[sg.id],
)
helper_vm = compute.Instance(
"helper-vm",
name="helper-vm",
flavor_id=self.props.helper_vm["flavor_id"],
image_name=self.props.helper_vm["image_name"],
networks=[
compute.InstanceNetworkArgs(name=self.props.deploy_network["name"]),
],
key_pair=self.props.keypair_name,
user_data=init_script,
opts=ResourceOptions(
delete_before_replace=True,
ignore_changes=["image_name"],
),
)
attach_external_ip = compute.InterfaceAttach(
"helper-vm-attatch",
instance_id=helper_vm.id,
port_id=external_port.id,
opts=ResourceOptions(delete_before_replace=True, depends_on=[helper_vm]),
)
# configure helper vm
conn_args = ConnectionArgs(
host=self.props.helper_vm["ip"],
username="******",
private_key_file=self.props.private_key_file,
)
exec_install_pwsh = RemoteExec(
"install-powershell",
host_id=helper_vm.id,
conn=conn_args,
commands=[
"[ ! -f packages-microsoft-prod.deb ] && wget -q https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb || true",
"sudo dpkg -i packages-microsoft-prod.deb",
"sudo apt-get update",
"echo 'debconf debconf/frontend select Noninteractive' | sudo debconf-set-selections",
"sudo apt-get install -y -q powershell",
"pwsh -Command Set-PSRepository -Name 'PSGallery' -InstallationPolicy Trusted",
"pwsh -Command Install-Module VMware.PowerCLI",
"pwsh -Command Set-PowerCLIConfiguration -InvalidCertificateAction Ignore -Confirm:0",
"pwsh -Command Set-PowerCLIConfiguration -Scope User -ParticipateInCEIP 0 -Confirm:0",
],
opts=ResourceOptions(depends_on=[attach_external_ip]),
)
# copy rsa key
CopyFile(
"copy-rsa-key",
host_id=helper_vm.id,
conn=conn_args,
src=self.props.private_key_file,
dest="/home/ccloud/esxi_rsa",
mode="600",
opts=ResourceOptions(depends_on=[attach_external_ip]),
)
# copy from path relative to the project root
CopyFile(
"copy-cleanup",
host_id=helper_vm.id,
conn=conn_args,
src="./scripts/cleanup.sh",
dest="/home/ccloud/cleanup.sh",
opts=ResourceOptions(depends_on=[attach_external_ip]),
)
with open("./scripts/config.sh") as f:
template = jinja2.Template(f.read())
config_script = template.render(
management_network=self.props.mgmt_network,
)
CopyFileFromString(
"copy-config-sh",
host_id=helper_vm.id,
conn=conn_args,
from_str=config_script,
dest="/home/ccloud/config.sh",
opts=ResourceOptions(depends_on=[attach_external_ip]),
)
pulumi.export(
"HelperVM",
Output.all(
helper_vm.name, helper_vm.id, external_port.all_fixed_ips[0]
).apply(lambda args: f"{args[0]} ({args[1]}, {args[2]})"),
)
"""An OpenStack Python Pulumi program"""
import pulumi
from pulumi_openstack import compute
# Create an OpenStack resource (Compute Instance)
instance = compute.Instance('test',
flavor_name='s1-2',
image_name='Ubuntu 16.04')
# Export the IP of the instance
pulumi.export('instance_ip', instance.access_ip_v4)
def _provision_esxi_servers(self):
""" esxi installation """
esxi_servers = []
for n in self.props.esxi_nodes:
node_name, node_id, node_ip = n["name"], n["id"], n["ip"]
parent_port = networking.Port(
node_name + "-deployment",
network_id=self.resources.deploy_network.id,
)
instance = compute.Instance(
"esxi-" + node_name,
name="esxi-" + node_name,
availability_zone_hints=f"::{node_id}",
flavor_name=self.props.esxi_flavor_name,
image_name=self.props.esxi_image,
networks=[compute.InstanceNetworkArgs(port=parent_port.id)],
key_pair=self.resources.keypair.name,
opts=ResourceOptions(
delete_before_replace=True,
ignore_changes=["image_name", "key_pair"],
),
)
esxi_servers.append(
{
"node_name": node_name,
"node_id": node_id,
"node_ip": node_ip,
"server": instance,
}
)
subport_vmotion = networking.Port(
node_name + "-vmotion",
admin_state_up=True,
network_id=self.resources.private_networks["vmotion"]["network"].id,
opts=ResourceOptions(
depends_on=[self.resources.private_networks["vmotion"]["subnet"]]
),
)
subport_edgetep = networking.Port(
node_name + "-edgetep",
network_id=self.resources.private_networks["edgetep"]["network"].id,
opts=ResourceOptions(
depends_on=[self.resources.private_networks["edgetep"]["subnet"]]
),
)
subport_hosttep = networking.Port(
node_name + "-hosttep",
network_id=self.resources.private_networks["hosttep"]["network"].id,
opts=ResourceOptions(
depends_on=[self.resources.private_networks["hosttep"]["subnet"]]
),
)
subport_nfs = networking.Port(
node_name + "-nfs",
network_id=self.resources.private_networks["nfs"]["network"].id,
opts=ResourceOptions(
depends_on=[self.resources.private_networks["nfs"]["subnet"]]
),
)
subport_vsan = networking.Port(
node_name + "-vsan",
network_id=self.resources.private_networks["vsan"]["network"].id,
opts=ResourceOptions(
depends_on=[self.resources.private_networks["vsan"]["subnet"]]
),
)
subport_vsanwitness = networking.Port(
node_name + "-vsanwitness",
network_id=self.resources.private_networks["vsanwitness"]["network"].id,
opts=ResourceOptions(
depends_on=[
self.resources.private_networks["vsanwitness"]["subnet"]
]
),
)
subport_management = networking.Port(
node_name + "-management-vcf01",
network_id=self.resources.mgmt_network.id,
fixed_ips=[
networking.PortFixedIpArgs(
subnet_id=self.resources.mgmt_subnet.id, ip_address=node_ip
)
],
)
pn = self.resources.private_networks
trunk = networking.trunk.Trunk(
node_name + "-trunk",
name=node_name + "-trunk",
admin_state_up=True,
port_id=parent_port.id,
sub_ports=[
networking.TrunkSubPortArgs(
port_id=subport_vmotion.id,
segmentation_id=pn["vmotion"]["vlan_id"],
segmentation_type="vlan",
),
networking.TrunkSubPortArgs(
port_id=subport_edgetep.id,
segmentation_id=pn["edgetep"]["vlan_id"],
segmentation_type="vlan",
),
networking.TrunkSubPortArgs(
port_id=subport_hosttep.id,
segmentation_id=pn["hosttep"]["vlan_id"],
segmentation_type="vlan",
),
networking.TrunkSubPortArgs(
port_id=subport_nfs.id,
segmentation_id=pn["nfs"]["vlan_id"],
segmentation_type="vlan",
),
networking.TrunkSubPortArgs(
port_id=subport_vsan.id,
segmentation_id=pn["vsan"]["vlan_id"],
segmentation_type="vlan",
),
networking.TrunkSubPortArgs(
port_id=subport_vsanwitness.id,
segmentation_id=pn["vsanwitness"]["vlan_id"],
segmentation_type="vlan",
),
networking.TrunkSubPortArgs(
port_id=subport_management.id,
segmentation_id=self.props.mgmt_network["vlan_id"],
segmentation_type="vlan",
),
],
opts=ResourceOptions(depends_on=[instance]),
)
pulumi.export(node_name + "_port_vmotion", subport_vmotion.name)
pulumi.export(node_name + "_port_edgetep", subport_edgetep.name)
pulumi.export(node_name + "_port_hosttep", subport_hosttep.name)
pulumi.export(node_name + "_port_nfs", subport_nfs.name)
pulumi.export(node_name + "_port_vsan", subport_vsan.name)
pulumi.export(node_name + "_port_vsanwiteness", subport_vsanwitness.name)
return esxi_servers
compute.InstanceNetworkArgs(uuid=galaxy_net.id,
port=info[vm]["port"].id)
]
if VM_CONFIG[vm].get("ext-net") and EXTERNAL_IP_TYPE == "fixed":
instance_networks.append(compute.InstanceNetworkArgs(uuid=EXT_NET))
# create the instance
info[vm]["instance"] = compute.Instance(
vm,
name=vm,
flavor_name=VM_CONFIG[vm].get("flavor", "C16R64D40"),
block_devices=[
compute.InstanceBlockDeviceArgs(
source_type="image",
boot_index=0,
delete_on_termination=True,
uuid=VM_IMAGE,
destination_type="volume",
volume_size=30,
)
],
key_pair=key.name,
networks=instance_networks,
user_data=USER_DATA,
)
# if we require external access, create and assign a floating ip
if VM_CONFIG[vm].get("ext-net") and EXTERNAL_IP_TYPE == "floating":
info[vm]["fip"] = networking.FloatingIp(vm + "-fip", pool="ext-net")
networking.FloatingIpAssociate(
vm + "-fip-assoc",
floating_ip=info[vm]["fip"].address,
