All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.digitalocean.kotlin.AppArgs.kt Maven / Gradle / Ivy

Go to download

Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.

There is a newer version: 4.38.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.digitalocean.kotlin

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.digitalocean.AppArgs.builder
import com.pulumi.digitalocean.kotlin.inputs.AppDedicatedIpArgs
import com.pulumi.digitalocean.kotlin.inputs.AppDedicatedIpArgsBuilder
import com.pulumi.digitalocean.kotlin.inputs.AppSpecArgs
import com.pulumi.digitalocean.kotlin.inputs.AppSpecArgsBuilder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 * Provides a DigitalOcean App resource.
 * ## Example Usage
 * To create an app, provide a [DigitalOcean app spec](https://docs.digitalocean.com/products/app-platform/reference/app-spec/) specifying the app's components.
 * ### Basic Example
 * 
 * ```typescript
 * 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",
 *         },
 *     }],
 * }});
 * ```
 * ```python
 * import pulumi
 * import pulumi_digitalocean as digitalocean
 * golang_sample = digitalocean.App("golang-sample", spec={
 *     "name": "golang-sample",
 *     "region": "ams",
 *     "services": [{
 *         "name": "go-service",
 *         "environment_slug": "go",
 *         "instance_count": 1,
 *         "instance_size_slug": "professional-xs",
 *         "git": {
 *             "repo_clone_url": "https://github.com/digitalocean/sample-golang.git",
 *             "branch": "main",
 *         },
 *     }],
 * })
 * ```
 * ```csharp
 * 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",
 *                     },
 *                 },
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * 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
 * 	})
 * }
 * ```
 * ```java
 * 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());
 *     }
 * }
 * ```
 * ```yaml
 * 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
 * 
 * ```typescript
 * 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",
 *         },
 *     }],
 * }});
 * ```
 * ```python
 * 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",
 *         },
 *     }],
 * })
 * ```
 * ```csharp
 * 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",
 *                     },
 *                 },
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * 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
 * 	})
 * }
 * ```
 * ```java
 * 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());
 *     }
 * }
 * ```
 * ```yaml
 * 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
 * 
 * ```java
 * 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());
 *     }
 * }
 * ```
 * ```yaml
 * 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.
 * ```sh
 * $ pulumi import digitalocean:index/app:App myapp fb06ad00-351f-45c8-b5eb-13523c438661
 * ```
 * @property dedicatedIps The dedicated egress IP addresses associated with the app.
 * @property projectId The ID of the project that the app is assigned to.
 * A spec can contain multiple components.
 * A `service` can contain:
 * @property spec A DigitalOcean App spec describing the app.
 */
public data class AppArgs(
    public val dedicatedIps: Output>? = null,
    public val projectId: Output? = null,
    public val spec: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.digitalocean.AppArgs = com.pulumi.digitalocean.AppArgs.builder()
        .dedicatedIps(
            dedicatedIps?.applyValue({ args0 ->
                args0.map({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                })
            }),
        )
        .projectId(projectId?.applyValue({ args0 -> args0 }))
        .spec(spec?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) })).build()
}

/**
 * Builder for [AppArgs].
 */
@PulumiTagMarker
public class AppArgsBuilder internal constructor() {
    private var dedicatedIps: Output>? = null

    private var projectId: Output? = null

    private var spec: Output? = null

    /**
     * @param value The dedicated egress IP addresses associated with the app.
     */
    @JvmName("cchnoebhaudlsosj")
    public suspend fun dedicatedIps(`value`: Output>) {
        this.dedicatedIps = value
    }

    @JvmName("koqgccehiimolyuj")
    public suspend fun dedicatedIps(vararg values: Output) {
        this.dedicatedIps = Output.all(values.asList())
    }

    /**
     * @param values The dedicated egress IP addresses associated with the app.
     */
    @JvmName("ctxdafuyukclxcvj")
    public suspend fun dedicatedIps(values: List>) {
        this.dedicatedIps = Output.all(values)
    }

    /**
     * @param value The ID of the project that the app is assigned to.
     * A spec can contain multiple components.
     * A `service` can contain:
     */
    @JvmName("iankmycjhfachjuj")
    public suspend fun projectId(`value`: Output) {
        this.projectId = value
    }

    /**
     * @param value A DigitalOcean App spec describing the app.
     */
    @JvmName("fhfltuqudfwcmvod")
    public suspend fun spec(`value`: Output) {
        this.spec = value
    }

    /**
     * @param value The dedicated egress IP addresses associated with the app.
     */
    @JvmName("upkrqodxnnxduldm")
    public suspend fun dedicatedIps(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dedicatedIps = mapped
    }

    /**
     * @param argument The dedicated egress IP addresses associated with the app.
     */
    @JvmName("vblfwxcnjwyaensn")
    public suspend fun dedicatedIps(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            AppDedicatedIpArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.dedicatedIps = mapped
    }

    /**
     * @param argument The dedicated egress IP addresses associated with the app.
     */
    @JvmName("hlwktmasrhajhjwu")
    public suspend fun dedicatedIps(vararg argument: suspend AppDedicatedIpArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            AppDedicatedIpArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.dedicatedIps = mapped
    }

    /**
     * @param argument The dedicated egress IP addresses associated with the app.
     */
    @JvmName("jjsolakqqljeandw")
    public suspend fun dedicatedIps(argument: suspend AppDedicatedIpArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(AppDedicatedIpArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.dedicatedIps = mapped
    }

    /**
     * @param values The dedicated egress IP addresses associated with the app.
     */
    @JvmName("mlaadjqcjrcqrrga")
    public suspend fun dedicatedIps(vararg values: AppDedicatedIpArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.dedicatedIps = mapped
    }

    /**
     * @param value The ID of the project that the app is assigned to.
     * A spec can contain multiple components.
     * A `service` can contain:
     */
    @JvmName("gobndiafjywmpsgh")
    public suspend fun projectId(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.projectId = mapped
    }

    /**
     * @param value A DigitalOcean App spec describing the app.
     */
    @JvmName("jenlkynjpassiywh")
    public suspend fun spec(`value`: AppSpecArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.spec = mapped
    }

    /**
     * @param argument A DigitalOcean App spec describing the app.
     */
    @JvmName("efqnvkyvbmspcrsq")
    public suspend fun spec(argument: suspend AppSpecArgsBuilder.() -> Unit) {
        val toBeMapped = AppSpecArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.spec = mapped
    }

    internal fun build(): AppArgs = AppArgs(
        dedicatedIps = dedicatedIps,
        projectId = projectId,
        spec = spec,
    )
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy