Region:
+ VPC
+ IGW

Site
- VPC(region A)
- IGW (region A)
+ Subnet
+ Route Table

Site Type A
- VPC(region A)
- IGW (region A)
- Subnet (site 1)
- Route Table (site 1)
+ EC2

Site Type B
- VPC(region A)
- IGW (region A)
- Subnet (site 1)
- Route Table (site 1)
+ ECK

xyz:index:StaticPage

company_name:module_name:resource_name

index

use1

usw2

def container_definition(image_name, service, env_variables):
    print("service:",service)
    print("env_vars:", env_variables)
    return json.dumps([{
        'name': 'server',
        'image': image_name,
        'networkMode': 'awsvpc',
        'readonlyRootFilesystem': False,
        'essential': True,
        'environment': env_variables,
        ..... Non relevant code continues
    }])

for service in config.common_config['services']:
    env_variables.append({'name': 'SERVICES', 'value': service})
    if service != 'frontend':
        env_variables.append({'name': 'TEMPORAL_CLI_ADDRESS',
            'value': f'{config.common_config["frontend"]["service_name"]}.{config.common_config["dns_namespace"]}'})
    task_definitions[service] = aws.ecs.TaskDefinition(config.common_config[service]['service_name'],
        family=config.common_config[service]['service_name'],
        cpu=config.common_config[service]['cpu'],
        memory=config.common_config[service]['memory'],
        network_mode='awsvpc',
        requires_compatibilities=['FARGATE'],
        execution_role_arn=ecs_task_role.arn,
        task_role_arn=ecs_task_role.arn,
        container_definitions=image.image_name.apply(
            lambda image_name: container_definition(image_name, service, env_variables)),
        tags={
            "Service": "temporal",
        },
        opts=ResourceOptions(depends_on=[log_group]))

service

config.common_config['services']

error: Exception calling application: There is no current event loop in thread 'ThreadPoolExecutor-0_0'.

from pprint import pprint
from pulumi_policy import (
  ReportViolation,
  ResourceValidationArgs,
)
import pulumi
import pulumi_aws as aws

config = pulumi.Config()

def ec2_validator(args: ResourceValidationArgs, report_violation: ReportViolation):

  if args.resource_type == "aws:ec2/instance:Instance":
    if args.props.get('vpcSecurityGroupIds'): 
      sg_id = aws.ec2.get_security_groups(tags={
        "key": "val",
        "key": "val",
      })

      pprint(vars(sg_id))

user_data=pulumi.Output.all(
    {
        "cluster_size": cluster_size,
        "secret_id": secret_id,
    }
).apply(
    lambda args: render_user_data_output(
        templating_env(),
        "userdata-server.sh.jinja",
        *args,
    )
),

def render_user_data_output(
        env: Environment, template_name: str, kwargs: Mapping[str, Any]
) -> str:
    rendered_template = render_template_file(env, template_name, kwargs)
    return base64.b64encode(rendered_template.encode("utf-8")).decode("utf-8")

def render_user_data_output(
        env: Environment, template_name: str, kwargs: Mapping[str, Any]
) -> pulumi.Output:
    rendered_template = render_template_file(env, template_name, kwargs)
    return pulumi.Output.from_input(base64.b64encode(rendered_template.encode("utf-8")).decode("utf-8"))

def render_user_data_output(
        env: Environment, template_name: str, kwargs: Mapping[str, Any]
) -> pulumi.Output:
    rendered_template = render_template_file(env, template_name, kwargs)
    return base64.b64encode(rendered_template.encode("utf-8")).decode("utf-8")

load_balancers_info

__init__.py

pulumi.export

__main__.py

from pulumi_aws import iam

iam.Policy('test', policy='{}')

transport is closing

pulumi

bucket=aws_s3control_bucket["example"]["arn"],   --> Bucket ARN

apply()

# vpc endpoints
        vpc_endpoints = ["s3", "ecr.dkr", "ecr.api", "logs"]
        region_output = self._config.aws_provider.region
        for endpoint in vpc_endpoints:
        
            service_name = region_output.apply(
                        lambda region: f"com.amazonaws.{region}.{endpoint}"  # endpoint here does not update from the loop variable
                    )
            pulumi_aws.ec2.VpcEndpoint(
                f"{self._config.name}-{endpoint}-vpc-endpoint",
                args=pulumi_aws.ec2.VpcEndpointArgs(
                    service_name=service_name,
                    vpc_id=self.vpc.id,
                    tags=self._config.tags,
                ),
                opts=self._opts,
            )

azure:core/getSubscription:getSubscription
azure-native:network:getVirtualNetwork
azure-native:network:getSubnet
azure:keyvault/getKeyVault:getKeyVault
azure:containerservice/getRegistry:getRegistry
azure-native:compute:getSshPublicKey

azuread:index/getGroup:getGroup