def resource_group(stem):
rg = core.ResourceGroup(
f'{stem}{s}vdc{s}rg{s}{suffix}',
location=location,
tags=tags,
)
return rg.name
def __init__(self,
name: str,
tags: dict = None,
opts: pulumi.ResourceOptions = None):
"""
:param name: The name of the resource.
:param tags: A mapping of tags to assign to the resource.
:param opts: Options for the resource.
"""
self.__resource_group = core.ResourceGroup(name,
tags=self.__get_tags(tags),
opts=opts)
from pulumi import Config, get_stack, ResourceOptions, export
from pulumi.resource import CustomTimeouts
from pulumi_azure import core
from hub import HubProps, Hub
from spoke import SpokeProps, Spoke
# retrieve the configuration data
config = Config()
# set default tags to be applied to all taggable resources
stack = get_stack()
default_tags = {'environment': stack}
# all resources will be created in the Resource Group location
resource_group = core.ResourceGroup(
stack + '-vdc-rg-',
tags=default_tags,
)
# Hub virtual network with gateway, firewall, DMZ and shared services subnets
hub1 = Hub(
config.require('hub_stem'),
HubProps(
config=config,
resource_group=resource_group,
tags=default_tags,
stack=stack,
),
opts=ResourceOptions(
custom_timeouts=CustomTimeouts(create='1h', update='1h', delete='1h')),
)
"""An Azure Python Pulumi program"""
import pulumi
from pulumi_azure import core, containerservice
from pulumi_docker import Image, ImageRegistry, DockerBuild
custom_image = "app"
resource_group = core.ResourceGroup('resource_group')
registry = containerservice.Registry("myregistry",
admin_enabled="true",
resource_group_name=resource_group.name,
sku="Basic")
my_image = Image("myimage",
image_name=registry.login_server.apply(
lambda server: f'{server}/{custom_image}:v1.0.0'),
build=DockerBuild(context=f'./{custom_image}'),
registry=ImageRegistry(registry.login_server,
registry.admin_username,
registry.admin_password))
from pulumi import Config, get_stack, export, Output
import pulumi_azuread as ad
import pulumi_random as random
from pulumi_azure import core, containerservice
config = Config()
password = config.get_secret("password") or random.RandomPassword(
"pwd", length=20, special=True).result
ssh_public_key = config.require("sshPublicKey")
resource_group = core.ResourceGroup("aksresourcegroup")
ad_app = ad.Application("aks")
ad_sp = ad.ServicePrincipal("aksSp", application_id=ad_app.application_id)
ad_sp_password = ad.ServicePrincipalPassword("aksSpPassword",
service_principal_id=ad_sp.id,
value=password,
end_date="2099-01-01T00:00:00Z")
aks_cluster_config = [
{
"name": "east",
"location": "eastus",
"node_count": 2,
"node_size": "Standard_D2_v2"
},
{
"name": "west",
"location": "westus",
from pulumi_azure import core, storage, sql, appservice, keyvault, authorization
from pulumi import export, Output, asset
import pulumi_random as random
def createFirewallRules(arg):
ips = arg.split(",")
for ip in ips:
rule = sql.FirewallRule("FR%s" % ip,
resource_group_name=resource_group.name,
start_ip_address=ip,
end_ip_address=ip,
server_name=sql_server.name)
resource_group = core.ResourceGroup("resourceGroup")
storage_account = storage.Account("storage",
resource_group_name=resource_group.name,
account_replication_type="LRS",
account_tier="Standard")
container = storage.Container("files",
storage_account_name=storage_account.name,
container_access_type="private")
administrator_login_password = random.RandomPassword(
"password",
length=16,
special=True,
).result
from pulumi import Config, ResourceOptions, Output
from pulumi_azure import core, storage, compute, network, sql
config = Config("sso-lab")
# 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,
def get_resource_group():
env = get_env()
return core.ResourceGroup('resource_group_{env}'.format(env=env))
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={
from pulumi import asset, export, Output
from pulumi_azure import core, storage, appservice
resource_group = core.ResourceGroup("linuxrg")
http_storage_account = storage.Account(
"http",
account_kind="StorageV2",
account_tier="Standard",
account_replication_type="LRS",
resource_group_name=resource_group.name,
)
http_container = storage.Container(
"http",
storage_account_name=http_storage_account.name,
container_access_type="private")
http_zib_blob = storage.Blob("http",
storage_account_name=http_storage_account.name,
storage_container_name=http_container.name,
type="Block",
source=asset.AssetArchive(
{".": asset.FileArchive("./python")}))
def get_sas(args):
blob_sas = storage.get_account_blob_container_sas(
connection_string=args[1],
start="2020-01-01",
expiry="2030-01-01",
from pulumi import Config, export
from pulumi_azure import core, storage, hdinsight
config = Config()
username = config.require("username")
password = config.require_secret("password")
resource_group = core.ResourceGroup("spark-rg")
storage_account = storage.Account("sparksa",
resource_group_name=resource_group.name,
account_replication_type="LRS",
account_tier="Standard")
storage_container = storage.Container(
"spark",
storage_account_name=storage_account.name,
container_access_type="private")
spark_cluster = hdinsight.SparkCluster("myspark",
resource_group_name=resource_group.name,
cluster_version="3.6",
component_version={"spark": "2.3"},
tier="Standard",
storage_accounts=[{
"is_default":
"true",
"storage_account_key":
storage_account.primary_access_key,
"storage_container_id":
storage_container.id
import pulumi
from pulumi_azure import core, compute, storage, network
# Create an Azure Resource Group
resource_group = core.ResourceGroup("eastus_update", location='EastUS')
# Create an Azure resource (Storage Account)
account = storage.Account("storageEastus",
resource_group_name=resource_group.name,
location=resource_group.location,
account_tier='Standard',
account_replication_type='ZRS')
# Export the connection string for the storage account
pulumi.export('connection_string', account.primary_connection_string)
import pulumi
from pulumi import Config, ResourceOptions
from pulumi_azure import core, storage, compute, network
config = Config("vms-python")
# retrieve password from config
pwd = config.require_secret("pwd")
print("Secret retrieved...")
# Create an Azure Resource Group
rg = core.ResourceGroup("rg-geba-vm-pulumi", name="rg-geba-vm-pulumi")
# create vnet
vnet = network.VirtualNetwork("pul-vm-vnet",
name="pul-vm-vnet",
address_spaces=["10.2.0.0/16"],
resource_group_name=rg.name)
subnet = network.Subnet("vm-sn",
opts=pulumi.ResourceOptions(depends_on=[vnet]),
virtual_network_name=vnet.name,
address_prefix="10.2.0.0/24",
resource_group_name=rg.name)
img2019 = {
"offer": "WindowsServer",
"publisher": "MicrosoftWindowsServer",
"sku": "2019-Datacenter",
"version": "latest"
}
import pulumi
from isodate import Duration, duration_isoformat
from pulumi_azure import core, cosmosdb, appservice, storage, servicebus
# Create an Azure Resource Group
resource_group = core.ResourceGroup('messaging-samples',
location='EastUs',
name='messaging-samples')
# Create an Azure Service Bus namespace
sbnamespace = servicebus.Namespace('ns-messaging-samples',
sku='Standard',
name='ns-messaging-samples',
location='EastUs',
resource_group_name=resource_group.name)
# Create an associated queue within the above namespace
servicebus.Queue('simplequeue',
name='simplequeue',
namespace_name=sbnamespace.name,
dead_lettering_on_message_expiration=True,
resource_group_name=resource_group.name,
max_size_in_megabytes=1024,
default_message_ttl=duration_isoformat(Duration(days=5)))
# Create an associated topic within the above namespace
simpletopic = servicebus.Topic('simpletopic',
name='simpletopic',
resource_group_name=resource_group.name,
namespace_name=sbnamespace.name,
max_size_in_megabytes=1024,
"""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"],
),
"""An Azure Python Pulumi program"""
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':
from pulumi_azure import core, appservice, containerservice
from pulumi import export
resource_group = core.ResourceGroup("samples")
plan = appservice.Plan(
"linux-apps",
resource_group_name=resource_group.name,
kind="Linux",
reserved=True,
sku=appservice.PlanSkuArgs(
tier="Basic",
size="B1",
))
docker_image = "microsoft/azure-appservices-go-quickstart"
hello_app = appservice.AppService(
"hello-app",
resource_group_name=resource_group.name,
app_service_plan_id=plan.id,
app_settings={
"WEBSITES_ENABLE_APP_SERVICE_STORAGE": "false",
},
site_config=appservice.AppServiceSiteConfigArgs(
always_on=True,
linux_fx_version="DOCKER|%s" % docker_image,
),
https_only=True)
export("hello_endpoint", hello_app.default_site_hostname.apply(
from pulumi import Config, export
from pulumi_azure import cdn, core, storage
from cloudflare import create_dns_record
config = Config(name="resume-infra")
domain = config.require("domain")
zone_id = config.require("zone_id")
resource_group = core.ResourceGroup('nvd-codes-resume')
account = storage.Account('resumestorage',
resource_group_name=resource_group.name,
account_tier='Standard',
account_replication_type='LRS',
enable_https_traffic_only=False,
static_website={
"indexDocument": "index.html",
}
)
cdn_profile = cdn.Profile(
"resume-cdn",
resource_group_name=resource_group.name,
sku="Standard_Microsoft"
)
endpoint = cdn.Endpoint(
"resume-cdn-ep",
resource_group_name=resource_group.name,
root_certificates = config.get("root_certificates")
public_certificate_data = config.get("public_certificate_data")
address_space = config.get("address_space")
vnet_address_spaces = config.get("vnet_address_spaces")
subnet_address_spaces = config.get("subnet_address_spaces")
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",
import pulumi
from pulumi_azure import core, storage, containerservice, network
from pulumi_kubernetes import Provider, yaml
from pulumi_kubernetes.core.v1 import Namespace
from pulumi_kubernetes.helm import v3
# read and set config values
config = pulumi.Config("aks-consul")
sshKey = config.require("sshkey")
# create a Resource Group and Network for all resources
rg = core.ResourceGroup("rg-aks-consul")
# create vnet
vnet = network.VirtualNetwork("aks-consul-vnet",
name="aks-consul-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_prefixes=["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",
"""An Azure Python Pulumi program"""
import pulumi
from pulumi import get_stack
from pulumi_azure import core
from accountstorage import aStorage
from logan import logan
config = pulumi.Config()
mi = config.get_int('maxinstance')
env = get_stack()
# Create an Azure Resource Group
resource_group = core.ResourceGroup('resource_group',
name='rgsa-' + env,
location='uksouth')
accounts = []
log = logan(resource_group.name, resource_group.location)
# Create an Azure resource (Storage Account)
for x in range(mi):
accounts.append(aStorage(resource_group.name, env + str(x)))
# Export the connection string for the storage account
for x in range(mi):
pulumi.export('connection_string ' + env + str(x), accounts[x])
pulumi.export('Loganalytics', log)
from pulumi import asset, export, Output
from pulumi_azure import core, storage, appservice
resource_group = core.ResourceGroup("windowsrg")
httpdotnet_storage_account = storage.Account(
"httpdotnet",
account_kind="StorageV2",
account_tier="Standard",
account_replication_type="LRS",
resource_group_name=resource_group.name,
)
httpdotnet_container = storage.Container(
"http-dotnet",
storage_account_name=httpdotnet_storage_account.name,
container_access_type="private")
httpdotnet_zib_blob = storage.ZipBlob(
"http-dotnet",
resource_group_name=resource_group.name,
storage_account_name=httpdotnet_storage_account.name,
storage_container_name=httpdotnet_container.name,
type="block",
content=asset.AssetArchive(
{".": asset.FileArchive("./dotnet/bin/Debug/netcoreapp2.1/publish")}))
account_sas = storage.get_account_sas(
connection_string=httpdotnet_storage_account.primary_connection_string,
start="2019-01-01",
expiry="2029-01-01",
def resource_group(stem):
rg = core.ResourceGroup(
f'{stem}-vdc-rg-',
tags=tags,
)
return rg.name
import pulumi
from pulumi_azure import core, storage
# Create an Azure Resource Group
resource_group = core.ResourceGroup("resource_group",
location='WestUS')
# Create an Azure resource (Storage Account)
account = storage.Account("storage",
resource_group_name=resource_group.name,
location=resource_group.location,
account_tier='Standard',
account_replication_type='LRS')
# Export the connection string for the storage account
pulumi.export('connection_string', account.primary_connection_string)
from pulumi import Config, export, asset, Output
from pulumi_azure import core, storage, appservice, appinsights, sql
username = "******"
config = Config()
pwd = config.require("sqlPassword")
resource_group = core.ResourceGroup("appservicerg")
storage_account = storage.Account("appservicesa",
resource_group_name=resource_group.name,
account_kind="StorageV2",
account_tier="Standard",
account_replication_type="LRS")
app_service_plan = appservice.Plan("appservice-asp",
resource_group_name=resource_group.name,
kind="App",
sku={
"tier": "Basic",
"size": "B1",
})
storage_container = storage.Container(
"appservice-c",
storage_account_name=storage_account.name,
container_access_type="private")
blob = storage.Blob("appservice-b",
storage_account_name=storage_account.name,
# 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 core, storage, appservice
# Create an Azure Resource Group
location = pulumi.config.get_config('location')
print(location)
resource_group = core.ResourceGroup('my_pulumi_resource_group',
location=location)
# Create an Azure resource (Storage Account)
account = storage.Account(
'storage',
# The location for the storage account will be derived automatically from the resource group.
resource_group_name=resource_group.name,
account_tier='Standard',
account_replication_type='LRS')
# play around with some resource groups and maybe a function?
appService = appservice.Plan("appServicePlan",
resource_group_name=resource_group.name,
sku={
"tier": "free",
"size": "F1"
})
example_function = appservice.FunctionApp(
"MyTestFunction",
resource_group_name=resource_group.name,
app_service_plan_id=appService.id,
app_settings={"runtime": "python"},
from pulumi import Config, export, ResourceOptions
from pulumi_azure import core, network, lb, compute
import pulumi_random as random
config = Config()
admin_user = config.get("adminUser") or "azureuser"
admin_password = config.get_secret("adminPassword") or random.RandomPassword(
"pwd", length=20, special="true").result
domain = config.get("domain") or random.RandomString(
"domain", length=10, number="false", special="false", upper="false").result
application_port = config.get_float("applicationPort") or 80
resource_group = core.ResourceGroup("vmss-rg")
public_ip = network.PublicIp("public-ip",
resource_group_name=resource_group.name,
allocation_method="Static",
domain_name_label=domain)
load_balancer = lb.LoadBalancer("lb",
resource_group_name=resource_group.name,
frontend_ip_configurations=[{
"name":
"PublicIPAddress",
"publicIpAddressId":
public_ip.id,
}])
bpepool = lb.BackendAddressPool("bpepool",
resource_group_name=resource_group.name,
loadbalancer_id=load_balancer.id)
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,
from pulumi import Config, export, asset, Output
from pulumi_azure import core, storage, appservice, appinsights, sql
import pulumi
env = pulumi.get_stack()
appname = pulumi.get_project()
config = Config()
username = config.require("sqlUsername")
pwd = config.require("sqlPassword")
resource_group = core.ResourceGroup(appname + '-' + env + '-rg')
sql_server = sql.SqlServer(resource_name=appname + '-' + env + '-sql',
resource_group_name=resource_group.name,
administrator_login=username,
administrator_login_password=pwd,
version="12.0")
database = sql.Database(appname + '-' + env + '-db',
resource_group_name=resource_group.name,
server_name=sql_server.name,
requested_service_objective_name="S0")
connection_string = Output.all(sql_server.name, database.name, username, pwd) \
.apply(lambda args: f"Server=tcp:{args[0]}.database.windows.net;initial catalog={args[1]};user ID={args[2]};password={args[3]};Min Pool Size=0;Max Pool Size=30;Persist Security Info=true;")
app_service_plan = appservice.Plan(appname + '-' + env + '-asp',
resource_group_name=resource_group.name,
kind="App",
sku={
