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",
        instanceCount: 1,
        instanceSizeSlug: "apps-s-1vcpu-1gb",
        git: {
            repoCloneUrl: "https://github.com/digitalocean/sample-golang.git",
            branch: "main",
        },
    }],
}});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
golang_sample = digitalocean.App("golang-sample", spec={
    "name": "golang-sample",
    "region": "ams",
    "services": [{
        "name": "go-service",
        "instance_count": 1,
        "instance_size_slug": "apps-s-1vcpu-1gb",
        "git": {
            "repo_clone_url": "https://github.com/digitalocean/sample-golang.git",
            "branch": "main",
        },
    }],
})
Content copied to clipboard
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",
                    InstanceCount = 1,
                    InstanceSizeSlug = "apps-s-1vcpu-1gb",
                    Git = new DigitalOcean.Inputs.AppSpecServiceGitArgs
                    {
                        RepoCloneUrl = "https://github.com/digitalocean/sample-golang.git",
                        Branch = "main",
                    },
                },
            },
        },
    });
});
Content copied to clipboard
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"),
						InstanceCount:    pulumi.Int(1),
						InstanceSizeSlug: pulumi.String("apps-s-1vcpu-1gb"),
						Git: &digitalocean.AppSpecServiceGitArgs{
							RepoCloneUrl: pulumi.String("https://github.com/digitalocean/sample-golang.git"),
							Branch:       pulumi.String("main"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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")
                    .instanceCount(1)
                    .instanceSizeSlug("apps-s-1vcpu-1gb")
                    .git(AppSpecServiceGitArgs.builder()
                        .repoCloneUrl("https://github.com/digitalocean/sample-golang.git")
                        .branch("main")
                        .build())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  golang-sample:
    type: digitalocean:App
    properties:
      spec:
        name: golang-sample
        region: ams
        services:
          - name: go-service
            instanceCount: 1
            instanceSizeSlug: apps-s-1vcpu-1gb
            git:
              repoCloneUrl: https://github.com/digitalocean/sample-golang.git
              branch: main
Content copied to clipboard

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",
        },
    }],
}});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
static_site_example = digitalocean.App("static-site-example", spec={
    "name": "static-site-example",
    "region": "ams",
    "static_sites": [{
        "name": "sample-jekyll",
        "build_command": "bundle exec jekyll build -d ./public",
        "output_dir": "/public",
        "git": {
            "repo_clone_url": "https://github.com/digitalocean/sample-jekyll.git",
            "branch": "main",
        },
    }],
})
Content copied to clipboard
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",
                    },
                },
            },
        },
    });
});
Content copied to clipboard
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
	})
}
Content copied to clipboard
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());
    }
}
Content copied to clipboard
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
Content copied to clipboard

Multiple Components Example

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: go-api
            instanceCount: 2
            instanceSizeSlug: apps-s-1vcpu-1gb
            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
            bitbucket:
              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: /
Content copied to clipboard

Log Destination Example with Opensearch

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",
        instanceCount: 1,
        instanceSizeSlug: "apps-s-1vcpu-1gb",
        git: {
            repoCloneUrl: "https://github.com/digitalocean/sample-golang.git",
            branch: "main",
        },
        logDestinations: [{
            name: "MyLogs",
            openSearch: {
                endpoint: "https://something:1234",
                basicAuth: {
                    user: "user",
                    password: "hi",
                },
            },
        }],
    }],
}});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
golang_sample = digitalocean.App("golang-sample", spec={
    "name": "golang-sample",
    "region": "ams",
    "services": [{
        "name": "go-service",
        "instance_count": 1,
        "instance_size_slug": "apps-s-1vcpu-1gb",
        "git": {
            "repo_clone_url": "https://github.com/digitalocean/sample-golang.git",
            "branch": "main",
        },
        "log_destinations": [{
            "name": "MyLogs",
            "open_search": {
                "endpoint": "https://something:1234",
                "basic_auth": {
                    "user": "user",
                    "password": "hi",
                },
            },
        }],
    }],
})
Content copied to clipboard
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",
                    InstanceCount = 1,
                    InstanceSizeSlug = "apps-s-1vcpu-1gb",
                    Git = new DigitalOcean.Inputs.AppSpecServiceGitArgs
                    {
                        RepoCloneUrl = "https://github.com/digitalocean/sample-golang.git",
                        Branch = "main",
                    },
                    LogDestinations = new[]
                    {
                        new DigitalOcean.Inputs.AppSpecServiceLogDestinationArgs
                        {
                            Name = "MyLogs",
                            OpenSearch = new DigitalOcean.Inputs.AppSpecServiceLogDestinationOpenSearchArgs
                            {
                                Endpoint = "https://something:1234",
                                BasicAuth = new DigitalOcean.Inputs.AppSpecServiceLogDestinationOpenSearchBasicAuthArgs
                                {
                                    User = "user",
                                    Password = "hi",
                                },
                            },
                        },
                    },
                },
            },
        },
    });
});
Content copied to clipboard
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"),
						InstanceCount:    pulumi.Int(1),
						InstanceSizeSlug: pulumi.String("apps-s-1vcpu-1gb"),
						Git: &digitalocean.AppSpecServiceGitArgs{
							RepoCloneUrl: pulumi.String("https://github.com/digitalocean/sample-golang.git"),
							Branch:       pulumi.String("main"),
						},
						LogDestinations: digitalocean.AppSpecServiceLogDestinationArray{
							&digitalocean.AppSpecServiceLogDestinationArgs{
								Name: pulumi.String("MyLogs"),
								OpenSearch: &digitalocean.AppSpecServiceLogDestinationOpenSearchArgs{
									Endpoint: pulumi.String("https://something:1234"),
									BasicAuth: &digitalocean.AppSpecServiceLogDestinationOpenSearchBasicAuthArgs{
										User:     pulumi.String("user"),
										Password: pulumi.String("hi"),
									},
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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")
                    .instanceCount(1)
                    .instanceSizeSlug("apps-s-1vcpu-1gb")
                    .git(AppSpecServiceGitArgs.builder()
                        .repoCloneUrl("https://github.com/digitalocean/sample-golang.git")
                        .branch("main")
                        .build())
                    .logDestinations(AppSpecServiceLogDestinationArgs.builder()
                        .name("MyLogs")
                        .openSearch(AppSpecServiceLogDestinationOpenSearchArgs.builder()
                            .endpoint("https://something:1234")
                            .basicAuth(AppSpecServiceLogDestinationOpenSearchBasicAuthArgs.builder()
                                .user("user")
                                .password("hi")
                                .build())
                            .build())
                        .build())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  golang-sample:
    type: digitalocean:App
    properties:
      spec:
        name: golang-sample
        region: ams
        services:
          - name: go-service
            instanceCount: 1
            instanceSizeSlug: apps-s-1vcpu-1gb
            git:
              repoCloneUrl: https://github.com/digitalocean/sample-golang.git
              branch: main
            logDestinations:
              - name: MyLogs
                openSearch:
                  endpoint: https://something:1234
                  basicAuth:
                    user: user
                    password: hi
Content copied to clipboard

Import

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

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

Properties

Link copied to clipboard
val activeDeploymentId: Output<String>

The ID the app's currently active deployment.

Link copied to clipboard
val appUrn: Output<String>

The uniform resource identifier for the app.

Link copied to clipboard
val createdAt: Output<String>

The date and time of when the app was created.

Link copied to clipboard
val dedicatedIps: Output<List<AppDedicatedIp>>

The dedicated egress IP addresses associated with the app.

Link copied to clipboard
val defaultIngress: Output<String>

The default URL to access the app.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val liveDomain: Output<String>

The live domain of the app.

Link copied to clipboard
val liveUrl: Output<String>

The live URL of the app.

Link copied to clipboard
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:

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val spec: Output<AppSpec>?

A DigitalOcean App spec describing the app.

Link copied to clipboard
val updatedAt: Output<String>

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

Link copied to clipboard
val urn: Output<String>