pulumi-aws-kotlin/com.pulumi.aws.apigateway.kotlin/MethodSettings

MethodSettings

class MethodSettings : KotlinCustomResource

Manages API Gateway Stage Method Settings. For example, CloudWatch logging and metrics.

NOTE: We recommend using this resource in conjunction with the aws.apigateway.Stage resource instead of a stage managed by the aws.apigateway.Deployment resource optional stage_name argument. Stages managed by the aws.apigateway.Deployment resource are recreated on redeployment and this resource will require a second apply to recreate the method settings.

Example Usage

End-to-end

Off

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const pathSpecific = new aws.apigateway.MethodSettings("path_specific", {
    restApi: example.id,
    stageName: exampleAwsApiGatewayStage.stageName,
    methodPath: "path1/GET",
    settings: {
        loggingLevel: "OFF",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
path_specific = aws.apigateway.MethodSettings("path_specific",
    rest_api=example["id"],
    stage_name=example_aws_api_gateway_stage["stageName"],
    method_path="path1/GET",
    settings=aws.apigateway.MethodSettingsSettingsArgs(
        logging_level="OFF",
    ))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var pathSpecific = new Aws.ApiGateway.MethodSettings("path_specific", new()
    {
        RestApi = example.Id,
        StageName = exampleAwsApiGatewayStage.StageName,
        MethodPath = "path1/GET",
        Settings = new Aws.ApiGateway.Inputs.MethodSettingsSettingsArgs
        {
            LoggingLevel = "OFF",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/apigateway"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewMethodSettings(ctx, "path_specific", &apigateway.MethodSettingsArgs{
			RestApi:    pulumi.Any(example.Id),
			StageName:  pulumi.Any(exampleAwsApiGatewayStage.StageName),
			MethodPath: pulumi.String("path1/GET"),
			Settings: &apigateway.MethodSettingsSettingsArgs{
				LoggingLevel: pulumi.String("OFF"),
			},
		})
		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.aws.apigateway.MethodSettings;
import com.pulumi.aws.apigateway.MethodSettingsArgs;
import com.pulumi.aws.apigateway.inputs.MethodSettingsSettingsArgs;
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 pathSpecific = new MethodSettings("pathSpecific", MethodSettingsArgs.builder()
            .restApi(example.id())
            .stageName(exampleAwsApiGatewayStage.stageName())
            .methodPath("path1/GET")
            .settings(MethodSettingsSettingsArgs.builder()
                .loggingLevel("OFF")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  pathSpecific:
    type: aws:apigateway:MethodSettings
    name: path_specific
    properties:
      restApi: ${example.id}
      stageName: ${exampleAwsApiGatewayStage.stageName}
      methodPath: path1/GET
      settings:
        loggingLevel: OFF
Content copied to clipboard

Errors Only

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const pathSpecific = new aws.apigateway.MethodSettings("path_specific", {
    restApi: example.id,
    stageName: exampleAwsApiGatewayStage.stageName,
    methodPath: "path1/GET",
    settings: {
        loggingLevel: "ERROR",
        metricsEnabled: true,
        dataTraceEnabled: false,
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
path_specific = aws.apigateway.MethodSettings("path_specific",
    rest_api=example["id"],
    stage_name=example_aws_api_gateway_stage["stageName"],
    method_path="path1/GET",
    settings=aws.apigateway.MethodSettingsSettingsArgs(
        logging_level="ERROR",
        metrics_enabled=True,
        data_trace_enabled=False,
    ))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var pathSpecific = new Aws.ApiGateway.MethodSettings("path_specific", new()
    {
        RestApi = example.Id,
        StageName = exampleAwsApiGatewayStage.StageName,
        MethodPath = "path1/GET",
        Settings = new Aws.ApiGateway.Inputs.MethodSettingsSettingsArgs
        {
            LoggingLevel = "ERROR",
            MetricsEnabled = true,
            DataTraceEnabled = false,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/apigateway"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewMethodSettings(ctx, "path_specific", &apigateway.MethodSettingsArgs{
			RestApi:    pulumi.Any(example.Id),
			StageName:  pulumi.Any(exampleAwsApiGatewayStage.StageName),
			MethodPath: pulumi.String("path1/GET"),
			Settings: &apigateway.MethodSettingsSettingsArgs{
				LoggingLevel:     pulumi.String("ERROR"),
				MetricsEnabled:   pulumi.Bool(true),
				DataTraceEnabled: pulumi.Bool(false),
			},
		})
		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.aws.apigateway.MethodSettings;
import com.pulumi.aws.apigateway.MethodSettingsArgs;
import com.pulumi.aws.apigateway.inputs.MethodSettingsSettingsArgs;
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 pathSpecific = new MethodSettings("pathSpecific", MethodSettingsArgs.builder()
            .restApi(example.id())
            .stageName(exampleAwsApiGatewayStage.stageName())
            .methodPath("path1/GET")
            .settings(MethodSettingsSettingsArgs.builder()
                .loggingLevel("ERROR")
                .metricsEnabled(true)
                .dataTraceEnabled(false)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  pathSpecific:
    type: aws:apigateway:MethodSettings
    name: path_specific
    properties:
      restApi: ${example.id}
      stageName: ${exampleAwsApiGatewayStage.stageName}
      methodPath: path1/GET
      settings:
        loggingLevel: ERROR
        metricsEnabled: true
        dataTraceEnabled: false
Content copied to clipboard

Errors and Info Logs

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const pathSpecific = new aws.apigateway.MethodSettings("path_specific", {
    restApi: example.id,
    stageName: exampleAwsApiGatewayStage.stageName,
    methodPath: "path1/GET",
    settings: {
        loggingLevel: "INFO",
        metricsEnabled: true,
        dataTraceEnabled: false,
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
path_specific = aws.apigateway.MethodSettings("path_specific",
    rest_api=example["id"],
    stage_name=example_aws_api_gateway_stage["stageName"],
    method_path="path1/GET",
    settings=aws.apigateway.MethodSettingsSettingsArgs(
        logging_level="INFO",
        metrics_enabled=True,
        data_trace_enabled=False,
    ))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var pathSpecific = new Aws.ApiGateway.MethodSettings("path_specific", new()
    {
        RestApi = example.Id,
        StageName = exampleAwsApiGatewayStage.StageName,
        MethodPath = "path1/GET",
        Settings = new Aws.ApiGateway.Inputs.MethodSettingsSettingsArgs
        {
            LoggingLevel = "INFO",
            MetricsEnabled = true,
            DataTraceEnabled = false,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/apigateway"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewMethodSettings(ctx, "path_specific", &apigateway.MethodSettingsArgs{
			RestApi:    pulumi.Any(example.Id),
			StageName:  pulumi.Any(exampleAwsApiGatewayStage.StageName),
			MethodPath: pulumi.String("path1/GET"),
			Settings: &apigateway.MethodSettingsSettingsArgs{
				LoggingLevel:     pulumi.String("INFO"),
				MetricsEnabled:   pulumi.Bool(true),
				DataTraceEnabled: pulumi.Bool(false),
			},
		})
		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.aws.apigateway.MethodSettings;
import com.pulumi.aws.apigateway.MethodSettingsArgs;
import com.pulumi.aws.apigateway.inputs.MethodSettingsSettingsArgs;
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 pathSpecific = new MethodSettings("pathSpecific", MethodSettingsArgs.builder()
            .restApi(example.id())
            .stageName(exampleAwsApiGatewayStage.stageName())
            .methodPath("path1/GET")
            .settings(MethodSettingsSettingsArgs.builder()
                .loggingLevel("INFO")
                .metricsEnabled(true)
                .dataTraceEnabled(false)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  pathSpecific:
    type: aws:apigateway:MethodSettings
    name: path_specific
    properties:
      restApi: ${example.id}
      stageName: ${exampleAwsApiGatewayStage.stageName}
      methodPath: path1/GET
      settings:
        loggingLevel: INFO
        metricsEnabled: true
        dataTraceEnabled: false
Content copied to clipboard

Full Request and Response Logs

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const pathSpecific = new aws.apigateway.MethodSettings("path_specific", {
    restApi: example.id,
    stageName: exampleAwsApiGatewayStage.stageName,
    methodPath: "path1/GET",
    settings: {
        loggingLevel: "INFO",
        metricsEnabled: true,
        dataTraceEnabled: true,
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
path_specific = aws.apigateway.MethodSettings("path_specific",
    rest_api=example["id"],
    stage_name=example_aws_api_gateway_stage["stageName"],
    method_path="path1/GET",
    settings=aws.apigateway.MethodSettingsSettingsArgs(
        logging_level="INFO",
        metrics_enabled=True,
        data_trace_enabled=True,
    ))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var pathSpecific = new Aws.ApiGateway.MethodSettings("path_specific", new()
    {
        RestApi = example.Id,
        StageName = exampleAwsApiGatewayStage.StageName,
        MethodPath = "path1/GET",
        Settings = new Aws.ApiGateway.Inputs.MethodSettingsSettingsArgs
        {
            LoggingLevel = "INFO",
            MetricsEnabled = true,
            DataTraceEnabled = true,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/apigateway"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewMethodSettings(ctx, "path_specific", &apigateway.MethodSettingsArgs{
			RestApi:    pulumi.Any(example.Id),
			StageName:  pulumi.Any(exampleAwsApiGatewayStage.StageName),
			MethodPath: pulumi.String("path1/GET"),
			Settings: &apigateway.MethodSettingsSettingsArgs{
				LoggingLevel:     pulumi.String("INFO"),
				MetricsEnabled:   pulumi.Bool(true),
				DataTraceEnabled: pulumi.Bool(true),
			},
		})
		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.aws.apigateway.MethodSettings;
import com.pulumi.aws.apigateway.MethodSettingsArgs;
import com.pulumi.aws.apigateway.inputs.MethodSettingsSettingsArgs;
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 pathSpecific = new MethodSettings("pathSpecific", MethodSettingsArgs.builder()
            .restApi(example.id())
            .stageName(exampleAwsApiGatewayStage.stageName())
            .methodPath("path1/GET")
            .settings(MethodSettingsSettingsArgs.builder()
                .loggingLevel("INFO")
                .metricsEnabled(true)
                .dataTraceEnabled(true)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  pathSpecific:
    type: aws:apigateway:MethodSettings
    name: path_specific
    properties:
      restApi: ${example.id}
      stageName: ${exampleAwsApiGatewayStage.stageName}
      methodPath: path1/GET
      settings:
        loggingLevel: INFO
        metricsEnabled: true
        dataTraceEnabled: true
Content copied to clipboard

Import

Using pulumi import, import aws_api_gateway_method_settings using REST-API-ID/STAGE-NAME/METHOD-PATH. For example:

$ pulumi import aws:apigateway/methodSettings:MethodSettings example 12345abcde/example/test/GET
Content copied to clipboard

Properties

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

/* Method path defined as {resource_path}/{http_method} for an individual method override, or */* for overriding all methods in the stage. Ensure to trim any leading forward slashes in the path (e.g., trimprefix(aws_api_gateway_resource.example.path, "/")).

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val restApi: Output<String>

ID of the REST API

Link copied to clipboard
val settings: Output<MethodSettingsSettings>

Settings block, see below.

Link copied to clipboard
val stageName: Output<String>

Name of the stage

Link copied to clipboard
val urn: Output<String>