serializeFunction

import serviceConfig from '../appsettings.json';

{
    "compilerOptions": {
        "strict": true,
        "outDir": "bin",
        "target": "es2016",
        "module": "commonjs",
        "moduleResolution": "node",
        "sourceMap": true,
        "experimentalDecorators": true,
        "pretty": true,
        "noFallthroughCasesInSwitch": true,
        "noImplicitReturns": true,
        "forceConsistentCasingInFileNames": true,
        "resolveJsonModule": true,
    },
    "files": [
        "index.ts"
    ]
}

aws:iam:RolePolicy (fooRolePolicy):
    error: aws:iam/rolePolicy:RolePolicy resource 'fooRolePolicy' has a problem: "policy" contains an invalid JSON: invalid character '\n' in string literal

new aws.iam.RolePolicy('fooRolePolicy', {
  role: fooRole.id,
  policy: `{
            "Version": "2012-10-17",
            "Statement": [
              {
                "Sid": "AWSCloudTrailCreateLogStream",
                "Effect": "Allow",
                "Action": [
                  "logs:CreateLogStream",
                  "logs:PutLogEvents"
                ],
                "Resource": "${foobarLogGroup.arn}:*"
              }
            ]
          }`,
})

Output<T>

T

Promise<T>

Output<T>

TS

Lambda

Python

Lambda

export const campuSolutionsLambdaIngestCleaner = new aws.lambda.Function(
    "campus-solutions-lambda-ingest-cleaner-foo",
    {
        name: "campuSolutions-LambdaIngestCleaner-foo",
        role: campusSolutionsLambdaRole.arn,
        // code: lambdaScriptBucketObjectCampuSolutionsCleaner,
        s3Bucket: lambdaScriptBucketObjectCampuSolutionsCleaner.bucket,
        s3Key: lambdaScriptBucketObjectCampuSolutionsCleaner.key,
        memorySize: 9000,
        runtime: "python3.8",
        timeout: 800,
        vpcConfig: {
            securityGroupIds: [lambdaSqlRedshiftSecurityGroupfoo.id],
            subnetIds: [
                config.require("az0SubnetPrivateId"),
                config.require("az1SubnetPrivateId"),
            ],
        },
        tags: tags(),
    },
    { deleteBeforeReplace: true },
)

* filename, s3_* or image_uri attributes must be set

error creating Lambda Function: ValidationException: status code: 400, request id: e8e53a21-e586-4bd1-a0dc-e9aa5627a87f

const exampleRecord: aws.route53.Record[];
for (const range of Object.entries(exampleCertificate.domainValidationOptions.apply(domainValidationOptions => domainValidationOptions.reduce((__obj, dvo) => { ...__obj, [dvo.domainName]: {
    name: dvo.resourceRecordName,
    record: dvo.resourceRecordValue,
    type: dvo.resourceRecordType,
} }))).map(([k, v]) => {key: k, value: v})) {
    exampleRecord.push(new aws.route53.Record(`exampleRecord-${range.key}`, {
        allowOverwrite: true,
        name: range.value.name,
        records: [range.value.record],
        ttl: 60,
        type: range.value.type,
        zoneId: exampleZone.then(exampleZone => exampleZone.zoneId),
    }));
}

runtime.setMocks({
    newResource(args: MockResourceArgs): { id: string | undefined; state: Record<string, any> } {
        const { type, id, name } = args;
        expect(type).toEqual("azure-nextgen:network/latest:Subnet");
        return {
            id,
            state: {
                ...args.inputs,
                name,
            },
        };
    },
    call(args: MockCallArgs) {
        return args.inputs;
    },
});

pulumi

data-fns

rootAccountId

const rootAccountId = organization.getOutput('rootAccountId'); <-- output from another stack

const adminRole = createRole({
  allowedActions: accountRoles.admin,
  principal: {
    AWS: [rootAccountId.apply((id) => `arn:aws:iam::${id}:root`)],
  },
  roleName: 'admin',
});

export function createRole({
  allowedActions,
  principal,
  roleName,
}: {
  allowedActions: string[];
  principal: aws.iam.Principal;
  roleName: string;
}) {
  const role = new aws.iam.Role(`${roleName}-role`, {
    assumeRolePolicy: aws.iam.assumeRolePolicyForPrincipal(principal),
  });
  ...
}

aws:elasticache:Cluster (data-feed-control):
    error: unmarshaling urn:pulumi:development::platform-data-feed::aws:elasticache/cluster:Cluster::data-feed-control's instance state: could not read field snapshot_arns: '' expected type 'string', got unconvertible type '[]interface {}', value: '[]'

return new aws.elasticache.Cluster('data-feed-control', {
  clusterId: 'data-feed-control',
  engine: 'redis',
  engineVersion: '6.x',
  nodeType: 'cache.t3.micro',
  numCacheNodes: 1,
  parameterGroupName: 'default.redis6.x',
  securityGroupIds: [defaultSecurityGroup.id],
  subnetGroupName: feedControlSubnetGroup.id
})

export const resources = pulumiResources.reduce(
  (result, res) => ({
    ...result,
    [res.location]: {
      // This variable is Output<string>
      resourceGroup: res.resourceGroup,
      otherProperty: res.foo,
    },
  }),
  {}
);

export const resources = pulumiResources.reduce((result, res) =>
  res.location.apply(
    (location) => ({
      ...result,
      [location]: {
        // This variable is Output<string>
        resourceGroup: res.resourceGroup,
        otherProperty: res.foo,
      },
    }),
    {}
  )
);

Error: Program run without the Pulumi engine available; re-run using the `pulumi` CLI

const vpc = new awsx.ec2.Vpc("BaseNetworkVPC", {
    cidrBlock: "10.50.0.0/22",
    subnets: [
        { type: "public" },
        { type: "private" },
    ],
});

// this is probably wrong, but not sure how to proceed!
const vpcPrivateSubnets = pulumi.output(vpc.privateSubnets).apply(psns => psns.map(psns => psns.routeTable?.id));

// I want to make a routeTable propagation for each of my VPC's private subnets
const routeTablePropagation2 = new aws.ec2.VpnGatewayRoutePropagation("VPGPropagateMainRouteTable", {
        vpnGatewayId: gatewayAssociation.associatedGatewayId,
        routeTableId: // what goes here?
    });
});

done

if-else

Error: Timeout of 2000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. (/Users/r.de.smet/Projects/pulumi-libs/test/gcp/network/index.spec.ts)

ts-mocha

mocha -r ts-node/register

@pulumi

aws.iam.User

max(last_5m):avg:gcp.pubsub.subscription.examplemetric{project_id} by {subscription_id}
Note:  {subscription_id} //contains multiple values

const fs = require('fs')
    const data = fs.readFileSync('./Files/certificates/dev.pfx', 'base64')
    var cert = new azure.keyvault.Certificate("LetsEncrypt", {
        name: "LetsEncrypt",
        keyVaultId: keyVaultId,
        certificate: {
            contents: data,
            password: "MyPassword"
        },
        certificatePolicy: {
             issuerParameters: {
                 name: "Unknown"
            },
            keyProperties: {
                exportable: false,
                keyType: "RSA",
                reuseKey: false,
                keySize: 2048
            },
            secretProperties: {
                contentType: "application/x-pkcs12",
            },
        }

    })