db_user = os.environ['DB_USER']

# Create Output[Mapping] for use with args[Input[Mapping[str,str]]]
gatheredDBOutput = pulumi.Output.all(
    db_host_address, 
    db_host_port, 
    db_name
)

def createBuildArgs(host_address, host_port, name, user):
    return json.dumps({
        "db_host_address": host_address,
        "db_host_port": host_port,
        "db_name": name,
        "db_user": user,
    })

buildArgs = gatheredDBOutput.apply(lambda args: 
    createBuildArgs(args[0], args[1], args[2], db_user)
)

flask_image = docker.Image("flask-dockerimage",
    image_name=app_ecr_repo_repository_url,
    build=docker.DockerBuild(
        context="./frontend",
        args=buildArgs
    ),
    skip_push=False,
    registry=app_registry
)

TypeError: Object of type Output is not JSON serializable

Output.all().apply()

json.dumps()

docker.Image()

Output

build.args

pulumi_docker

pulumi.Input[Mapping[str, pulumi.Input[str]]]

mkdir example-stack

pulumi new--dir example-stack

aws-python

cd example-stack

pulumi up

const resourceId = (resource: string) =>
  pulumi
    .all([resourceGroup.name, currentSubscription])
    .apply(
      ([resourceGroupName, subscription]) =>
        `/subscriptions/${subscription.subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.Network/applicationGateways/${applicationGatewayName}/${resource}/${defaultName}`
    );

VM_SIZE = pulumi_azure_native.containerservice.ContainerServiceVMSizeTypes(
        config.require('vmSize'),
)

ResourceOptions

parent

dependsOn

def get_appgw_id(gw_name):
    return Output.concat("/subscriptions/",subscription_id,"/resourceGroups/",resource_group.name,"/providers/Microsoft.ManagedIdentity/userAssignedIdentities/",gw_name)
...
...
identity=network.ManagedServiceIdentityArgs(
        type="UserAssigned",
        user_assigned_identities={
        str(Output.concat(gatewayId.id)): {},
        f"{gatewayId.id.apply(lambda id: id)}": {},
        f"{Output.concat('/subscriptions/',subscription_id,'/resourceGroups/',resource_group.name,'/providers/Microsoft.ManagedIdentity/userAssignedIdentities',gatewayId.name)}": {},
        f"/subscriptions/{subscription_id}/resourcegroups/{resource_group.name}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{gatewayId.name}": {},
        f"{get_appgw_id(gatewayId.name)}": {},
        f"/subscriptions/*****/resourcegroups/*****/providers/Microsoft.ManagedIdentity/userAssignedIdentities/*****": {},

        },
    ),

for i in range(replicas):
    vm_fqdn = dns_zone.apply(lambda a: f"couchbase{i + 1}-{db_name}.{a}")
    dns.RecordSet(f'couchbase{i + 1}-recordset-pubzone',
        managed_zone = dns_name,
        name = vm_fqdn,
        rrdatas=[replica.network_interfaces.apply(lambda a: a[0].get('networkIp'))],
        ttl = 300,
        type = "A",
        opts=pulumi.ResourceOptions(depends_on=[couch]))

pulumi up

CONFIG_PROJ = p.Config()
REGISTRY_USERNAME = CONFIG_PROJ.require('registryUsername')
REGISTRY_PASSWORD = CONFIG_PROJ.require_secret('registryPassword')

registry_credentials_encoded = base64.b64encode(
    f'{REGISTRY_USERNAME}:{REGISTRY_PASSWORD}'.encode(),
).decode()

REGISTRY_PASSWORD

<pulumi.output.Output object at 0x152478cd0>

REGISTRY_PASSWORD.apply(lambda s: s)

pulumi.Output.all(REGISTRY_PASSWORD).apply(lambda s: s)

Output

serviceAccounts = [
    ("droneci", "droneci", "Drone Service Account", ["roles/storage.admin"]),
    (
        "spinnaker",
        "spinnaker",
        "Spinnaker Service Account",
        [
            "roles/container.admin",
            "roles/container.clusterAdmin",
            "roles/container.developer",
            "roles/storage.admin",
        ],
    )
]

def bindToRole(name: str, sa: Account, args: Optional[dict] = None):
    """Given a GCP IAM Service Account and a list of roles, create a IAMBinginh between them."""
    for i, role in enumerate(args["roles"]):
        IAMBinding(
            f"{name}-{i}",
            members=[sa.email.apply(lambda email: f"serviceAccount:{email}")],
            project=args["project"],
            role=role,
        )

for saName, saId, saDesc, saRoles in serviceAccounts:
    sa = Account(
        saName, project=conf.get("project"), account_id=saId, display_name=saDesc
    )
    bindToRole(
        f"{saName}-roleBinding", sa, {"project": conf.get("project"), "roles": saRoles}
    )
    saKey = util.createServiceAccountKey(f"{saName}-key", sa)
    export(name=f"{saName}-serviceAccount-key", value=saKey)
    export(name=f"{saName}-serviceAccount-secret", value=util.clientSecret(saKey))
    export(name=f"{saName}-serviceAccount-email", value=sa.email)

~ gcp:projects/iAMBinding:IAMBinding: (refresh)
        [id=my-project/roles/storage.admin]
        [urn=urn:pulumi:dev::my-stack::gcp:projects/iAMBinding:IAMBinding::spinnaker-roleBinding-3]
        [provider=urn:pulumi:dev::my stack::pulumi:providers:gcp::default_4_17_0::620feff3-c68d-4f3f-b35d-715c080f8b7d]
        --outputs:--
      ~ etag     : "BwW/YsjdngI=" => "BwW/YucGdm0="
      ~ members  : [
          ~ [0]: "serviceAccount:spinnaker@my-project.iam.gserviceaccount.com" => "serviceAccount:droneci@my-project.iam.gserviceaccount.com"
        ]

self.user_email_iam_role = iam.IAMMember(
            resource_name="gcp-default-account-iam",
            member=self.user_email,
            role="roles/iam.serviceAccountUser",
            service_account_id=<http://self.sa|self.sa>
        )

<http://self.sa|self.sa> = iam.Account(
            resource_name="xx",
            project="xx",
            account_id="xx",
            display_name="xx"
        ),