def __init__(self,
name: str,
resource_group_name: str,
cidr: list,
subnets: dict,
tags: dict = None,
opts: pulumi.ResourceOptions = None):
"""
:param name: The name of the resource.
:param resource_group_name: The name of resource group
:param subnets A mapping of subnets to assign to Virtual Network.
:param tags: A mapping of tags to assign to the resource.
:param opts: Options for the resource.
"""
self.__subnets: dict = dict()
__vnet = network.VirtualNetwork(
name,
resource_group_name=resource_group_name,
address_spaces=cidr,
tags=self.__get_tags(tags),
opts=opts)
__input_subnets = subnets["subnets"]
for subnet in __input_subnets:
__service_endpoints = None
__subnet_name = subnet["name"]
if subnet.get("service_endpoints") != None:
__service_endpoints = subnet["service_endpoints"]
__subnet = network.Subnet(
__subnet_name,
name=__subnet_name,
resource_group_name=resource_group_name,
virtual_network_name=__vnet.name,
address_prefixes=subnet["address_prefixes"],
service_endpoints=__service_endpoints)
__security_rules = None
if subnet.get("nsg_security_rules") != None:
__security_rules = subnet["nsg_security_rules"]
# Create nsg
__nsg = network.NetworkSecurityGroup(
__subnet_name + "-nsg",
resource_group_name=resource_group_name,
security_rules=__security_rules,
tags=self.__get_tags(tags))
# Associate subnet with nsg
network.SubnetNetworkSecurityGroupAssociation(
__subnet_name + "nsg-as",
subnet_id=__subnet.id,
network_security_group_id=__nsg.id,
)
self.__subnets[subnet["name"]] = __subnet
def virtual_network(stem, address_spaces):
vn = network.VirtualNetwork(
f'{stem}-vn-',
resource_group_name=resource_group_name,
address_spaces=address_spaces,
tags=tags,
opts=ResourceOptions(parent=self),
)
return vn
def virtual_network(stem, address_spaces):
vn = network.VirtualNetwork(
f'{stem}{s}vn{s}{suffix}',
resource_group_name=resource_group_name,
location=location,
address_spaces=address_spaces,
tags=tags,
opts=ResourceOptions(parent=self),
)
return vn
import pulumi
from pulumi import Output
from pulumi_azure import core, compute, network
config = pulumi.Config("azure-web")
username = config.require("username")
password = config.require("password")
resource_group = core.ResourceGroup("server", location="West US")
net = network.VirtualNetwork("server-network",
resource_group_name=resource_group.name,
location=resource_group.location,
address_spaces=["10.0.0.0/16"],
subnets=[{
"name": "default",
"address_prefix": "10.0.1.0/24",
}])
subnet = network.Subnet("server-subnet",
resource_group_name=resource_group.name,
virtual_network_name=net.name,
address_prefix="10.0.2.0/24",
enforce_private_link_endpoint_network_policies="false")
public_ip = network.PublicIp("server-ip",
resource_group_name=resource_group.name,
location=resource_group.location,
allocation_method="Dynamic")
network_iface = network.NetworkInterface(
"server-nic",
resource_group_name=resource_group.name,
import pulumi
from pulumi import Output
from pulumi_azure import core, compute, network
config = pulumi.Config()
username = config.require("username")
password = config.require_secret("password")
resource_group = core.ResourceGroup("server", location="West US")
net = network.VirtualNetwork("server-network",
resource_group_name=resource_group.name,
location=resource_group.location,
address_spaces=["10.0.0.0/16"],
subnets=[
network.VirtualNetworkSubnetArgs(
name="default",
address_prefix="10.0.1.0/24",
)
])
subnet = network.Subnet("server-subnet",
resource_group_name=resource_group.name,
virtual_network_name=net.name,
address_prefixes=["10.0.2.0/24"],
enforce_private_link_endpoint_network_policies=False)
public_ip = network.PublicIp("server-ip",
resource_group_name=resource_group.name,
location=resource_group.location,
allocation_method="Dynamic")
# retrieve password from config
pwd = config.require_secret("pwd")
sqlpwd = config.require_secret("sqlpwd")
print("Secrets retrieved...")
# set some vars
server_user = "******"
sql_user = "******"
# Create an Azure Resource Group
rg = core.ResourceGroup("rg-ssolab")
# create vnet
vnet = network.VirtualNetwork("vnet-sso",
address_spaces=["10.2.0.0/16"],
resource_group_name=rg.name,
dns_servers=["10.2.0.4"])
subnet = network.Subnet("servers",
virtual_network_name=vnet.name,
address_prefix="10.2.0.0/24",
resource_group_name=rg.name)
bastionSubnet = network.Subnet("bastion",
name="AzureBastionSubnet",
virtual_network_name=vnet.name,
address_prefix="10.2.1.0/24",
resource_group_name=rg.name)
# public ip
ip = network.PublicIp("geba-sso-ip",
vhd_name = config.get("vhd_name")
rhcos_storage_name = config.get("rhcos_storage_name")
gateway_address_spaces = config.get("gateway_address_spaces")
ssh_public_key = config.get("ssh_public_key")
config = pulumi.Config("repository")
admin_user = config.require("adminUser")
admin_password = config.require("adminPassword")
# Create an Azure Resource Group
resource_group = core.ResourceGroup('common-ocp', name='common-ocp')
# Create an Azure network
vnet = network.VirtualNetwork(
"company-vnet",
name="company-vnet",
resource_group_name=resource_group.name,
address_spaces=[vnet_address_spaces])
# Create an Azure subnet
subnet = network.Subnet(
"registry",
resource_group_name=resource_group.name,
address_prefix=subnet_address_spaces,
virtual_network_name=vnet.name,
name="registry",
enforce_private_link_endpoint_network_policies="false")
# Create an Azure subnet
gatewaysubnet = network.Subnet(
import pulumi
from pulumi_azure import core, storage, containerservice, network
from pulumi_azuread import Application, ServicePrincipal, ServicePrincipalPassword
from pulumi_kubernetes import Provider, yaml
# read and set config values
config = pulumi.Config("kub-python")
SSHKEY = config.require("sshkey")
# create a Resource Group and Network for all resources
rg = core.ResourceGroup("rg-pul-aks")
# create vnet
vnet = network.VirtualNetwork("pul-aks-vnet",
name="pul-aks-vnet",
address_spaces=["10.1.0.0/16"],
resource_group_name=rg.name)
subnet = network.Subnet("aks-sn",
opts=pulumi.ResourceOptions(depends_on=[vnet]),
virtual_network_name=vnet.name,
address_prefix="10.1.0.0/24",
resource_group_name=rg.name)
aks = containerservice.KubernetesCluster(
"aksCluster",
opts=pulumi.ResourceOptions(depends_on=[subnet]),
resource_group_name=rg.name,
dns_prefix="pul",
linux_profile={
"adminUsername": "******",
"""An Azure Python Pulumi program"""
import pulumi
from pulumi_azure import core, storage, network
import pulumi_azure_native as azure_native
# comment
name = "demo"
mylocation = "centralus"
# Create an Azure Resource Group
myresourcegroup = core.ResourceGroup(f"{name}-resource_group",
location=mylocation)
mynetwork = network.VirtualNetwork(
f"{name}-vnet",
resource_group_name=myresourcegroup.name,
location=myresourcegroup.location,
address_spaces=["10.0.0.0/16"],
)
mysubnet1 = network.Subnet(
f"{name}-subnet1",
resource_group_name=myresourcegroup.name,
virtual_network_name=mynetwork.name,
address_prefixes=["10.0.1.0/24"],
delegations=[
network.SubnetDelegationArgs(
name=f"{name}-subnet1-delegation",
service_delegation=network.SubnetDelegationServiceDelegationArgs(
name="Microsoft.ContainerInstance/containerGroups",
actions=["Microsoft.Network/virtualNetworks/subnets/action"],
),
resource_group_name=resource_group.name,
loadbalancer_id=load_balancer.id,
port=application_port)
nat_ule = lb.Rule("lbnatrule-http",
resource_group_name=resource_group.name,
backend_address_pool_id=bpepool.id,
backend_port=application_port,
frontend_ip_configuration_name="PublicIPAddress",
frontend_port=application_port,
loadbalancer_id=load_balancer.id,
probe_id=ssh_probe.id,
protocol="Tcp")
vnet = network.VirtualNetwork("vnet",
resource_group_name=resource_group.name,
address_spaces=["10.0.0.0/16"])
subnet = network.Subnet("subnet",
resource_group_name=resource_group.name,
address_prefix="10.0.2.0/24",
virtual_network_name=vnet.name)
scale_set = compute.ScaleSet(
"vmscaleset",
resource_group_name=resource_group.name,
network_profiles=[{
"ipConfigurations": [{
"load_balancer_backend_address_pool_ids": [bpepool.id],
"name":
"IPConfiguration",
# Copyright 2016-2020, Pulumi Corporation. All rights reserved.
from pulumi_azure import core, compute, network
name = "webserver"
resource_group = core.ResourceGroup(name)
net = network.VirtualNetwork(
name,
resource_group_name=resource_group.name,
address_spaces=["10.0.0.0/16"],
subnets=[{
"name": "default",
"address_prefix": "10.0.1.0/24",
}])
network_interface = network.NetworkInterface(
name,
resource_group_name=resource_group.name,
ip_configurations=[{
"name": "webserveripcfg",
"subnet_id": net.subnets.apply(lambda subnets: subnets[0].get("id")),
"private_ip_address_allocation": "dynamic",
}])
vm = compute.VirtualMachine(
"webservervm",
resource_group_name=resource_group.name,
network_interface_ids=[network_interface.id],
vm_size="Standard_A0",
import pulumi
from pulumi_azure import compute, core, network
config = pulumi.Config("pulumi-demo")
password = config.require("password")
# Create an Azure Resource Group
resource_group = core.ResourceGroup('pulumi_group')
# Create network, subnet and NIC
vnet = network.VirtualNetwork('network',
address_spaces=['10.1.0.0/16'],
location=resource_group.location,
name='pulumi-network',
resource_group_name=resource_group.name,
subnets=[{
"name": "default",
"address_prefix": "10.1.1.0/24",
}])
subnet = network.Subnet("server-subnet",
resource_group_name=resource_group.name,
virtual_network_name=vnet.name,
address_prefixes=['10.1.2.0/24'],
name='pulumi-subnet')
nic = network.NetworkInterface('nic',
ip_configurations=[{
'name':
'pulumi-ipconf',
import pulumi
from pulumi_azure import compute, core, network, storage
config = pulumi.Config('webserver-azure')
username = config.require('username')
password = config.require('password')
resource_group = core.ResourceGroup(
'server',
location='West US',
)
vnet = network.VirtualNetwork(
'server-network',
resource_group_name=resource_group.name,
location=resource_group.location,
address_spaces=['10.0.0.0/16'],
)
subnets = {
'default': '10.0.1.0/24',
'server-subnet': '10.0.2.0/24',
}
for name, prefix in subnets.iteritems():
subnet = network.Subnet(
name,
resource_group_name=resource_group.name,
virtual_network_name=vnet.name,
address_prefix=prefix,
)
import pulumi
from pulumi_azure import core, network
from bastion import bastion
# Create an Azure Resource Group
resource_group = core.ResourceGroup("resource_group", location='australiaeast')
vnet = network.VirtualNetwork("vnet",
location=resource_group.location,
resource_group_name=resource_group.name,
address_spaces=["10.0.0.0/8"])
bastion = bastion.Bastion("bastion",
location=resource_group.location,
resource_group_name=resource_group.name,
address_prefix="10.1.0.0/24",
vnet_name=vnet.name)
# settings for all VMs
admin_username = hcl_vars['variable']['admin_username']['default']
ssh_key_data = hcl_vars['variable']['ssh_key_data']['default']
resource_group = core.ResourceGroup(
hcl_vars['variable']['resource_group_name']['default'],
name=hcl_vars['variable']['resource_group_name']['default'],
location=hcl_vars['variable']['location']['default'])
net = network.VirtualNetwork(
hcl_vars['variable']['network_name']['default'],
name=hcl_vars['variable']['network_name']['default'],
resource_group_name=resource_group.name,
location=resource_group.location,
address_spaces=hcl_vars['variable']['network_address_spaces']['default'],
subnets=hcl_vars['variable']['network_subnets']['default']
)
subnet = network.Subnet(
hcl_vars['variable']['network_additional_subnet_name']['default'],
name=hcl_vars['variable']['network_additional_subnet_name']['default'],
resource_group_name=resource_group.name,
virtual_network_name=net.name,
address_prefix=hcl_vars['variable']['network_additional_subnet_address_prefix']['default'])
public_ip = network.PublicIp(
hcl_vars['variable']['network_public_ip_name']['default'],
name=hcl_vars['variable']['network_public_ip_name']['default'],
resource_group_name=resource_group.name,
