Fork me on GitHub

Package @pulumi/cloud-aws

Node.js:

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

ES6 modules:

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

Index

api.ts function.ts service.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 deployment

public deployment?: HttpDeployment;

class Function

constructor

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

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | Promise<Inputs> | Output<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 getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | Promise<Inputs> | Output<Inputs> | undefined): void

property api

public api: x.API;

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: ServiceArguments, opts?: pulumi.ResourceOptions)

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method getTaskRole

public static getTaskRole(): aws.iam.Role

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | Promise<Inputs> | Output<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 getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method getVolumeName

getVolumeName(): string

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | Promise<Inputs> | Output<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 getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | Promise<Inputs> | Output<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 getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method getTaskRole

public static getTaskRole(): aws.iam.Role

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | Promise<Inputs> | Output<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 Topic

constructor

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

method getProvider

getProvider(moduleMember: string): ProviderResource | undefined

method isInstance

static isInstance(obj: any): boolean

method registerOutputs

protected registerOutputs(outputs: Inputs | Promise<Inputs> | Output<Inputs> | undefined): void

method subscribe

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

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.

function apply

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

function createCallbackFunction

createCallbackFunction(name: string, handler: aws.serverless.Handler | aws.serverless.HandlerFactory, isFactoryFunction: boolean, opts?: pulumi.ResourceOptions): aws.lambda.CallbackFunction<any, any>

function createFactoryFunction

createFactoryFunction(name: string, handler: aws.serverless.HandlerFactory, opts?: pulumi.ResourceOptions): Function

function createFunction

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

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 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 liftResource

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

function sha1hash

sha1hash(s: string): string

interface AWSDomain

property certificateArn

certificateArn: pulumi.Input<string>;

property domainName

domainName: string;

interface Endpoint

property hostname

hostname: string;

property loadBalancer

loadBalancer: aws.elasticloadbalancingv2.LoadBalancer;

property port

port: number;

interface ProxyRoute

property path

path: string;

property target

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

interface Route

property handlers

handlers: cloud.RouteHandler[];

property method

method: string;

property path

path: string;

interface ServiceArguments

property build

build?: string | ContainerBuild;

Either a path to a folder in which a Docker build should be run to construct the image for this Container, or a ContainerBuild object with more detailed build instructions. If image is also specified, the built container will be tagged with that name, but otherwise will get an auto-generated image name.

property command

command?: pulumi.Input<string[]>;

The command line that is passed to the container. This parameter maps to Cmd in the Create a container section of the Docker Remote API and the COMMAND parameter to docker run. For more information about the Docker CMD parameter, go to https://docs.docker.com/engine/reference/builder/#cmd.

property containers

containers?: Containers;

A collection of containers that will be deployed as part of this Service, if there are multiple.

property cpu

cpu?: pulumi.Input<number>;

Number of CPUs for the container to use. Maps to the Docker --cpus option - see https://docs.docker.com/engine/reference/commandline/run.

property dockerLabels

dockerLabels?: pulumi.Input<{ ... }>;

A key/value map of labels to add to the container. This parameter maps to Labels in the Create a container section of the Docker Remote API and the –label option to docker run.

property environment

environment?: undefined | { ... };

Optional environment variables to set and make available to the container as it is running.

property function

function?: undefined | { ... };

The function code to use as the implementation of the contaner. If function is specified, neither image nor build are legal.

property healthCheckGracePeriodSeconds

healthCheckGracePeriodSeconds?: pulumi.Input<number>;

Seconds to ignore failing load balancer health checks on newly instantiated tasks to prevent premature shutdown, up to 7200. Only valid for services configured to use load balancers.

property host

host?: HostProperties;

The properties of the host where this service can run.

property image

image?: undefined | string;

The image to use for the container. If image is specified, but not build, the image will be pulled from the Docker Hub. If image and build are specified, the image controls the resulting image tag for the build image that gets pushed.

property memory

memory?: pulumi.Input<number>;

The maximum amount of memory the container will be allowed to use. Maps to the Docker --memory option - see https://docs.docker.com/engine/reference/commandline/run.

This should be supplied in MB. i.e. A value of 1024 would equal one gigabyte.

property memoryReservation

memoryReservation?: pulumi.Input<number>;

The amount of memory to reserve for the container, but the container will be allowed to use more memory if it’s available. At least one of memory and memoryReservation must be specified. Maps to the Docker --memory-reservation option - see https://docs.docker.com/engine/reference/commandline/run.

This should be supplied in MB. i.e. A value of 1024 would equal one gigabyte.

property ports

ports?: ContainerPort[];

An array of ports to publish from the container. Ports are exposed using the TCP protocol. If the [external] flag is true, the port will be exposed to the Internet even if the service is running in a private network. Maps to the Docker --publish option - see https://docs.docker.com/engine/reference/commandline/run.

property replicas

replicas?: undefined | number;

The number of copies of this Service’s containers to deploy and maintain as part of the running service. Defaults to 1.

property volumes

volumes?: ContainerVolumeMount[];

An array of volume mounts, indicating a volume to mount and a path within the container at which to moung the volume. Maps to the Docker --volume option - see https://docs.docker.com/engine/reference/commandline/run.

property waitForSteadyState

waitForSteadyState?: undefined | false | true;

Determines whether the service should wait to fully transition to a new steady state on creation and updates. If set to false, the service may complete its deployment before it is fully ready to be used. Defaults to ‘true’.

interface StaticRoute

property localPath

localPath: string;

property options

options: cloud.ServeStaticOptions;

property path

path: string;

interface Volume

method getHostPath

getHostPath(): any

method getVolumeName

getVolumeName(): any

property kind

kind: VolumeKind;

type Domain

type Domain = cloud.Domain | AWSDomain;

type Endpoints

type Endpoints = { ... };

type HttpEndpoint

type HttpEndpoint = API;