Service class

Manages an App Runner Service.

Example Usage

Service with a Code Repository Source

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.apprunner.Service("example", {
    sourceConfiguration: {
        authenticationConfiguration: {
            connectionArn: exampleAwsApprunnerConnection.arn,
        },
        codeRepository: {
            codeConfiguration: {
                codeConfigurationValues: {
                    buildCommand: "python setup.py develop",
                    port: "8000",
                    runtime: "PYTHON_3",
                    startCommand: "python runapp.py",
                },
                configurationSource: "API",
            },
            sourceCodeVersion: {
                type: "BRANCH",
                value: "main",
            },
            repositoryUrl: "https://github.com/example/my-example-python-app",
        },
    },
    networkConfiguration: {
        egressConfiguration: {
            egressType: "VPC",
            vpcConnectorArn: connector.arn,
        },
    },
    serviceName: "example",
    tags: {
        Name: "example-apprunner-service",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.apprunner.Service("example",
    source_configuration={
        "authentication_configuration": {
            "connection_arn": example_aws_apprunner_connection["arn"],
        },
        "code_repository": {
            "code_configuration": {
                "code_configuration_values": {
                    "build_command": "python setup.py develop",
                    "port": "8000",
                    "runtime": "PYTHON_3",
                    "start_command": "python runapp.py",
                },
                "configuration_source": "API",
            },
            "source_code_version": {
                "type": "BRANCH",
                "value": "main",
            },
            "repository_url": "https://github.com/example/my-example-python-app",
        },
    },
    network_configuration={
        "egress_configuration": {
            "egress_type": "VPC",
            "vpc_connector_arn": connector["arn"],
        },
    },
    service_name="example",
    tags={
        "Name": "example-apprunner-service",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.AppRunner.Service("example", new()
    {
        SourceConfiguration = new Aws.AppRunner.Inputs.ServiceSourceConfigurationArgs
        {
            AuthenticationConfiguration = new Aws.AppRunner.Inputs.ServiceSourceConfigurationAuthenticationConfigurationArgs
            {
                ConnectionArn = exampleAwsApprunnerConnection.Arn,
            },
            CodeRepository = new Aws.AppRunner.Inputs.ServiceSourceConfigurationCodeRepositoryArgs
            {
                CodeConfiguration = new Aws.AppRunner.Inputs.ServiceSourceConfigurationCodeRepositoryCodeConfigurationArgs
                {
                    CodeConfigurationValues = new Aws.AppRunner.Inputs.ServiceSourceConfigurationCodeRepositoryCodeConfigurationCodeConfigurationValuesArgs
                    {
                        BuildCommand = "python setup.py develop",
                        Port = "8000",
                        Runtime = "PYTHON_3",
                        StartCommand = "python runapp.py",
                    },
                    ConfigurationSource = "API",
                },
                SourceCodeVersion = new Aws.AppRunner.Inputs.ServiceSourceConfigurationCodeRepositorySourceCodeVersionArgs
                {
                    Type = "BRANCH",
                    Value = "main",
                },
                RepositoryUrl = "https://github.com/example/my-example-python-app",
            },
        },
        NetworkConfiguration = new Aws.AppRunner.Inputs.ServiceNetworkConfigurationArgs
        {
            EgressConfiguration = new Aws.AppRunner.Inputs.ServiceNetworkConfigurationEgressConfigurationArgs
            {
                EgressType = "VPC",
                VpcConnectorArn = connector.Arn,
            },
        },
        ServiceName = "example",
        Tags =
        {
            { "Name", "example-apprunner-service" },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/apprunner"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apprunner.NewService(ctx, "example", &apprunner.ServiceArgs{
			SourceConfiguration: &apprunner.ServiceSourceConfigurationArgs{
				AuthenticationConfiguration: &apprunner.ServiceSourceConfigurationAuthenticationConfigurationArgs{
					ConnectionArn: pulumi.Any(exampleAwsApprunnerConnection.Arn),
				},
				CodeRepository: &apprunner.ServiceSourceConfigurationCodeRepositoryArgs{
					CodeConfiguration: &apprunner.ServiceSourceConfigurationCodeRepositoryCodeConfigurationArgs{
						CodeConfigurationValues: &apprunner.ServiceSourceConfigurationCodeRepositoryCodeConfigurationCodeConfigurationValuesArgs{
							BuildCommand: pulumi.String("python setup.py develop"),
							Port:         pulumi.String("8000"),
							Runtime:      pulumi.String("PYTHON_3"),
							StartCommand: pulumi.String("python runapp.py"),
						},
						ConfigurationSource: pulumi.String("API"),
					},
					SourceCodeVersion: &apprunner.ServiceSourceConfigurationCodeRepositorySourceCodeVersionArgs{
						Type:  pulumi.String("BRANCH"),
						Value: pulumi.String("main"),
					},
					RepositoryUrl: pulumi.String("https://github.com/example/my-example-python-app"),
				},
			},
			NetworkConfiguration: &apprunner.ServiceNetworkConfigurationArgs{
				EgressConfiguration: &apprunner.ServiceNetworkConfigurationEgressConfigurationArgs{
					EgressType:      pulumi.String("VPC"),
					VpcConnectorArn: pulumi.Any(connector.Arn),
				},
			},
			ServiceName: pulumi.String("example"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("example-apprunner-service"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_apprunner_service" "example" {
  source_configuration = {
    authentication_configuration = {
      connection_arn = exampleAwsApprunnerConnection.arn
    }
    code_repository = {
      code_configuration = {
        code_configuration_values = {
          build_command = "python setup.py develop"
          port          = "8000"
          runtime       = "PYTHON_3"
          start_command = "python runapp.py"
        }
        configuration_source = "API"
      }
      source_code_version = {
        type  = "BRANCH"
        value = "main"
      }
      repository_url = "https://github.com/example/my-example-python-app"
    }
  }
  network_configuration = {
    egress_configuration = {
      egress_type       = "VPC"
      vpc_connector_arn = connector.arn
    }
  }
  service_name = "example"
  tags = {
    "Name" = "example-apprunner-service"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.apprunner.Service;
import com.pulumi.aws.apprunner.ServiceArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationAuthenticationConfigurationArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationCodeRepositoryArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationCodeRepositoryCodeConfigurationArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationCodeRepositoryCodeConfigurationCodeConfigurationValuesArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationCodeRepositorySourceCodeVersionArgs;
import com.pulumi.aws.apprunner.inputs.ServiceNetworkConfigurationArgs;
import com.pulumi.aws.apprunner.inputs.ServiceNetworkConfigurationEgressConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new Service("example", ServiceArgs.builder()
            .sourceConfiguration(ServiceSourceConfigurationArgs.builder()
                .authenticationConfiguration(ServiceSourceConfigurationAuthenticationConfigurationArgs.builder()
                    .connectionArn(exampleAwsApprunnerConnection.arn())
                    .build())
                .codeRepository(ServiceSourceConfigurationCodeRepositoryArgs.builder()
                    .codeConfiguration(ServiceSourceConfigurationCodeRepositoryCodeConfigurationArgs.builder()
                        .codeConfigurationValues(ServiceSourceConfigurationCodeRepositoryCodeConfigurationCodeConfigurationValuesArgs.builder()
                            .buildCommand("python setup.py develop")
                            .port("8000")
                            .runtime("PYTHON_3")
                            .startCommand("python runapp.py")
                            .build())
                        .configurationSource("API")
                        .build())
                    .sourceCodeVersion(ServiceSourceConfigurationCodeRepositorySourceCodeVersionArgs.builder()
                        .type("BRANCH")
                        .value("main")
                        .build())
                    .repositoryUrl("https://github.com/example/my-example-python-app")
                    .build())
                .build())
            .networkConfiguration(ServiceNetworkConfigurationArgs.builder()
                .egressConfiguration(ServiceNetworkConfigurationEgressConfigurationArgs.builder()
                    .egressType("VPC")
                    .vpcConnectorArn(connector.arn())
                    .build())
                .build())
            .serviceName("example")
            .tags(Map.of("Name", "example-apprunner-service"))
            .build());

    }
}

resources:
  example:
    type: aws:apprunner:Service
    properties:
      sourceConfiguration:
        authenticationConfiguration:
          connectionArn: ${exampleAwsApprunnerConnection.arn}
        codeRepository:
          codeConfiguration:
            codeConfigurationValues:
              buildCommand: python setup.py develop
              port: '8000'
              runtime: PYTHON_3
              startCommand: python runapp.py
            configurationSource: API
          sourceCodeVersion:
            type: BRANCH
            value: main
          repositoryUrl: https://github.com/example/my-example-python-app
      networkConfiguration:
        egressConfiguration:
          egressType: VPC
          vpcConnectorArn: ${connector.arn}
      serviceName: example
      tags:
        Name: example-apprunner-service

Service with an Image Repository Source

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.apprunner.Service("example", {
    sourceConfiguration: {
        imageRepository: {
            imageConfiguration: {
                port: "8000",
            },
            imageIdentifier: "public.ecr.aws/aws-containers/hello-app-runner:latest",
            imageRepositoryType: "ECR_PUBLIC",
        },
        autoDeploymentsEnabled: false,
    },
    serviceName: "example",
    tags: {
        Name: "example-apprunner-service",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.apprunner.Service("example",
    source_configuration={
        "image_repository": {
            "image_configuration": {
                "port": "8000",
            },
            "image_identifier": "public.ecr.aws/aws-containers/hello-app-runner:latest",
            "image_repository_type": "ECR_PUBLIC",
        },
        "auto_deployments_enabled": False,
    },
    service_name="example",
    tags={
        "Name": "example-apprunner-service",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.AppRunner.Service("example", new()
    {
        SourceConfiguration = new Aws.AppRunner.Inputs.ServiceSourceConfigurationArgs
        {
            ImageRepository = new Aws.AppRunner.Inputs.ServiceSourceConfigurationImageRepositoryArgs
            {
                ImageConfiguration = new Aws.AppRunner.Inputs.ServiceSourceConfigurationImageRepositoryImageConfigurationArgs
                {
                    Port = "8000",
                },
                ImageIdentifier = "public.ecr.aws/aws-containers/hello-app-runner:latest",
                ImageRepositoryType = "ECR_PUBLIC",
            },
            AutoDeploymentsEnabled = false,
        },
        ServiceName = "example",
        Tags =
        {
            { "Name", "example-apprunner-service" },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/apprunner"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apprunner.NewService(ctx, "example", &apprunner.ServiceArgs{
			SourceConfiguration: &apprunner.ServiceSourceConfigurationArgs{
				ImageRepository: &apprunner.ServiceSourceConfigurationImageRepositoryArgs{
					ImageConfiguration: &apprunner.ServiceSourceConfigurationImageRepositoryImageConfigurationArgs{
						Port: pulumi.String("8000"),
					},
					ImageIdentifier:     pulumi.String("public.ecr.aws/aws-containers/hello-app-runner:latest"),
					ImageRepositoryType: pulumi.String("ECR_PUBLIC"),
				},
				AutoDeploymentsEnabled: pulumi.Bool(false),
			},
			ServiceName: pulumi.String("example"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("example-apprunner-service"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_apprunner_service" "example" {
  source_configuration = {
    image_repository = {
      image_configuration = {
        port = "8000"
      }
      image_identifier      = "public.ecr.aws/aws-containers/hello-app-runner:latest"
      image_repository_type = "ECR_PUBLIC"
    }
    auto_deployments_enabled = false
  }
  service_name = "example"
  tags = {
    "Name" = "example-apprunner-service"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.apprunner.Service;
import com.pulumi.aws.apprunner.ServiceArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationImageRepositoryArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationImageRepositoryImageConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new Service("example", ServiceArgs.builder()
            .sourceConfiguration(ServiceSourceConfigurationArgs.builder()
                .imageRepository(ServiceSourceConfigurationImageRepositoryArgs.builder()
                    .imageConfiguration(ServiceSourceConfigurationImageRepositoryImageConfigurationArgs.builder()
                        .port("8000")
                        .build())
                    .imageIdentifier("public.ecr.aws/aws-containers/hello-app-runner:latest")
                    .imageRepositoryType("ECR_PUBLIC")
                    .build())
                .autoDeploymentsEnabled(false)
                .build())
            .serviceName("example")
            .tags(Map.of("Name", "example-apprunner-service"))
            .build());

    }
}

resources:
  example:
    type: aws:apprunner:Service
    properties:
      sourceConfiguration:
        imageRepository:
          imageConfiguration:
            port: '8000'
          imageIdentifier: public.ecr.aws/aws-containers/hello-app-runner:latest
          imageRepositoryType: ECR_PUBLIC
        autoDeploymentsEnabled: false
      serviceName: example
      tags:
        Name: example-apprunner-service

Service with Observability Configuration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const exampleObservabilityConfiguration = new aws.apprunner.ObservabilityConfiguration("example", {
    traceConfiguration: {
        vendor: "AWSXRAY",
    },
    observabilityConfigurationName: "example",
});
const example = new aws.apprunner.Service("example", {
    observabilityConfiguration: {
        observabilityConfigurationArn: exampleObservabilityConfiguration.arn,
        observabilityEnabled: true,
    },
    sourceConfiguration: {
        imageRepository: {
            imageConfiguration: {
                port: "8000",
            },
            imageIdentifier: "public.ecr.aws/aws-containers/hello-app-runner:latest",
            imageRepositoryType: "ECR_PUBLIC",
        },
        autoDeploymentsEnabled: false,
    },
    serviceName: "example",
    tags: {
        Name: "example-apprunner-service",
    },
});

import pulumi
import pulumi_aws as aws

example_observability_configuration = aws.apprunner.ObservabilityConfiguration("example",
    trace_configuration={
        "vendor": "AWSXRAY",
    },
    observability_configuration_name="example")
example = aws.apprunner.Service("example",
    observability_configuration={
        "observability_configuration_arn": example_observability_configuration.arn,
        "observability_enabled": True,
    },
    source_configuration={
        "image_repository": {
            "image_configuration": {
                "port": "8000",
            },
            "image_identifier": "public.ecr.aws/aws-containers/hello-app-runner:latest",
            "image_repository_type": "ECR_PUBLIC",
        },
        "auto_deployments_enabled": False,
    },
    service_name="example",
    tags={
        "Name": "example-apprunner-service",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var exampleObservabilityConfiguration = new Aws.AppRunner.ObservabilityConfiguration("example", new()
    {
        TraceConfiguration = new Aws.AppRunner.Inputs.ObservabilityConfigurationTraceConfigurationArgs
        {
            Vendor = "AWSXRAY",
        },
        ObservabilityConfigurationName = "example",
    });

    var example = new Aws.AppRunner.Service("example", new()
    {
        ObservabilityConfiguration = new Aws.AppRunner.Inputs.ServiceObservabilityConfigurationArgs
        {
            ObservabilityConfigurationArn = exampleObservabilityConfiguration.Arn,
            ObservabilityEnabled = true,
        },
        SourceConfiguration = new Aws.AppRunner.Inputs.ServiceSourceConfigurationArgs
        {
            ImageRepository = new Aws.AppRunner.Inputs.ServiceSourceConfigurationImageRepositoryArgs
            {
                ImageConfiguration = new Aws.AppRunner.Inputs.ServiceSourceConfigurationImageRepositoryImageConfigurationArgs
                {
                    Port = "8000",
                },
                ImageIdentifier = "public.ecr.aws/aws-containers/hello-app-runner:latest",
                ImageRepositoryType = "ECR_PUBLIC",
            },
            AutoDeploymentsEnabled = false,
        },
        ServiceName = "example",
        Tags =
        {
            { "Name", "example-apprunner-service" },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/apprunner"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleObservabilityConfiguration, err := apprunner.NewObservabilityConfiguration(ctx, "example", &apprunner.ObservabilityConfigurationArgs{
			TraceConfiguration: &apprunner.ObservabilityConfigurationTraceConfigurationArgs{
				Vendor: pulumi.String("AWSXRAY"),
			},
			ObservabilityConfigurationName: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		_, err = apprunner.NewService(ctx, "example", &apprunner.ServiceArgs{
			ObservabilityConfiguration: &apprunner.ServiceObservabilityConfigurationArgs{
				ObservabilityConfigurationArn: exampleObservabilityConfiguration.Arn,
				ObservabilityEnabled:          pulumi.Bool(true),
			},
			SourceConfiguration: &apprunner.ServiceSourceConfigurationArgs{
				ImageRepository: &apprunner.ServiceSourceConfigurationImageRepositoryArgs{
					ImageConfiguration: &apprunner.ServiceSourceConfigurationImageRepositoryImageConfigurationArgs{
						Port: pulumi.String("8000"),
					},
					ImageIdentifier:     pulumi.String("public.ecr.aws/aws-containers/hello-app-runner:latest"),
					ImageRepositoryType: pulumi.String("ECR_PUBLIC"),
				},
				AutoDeploymentsEnabled: pulumi.Bool(false),
			},
			ServiceName: pulumi.String("example"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("example-apprunner-service"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_apprunner_service" "example" {
  observability_configuration = {
    observability_configuration_arn = aws_apprunner_observabilityconfiguration.example.arn
    observability_enabled           = true
  }
  source_configuration = {
    image_repository = {
      image_configuration = {
        port = "8000"
      }
      image_identifier      = "public.ecr.aws/aws-containers/hello-app-runner:latest"
      image_repository_type = "ECR_PUBLIC"
    }
    auto_deployments_enabled = false
  }
  service_name = "example"
  tags = {
    "Name" = "example-apprunner-service"
  }
}
resource "aws_apprunner_observabilityconfiguration" "example" {
  trace_configuration = {
    vendor = "AWSXRAY"
  }
  observability_configuration_name = "example"
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.apprunner.ObservabilityConfiguration;
import com.pulumi.aws.apprunner.ObservabilityConfigurationArgs;
import com.pulumi.aws.apprunner.inputs.ObservabilityConfigurationTraceConfigurationArgs;
import com.pulumi.aws.apprunner.Service;
import com.pulumi.aws.apprunner.ServiceArgs;
import com.pulumi.aws.apprunner.inputs.ServiceObservabilityConfigurationArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationImageRepositoryArgs;
import com.pulumi.aws.apprunner.inputs.ServiceSourceConfigurationImageRepositoryImageConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 exampleObservabilityConfiguration = new ObservabilityConfiguration("exampleObservabilityConfiguration", ObservabilityConfigurationArgs.builder()
            .traceConfiguration(ObservabilityConfigurationTraceConfigurationArgs.builder()
                .vendor("AWSXRAY")
                .build())
            .observabilityConfigurationName("example")
            .build());

        var example = new Service("example", ServiceArgs.builder()
            .observabilityConfiguration(ServiceObservabilityConfigurationArgs.builder()
                .observabilityConfigurationArn(exampleObservabilityConfiguration.arn())
                .observabilityEnabled(true)
                .build())
            .sourceConfiguration(ServiceSourceConfigurationArgs.builder()
                .imageRepository(ServiceSourceConfigurationImageRepositoryArgs.builder()
                    .imageConfiguration(ServiceSourceConfigurationImageRepositoryImageConfigurationArgs.builder()
                        .port("8000")
                        .build())
                    .imageIdentifier("public.ecr.aws/aws-containers/hello-app-runner:latest")
                    .imageRepositoryType("ECR_PUBLIC")
                    .build())
                .autoDeploymentsEnabled(false)
                .build())
            .serviceName("example")
            .tags(Map.of("Name", "example-apprunner-service"))
            .build());

    }
}

resources:
  example:
    type: aws:apprunner:Service
    properties:
      observabilityConfiguration:
        observabilityConfigurationArn: ${exampleObservabilityConfiguration.arn}
        observabilityEnabled: true
      sourceConfiguration:
        imageRepository:
          imageConfiguration:
            port: '8000'
          imageIdentifier: public.ecr.aws/aws-containers/hello-app-runner:latest
          imageRepositoryType: ECR_PUBLIC
        autoDeploymentsEnabled: false
      serviceName: example
      tags:
        Name: example-apprunner-service
  exampleObservabilityConfiguration:
    type: aws:apprunner:ObservabilityConfiguration
    name: example
    properties:
      traceConfiguration:
        vendor: AWSXRAY
      observabilityConfigurationName: example

Import

Identity Schema

Required

  • arn (String) ARN of the App Runner service.

Using pulumi import, import App Runner Services using the arn. For example:

$ pulumi import aws:apprunner/service:Service example arn:aws:apprunner:us-east-1:1234567890:service/example/0a03292a89764e5882c41d8f991c82fe

Constructors

Service(String name, {ServiceArgs? args, CustomResourceOptions? options})
Creates a new Service. name The Pulumi resource name. args Arguments used to configure this Service. The set of arguments for Service. options Resource options controlling this resource's behavior.
Service.reference(String urn)
Creates a typed reference to an existing Service resource.

Properties

arn ↔ Output<String>
ARN of the App Runner service.
latefinal
autoScalingConfigurationArn ↔ Output<String>
ARN of an App Runner automatic scaling configuration resource that you want to associate with your service. If not provided, App Runner associates the latest revision of a default auto scaling configuration.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
encryptionConfiguration ↔ Output<ServiceEncryptionConfiguration?>
Custom encryption key that App Runner uses to encrypt the copy of your source repository that it maintains and your service logs. By default, App Runner uses an AWS managed CMK. See encryptionConfiguration below.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
healthCheckConfiguration ↔ Output<ServiceHealthCheckConfiguration>
Settings of the health check that AWS App Runner performs to monitor the health of your service. See healthCheckConfiguration below.
latefinal
id ↔ Output<String>
getter/setter pairinherited
instanceConfiguration ↔ Output<ServiceInstanceConfiguration>
Runtime configuration of instances (scaling units) of the App Runner service. See instanceConfiguration below.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
networkConfiguration ↔ Output<ServiceNetworkConfiguration>
Configuration settings related to network traffic of the web application that the App Runner service runs. See networkConfiguration below.
latefinal
observabilityConfiguration ↔ Output<ServiceObservabilityConfiguration?>
Observability configuration of your service. See observabilityConfiguration below.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
serviceId ↔ Output<String>
Alphanumeric ID that App Runner generated for this service. Unique within the AWS Region.
latefinal
serviceName ↔ Output<String>
Name of the service.
latefinal
serviceUrl ↔ Output<String>
Subdomain URL that App Runner generated for this service. You can use this URL to access your service web application.
latefinal
sourceConfiguration ↔ Output<ServiceSourceConfiguration>
Source to deploy to the App Runner service. Can be a code or an image repository. See sourceConfiguration below.
latefinal
status ↔ Output<String>
Current state of the App Runner service.
latefinal
tags ↔ Output<Map<String, String>?>
Key-value map of resource tags. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {ServiceState? state, CustomResourceOptions? options}) → Service
Gets an existing Service resource's state with the given name and id.