heroku.formation.Formation

Provides a Heroku Formation resource.

A formation represents the formation of processes that should be set for an application.

Please note the following:

• The application must have a dyno in order to update its formation.
• If the heroku formation resource is removed and deleted, this will be a no-op action in Heroku. The Heroku Platform does not have a DELETE endpoint for formation.
• This resource works well with the heroku.app.Release resource, which allows you to deploy a slug/release to an application before the formation can be updated.

Example Usage

# Creates a new application called foobar
resource "heroku_app" "foobar" {
    name = "foobar"
    region = "us"
}

# Creates a new release for application foobar using a slug id
resource "heroku_app_release" "foobar-release" {
    app_id = heroku_app.foobar.id
    slug_id = "01234567-89ab-cdef-0123-456789abcdef"
}

# Update the web formation for the foobar application's web
resource "heroku_formation" "foobar-web" {
    app_id = heroku_app.foobar.id
    type = "web"
    quantity = 2
    size = "standard-2x"

    # Tells Terraform that this formation must be created/updated only after the app release has been created
    depends_on = ["heroku_app_release.foobar-release"]
}

Create Formation Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new Formation(name: string, args: FormationArgs, opts?: CustomResourceOptions);

@overload
def Formation(resource_name: str,
              args: FormationArgs,
              opts: Optional[ResourceOptions] = None)

@overload
def Formation(resource_name: str,
              opts: Optional[ResourceOptions] = None,
              app_id: Optional[str] = None,
              quantity: Optional[int] = None,
              size: Optional[str] = None,
              type: Optional[str] = None)

func NewFormation(ctx *Context, name string, args FormationArgs, opts ...ResourceOption) (*Formation, error)

public Formation(string name, FormationArgs args, CustomResourceOptions? opts = null)

public Formation(String name, FormationArgs args)
public Formation(String name, FormationArgs args, CustomResourceOptions options)

type: heroku:formation:Formation
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

Constructor example

The following reference example uses placeholder values for all input properties.

var formationResource = new Heroku.Formation.Formation("formationResource", new()
{
    AppId = "string",
    Quantity = 0,
    Size = "string",
    Type = "string",
});

example, err := formation.NewFormation(ctx, "formationResource", &formation.FormationArgs{
	AppId:    pulumi.String("string"),
	Quantity: pulumi.Int(0),
	Size:     pulumi.String("string"),
	Type:     pulumi.String("string"),
})

var formationResource = new Formation("formationResource", FormationArgs.builder()
    .appId("string")
    .quantity(0)
    .size("string")
    .type("string")
    .build());

formation_resource = heroku.formation.Formation("formationResource",
    app_id="string",
    quantity=0,
    size="string",
    type="string")

const formationResource = new heroku.formation.Formation("formationResource", {
    appId: "string",
    quantity: 0,
    size: "string",
    type: "string",
});

type: heroku:formation:Formation
properties:
    appId: string
    quantity: 0
    size: string
    type: string

Formation Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

The Formation resource accepts the following input properties:

Outputs

All input properties are implicitly available as output properties. Additionally, the Formation resource produces the following output properties:

Look up Existing Formation Resource

Get an existing Formation resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: FormationState, opts?: CustomResourceOptions): Formation

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        app_id: Optional[str] = None,
        quantity: Optional[int] = None,
        size: Optional[str] = None,
        type: Optional[str] = None) -> Formation

func GetFormation(ctx *Context, name string, id IDInput, state *FormationState, opts ...ResourceOption) (*Formation, error)

public static Formation Get(string name, Input<string> id, FormationState? state, CustomResourceOptions? opts = null)

public static Formation get(String name, Output<String> id, FormationState state, CustomResourceOptions options)

resources:  _:    type: heroku:formation:Formation    get:      id: ${id}

Import

Existing formations can be imported using the combination of the application name, a colon, and the formation’s type.

For example:

$ pulumi import heroku:formation/formation:Formation foobar-web foobar:web

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository

heroku pulumiverse/pulumi-heroku

License

Apache-2.0

Notes

This Pulumi package is based on the heroku Terraform Provider.