pulumi-digitalocean-kotlin/com.pulumi.digitalocean.kotlin/App

App

class App : KotlinCustomResource

Provides a DigitalOcean App resource.

Example Usage

To create an app, provide a DigitalOcean app spec specifying the app's components.

Basic Example

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const golang_sample = new digitalocean.App("golang-sample", {spec: {
    name: "golang-sample",
    region: "ams",
    services: [{
        name: "go-service",
        environmentSlug: "go",
        instanceCount: 1,
        instanceSizeSlug: "professional-xs",
        git: {
            repoCloneUrl: "https://github.com/digitalocean/sample-golang.git",
            branch: "main",
        },
    }],
}});

import pulumi
import pulumi_digitalocean as digitalocean
golang_sample = digitalocean.App("golang-sample", spec=digitalocean.AppSpecArgs(
    name="golang-sample",
    region="ams",
    services=[digitalocean.AppSpecServiceArgs(
        name="go-service",
        environment_slug="go",
        instance_count=1,
        instance_size_slug="professional-xs",
        git=digitalocean.AppSpecServiceGitArgs(
            repo_clone_url="https://github.com/digitalocean/sample-golang.git",
            branch="main",
        ),
    )],
))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var golang_sample = new DigitalOcean.App("golang-sample", new()
    {
        Spec = new DigitalOcean.Inputs.AppSpecArgs
        {
            Name = "golang-sample",
            Region = "ams",
            Services = new[]
            {
                new DigitalOcean.Inputs.AppSpecServiceArgs
                {
                    Name = "go-service",
                    EnvironmentSlug = "go",
                    InstanceCount = 1,
                    InstanceSizeSlug = "professional-xs",
                    Git = new DigitalOcean.Inputs.AppSpecServiceGitArgs
                    {
                        RepoCloneUrl = "https://github.com/digitalocean/sample-golang.git",
                        Branch = "main",
                    },
                },
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.NewApp(ctx, "golang-sample", &digitalocean.AppArgs{
			Spec: &digitalocean.AppSpecArgs{
				Name:   pulumi.String("golang-sample"),
				Region: pulumi.String("ams"),
				Services: digitalocean.AppSpecServiceArray{
					&digitalocean.AppSpecServiceArgs{
						Name:             pulumi.String("go-service"),
						EnvironmentSlug:  pulumi.String("go"),
						InstanceCount:    pulumi.Int(1),
						InstanceSizeSlug: pulumi.String("professional-xs"),
						Git: &digitalocean.AppSpecServiceGitArgs{
							RepoCloneUrl: pulumi.String("https://github.com/digitalocean/sample-golang.git"),
							Branch:       pulumi.String("main"),
						},
					},
				},
			},
		})
		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.digitalocean.App;
import com.pulumi.digitalocean.AppArgs;
import com.pulumi.digitalocean.inputs.AppSpecArgs;
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 golang_sample = new App("golang-sample", AppArgs.builder()
            .spec(AppSpecArgs.builder()
                .name("golang-sample")
                .region("ams")
                .services(AppSpecServiceArgs.builder()
                    .name("go-service")
                    .environmentSlug("go")
                    .instanceCount(1)
                    .instanceSizeSlug("professional-xs")
                    .git(AppSpecServiceGitArgs.builder()
                        .repoCloneUrl("https://github.com/digitalocean/sample-golang.git")
                        .branch("main")
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  golang-sample:
    type: digitalocean:App
    properties:
      spec:
        name: golang-sample
        region: ams
        services:
          - name: go-service
            environmentSlug: go
            instanceCount: 1
            instanceSizeSlug: professional-xs
            git:
              repoCloneUrl: https://github.com/digitalocean/sample-golang.git
              branch: main

Static Site Example

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const static_site_example = new digitalocean.App("static-site-example", {spec: {
    name: "static-site-example",
    region: "ams",
    staticSites: [{
        name: "sample-jekyll",
        buildCommand: "bundle exec jekyll build -d ./public",
        outputDir: "/public",
        git: {
            repoCloneUrl: "https://github.com/digitalocean/sample-jekyll.git",
            branch: "main",
        },
    }],
}});

import pulumi
import pulumi_digitalocean as digitalocean
static_site_example = digitalocean.App("static-site-example", spec=digitalocean.AppSpecArgs(
    name="static-site-example",
    region="ams",
    static_sites=[digitalocean.AppSpecStaticSiteArgs(
        name="sample-jekyll",
        build_command="bundle exec jekyll build -d ./public",
        output_dir="/public",
        git=digitalocean.AppSpecStaticSiteGitArgs(
            repo_clone_url="https://github.com/digitalocean/sample-jekyll.git",
            branch="main",
        ),
    )],
))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var static_site_example = new DigitalOcean.App("static-site-example", new()
    {
        Spec = new DigitalOcean.Inputs.AppSpecArgs
        {
            Name = "static-site-example",
            Region = "ams",
            StaticSites = new[]
            {
                new DigitalOcean.Inputs.AppSpecStaticSiteArgs
                {
                    Name = "sample-jekyll",
                    BuildCommand = "bundle exec jekyll build -d ./public",
                    OutputDir = "/public",
                    Git = new DigitalOcean.Inputs.AppSpecStaticSiteGitArgs
                    {
                        RepoCloneUrl = "https://github.com/digitalocean/sample-jekyll.git",
                        Branch = "main",
                    },
                },
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.NewApp(ctx, "static-site-example", &digitalocean.AppArgs{
			Spec: &digitalocean.AppSpecArgs{
				Name:   pulumi.String("static-site-example"),
				Region: pulumi.String("ams"),
				StaticSites: digitalocean.AppSpecStaticSiteArray{
					&digitalocean.AppSpecStaticSiteArgs{
						Name:         pulumi.String("sample-jekyll"),
						BuildCommand: pulumi.String("bundle exec jekyll build -d ./public"),
						OutputDir:    pulumi.String("/public"),
						Git: &digitalocean.AppSpecStaticSiteGitArgs{
							RepoCloneUrl: pulumi.String("https://github.com/digitalocean/sample-jekyll.git"),
							Branch:       pulumi.String("main"),
						},
					},
				},
			},
		})
		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.digitalocean.App;
import com.pulumi.digitalocean.AppArgs;
import com.pulumi.digitalocean.inputs.AppSpecArgs;
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 static_site_example = new App("static-site-example", AppArgs.builder()
            .spec(AppSpecArgs.builder()
                .name("static-site-example")
                .region("ams")
                .staticSites(AppSpecStaticSiteArgs.builder()
                    .name("sample-jekyll")
                    .buildCommand("bundle exec jekyll build -d ./public")
                    .outputDir("/public")
                    .git(AppSpecStaticSiteGitArgs.builder()
                        .repoCloneUrl("https://github.com/digitalocean/sample-jekyll.git")
                        .branch("main")
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  static-site-example:
    type: digitalocean:App
    properties:
      spec:
        name: static-site-example
        region: ams
        staticSites:
          - name: sample-jekyll
            buildCommand: bundle exec jekyll build -d ./public
            outputDir: /public
            git:
              repoCloneUrl: https://github.com/digitalocean/sample-jekyll.git
              branch: main

Multiple Components Example

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.App;
import com.pulumi.digitalocean.AppArgs;
import com.pulumi.digitalocean.inputs.AppSpecArgs;
import com.pulumi.digitalocean.inputs.AppSpecIngressArgs;
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 mono_repo_example = new App("mono-repo-example", AppArgs.builder()
            .spec(AppSpecArgs.builder()
                .name("mono-repo-example")
                .region("ams")
                .domains(Map.of("name", "foo.example.com"))
                .alerts(AppSpecAlertArgs.builder()
                    .rule("DEPLOYMENT_FAILED")
                    .build())
                .services(AppSpecServiceArgs.builder()
                    .name("api")
                    .environmentSlug("go")
                    .instanceCount(2)
                    .instanceSizeSlug("professional-xs")
                    .github(AppSpecServiceGithubArgs.builder()
                        .branch("main")
                        .deployOnPush(true)
                        .repo("username/repo")
                        .build())
                    .sourceDir("api/")
                    .httpPort(3000)
                    .alerts(AppSpecServiceAlertArgs.builder()
                        .value(75)
                        .operator("GREATER_THAN")
                        .window("TEN_MINUTES")
                        .rule("CPU_UTILIZATION")
                        .build())
                    .logDestinations(AppSpecServiceLogDestinationArgs.builder()
                        .name("MyLogs")
                        .papertrail(AppSpecServiceLogDestinationPapertrailArgs.builder()
                            .endpoint("syslog+tls://example.com:12345")
                            .build())
                        .build())
                    .runCommand("bin/api")
                    .build())
                .staticSites(AppSpecStaticSiteArgs.builder()
                    .name("web")
                    .buildCommand("npm run build")
                    .github(AppSpecStaticSiteGithubArgs.builder()
                        .branch("main")
                        .deployOnPush(true)
                        .repo("username/repo")
                        .build())
                    .build())
                .databases(AppSpecDatabaseArgs.builder()
                    .name("starter-db")
                    .engine("PG")
                    .production(false)
                    .build())
                .ingress(AppSpecIngressArgs.builder()
                    .rules(
                        AppSpecIngressRuleArgs.builder()
                            .component(AppSpecIngressRuleComponentArgs.builder()
                                .name("api")
                                .build())
                            .match(AppSpecIngressRuleMatchArgs.builder()
                                .path(AppSpecIngressRuleMatchPathArgs.builder()
                                    .prefix("/api")
                                    .build())
                                .build())
                            .build(),
                        AppSpecIngressRuleArgs.builder()
                            .component(AppSpecIngressRuleComponentArgs.builder()
                                .name("web")
                                .build())
                            .match(AppSpecIngressRuleMatchArgs.builder()
                                .path(AppSpecIngressRuleMatchPathArgs.builder()
                                    .prefix("/")
                                    .build())
                                .build())
                            .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  mono-repo-example:
    type: digitalocean:App
    properties:
      spec:
        name: mono-repo-example
        region: ams
        domains:
          - name: foo.example.com
        alerts:
          - rule: DEPLOYMENT_FAILED
        services:
          - name: api
            environmentSlug: go
            instanceCount: 2
            instanceSizeSlug: professional-xs
            github:
              branch: main
              deployOnPush: true
              repo: username/repo
            sourceDir: api/
            httpPort: 3000
            alerts:
              - value: 75
                operator: GREATER_THAN
                window: TEN_MINUTES
                rule: CPU_UTILIZATION
            logDestinations:
              - name: MyLogs
                papertrail:
                  endpoint: syslog+tls://example.com:12345
            runCommand: bin/api
        staticSites:
          - name: web
            buildCommand: npm run build
            github:
              branch: main
              deployOnPush: true
              repo: username/repo
        databases:
          - name: starter-db
            engine: PG
            production: false
        ingress:
          rules:
            - component:
                name: api
              match:
                path:
                  prefix: /api
            - component:
                name: web
              match:
                path:
                  prefix: /

Import

An app can be imported using its id, e.g.

$ pulumi import digitalocean:index/app:App myapp fb06ad00-351f-45c8-b5eb-13523c438661

Properties

activeDeploymentId

val activeDeploymentId: Output<String>

The ID the app's currently active deployment.

appUrn

val appUrn: Output<String>

The uniform resource identifier for the app.

createdAt

val createdAt: Output<String>

The date and time of when the app was created.

dedicatedIps

val dedicatedIps: Output<List<AppDedicatedIp>>

The dedicated egress IP addresses associated with the app.

defaultIngress

val defaultIngress: Output<String>

The default URL to access the app.

val id: Output<String>

liveUrl

val liveUrl: Output<String>

The live URL of the app.

projectId

val projectId: Output<String>

The ID of the project that the app is assigned to. A spec can contain multiple components. A service can contain:

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

spec

val spec: Output<AppSpec>?

A DigitalOcean App spec describing the app.

updatedAt

val updatedAt: Output<String>

The date and time of when the app was last updated.

urn

val urn: Output<String>