Package @pulumi/cloud-aws

Node.js:

var cloud-aws = require("@pulumi/cloud-aws");

ES6 modules:

import * as cloud-aws from "@pulumi/cloud-aws";

Index

api.ts docker.ts function.ts index.ts service.ts sns.ts table.ts timer.ts topic.ts utils.ts

Modules

class API

constructor

new API(name: string)

method all

public all(path: string, handlers: cloud.RouteHandler[]): void

method attachCustomDomain

public attachCustomDomain(domain: Domain): void

method delete

public delete(path: string, handlers: cloud.RouteHandler[]): void

method get

public get(path: string, handlers: cloud.RouteHandler[]): void

method options

public options(path: string, handlers: cloud.RouteHandler[]): void

method post

public post(path: string, handlers: cloud.RouteHandler[]): void

method proxy

public proxy(path: string, target: string | pulumi.Output<cloud.Endpoint>): void

method publish

public publish(): HttpDeployment

method put

public put(path: string, handlers: cloud.RouteHandler[]): void

method route

public route(method: string, path: string, handlers: cloud.RouteHandler[]): void

method static

public static(path: string, localPath: string, options?: cloud.ServeStaticOptions): void

property customDomains

private customDomains: Domain[];

property deployment

public deployment?: HttpDeployment;

property name

private name: string;

property proxyRoutes

private proxyRoutes: ProxyRoute[];

property routes

private routes: Route[];

property staticRoutes

private staticRoutes: StaticRoute[];

class Function

constructor

new Function(name: string, handler: aws.serverless.Handler, opts?: pulumi.ResourceOptions)

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | undefined): void

property handler

public handler: aws.serverless.Handler;

property lambda

public lambda: aws.lambda.Function;

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class HostPathVolume

constructor

new HostPathVolume(path: string)

method getHostPath

getHostPath(): string

method getVolumeName

getVolumeName(): string

property kind

public kind: cloud.VolumeKind;

property path

public path: string;

class HttpDeployment

constructor

new HttpDeployment(name: string, staticRoutes: StaticRoute[], proxyRoutes: ProxyRoute[], routes: Route[], customDomains: Domain[], opts?: pulumi.ResourceOptions)

method isInstance

static isInstance(obj: any): boolean

method registerCustomDomains

private static registerCustomDomains(parent: pulumi.Resource, apiName: string, api: aws.apigateway.RestApi, domains: Domain[]): aws.apigateway.DomainName[]

method registerOutputs

protected registerOutputs(outputs: Inputs | undefined): void

method registerProxyRoutes

private static registerProxyRoutes(parent: pulumi.Resource, apiName: string, proxyRoutes: ProxyRoute[], swagger: SwaggerSpec): void

method registerRoutes

private static registerRoutes(parent: pulumi.Resource, apiName: string, routes: Route[], swagger: SwaggerSpec): { ... }

method registerStaticRoutes

private static registerStaticRoutes(parent: pulumi.Resource, apiName: string, staticRoutes: StaticRoute[], swagger: SwaggerSpec): void

property customDomainNames

public customDomainNames: pulumi.Output<string>[];

property customDomains

public customDomains: aws.apigateway.DomainName[];

property routes

public routes: Route[];

property staticRoutes

public staticRoutes: StaticRoute[];

property url

public url: pulumi.Output<string>;

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class Service

constructor

new Service(name: string, args: cloud.ServiceArguments, opts?: pulumi.ResourceOptions)

method getTaskRole

public static getTaskRole(): aws.iam.Role

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | undefined): void

property cluster

public cluster: CloudCluster;

property containers

public containers: cloud.Containers;

property defaultEndpoint

public defaultEndpoint: pulumi.Output<Endpoint>;

property ecsService

public ecsService: aws.ecs.Service;

property endpoints

public endpoints: pulumi.Output<Endpoints>;

property getEndpoint

public getEndpoint: { ... };

property name

public name: string;

property replicas

public replicas: number;

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class SharedVolume

constructor

new SharedVolume(name: string, opts?: pulumi.ResourceOptions)

method getHostPath

getHostPath(): string

method getVolumeName

getVolumeName(): string

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | undefined): void

property kind

public kind: cloud.VolumeKind;

property name

public name: string;

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class Table

constructor

new Table(name: string, primaryKey?: pulumi.Input<string>, primaryKeyType?: pulumi.Input<cloud.PrimaryKeyType>, opts?: pulumi.ResourceOptions)

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | undefined): void

property delete

public delete: { ... };

property dynamodbTable

public dynamodbTable: aws.dynamodb.Table;

property get

public get: { ... };

property insert

public insert: { ... };

property primaryKey

public primaryKey: pulumi.Output<string>;

property primaryKeyType

public primaryKeyType: pulumi.Output<string>;

property scan

public scan: { ... };

property update

public update: { ... };

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class Task

A Task represents a container which can be [run] dynamically whenever (and as many times as) needed.

constructor

new Task(name: string, container: cloud.Container, opts?: pulumi.ResourceOptions)

method getTaskRole

public static getTaskRole(): aws.iam.Role

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | undefined): void

property cluster

public cluster: CloudCluster;

property run

public run: { ... };

property taskDefinition

public taskDefinition: aws.ecs.TaskDefinition;

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class Timer

constructor

new Timer(name: string, scheduleExpression: string, handler: timer.Action, opts?: pulumi.ResourceOptions)

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | undefined): void

property function

public function: Function;

property rule

public rule: aws.cloudwatch.EventRule;

property scheduleExpression

public scheduleExpression: string;

property target

public target: aws.cloudwatch.EventTarget;

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

class Topic

constructor

new Topic(name: string, opts?: pulumi.ResourceOptions)

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | undefined): void

method subscribe

public subscribe(name: string, handler: { ... }): void

property name

private name: string;

property publish

public publish: { ... };

property subscriptions

public subscriptions: aws.sns.TopicSubscription[];

property topic

public topic: aws.sns.Topic;

property urn

urn: Output<URN>;

urn is the stable logical URN used to distinctly address a resource, both before and after deployments.

const apigatewayAssumeRolePolicyDocument

let Statement

let Statement: { ... }[] =  [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service": "apigateway.amazonaws.com",
            },
            "Action": "sts:AssumeRole",
        },
    ];

let Version

let Version: string = "2012-10-17";

const buildImageCache

const buildImageCache: Map<string, Output<string>> =  new Map<string, pulumi.Output<string>>();

const consistentRead

const consistentRead: true = true;

const repositories

const repositories: Map<string, Repository> =  new Map<string, aws.ecr.Repository>();

const stageName

const stageName: stage = "stage";

const taskRolePolicy

let Statement

let Statement: { ... }[] =  [
        {
            "Action": "sts:AssumeRole",
            "Principal": {
                "Service": "ecs-tasks.amazonaws.com",
            },
            "Effect": "Allow",
            "Sid": "",
        },
    ];

let Version

let Version: string = "2012-10-17";

const thisShape

const thisShape: "/Users/swgillespie/go/src/github.com/pulumi/pulumi-cloud/aws/index" =  undefined as any;

const volumeNames

const volumeNames: Set<string> =  new Set<string>();

function apiGatewayToRequestResponse

apiGatewayToRequestResponse(ev: APIGatewayRequest, body: Buffer, cb: { ... }): RequestResponse

function apply

apply<T,U>(val: Record<string, T>, func: { ... }): Record<string, U>

function buildAndPushImage

buildAndPushImage(imageName: string, container: cloud.Container, repositoryUrl: pulumi.Input<string>, logResource: pulumi.Resource, connectToRegistry: { ... }): pulumi.Output<string>

function buildImageAsync

buildImageAsync(imageName: string, container: cloud.Container, logResource: pulumi.Resource, cacheFrom: Promise<string[] | undefined>): Promise<BuildResult>

function computeContainerDefinitions

computeContainerDefinitions(containers: cloud.Containers, ports: ExposedPorts | undefined, logGroup: aws.cloudwatch.LogGroup): pulumi.Output<aws.ecs.ContainerDefinition[]>

function computeImage

computeImage(imageName: string, container: cloud.Container, ports: ExposedPorts | undefined, repository: aws.ecr.Repository | undefined): pulumi.Output<ImageOptions>

function createBaseSpec

createBaseSpec(apiName: string): SwaggerSpec

function createLoadBalancer

createLoadBalancer(parent: pulumi.Resource, cluster: CloudCluster, serviceName: string, containerName: string, portMapping: cloud.ContainerPort, network: CloudNetwork): ContainerPortLoadBalancer

function createPathSpecLambda

createPathSpecLambda(lambda: aws.lambda.Function): SwaggerOperationAsync

function createPathSpecObject

createPathSpecObject(bucket: aws.s3.Bucket, key: string, role: aws.iam.Role, pathParameter?: undefined | string): SwaggerOperationAsync

function createPathSpecProxy

createPathSpecProxy(target: string | pulumi.Output<cloud.Endpoint>, vpcLink: aws.apigateway.VpcLink | undefined, useProxyPathParameter: boolean): SwaggerOperationAsync

function createScheduledEvent

createScheduledEvent(name: string, scheduleExpression: string, handler: timer.Action, opts?: pulumi.ResourceOptions): void

function createSubscription

createSubscription(resName: string, topic: aws.sns.Topic, handler: { ... }): aws.sns.TopicSubscription

function createSwaggerString

createSwaggerString(spec: SwaggerSpec): pulumi.Output<string>

function createTaskDefinition

createTaskDefinition(parent: pulumi.Resource, name: string, containers: cloud.Containers, ports?: ExposedPorts): TaskDefinition

function cron

cron(name: string, cronTab: string, handler: timer.Action, opts?: pulumi.ResourceOptions): void

function daily

daily(name: string, scheduleOrHandler: timer.DailySchedule | timer.Action, handlerOrOptions?: timer.Action | pulumi.ResourceOptions, opts?: pulumi.ResourceOptions): void

function dockerBuild

dockerBuild(imageName: string, build: cloud.ContainerBuild, cacheFrom: Promise<string[] | undefined>, target?: undefined | string): Promise<void>

function getEndpointHelper

getEndpointHelper(endpoints: Endpoints, containerName: string | undefined, containerPort: number | undefined): Endpoint

function getEndpoints

getEndpoints(ports: ExposedPorts): pulumi.Output<Endpoints>

function getExecutionRole

getExecutionRole(): aws.iam.Role

function getImageName

getImageName(container: cloud.Container): string

function getOrCreateRepository

getOrCreateRepository(imageName: string): aws.ecr.Repository

function getTaskRole

getTaskRole(): aws.iam.Role

function hourly

hourly(name: string, scheduleOrHandler: timer.HourlySchedule | timer.Action, handlerOrOptions?: timer.Action | pulumi.ResourceOptions, opts?: pulumi.ResourceOptions): void

function interval

interval(name: string, options: timer.IntervalRate, handler: timer.Action, opts?: pulumi.ResourceOptions): void

function isCloudDomain

isCloudDomain(domain: Domain): boolean

function liftResource

liftResource<T>(resource: T): pulumi.Output<T>

function localStageImageName

localStageImageName(imageName: string, stage: string): string

function loginToRegistry

loginToRegistry(registry: Registry): Promise<void>

function makeServiceEnvName

makeServiceEnvName(service: string): string

function parseDockerEngineUpdatesFromBuffer

parseDockerEngineUpdatesFromBuffer(buffer: Buffer): any[]

function placementConstraintsForHost

placementConstraintsForHost(host: cloud.HostProperties | undefined): undefined | { ... }[]

function pullCacheAsync

pullCacheAsync(imageName: string, cacheFrom: cloud.CacheFrom, login: { ... }, repositoryUrl: Promise<string>, logResource: pulumi.Resource): Promise<string[] | undefined>

function pulumiKeyTypeToDynamoKeyType

pulumiKeyTypeToDynamoKeyType(keyType: cloud.PrimaryKeyType): string

function pushImageAsync

pushImageAsync(imageName: string, repositoryUrl: string, tag?: undefined | string): Promise<void>

function runCLICommand

runCLICommand(cmd: string, args: string[], returnStdout?: undefined | true | false, stdin?: undefined | string): Promise<CommandResult>

function safeS3BucketName

safeS3BucketName(apiName: string): string

function sha1hash

sha1hash(s: string): string

function swaggerMethod

swaggerMethod(method: string): string

function taskMemoryAndCPUForContainers

taskMemoryAndCPUForContainers(defs: aws.ecs.ContainerDefinition[]): { ... }

interface APIGatewayIdentity

property accountId

accountId?: undefined | string;

property apiKey

apiKey?: undefined | string;

property caller

caller?: undefined | string;

property cognitoAuthenticationProvider

cognitoAuthenticationProvider?: undefined | string;

property cognitoAuthenticationType

cognitoAuthenticationType?: undefined | string;

property cognitoIdentityId

cognitoIdentityId?: undefined | string;

property cognitoIdentityPoolId

cognitoIdentityPoolId?: undefined | string;

property sourceIp

sourceIp?: undefined | string;

property user

user?: undefined | string;

property userAgent

userAgent?: undefined | string;

property userArn

userArn?: undefined | string;

interface APIGatewayRequest

property body

body: string;

property headers

headers: { ... };

property httpMethod

httpMethod: string;

property isBase64Encoded

isBase64Encoded: boolean;

property path

path: string;

property pathParameters

pathParameters: { ... };

property queryStringParameters

queryStringParameters: { ... };

property requestContext

requestContext: APIGatewayRequestContext;

property resource

resource: string;

property stageVariables

stageVariables: { ... };

interface APIGatewayRequestContext

property accountId

accountId: string;

property apiId

apiId: string;

property httpMethod

httpMethod: string;

property identity

identity: APIGatewayIdentity;

property requestId

requestId: string;

property resourceId

resourceId: string;

property resourcePath

resourcePath: string;

property stage

stage: string;

interface APIGatewayResponse

property body

body: string;

property headers

headers?: undefined | { ... };

property isBase64Encoded

isBase64Encoded?: undefined | true | false;

property statusCode

statusCode: number;

interface AWSDomain

property certificateArn

certificateArn: pulumi.Input<string>;

property domainName

domainName: string;

interface ApigatewayIntegration

property connectionId

connectionId?: undefined | string;

property connectionType

connectionType?: undefined | string;

property credentials

credentials?: undefined | string;

property httpMethod

httpMethod: string;

property passthroughBehavior

passthroughBehavior?: undefined | string;

property requestParameters

requestParameters?: any;

property responses

responses?: undefined | { ... };

property type

type: string;

property uri

uri: string;

interface ApigatewayIntegrationAsync

property connectionId

connectionId?: pulumi.Output<string>;

property connectionType

connectionType?: undefined | string;

property credentials

credentials?: pulumi.Output<string>;

property httpMethod

httpMethod: string;

property passthroughBehavior

passthroughBehavior?: undefined | string;

property requestParameters

requestParameters?: any;

property responses

responses?: undefined | { ... };

property type

type: string;

property uri

uri: pulumi.Output<string>;

interface ApigatewayIntegrationBase

property connectionType

connectionType?: undefined | string;

property httpMethod

httpMethod: string;

property passthroughBehavior

passthroughBehavior?: undefined | string;

property requestParameters

requestParameters?: any;

property responses

responses?: undefined | { ... };

property type

type: string;

interface BuildResult

property digest

digest: string;

property stages

stages: string[];

interface CommandResult

property code

code: number;

property stdout

stdout?: undefined | string;

interface ContainerPortLoadBalancer

property loadBalancer

loadBalancer: aws.elasticloadbalancingv2.LoadBalancer;

property protocol

protocol: cloud.ContainerProtocol;

property targetGroup

targetGroup: aws.elasticloadbalancingv2.TargetGroup;

interface Endpoint

property hostname

hostname: string;

property loadBalancer

loadBalancer: aws.elasticloadbalancingv2.LoadBalancer;

property port

port: number;

interface ExposedPort

property host

host: aws.elasticloadbalancingv2.LoadBalancer;

property hostPort

hostPort: number;

property hostProtocol

hostProtocol: cloud.ContainerProtocol;

interface ExposedPorts

interface ImageOptions

property environment

environment: Record<string, string>;

property image

image: string;

interface ProxyRoute

property path

path: string;

property target

target: string | pulumi.Output<cloud.Endpoint>;

interface Registry

property password

password: string;

property registry

registry: string;

property username

username: string;

interface RequestResponse

property req

req: cloud.Request;

property res

res: cloud.Response;

interface Route

property handlers

handlers: cloud.RouteHandler[];

property method

method: string;

property path

path: string;

interface SNSEvent

property Records

Records: SNSRecord[];

interface SNSItem

property Message

Message: string;

property MessageAttributes

MessageAttributes: { ... };

property MessageId

MessageId: string;

property Signature

Signature: string;

property SignatureVersion

SignatureVersion: string;

property SigningCertUrl

SigningCertUrl: string;

property Subject

Subject: string;

property Timestamp

Timestamp: string;

property TopicArn

TopicArn: string;

property Type

Type: string;

property UnsubscribeUrl

UnsubscribeUrl: string;

interface SNSMessageAttribute

property Type

Type: string;

property Value

Value: string;

interface SNSRecord

property EventSource

EventSource: string;

property EventSubscriptionArn

EventSubscriptionArn: string;

property EventVersion

EventVersion: string;

property Sns

Sns: SNSItem;

interface StaticRoute

property localPath

localPath: string;

property options

options: cloud.ServeStaticOptions;

property path

path: string;

interface SwaggerAPIGatewayIntegrationResponse

property responseParameters

responseParameters?: undefined | { ... };

property statusCode

statusCode: string;

interface SwaggerHeader

property items

items?: SwaggerItems;

property type

type: string | number | integer | boolean | array;

interface SwaggerInfo

property title

title: string;

property version

version: string;

interface SwaggerItems

property items

items?: SwaggerItems;

property type

type: string | number | integer | boolean | array;

interface SwaggerOperation

property parameters

parameters?: any[];

property responses

responses?: undefined | { ... };

property x-amazon-apigateway-integration

x-amazon-apigateway-integration: ApigatewayIntegration;

interface SwaggerOperationAsync

property parameters

parameters?: any[];

property responses

responses?: undefined | { ... };

property x-amazon-apigateway-integration

x-amazon-apigateway-integration: ApigatewayIntegrationAsync;

interface SwaggerResponse

property description

description: string;

property headers

headers?: undefined | { ... };

property schema

schema?: SwaggerSchema;

interface SwaggerSchema

property type

type: string;

interface SwaggerSpec

property info

info: SwaggerInfo;

property paths

paths: { ... };

property swagger

swagger: string;

property x-amazon-apigateway-binary-media-types

x-amazon-apigateway-binary-media-types?: string[];

interface TaskDefinition

property logGroup

logGroup: aws.cloudwatch.LogGroup;

property task

task: aws.ecs.TaskDefinition;

interface Volume

method getHostPath

getHostPath(): any

method getVolumeName

getVolumeName(): any

property kind

kind: VolumeKind;

let apiShape

let apiShape: "/Users/swgillespie/go/src/github.com/pulumi/pulumi-cloud/aws/node_modules/@pulumi/cloud/types" =  undefined as any;

let cachedDockerVersionString

let cachedDockerVersionString: string | undefined;

let dockerPasswordStdin

let dockerPasswordStdin: boolean = false;

let executionRole

let executionRole: aws.iam.Role | undefined;

let taskRole

let taskRole: aws.iam.Role | undefined;

type Domain

type Domain = cloud.Domain | AWSDomain;

type Endpoints

type Endpoints = { ... };

type HttpEndpoint

type HttpEndpoint = API;