koyeb.KoyebService

using System.Collections.Generic;
using Pulumi;
using Koyeb = Pulumi.Koyeb;

return await Deployment.RunAsync(() => 
{
    var my_service = new Koyeb.KoyebService("my-service", new()
    {
        AppName = koyeb_app.My_app.Name,
        Definition = new Koyeb.Inputs.KoyebServiceDefinitionArgs
        {
            Name = "my-service",
            InstanceTypes = new Koyeb.Inputs.KoyebServiceDefinitionInstanceTypesArgs
            {
                Type = "micro",
            },
            Ports = new[]
            {
                new Koyeb.Inputs.KoyebServiceDefinitionPortArgs
                {
                    Port = 3000,
                    Protocol = "http",
                },
            },
            Scalings = new Koyeb.Inputs.KoyebServiceDefinitionScalingsArgs
            {
                Min = 1,
                Max = 1,
            },
            Envs = new[]
            {
                new Koyeb.Inputs.KoyebServiceDefinitionEnvArgs
                {
                    Key = "FOO",
                    Value = "BAR",
                },
            },
            Routes = new[]
            {
                new Koyeb.Inputs.KoyebServiceDefinitionRouteArgs
                {
                    Path = "/",
                    Port = 3000,
                },
            },
            Regions = new[]
            {
                "par",
            },
            Docker = new Koyeb.Inputs.KoyebServiceDefinitionDockerArgs
            {
                Image = "koyeb/demo",
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            koyeb_app.My_app,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-koyeb/sdk/go/koyeb"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := koyeb.NewKoyebService(ctx, "my-service", &koyeb.KoyebServiceArgs{
			AppName: pulumi.Any(koyeb_app.My_app.Name),
			Definition: &KoyebServiceDefinitionArgs{
				Name: pulumi.String("my-service"),
				InstanceTypes: &KoyebServiceDefinitionInstanceTypesArgs{
					Type: pulumi.String("micro"),
				},
				Ports: KoyebServiceDefinitionPortArray{
					&KoyebServiceDefinitionPortArgs{
						Port:     pulumi.Int(3000),
						Protocol: pulumi.String("http"),
					},
				},
				Scalings: &KoyebServiceDefinitionScalingsArgs{
					Min: pulumi.Int(1),
					Max: pulumi.Int(1),
				},
				Envs: KoyebServiceDefinitionEnvArray{
					&KoyebServiceDefinitionEnvArgs{
						Key:   pulumi.String("FOO"),
						Value: pulumi.String("BAR"),
					},
				},
				Routes: KoyebServiceDefinitionRouteArray{
					&KoyebServiceDefinitionRouteArgs{
						Path: pulumi.String("/"),
						Port: pulumi.Int(3000),
					},
				},
				Regions: pulumi.StringArray{
					pulumi.String("par"),
				},
				Docker: &KoyebServiceDefinitionDockerArgs{
					Image: pulumi.String("koyeb/demo"),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			koyeb_app.My - app,
		}))
		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.koyeb.KoyebService;
import com.pulumi.koyeb.KoyebServiceArgs;
import com.pulumi.koyeb.inputs.KoyebServiceDefinitionArgs;
import com.pulumi.koyeb.inputs.KoyebServiceDefinitionInstanceTypesArgs;
import com.pulumi.koyeb.inputs.KoyebServiceDefinitionScalingsArgs;
import com.pulumi.koyeb.inputs.KoyebServiceDefinitionDockerArgs;
import com.pulumi.resources.CustomResourceOptions;
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 my_service = new KoyebService("my-service", KoyebServiceArgs.builder()        
            .appName(koyeb_app.my_app().name())
            .definition(KoyebServiceDefinitionArgs.builder()
                .name("my-service")
                .instanceTypes(KoyebServiceDefinitionInstanceTypesArgs.builder()
                    .type("micro")
                    .build())
                .ports(KoyebServiceDefinitionPortArgs.builder()
                    .port(3000)
                    .protocol("http")
                    .build())
                .scalings(KoyebServiceDefinitionScalingsArgs.builder()
                    .min(1)
                    .max(1)
                    .build())
                .envs(KoyebServiceDefinitionEnvArgs.builder()
                    .key("FOO")
                    .value("BAR")
                    .build())
                .routes(KoyebServiceDefinitionRouteArgs.builder()
                    .path("/")
                    .port(3000)
                    .build())
                .regions("par")
                .docker(KoyebServiceDefinitionDockerArgs.builder()
                    .image("koyeb/demo")
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(koyeb_app.my-app())
                .build());

    }
}

import pulumi
import pulumi_koyeb as koyeb

my_service = koyeb.KoyebService("my-service",
    app_name=koyeb_app["my_app"]["name"],
    definition=koyeb.KoyebServiceDefinitionArgs(
        name="my-service",
        instance_types=koyeb.KoyebServiceDefinitionInstanceTypesArgs(
            type="micro",
        ),
        ports=[koyeb.KoyebServiceDefinitionPortArgs(
            port=3000,
            protocol="http",
        )],
        scalings=koyeb.KoyebServiceDefinitionScalingsArgs(
            min=1,
            max=1,
        ),
        envs=[koyeb.KoyebServiceDefinitionEnvArgs(
            key="FOO",
            value="BAR",
        )],
        routes=[koyeb.KoyebServiceDefinitionRouteArgs(
            path="/",
            port=3000,
        )],
        regions=["par"],
        docker=koyeb.KoyebServiceDefinitionDockerArgs(
            image="koyeb/demo",
        ),
    ),
    opts=pulumi.ResourceOptions(depends_on=[koyeb_app["my-app"]]))

import * as pulumi from "@pulumi/pulumi";
import * as pulumi_koyeb from "@koyeb/pulumi-koyeb";

const my_service = new koyeb.KoyebService("my-service", {
    appName: koyeb_app.my_app.name,
    definition: {
        name: "my-service",
        instanceTypes: {
            type: "micro",
        },
        ports: [{
            port: 3000,
            protocol: "http",
        }],
        scalings: {
            min: 1,
            max: 1,
        },
        envs: [{
            key: "FOO",
            value: "BAR",
        }],
        routes: [{
            path: "/",
            port: 3000,
        }],
        regions: ["par"],
        docker: {
            image: "koyeb/demo",
        },
    },
}, {
    dependsOn: [koyeb_app["my-app"]],
});

resources:
  my-service:
    type: koyeb:KoyebService
    properties:
      appName: ${koyeb_app.my_app.name}
      definition:
        name: my-service
        instanceTypes:
          type: micro
        ports:
          - port: 3000
            protocol: http
        scalings:
          min: 1
          max: 1
        envs:
          - key: FOO
            value: BAR
        routes:
          - path: /
            port: 3000
        regions:
          - par
        docker:
          image: koyeb/demo
    options:
      dependson:
        - ${koyeb_app"my-app"[%!s(MISSING)]}