Application

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as std from "@pulumi/std";
const foo_app = new aws.opsworks.Application("foo-app", {
    name: "foobar application",
    shortName: "foobar",
    stackId: main.id,
    type: "rails",
    description: "This is a Rails application",
    domains: [
        "example.com",
        "sub.example.com",
    ],
    environments: [{
        key: "key",
        value: "value",
        secure: false,
    }],
    appSources: [{
        type: "git",
        revision: "master",
        url: "https://github.com/example.git",
    }],
    enableSsl: true,
    sslConfigurations: [{
        privateKey: std.file({
            input: "./foobar.key",
        }).then(invoke => invoke.result),
        certificate: std.file({
            input: "./foobar.crt",
        }).then(invoke => invoke.result),
    }],
    documentRoot: "public",
    autoBundleOnDeploy: "true",
    railsEnv: "staging",
});

import pulumi
import pulumi_aws as aws
import pulumi_std as std
foo_app = aws.opsworks.Application("foo-app",
    name="foobar application",
    short_name="foobar",
    stack_id=main["id"],
    type="rails",
    description="This is a Rails application",
    domains=[
        "example.com",
        "sub.example.com",
    ],
    environments=[aws.opsworks.ApplicationEnvironmentArgs(
        key="key",
        value="value",
        secure=False,
    )],
    app_sources=[aws.opsworks.ApplicationAppSourceArgs(
        type="git",
        revision="master",
        url="https://github.com/example.git",
    )],
    enable_ssl=True,
    ssl_configurations=[aws.opsworks.ApplicationSslConfigurationArgs(
        private_key=std.file(input="./foobar.key").result,
        certificate=std.file(input="./foobar.crt").result,
    )],
    document_root="public",
    auto_bundle_on_deploy="true",
    rails_env="staging")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Std = Pulumi.Std;
return await Deployment.RunAsync(() =>
{
    var foo_app = new Aws.OpsWorks.Application("foo-app", new()
    {
        Name = "foobar application",
        ShortName = "foobar",
        StackId = main.Id,
        Type = "rails",
        Description = "This is a Rails application",
        Domains = new[]
        {
            "example.com",
            "sub.example.com",
        },
        Environments = new[]
        {
            new Aws.OpsWorks.Inputs.ApplicationEnvironmentArgs
            {
                Key = "key",
                Value = "value",
                Secure = false,
            },
        },
        AppSources = new[]
        {
            new Aws.OpsWorks.Inputs.ApplicationAppSourceArgs
            {
                Type = "git",
                Revision = "master",
                Url = "https://github.com/example.git",
            },
        },
        EnableSsl = true,
        SslConfigurations = new[]
        {
            new Aws.OpsWorks.Inputs.ApplicationSslConfigurationArgs
            {
                PrivateKey = Std.File.Invoke(new()
                {
                    Input = "./foobar.key",
                }).Apply(invoke => invoke.Result),
                Certificate = Std.File.Invoke(new()
                {
                    Input = "./foobar.crt",
                }).Apply(invoke => invoke.Result),
            },
        },
        DocumentRoot = "public",
        AutoBundleOnDeploy = "true",
        RailsEnv = "staging",
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/opsworks"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "./foobar.key",
		}, nil)
		if err != nil {
			return err
		}
		invokeFile1, err := std.File(ctx, &std.FileArgs{
			Input: "./foobar.crt",
		}, nil)
		if err != nil {
			return err
		}
		_, err = opsworks.NewApplication(ctx, "foo-app", &opsworks.ApplicationArgs{
			Name:        pulumi.String("foobar application"),
			ShortName:   pulumi.String("foobar"),
			StackId:     pulumi.Any(main.Id),
			Type:        pulumi.String("rails"),
			Description: pulumi.String("This is a Rails application"),
			Domains: pulumi.StringArray{
				pulumi.String("example.com"),
				pulumi.String("sub.example.com"),
			},
			Environments: opsworks.ApplicationEnvironmentArray{
				&opsworks.ApplicationEnvironmentArgs{
					Key:    pulumi.String("key"),
					Value:  pulumi.String("value"),
					Secure: pulumi.Bool(false),
				},
			},
			AppSources: opsworks.ApplicationAppSourceArray{
				&opsworks.ApplicationAppSourceArgs{
					Type:     pulumi.String("git"),
					Revision: pulumi.String("master"),
					Url:      pulumi.String("https://github.com/example.git"),
				},
			},
			EnableSsl: pulumi.Bool(true),
			SslConfigurations: opsworks.ApplicationSslConfigurationArray{
				&opsworks.ApplicationSslConfigurationArgs{
					PrivateKey:  invokeFile.Result,
					Certificate: invokeFile1.Result,
				},
			},
			DocumentRoot:       pulumi.String("public"),
			AutoBundleOnDeploy: pulumi.String("true"),
			RailsEnv:           pulumi.String("staging"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.opsworks.Application;
import com.pulumi.aws.opsworks.ApplicationArgs;
import com.pulumi.aws.opsworks.inputs.ApplicationEnvironmentArgs;
import com.pulumi.aws.opsworks.inputs.ApplicationAppSourceArgs;
import com.pulumi.aws.opsworks.inputs.ApplicationSslConfigurationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var foo_app = new Application("foo-app", ApplicationArgs.builder()
            .name("foobar application")
            .shortName("foobar")
            .stackId(main.id())
            .type("rails")
            .description("This is a Rails application")
            .domains(
                "example.com",
                "sub.example.com")
            .environments(ApplicationEnvironmentArgs.builder()
                .key("key")
                .value("value")
                .secure(false)
                .build())
            .appSources(ApplicationAppSourceArgs.builder()
                .type("git")
                .revision("master")
                .url("https://github.com/example.git")
                .build())
            .enableSsl(true)
            .sslConfigurations(ApplicationSslConfigurationArgs.builder()
                .privateKey(StdFunctions.file(FileArgs.builder()
                    .input("./foobar.key")
                    .build()).result())
                .certificate(StdFunctions.file(FileArgs.builder()
                    .input("./foobar.crt")
                    .build()).result())
                .build())
            .documentRoot("public")
            .autoBundleOnDeploy(true)
            .railsEnv("staging")
            .build());
    }
}

resources:
  foo-app:
    type: aws:opsworks:Application
    properties:
      name: foobar application
      shortName: foobar
      stackId: ${main.id}
      type: rails
      description: This is a Rails application
      domains:
        - example.com
        - sub.example.com
      environments:
        - key: key
          value: value
          secure: false
      appSources:
        - type: git
          revision: master
          url: https://github.com/example.git
      enableSsl: true
      sslConfigurations:
        - privateKey:
            fn::invoke:
              Function: std:file
              Arguments:
                input: ./foobar.key
              Return: result
          certificate:
            fn::invoke:
              Function: std:file
              Arguments:
                input: ./foobar.crt
              Return: result
      documentRoot: public
      autoBundleOnDeploy: true
      railsEnv: staging

$ pulumi import aws:opsworks/application:Application test <id>