def resource_group(stem):
rg = resources.ResourceGroup(
f'{stem}{s}vdc{s}rg',
resource_group_name=f'{stem}{s}vdc{s}rg{s}{suffix}',
location=location,
tags=tags,
)
return rg.name
# Copyright 2016-2020, Pulumi Corporation. All rights reserved.
import pulumi
from pulumi_azure_nextgen.authorization import v20200401preview as authorization
from pulumi_azure_nextgen.storage import latest as storage
from pulumi_azure_nextgen.synapse import v20190601preview as synapse
from pulumi_azure_nextgen.resources import latest as resources
import pulumi_random as random
config = pulumi.Config()
location = config.get("location") or "WestUS"
resource_group = resources.ResourceGroup("resourceGroup",
resource_group_name="synapse-rg",
location=location)
storage_account = storage.StorageAccount("storageAccount",
resource_group_name=resource_group.name,
location=resource_group.location,
account_name="synapsesa",
access_tier="Hot",
enable_https_traffic_only=True,
is_hns_enabled=True,
kind="StorageV2",
sku=storage.SkuArgs(
name="Standard_RAGRS",
))
data_lake_storage_account_url = storage_account.name.apply(lambda name: f"https://{name}.dfs.core.windows.net")
users = storage.BlobContainer("users",
generic_params_data = json.load(generic_params_file)
print("Generic parameter file contents:")
pprint(generic_params_data)
# Import environment-specific variables from JSON
env_params_file_location = str("../../generic/json/infrastructure-" +
stackName + ".json")
with open(env_params_file_location) as env_params_file:
env_params_data = json.load(env_params_file)
print("Environment parameter file contents:")
pprint(env_params_data)
# Create an Azure Resource Group
platformResourceGroup = resources.ResourceGroup(
env_params_data["resourceGroups"]["platform"]["name"],
resource_group_name=env_params_data["resourceGroups"]["platform"]["name"],
location=generic_params_data["regions"]["primaryRegion"]["name"],
)
# Create an Azure Storage Account
print(
"Creating or updating storage account in resource group: ",
str(platformResourceGroup.name),
)
platformStorageAccount = storage.StorageAccount(
env_params_data["storageAccounts"]["platform"]["name"],
account_name=env_params_data["storageAccounts"]["platform"]["name"],
kind=env_params_data["storageAccounts"]["settings"]["kind"],
location=platformResourceGroup.location,
resource_group_name=platformResourceGroup.name,
sku=storage.SkuArgs(name=env_params_data["storageAccounts"]["settings"]
# The privateKey associated with the selected key must be provided (either directly or base64 encoded),
# along with an optional passphrase if needed.
def decode_key(key):
if key.startswith('-----BEGIN RSA PRIVATE KEY-----'):
return key
return key.encode('ascii')
private_key = config.require_secret('privateKey').apply(decode_key)
private_key_passphrase = config.get_secret('privateKeyPassphrase')
# Create a resource group to hold project resources.
resource_group = resources.ResourceGroup("server-rg",
resource_group_name="minecraft",
location=location)
# Create a virtual network resource.
net = network.VirtualNetwork("server-network",
resource_group_name=resource_group.name,
location=location,
virtual_network_name="server-network",
address_space=network.AddressSpaceArgs(
address_prefixes=["10.0.0.0/16"], ),
subnets=[
network.SubnetArgs(
name="default",
address_prefix="10.0.0.0/24",
)
])
"stack": stackName,
"env": "databricks",
"team": "engineering",
"pulumi_cli": "yes",
"cloud_location": my_location,
"console_azure": "no"
}
#
# Azure Resource creating starting here.
#
# Create an azure resource group
resource_group = resources.ResourceGroup(
f"{my_name}-resourcegroup",
resource_group_name=my_resource_group_name,
location=my_location,
tags=basetags,
)
# Create an azure workspace
workspace = databricks.Workspace(
f"{my_name}-workspace",
location=my_location,
resource_group_name=resource_group.name,
workspace_name=my_Workspacename,
parameters={
"prepareEncryption": {
"value": True,
},
},
managed_resource_group_id=
# Copyright 2016-2020, Pulumi Corporation. All rights reserved.
import base64
from pulumi import Config, Output, export
from pulumi_azure_nextgen.compute import latest as compute
from pulumi_azure_nextgen.network import latest as network
from pulumi_azure_nextgen.resources import latest as resources
config = Config()
location = config.get("location") or "westus"
username = config.require("username")
password = config.require("password")
resource_group = resources.ResourceGroup("server",
resource_group_name="server",
location=location)
net = network.VirtualNetwork("server-network",
resource_group_name=resource_group.name,
location=location,
virtual_network_name="server-network",
address_space=network.AddressSpaceArgs(
address_prefixes=["10.0.0.0/16"], ),
subnets=[
network.SubnetArgs(
name="default",
address_prefix="10.0.1.0/24",
)
])
public_ip = network.PublicIPAddress("server-ip",
stackName = get_stack()
mytags = {
"stack": stackName,
"project": projectName,
"created_by": "johnsmith",
"launched_via": "pulumi",
"team": "engineering",
"cli": "yes"
}
# Create an Azure Resource Group
# https://www.pulumi.com/docs/reference/pkg/azure-nextgen/resources/resourcegroup/
resource_group = resources.ResourceGroup(
f"{my_network_name}-resource-group",
resource_group_name=my_resource_group_name,
location=my_location,
tags=mytags,
)
# Create a virtual network
# https://www.pulumi.com/docs/reference/pkg/azure-nextgen/network/virtualnetwork/
virtual_network = network.VirtualNetwork(
f"{my_network_name}-virtualNetwork",
address_space={
"addressPrefixes": [my_cidr_block],
},
location=resource_group.location,
resource_group_name=resource_group.name,
virtual_network_name=my_network_name,
tags=mytags)
location_param = config.get("locationParam")
resource_group_name_param = config.require("resourceGroupNameParam")
vulnerability_assessments_default_storage_container_path_param = config.require(
"vulnerabilityAssessmentsDefaultStorageContainerPathParam")
#resource_group_name=resource_group_name_param
database_tags = {
"created-by": "tusharshah",
"creationSource": "pulumiapi",
"owner": "team-qa",
"purpose": "test template",
"env": "dev"
}
resource_group = resources.ResourceGroup(
"shaht-rg",
location=location_param,
resource_group_name=resource_group_name_param)
administrator_login_param = config.require("administratorLoginParam")
administrator_login_password_param = config.require_secret(
"administratorLoginPasswordParam")
server_name_param = config.require("serverNameParam")
sql_db_name_param = config.get("sqlDBNameParam")
advisor_resource = None
auditing_policy_resource = None
encryption_protector_resource = None
geo_backup_policy_resource = None
security_alert_policy_resource = None
transparent_data_encryption_resource = None
vulnerability_assessment_resource = None
# Copyright 2016-2020, Pulumi Corporation. All rights reserved.
import pulumi
from pulumi_azure_nextgen.containerregistry import latest as containerregistry
from pulumi_azure_nextgen.resources import latest as resources
from pulumi_azure_nextgen.storage import latest as storage
from pulumi_azure_nextgen.web import latest as web
import pulumi_docker as docker
import pulumi_random as random
config = pulumi.Config()
location = config.get("location") or "WestUS"
resource_group = resources.ResourceGroup(
"resourceGroup",
resource_group_name="appservice-docker-rg",
location=location)
plan = web.AppServicePlan("plan",
resource_group_name=resource_group.name,
name="linux-asp",
location=resource_group.location,
kind="Linux",
reserved=True,
sku=web.SkuDescriptionArgs(
name="B1",
tier="Basic",
))
suffix = random.RandomString("suffix", length=6, special=False, upper=False)
# Copyright 2016-2020, Pulumi Corporation. All rights reserved.
import pulumi
from pulumi_azure_nextgen.containerinstance import latest as containerinstance
from pulumi_azure_nextgen.resources import latest as resources
config = pulumi.Config()
location = config.get("location") or "WestUS"
resource_group = resources.ResourceGroup("resourceGroup",
resource_group_name="aci-rg",
location=location)
image_name = "mcr.microsoft.com/azuredocs/aci-helloworld"
container_group = containerinstance.ContainerGroup(
"containerGroup",
resource_group_name=resource_group.name,
location=resource_group.location,
container_group_name="helloworld",
os_type="Linux",
containers=[
containerinstance.ContainerArgs(
name="acilinuxpublicipcontainergroup",
image=image_name,
ports=[containerinstance.ContainerPortArgs(port=80)],
resources=containerinstance.ResourceRequirementsArgs(
requests=containerinstance.ResourceRequestsArgs(
cpu=1.0,
memory_in_gb=1.5,
)),
)
import pulumi_azure_nextgen.insights.latest as insights
import pulumi_azure_nextgen.resources.latest as resource
import pulumi_azure_nextgen.sql.latest as sql
import pulumi_azure_nextgen.storage.latest as storage
import pulumi_azure_nextgen.web.latest as web
from pulumi import Config, Output, asset, export
from pulumi_azure_nextgen.storage.latest import (BlobContainer, PublicAccess,
StorageAccount)
username = "******"
config = Config()
pwd = config.require("sqlPassword")
resource_group = resource.ResourceGroup("appservicerg",
resource_group_name="appservicerg",
location="westus2")
storage_account = storage.StorageAccount(
"appservicesa",
account_name="appservicesa",
resource_group_name=resource_group.name,
kind="StorageV2",
sku=storage.SkuArgs(name=storage.SkuName.STANDARD_LRS))
app_service_plan = web.AppServicePlan(
"appservice-asp",
name="appservice-asp",
resource_group_name=resource_group.name,
kind="App",
sku=web.SkuDescriptionArgs(
"""An Azure RM Python Pulumi program"""
import pulumi
from pulumi_azure_nextgen.storage import latest as storage
from pulumi_azure_nextgen.resources import latest as resources
# Create an Azure Resource Group
resource_group = resources.ResourceGroup('resource_group',
resource_group_name='martin-test-rg',
location='westeurope')
# Create an Azure resource (Storage Account)
account = storage.StorageAccount('sa',
account_name='martinteststorage123',
resource_group_name=resource_group.name,
location=resource_group.location,
sku=storage.SkuArgs(name='Standard_LRS', ),
kind='StorageV2')
# Export the primary key of the Storage Account
primary_key = pulumi.Output.all(resource_group.name, account.name) \
.apply(lambda args: storage.list_storage_account_keys(
resource_group_name=args[0],
account_name=args[1]
)).apply(lambda accountKeys: accountKeys.keys[0].value)
pulumi.export("primary_storage_key", primary_key)
# Copyright 2016-2020, Pulumi Corporation. All rights reserved.
import base64
import pulumi
import pulumi_azure_nextgen.resources.latest as resources
import pulumi_azure_nextgen.containerservice.latest as containerservice
import pulumi_azuread as azuread
import pulumi_random as random
import pulumi_tls as tls
config = pulumi.Config()
# Create new resource group
resource_group = resources.ResourceGroup(
"resourceGroup",
resource_group_name="azure-nextgen-py-aks",
location="WESTUS")
# Create an AD service principal
ad_app = azuread.Application("aks", None)
ad_sp = azuread.ServicePrincipal("aksSp", application_id=ad_app.application_id)
# Generate random password
password = random.RandomPassword("password", length=20, special=True)
# Create the Service Principal Password
ad_sp_password = azuread.ServicePrincipalPassword(
"aksSpPassword",
service_principal_id=ad_sp.id,
value=password.result,
end_date="2099-01-01T00:00:00Z")
# 'sass' creates a new PostgreSQL instance using Azure's SasS offering
db_type = config.require("db_type")
if not db_type == 'sass' and not db_type == 'local':
raise ValueError(
"db_type must be either 'sass' or 'local'. Invalid value: {0}".format(
db_type))
if db_type == 'sass':
# The admin user created on the new PostgreSQL instance
db_admin_username = config.get('db_admin_username') or 'controller'
# The password for the admin user on the new PostgreSQL instance
db_admin_password = config.require_secret('db_admin_password')
pulumi.log.info("Azure Location: {0}".format(location))
resource_group = resources.ResourceGroup(
resource_name='rg-nc',
resource_group_name='rg-nc-{0}'.format(installation_id),
location=location)
storage_account = storage.StorageAccount(
account_name='stnc{0}'.format(installation_id),
resource_name='stnc',
resource_group_name=resource_group.name,
location=location,
access_tier="Hot",
enable_https_traffic_only=True,
allow_blob_public_access=False,
kind="StorageV2",
sku=storage.SkuArgs(name="Standard_LRS", ))
net = network.VirtualNetwork(
resource_name='vnet-nc',
# Copyright 2016-2021, Pulumi Corporation. All rights reserved.
import pulumi
import pulumi_azure_nextgen.authorization.latest as authorization
import pulumi_azure_nextgen.documentdb.latest as documentdb
import pulumi_azure_nextgen.logic.latest as logic
import pulumi_azure_nextgen.resources.latest as resources
import pulumi_azure_nextgen.storage.latest as storage
import pulumi_azure_nextgen.web.latest as web
# Create an Azure Resource Group
resource_group = resources.ResourceGroup("resourceGroup",
resource_group_name="logicappdemo-rg")
# Create an Azure resource (Storage Account)
storage_account = storage.StorageAccount(
"storageAccount",
account_name="logicappdemosa21",
resource_group_name=resource_group.name,
sku=storage.SkuArgs(name=storage.SkuName.STANDARD_LRS, ),
kind=storage.Kind.STORAGE_V2)
# Cosmos DB Account
cosmosdb_account = documentdb.DatabaseAccount(
"cosmosdbAccount",
account_name="logicappdemo-cdb",
resource_group_name=resource_group.name,
database_account_offer_type=documentdb.DatabaseAccountOfferType.STANDARD,
locations=[
documentdb.LocationArgs(
location_name=resource_group.location,
