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={