def aStorage(rg_name, suff): # Create an Azure resource (Storage Account) account = storage.Account( 'storagerick' + suff, name='cicciopasticcio' + suff.lower(), # The location for the storage account will be derived automatically from the resource group. resource_group_name=rg_name, account_tier='Standard', account_replication_type='LRS', tags={ "Environment": "Dev", "CostCenter": "12345" }) # Export the connection string for the storage account return account.primary_connection_string
def __init__(self, name: str, resource_group_name: str, index_html: str = None, network_rules=None, tags: dict = None, opts: pulumi.ResourceOptions = None): """ :param resource_name: The name of the resource. :param resource_group_name: The name of resource group :param index_html: The name of the index.html upload to $web container. :param network_rules: A `network_rules` block as documented below. :param tags: A mapping of tags to assign to the resource. :param opts: Options for the resource. The **network_rules** object supports the following: * `bypasses` (`pulumi.Input[list]`) - Specifies whether traffic is bypassed for Logging/Metrics/AzureServices. Valid options are any combination of `Logging`, `Metrics`, `AzureServices`, or `None`. * `default_action` (`pulumi.Input[str]`) - Specifies the default action of allow or deny when no other rules match. Valid options are `Deny` or `Allow`. * `ip_rules` (`pulumi.Input[list]`) - List of public IP or IP ranges in CIDR Format. Only IPV4 addresses are allowed. Private IP address ranges (as defined in [RFC 1918](https://tools.ietf.org/html/rfc1918#section-3)) are not allowed. * `virtual_network_subnet_ids` (`pulumi.Input[list]`) - A list of resource ids for subnets. """ self.__account = storage.Account(name, resource_group_name=resource_group_name, account_tier="Standard", account_kind="StorageV2", account_replication_type="LRS", static_website={ "indexDocument": "index.html", "error404Document": "error.html" }, network_rules=network_rules, enable_https_traffic_only=True, tags=self.__get_tags(tags), opts=opts) if index_html is not None: storage.Blob("index.html", name="index.html", content_type="text/html", storage_account_name=self.__account.name, storage_container_name="$web", type="Block", source=pulumi.FileAsset(index_html), opts=opts)
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, 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,
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 sql_server = sql.SqlServer( "sqlserver", resource_group_name=resource_group.name,
}], vpn_client_configuration={ "rootCertificates": [{ "name": root_certificates, "publicCertData": public_certificate_data }], "vpnClientProtocols": ["IkeV2"], "address_spaces": [address_space] } ) # preparation of the RHCOS image # Create an Azure Storage Account storageaccount = storage.Account("pulumistorage", name=rhcos_storage_name, resource_group_name=resource_group.name, account_kind = 'StorageV2', account_tier='Standard', access_tier='Hot', account_replication_type= 'LRS' ) export('primary_connection_string', storageaccount.primary_connection_string) export('primary_account_key', storageaccount.primary_access_key) # Create an Azure storage container storagecontainer = storage.Container("vhd", name="vhd", storage_account_name=storageaccount.name ) # Create an Azure group resource_group_images = core.ResourceGroup('rhcos_images', name='rhcos_images')
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 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",
import pulumi from pulumi_azure import core, storage # Create an Azure Resource Group resource_group = core.ResourceGroup("resource_group") # Create an Azure resource (Storage Account) account = storage.Account("storage", resource_group_name=resource_group.name, account_tier='Standard', account_replication_type='LRS', enable_https_traffic_only=True) # Export the connection string for the storage account pulumi.export('connection_string', account.primary_connection_string)
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, profile_name=cdn_profile.name,
import pulumi from pulumi_azure import core, storage config = pulumi.Config() # Create an Azure Resource Group resource_group = core.ResourceGroup('resource_group') account = storage.Account('storage', resource_group_name=resource_group.name, account_tier='Standard', account_replication_type='LRS') container = storage.Container('mycontainer', name=config.require('container'), storage_account_name=account.name) pulumi.export('account_name', account.name)
location=resource_group.location, ip_configurations=[{ 'name': 'ipconfig1', 'subnet_id': subnet.id, 'private_ip_address_allocation': 'Dynamic', 'public_ip_address_id': public_ip.id, }]) sa = storage.Account( 'diagnostics', resource_group_name=resource_group.name, location=resource_group.location, account_replication_type='LRS', account_tier='Standard', ) user_data = """#!/bin/bash echo "Hello, World!" > index.html nohup python -m SimpleHTTPServer 80 & """ vm = compute.VirtualMachine('server-vm', resource_group_name=resource_group.name, location=resource_group.location, network_interface_ids=[nic.id], vm_size='Standard_A0', delete_data_disks_on_termination=True,
location='EastUs', resource_group_name=resource_group.name) # Create an associated queue within the above namespace servicebus.Queue('scheduled-tweets', name='scheduled-tweets', 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 Azure Storage Account scheduler_account = storage.Account('serverlessschedulerstore', name='serverlessschedulerstore', account_kind="StorageV2", resource_group_name=resource_group.name, account_tier='Standard', account_replication_type='LRS') scheduler_plan = appservice.Plan("serverless-scheduler", name='serverless-scheduler', resource_group_name=resource_group.name, kind="FunctionApp", reserved=True, sku={ "tier": "Dynamic", "size": "Y1" }) scheduler_app = appservice.FunctionApp( "serverless-scheduler",