The aws:apprunner/service:Service resource, part of the Pulumi AWS provider, defines an App Runner service that deploys and runs web applications from source code or container images. This guide focuses on three capabilities: GitHub repository deployment with build configuration, container image deployment from ECR, and X-Ray tracing integration.
App Runner services require GitHub connections for code repositories, VPC connectors for private networking, and observability configurations for tracing. The examples are intentionally small. Combine them with your own scaling policies, health checks, and instance configurations.
Deploy from a GitHub repository with build configuration
Teams building web applications from source code often connect App Runner directly to GitHub repositories. App Runner clones the code, runs the build, and deploys the result as a managed service.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.apprunner.Service("example", {
serviceName: "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",
},
repositoryUrl: "https://github.com/example/my-example-python-app",
sourceCodeVersion: {
type: "BRANCH",
value: "main",
},
},
},
networkConfiguration: {
egressConfiguration: {
egressType: "VPC",
vpcConnectorArn: connector.arn,
},
},
tags: {
Name: "example-apprunner-service",
},
});
import pulumi
import pulumi_aws as aws
example = aws.apprunner.Service("example",
service_name="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",
},
"repository_url": "https://github.com/example/my-example-python-app",
"source_code_version": {
"type": "BRANCH",
"value": "main",
},
},
},
network_configuration={
"egress_configuration": {
"egress_type": "VPC",
"vpc_connector_arn": connector["arn"],
},
},
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{
ServiceName: pulumi.String("example"),
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"),
},
RepositoryUrl: pulumi.String("https://github.com/example/my-example-python-app"),
SourceCodeVersion: &apprunner.ServiceSourceConfigurationCodeRepositorySourceCodeVersionArgs{
Type: pulumi.String("BRANCH"),
Value: pulumi.String("main"),
},
},
},
NetworkConfiguration: &apprunner.ServiceNetworkConfigurationArgs{
EgressConfiguration: &apprunner.ServiceNetworkConfigurationEgressConfigurationArgs{
EgressType: pulumi.String("VPC"),
VpcConnectorArn: pulumi.Any(connector.Arn),
},
},
Tags: pulumi.StringMap{
"Name": pulumi.String("example-apprunner-service"),
},
})
if err != nil {
return err
}
return nil
})
}
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()
{
ServiceName = "example",
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",
},
RepositoryUrl = "https://github.com/example/my-example-python-app",
SourceCodeVersion = new Aws.AppRunner.Inputs.ServiceSourceConfigurationCodeRepositorySourceCodeVersionArgs
{
Type = "BRANCH",
Value = "main",
},
},
},
NetworkConfiguration = new Aws.AppRunner.Inputs.ServiceNetworkConfigurationArgs
{
EgressConfiguration = new Aws.AppRunner.Inputs.ServiceNetworkConfigurationEgressConfigurationArgs
{
EgressType = "VPC",
VpcConnectorArn = connector.Arn,
},
},
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.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 example = new Service("example", ServiceArgs.builder()
.serviceName("example")
.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())
.repositoryUrl("https://github.com/example/my-example-python-app")
.sourceCodeVersion(ServiceSourceConfigurationCodeRepositorySourceCodeVersionArgs.builder()
.type("BRANCH")
.value("main")
.build())
.build())
.build())
.networkConfiguration(ServiceNetworkConfigurationArgs.builder()
.egressConfiguration(ServiceNetworkConfigurationEgressConfigurationArgs.builder()
.egressType("VPC")
.vpcConnectorArn(connector.arn())
.build())
.build())
.tags(Map.of("Name", "example-apprunner-service"))
.build());
}
}
resources:
example:
type: aws:apprunner:Service
properties:
serviceName: 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
repositoryUrl: https://github.com/example/my-example-python-app
sourceCodeVersion:
type: BRANCH
value: main
networkConfiguration:
egressConfiguration:
egressType: VPC
vpcConnectorArn: ${connector.arn}
tags:
Name: example-apprunner-service
The sourceConfiguration.codeRepository block points to your GitHub repository and specifies the branch to track. The authenticationConfiguration.connectionArn references a GitHub connection that grants App Runner repository access. Inside codeConfigurationValues, buildCommand and startCommand define how App Runner builds and runs your application, while runtime and port specify the execution environment.
Deploy from a container image in ECR
Applications already packaged as container images can deploy directly from ECR without build steps.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.apprunner.Service("example", {
serviceName: "example",
sourceConfiguration: {
imageRepository: {
imageConfiguration: {
port: "8000",
},
imageIdentifier: "public.ecr.aws/aws-containers/hello-app-runner:latest",
imageRepositoryType: "ECR_PUBLIC",
},
autoDeploymentsEnabled: false,
},
tags: {
Name: "example-apprunner-service",
},
});
import pulumi
import pulumi_aws as aws
example = aws.apprunner.Service("example",
service_name="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,
},
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{
ServiceName: pulumi.String("example"),
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),
},
Tags: pulumi.StringMap{
"Name": pulumi.String("example-apprunner-service"),
},
})
if err != nil {
return err
}
return nil
})
}
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()
{
ServiceName = "example",
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,
},
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.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 example = new Service("example", ServiceArgs.builder()
.serviceName("example")
.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())
.tags(Map.of("Name", "example-apprunner-service"))
.build());
}
}
resources:
example:
type: aws:apprunner:Service
properties:
serviceName: example
sourceConfiguration:
imageRepository:
imageConfiguration:
port: '8000'
imageIdentifier: public.ecr.aws/aws-containers/hello-app-runner:latest
imageRepositoryType: ECR_PUBLIC
autoDeploymentsEnabled: false
tags:
Name: example-apprunner-service
The sourceConfiguration.imageRepository block specifies the container image location and type. The imageIdentifier points to your ECR image, and imageRepositoryType indicates whether it’s public or private ECR. Setting autoDeploymentsEnabled to false means App Runner won’t automatically redeploy when you push new image tags; you control deployments manually.
Enable X-Ray tracing for request monitoring
Production services often need distributed tracing to diagnose latency and errors across service boundaries.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const exampleObservabilityConfiguration = new aws.apprunner.ObservabilityConfiguration("example", {
observabilityConfigurationName: "example",
traceConfiguration: {
vendor: "AWSXRAY",
},
});
const example = new aws.apprunner.Service("example", {
serviceName: "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,
},
tags: {
Name: "example-apprunner-service",
},
});
import pulumi
import pulumi_aws as aws
example_observability_configuration = aws.apprunner.ObservabilityConfiguration("example",
observability_configuration_name="example",
trace_configuration={
"vendor": "AWSXRAY",
})
example = aws.apprunner.Service("example",
service_name="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,
},
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{
ObservabilityConfigurationName: pulumi.String("example"),
TraceConfiguration: &apprunner.ObservabilityConfigurationTraceConfigurationArgs{
Vendor: pulumi.String("AWSXRAY"),
},
})
if err != nil {
return err
}
_, err = apprunner.NewService(ctx, "example", &apprunner.ServiceArgs{
ServiceName: pulumi.String("example"),
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),
},
Tags: pulumi.StringMap{
"Name": pulumi.String("example-apprunner-service"),
},
})
if err != nil {
return err
}
return nil
})
}
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()
{
ObservabilityConfigurationName = "example",
TraceConfiguration = new Aws.AppRunner.Inputs.ObservabilityConfigurationTraceConfigurationArgs
{
Vendor = "AWSXRAY",
},
});
var example = new Aws.AppRunner.Service("example", new()
{
ServiceName = "example",
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,
},
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.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.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 exampleObservabilityConfiguration = new ObservabilityConfiguration("exampleObservabilityConfiguration", ObservabilityConfigurationArgs.builder()
.observabilityConfigurationName("example")
.traceConfiguration(ObservabilityConfigurationTraceConfigurationArgs.builder()
.vendor("AWSXRAY")
.build())
.build());
var example = new Service("example", ServiceArgs.builder()
.serviceName("example")
.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())
.tags(Map.of("Name", "example-apprunner-service"))
.build());
}
}
resources:
example:
type: aws:apprunner:Service
properties:
serviceName: 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
tags:
Name: example-apprunner-service
exampleObservabilityConfiguration:
type: aws:apprunner:ObservabilityConfiguration
name: example
properties:
observabilityConfigurationName: example
traceConfiguration:
vendor: AWSXRAY
The observabilityConfiguration block connects your service to an App Runner observability configuration resource. Setting observabilityEnabled to true activates tracing, and the observabilityConfigurationArn references the configuration that specifies X-Ray as the tracing vendor. This extends the image-based deployment pattern with request-level visibility.
Beyond these examples
These snippets focus on specific App Runner service features: code and image repository sources, VPC egress configuration, and X-Ray distributed tracing. They’re intentionally minimal rather than full application deployments.
The examples may reference pre-existing infrastructure such as GitHub connections for code repositories, VPC connectors for private egress, and ECR repositories for container images. They focus on configuring the service rather than provisioning everything around it.
To keep things focused, common service patterns are omitted, including:
- Instance sizing and memory allocation (instanceConfiguration)
- Auto scaling policies (autoScalingConfigurationArn)
- Health check intervals and thresholds (healthCheckConfiguration)
- Custom encryption keys (encryptionConfiguration)
These omissions are intentional: the goal is to illustrate how each App Runner feature is wired, not provide drop-in production modules. See the App Runner Service resource reference for all available configuration options.
Let's deploy AWS App Runner Services
Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.
Try Pulumi Cloud for FREEFrequently Asked Questions
Source Configuration & Deployment
What's the difference between code repository and image repository sources?
Code repository sources deploy from source code (like GitHub) and require build commands, runtime, and start commands. Image repository sources deploy pre-built container images from ECR and only need the image identifier and repository type.
How do I deploy from a GitHub repository?
Use
sourceConfiguration.codeRepository with a connectionArn for authentication, repositoryUrl pointing to your GitHub repo, and codeConfiguration specifying your buildCommand, startCommand, runtime, and port.How do I deploy from an ECR container image?
Use
sourceConfiguration.imageRepository with imageIdentifier (your ECR image URL) and imageRepositoryType set to ECR_PUBLIC or ECR. You can disable automatic deployments by setting autoDeploymentsEnabled to false.Immutability & Lifecycle
What properties can't I change after creating the service?
The
serviceName and encryptionConfiguration are immutable. Changing either requires replacing the entire service, so plan these values carefully during initial creation.Networking & VPC
How do I connect my App Runner service to private VPC resources?
Configure
networkConfiguration.egressConfiguration with egressType set to VPC and provide a vpcConnectorArn that defines your VPC connection settings.Observability & Monitoring
How do I enable X-Ray tracing for my service?
Create an
aws.apprunner.ObservabilityConfiguration resource with traceConfiguration.vendor set to AWSXRAY, then reference its ARN in your service’s observabilityConfiguration with observabilityEnabled set to true.Configuration & Defaults
What happens if I don't specify an auto scaling configuration?
App Runner automatically associates the latest revision of a default auto scaling configuration if you don’t provide an
autoScalingConfigurationArn.