1. Packages
  2. Packages
  3. Scaleway
  4. API Docs
  5. EdgeServicesRouteStage
Viewing docs for Scaleway v1.48.0
published on Wednesday, Apr 29, 2026 by pulumiverse
Schema (JSON)
pulumiverse/pulumi-scaleway

scaleway.EdgeServicesRouteStage

scaleway logo
Viewing docs for Scaleway v1.48.0
published on Wednesday, Apr 29, 2026 by pulumiverse
Schema (JSON)
pulumiverse/pulumi-scaleway
    Deprecated: scaleway.index/edgeservicesroutestage.EdgeServicesRouteStage has been deprecated in favor of scaleway.edgeservices/routestage.RouteStage

    Creates and manages Scaleway Edge Services Route Stages.

    Example Usage

    Default to WAF with backend rules

    Routes all unmatched traffic through a WAF stage, while requests matching specific patterns are sent directly to a backend stage.

    import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

const main = new scaleway.edgeservices.RouteStage("main", {
    pipelineId: mainScalewayEdgeServicesPipeline.id,
    wafStageId: waf.id,
    rules: [{
        backendStageId: backend.id,
        ruleHttpMatch: {
            methodFilters: [
                "get",
                "post",
            ],
            pathFilter: {
                pathFilterType: "regex",
                value: ".*",
            },
        },
    }],
});

    import pulumi
import pulumiverse_scaleway as scaleway

main = scaleway.edgeservices.RouteStage("main",
    pipeline_id=main_scaleway_edge_services_pipeline["id"],
    waf_stage_id=waf["id"],
    rules=[{
        "backend_stage_id": backend["id"],
        "rule_http_match": {
            "method_filters": [
                "get",
                "post",
            ],
            "path_filter": {
                "path_filter_type": "regex",
                "value": ".*",
            },
        },
    }])

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/edgeservices"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := edgeservices.NewRouteStage(ctx, "main", &edgeservices.RouteStageArgs{
			PipelineId: pulumi.Any(mainScalewayEdgeServicesPipeline.Id),
			WafStageId: pulumi.Any(waf.Id),
			Rules: edgeservices.RouteStageRuleArray{
				&edgeservices.RouteStageRuleArgs{
					BackendStageId: pulumi.Any(backend.Id),
					RuleHttpMatch: &edgeservices.RouteStageRuleRuleHttpMatchArgs{
						MethodFilters: pulumi.StringArray{
							pulumi.String("get"),
							pulumi.String("post"),
						},
						PathFilter: &edgeservices.RouteStageRuleRuleHttpMatchPathFilterArgs{
							PathFilterType: pulumi.String("regex"),
							Value:          pulumi.String(".*"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.Edgeservices.RouteStage("main", new()
    {
        PipelineId = mainScalewayEdgeServicesPipeline.Id,
        WafStageId = waf.Id,
        Rules = new[]
        {
            new Scaleway.Edgeservices.Inputs.RouteStageRuleArgs
            {
                BackendStageId = backend.Id,
                RuleHttpMatch = new Scaleway.Edgeservices.Inputs.RouteStageRuleRuleHttpMatchArgs
                {
                    MethodFilters = new[]
                    {
                        "get",
                        "post",
                    },
                    PathFilter = new Scaleway.Edgeservices.Inputs.RouteStageRuleRuleHttpMatchPathFilterArgs
                    {
                        PathFilterType = "regex",
                        Value = ".*",
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.edgeservices.RouteStage;
import com.pulumi.scaleway.edgeservices.RouteStageArgs;
import com.pulumi.scaleway.edgeservices.inputs.RouteStageRuleArgs;
import com.pulumi.scaleway.edgeservices.inputs.RouteStageRuleRuleHttpMatchArgs;
import com.pulumi.scaleway.edgeservices.inputs.RouteStageRuleRuleHttpMatchPathFilterArgs;
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 main = new RouteStage("main", RouteStageArgs.builder()
            .pipelineId(mainScalewayEdgeServicesPipeline.id())
            .wafStageId(waf.id())
            .rules(RouteStageRuleArgs.builder()
                .backendStageId(backend.id())
                .ruleHttpMatch(RouteStageRuleRuleHttpMatchArgs.builder()
                    .methodFilters(                    
                        "get",
                        "post")
                    .pathFilter(RouteStageRuleRuleHttpMatchPathFilterArgs.builder()
                        .pathFilterType("regex")
                        .value(".*")
                        .build())
                    .build())
                .build())
            .build());

    }
}

    resources:
  main:
    type: scaleway:edgeservices:RouteStage
    properties:
      pipelineId: ${mainScalewayEdgeServicesPipeline.id}
      wafStageId: ${waf.id}
      rules:
        - backendStageId: ${backend.id}
          ruleHttpMatch:
            methodFilters:
              - get
              - post
            pathFilter:
              pathFilterType: regex
              value: .*

    Host-based routing

    Routes requests to different backends based on the hostname, allowing a single pipeline to serve multiple domains.

    import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

const main = new scaleway.edgeservices.Pipeline("main", {
    name: "my-pipeline",
    description: "Multi-host pipeline with host-based routing",
});
const api = new scaleway.object.Bucket("api", {name: "my-api-bucket"});
const static = new scaleway.object.Bucket("static", {name: "my-static-site"});
const apiBackendStage = new scaleway.edgeservices.BackendStage("api", {
    pipelineId: main.id,
    s3BackendConfig: {
        bucketName: api.name,
        bucketRegion: "fr-par",
    },
});
const staticBackendStage = new scaleway.edgeservices.BackendStage("static", {
    pipelineId: main.id,
    s3BackendConfig: {
        bucketName: static.name,
        bucketRegion: "fr-par",
    },
});
const mainRouteStage = new scaleway.edgeservices.RouteStage("main", {
    pipelineId: main.id,
    backendStageId: staticBackendStage.id,
    rules: [{
        backendStageId: apiBackendStage.id,
        ruleHttpMatch: {
            hostFilter: {
                hostFilterType: "regex",
                value: "api\\.example\\.com",
            },
        },
    }],
});

    import pulumi
import pulumiverse_scaleway as scaleway

main = scaleway.edgeservices.Pipeline("main",
    name="my-pipeline",
    description="Multi-host pipeline with host-based routing")
api = scaleway.object.Bucket("api", name="my-api-bucket")
static = scaleway.object.Bucket("static", name="my-static-site")
api_backend_stage = scaleway.edgeservices.BackendStage("api",
    pipeline_id=main.id,
    s3_backend_config={
        "bucket_name": api.name,
        "bucket_region": "fr-par",
    })
static_backend_stage = scaleway.edgeservices.BackendStage("static",
    pipeline_id=main.id,
    s3_backend_config={
        "bucket_name": static.name,
        "bucket_region": "fr-par",
    })
main_route_stage = scaleway.edgeservices.RouteStage("main",
    pipeline_id=main.id,
    backend_stage_id=static_backend_stage.id,
    rules=[{
        "backend_stage_id": api_backend_stage.id,
        "rule_http_match": {
            "host_filter": {
                "host_filter_type": "regex",
                "value": "api\\.example\\.com",
            },
        },
    }])

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/edgeservices"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/object"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := edgeservices.NewPipeline(ctx, "main", &edgeservices.PipelineArgs{
			Name:        pulumi.String("my-pipeline"),
			Description: pulumi.String("Multi-host pipeline with host-based routing"),
		})
		if err != nil {
			return err
		}
		api, err := object.NewBucket(ctx, "api", &object.BucketArgs{
			Name: pulumi.String("my-api-bucket"),
		})
		if err != nil {
			return err
		}
		static, err := object.NewBucket(ctx, "static", &object.BucketArgs{
			Name: pulumi.String("my-static-site"),
		})
		if err != nil {
			return err
		}
		apiBackendStage, err := edgeservices.NewBackendStage(ctx, "api", &edgeservices.BackendStageArgs{
			PipelineId: main.ID(),
			S3BackendConfig: &edgeservices.BackendStageS3BackendConfigArgs{
				BucketName:   api.Name,
				BucketRegion: pulumi.String("fr-par"),
			},
		})
		if err != nil {
			return err
		}
		staticBackendStage, err := edgeservices.NewBackendStage(ctx, "static", &edgeservices.BackendStageArgs{
			PipelineId: main.ID(),
			S3BackendConfig: &edgeservices.BackendStageS3BackendConfigArgs{
				BucketName:   static.Name,
				BucketRegion: pulumi.String("fr-par"),
			},
		})
		if err != nil {
			return err
		}
		_, err = edgeservices.NewRouteStage(ctx, "main", &edgeservices.RouteStageArgs{
			PipelineId:     main.ID(),
			BackendStageId: staticBackendStage.ID(),
			Rules: edgeservices.RouteStageRuleArray{
				&edgeservices.RouteStageRuleArgs{
					BackendStageId: apiBackendStage.ID(),
					RuleHttpMatch: &edgeservices.RouteStageRuleRuleHttpMatchArgs{
						HostFilter: &edgeservices.RouteStageRuleRuleHttpMatchHostFilterArgs{
							HostFilterType: pulumi.String("regex"),
							Value:          pulumi.String("api\\.example\\.com"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.Edgeservices.Pipeline("main", new()
    {
        Name = "my-pipeline",
        Description = "Multi-host pipeline with host-based routing",
    });

    var api = new Scaleway.Object.Bucket("api", new()
    {
        Name = "my-api-bucket",
    });

    var @static = new Scaleway.Object.Bucket("static", new()
    {
        Name = "my-static-site",
    });

    var apiBackendStage = new Scaleway.Edgeservices.BackendStage("api", new()
    {
        PipelineId = main.Id,
        S3BackendConfig = new Scaleway.Edgeservices.Inputs.BackendStageS3BackendConfigArgs
        {
            BucketName = api.Name,
            BucketRegion = "fr-par",
        },
    });

    var staticBackendStage = new Scaleway.Edgeservices.BackendStage("static", new()
    {
        PipelineId = main.Id,
        S3BackendConfig = new Scaleway.Edgeservices.Inputs.BackendStageS3BackendConfigArgs
        {
            BucketName = @static.Name,
            BucketRegion = "fr-par",
        },
    });

    var mainRouteStage = new Scaleway.Edgeservices.RouteStage("main", new()
    {
        PipelineId = main.Id,
        BackendStageId = staticBackendStage.Id,
        Rules = new[]
        {
            new Scaleway.Edgeservices.Inputs.RouteStageRuleArgs
            {
                BackendStageId = apiBackendStage.Id,
                RuleHttpMatch = new Scaleway.Edgeservices.Inputs.RouteStageRuleRuleHttpMatchArgs
                {
                    HostFilter = new Scaleway.Edgeservices.Inputs.RouteStageRuleRuleHttpMatchHostFilterArgs
                    {
                        HostFilterType = "regex",
                        Value = "api\\.example\\.com",
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.edgeservices.Pipeline;
import com.pulumi.scaleway.edgeservices.PipelineArgs;
import com.pulumi.scaleway.object.Bucket;
import com.pulumi.scaleway.object.BucketArgs;
import com.pulumi.scaleway.edgeservices.BackendStage;
import com.pulumi.scaleway.edgeservices.BackendStageArgs;
import com.pulumi.scaleway.edgeservices.inputs.BackendStageS3BackendConfigArgs;
import com.pulumi.scaleway.edgeservices.RouteStage;
import com.pulumi.scaleway.edgeservices.RouteStageArgs;
import com.pulumi.scaleway.edgeservices.inputs.RouteStageRuleArgs;
import com.pulumi.scaleway.edgeservices.inputs.RouteStageRuleRuleHttpMatchArgs;
import com.pulumi.scaleway.edgeservices.inputs.RouteStageRuleRuleHttpMatchHostFilterArgs;
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 main = new Pipeline("main", PipelineArgs.builder()
            .name("my-pipeline")
            .description("Multi-host pipeline with host-based routing")
            .build());

        var api = new Bucket("api", BucketArgs.builder()
            .name("my-api-bucket")
            .build());

        var static_ = new Bucket("static", BucketArgs.builder()
            .name("my-static-site")
            .build());

        var apiBackendStage = new BackendStage("apiBackendStage", BackendStageArgs.builder()
            .pipelineId(main.id())
            .s3BackendConfig(BackendStageS3BackendConfigArgs.builder()
                .bucketName(api.name())
                .bucketRegion("fr-par")
                .build())
            .build());

        var staticBackendStage = new BackendStage("staticBackendStage", BackendStageArgs.builder()
            .pipelineId(main.id())
            .s3BackendConfig(BackendStageS3BackendConfigArgs.builder()
                .bucketName(static_.name())
                .bucketRegion("fr-par")
                .build())
            .build());

        var mainRouteStage = new RouteStage("mainRouteStage", RouteStageArgs.builder()
            .pipelineId(main.id())
            .backendStageId(staticBackendStage.id())
            .rules(RouteStageRuleArgs.builder()
                .backendStageId(apiBackendStage.id())
                .ruleHttpMatch(RouteStageRuleRuleHttpMatchArgs.builder()
                    .hostFilter(RouteStageRuleRuleHttpMatchHostFilterArgs.builder()
                        .hostFilterType("regex")
                        .value("api\\.example\\.com")
                        .build())
                    .build())
                .build())
            .build());

    }
}

    resources:
  main:
    type: scaleway:edgeservices:Pipeline
    properties:
      name: my-pipeline
      description: Multi-host pipeline with host-based routing
  api:
    type: scaleway:object:Bucket
    properties:
      name: my-api-bucket
  static:
    type: scaleway:object:Bucket
    properties:
      name: my-static-site
  apiBackendStage:
    type: scaleway:edgeservices:BackendStage
    name: api
    properties:
      pipelineId: ${main.id}
      s3BackendConfig:
        bucketName: ${api.name}
        bucketRegion: fr-par
  staticBackendStage:
    type: scaleway:edgeservices:BackendStage
    name: static
    properties:
      pipelineId: ${main.id}
      s3BackendConfig:
        bucketName: ${static.name}
        bucketRegion: fr-par
  mainRouteStage:
    type: scaleway:edgeservices:RouteStage
    name: main
    properties:
      pipelineId: ${main.id}
      backendStageId: ${staticBackendStage.id}
      rules:
        - backendStageId: ${apiBackendStage.id}
          ruleHttpMatch:
            hostFilter:
              hostFilterType: regex
              value: api\.example\.com

    Default to backend with selective WAF protection

    Serves static content directly from a backend by default, while routing API traffic through a WAF stage for protection against common web attacks.

    import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

const main = new scaleway.edgeservices.Pipeline("main", {
    name: "my-pipeline",
    description: "Static site with WAF-protected API",
});
const mainBucket = new scaleway.object.Bucket("main", {name: "my-static-site"});
const static = new scaleway.edgeservices.BackendStage("static", {
    pipelineId: main.id,
    s3BackendConfig: {
        bucketName: mainBucket.name,
        bucketRegion: "fr-par",
    },
});
const api = new scaleway.edgeservices.WafStage("api", {
    pipelineId: main.id,
    backendStageId: static.id,
    mode: "enable",
    paranoiaLevel: 2,
});
const mainRouteStage = new scaleway.edgeservices.RouteStage("main", {
    pipelineId: main.id,
    backendStageId: static.id,
    rules: [{
        wafStageId: api.id,
        ruleHttpMatch: {
            methodFilters: [
                "get",
                "post",
                "put",
                "patch",
                "delete",
            ],
            pathFilter: {
                pathFilterType: "regex",
                value: "/api/.*",
            },
        },
    }],
});

    import pulumi
import pulumiverse_scaleway as scaleway

main = scaleway.edgeservices.Pipeline("main",
    name="my-pipeline",
    description="Static site with WAF-protected API")
main_bucket = scaleway.object.Bucket("main", name="my-static-site")
static = scaleway.edgeservices.BackendStage("static",
    pipeline_id=main.id,
    s3_backend_config={
        "bucket_name": main_bucket.name,
        "bucket_region": "fr-par",
    })
api = scaleway.edgeservices.WafStage("api",
    pipeline_id=main.id,
    backend_stage_id=static.id,
    mode="enable",
    paranoia_level=2)
main_route_stage = scaleway.edgeservices.RouteStage("main",
    pipeline_id=main.id,
    backend_stage_id=static.id,
    rules=[{
        "waf_stage_id": api.id,
        "rule_http_match": {
            "method_filters": [
                "get",
                "post",
                "put",
                "patch",
                "delete",
            ],
            "path_filter": {
                "path_filter_type": "regex",
                "value": "/api/.*",
            },
        },
    }])

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/edgeservices"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/object"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := edgeservices.NewPipeline(ctx, "main", &edgeservices.PipelineArgs{
			Name:        pulumi.String("my-pipeline"),
			Description: pulumi.String("Static site with WAF-protected API"),
		})
		if err != nil {
			return err
		}
		mainBucket, err := object.NewBucket(ctx, "main", &object.BucketArgs{
			Name: pulumi.String("my-static-site"),
		})
		if err != nil {
			return err
		}
		static, err := edgeservices.NewBackendStage(ctx, "static", &edgeservices.BackendStageArgs{
			PipelineId: main.ID(),
			S3BackendConfig: &edgeservices.BackendStageS3BackendConfigArgs{
				BucketName:   mainBucket.Name,
				BucketRegion: pulumi.String("fr-par"),
			},
		})
		if err != nil {
			return err
		}
		api, err := edgeservices.NewWafStage(ctx, "api", &edgeservices.WafStageArgs{
			PipelineId:     main.ID(),
			BackendStageId: static.ID(),
			Mode:           pulumi.String("enable"),
			ParanoiaLevel:  pulumi.Int(2),
		})
		if err != nil {
			return err
		}
		_, err = edgeservices.NewRouteStage(ctx, "main", &edgeservices.RouteStageArgs{
			PipelineId:     main.ID(),
			BackendStageId: static.ID(),
			Rules: edgeservices.RouteStageRuleArray{
				&edgeservices.RouteStageRuleArgs{
					WafStageId: api.ID(),
					RuleHttpMatch: &edgeservices.RouteStageRuleRuleHttpMatchArgs{
						MethodFilters: pulumi.StringArray{
							pulumi.String("get"),
							pulumi.String("post"),
							pulumi.String("put"),
							pulumi.String("patch"),
							pulumi.String("delete"),
						},
						PathFilter: &edgeservices.RouteStageRuleRuleHttpMatchPathFilterArgs{
							PathFilterType: pulumi.String("regex"),
							Value:          pulumi.String("/api/.*"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.Edgeservices.Pipeline("main", new()
    {
        Name = "my-pipeline",
        Description = "Static site with WAF-protected API",
    });

    var mainBucket = new Scaleway.Object.Bucket("main", new()
    {
        Name = "my-static-site",
    });

    var @static = new Scaleway.Edgeservices.BackendStage("static", new()
    {
        PipelineId = main.Id,
        S3BackendConfig = new Scaleway.Edgeservices.Inputs.BackendStageS3BackendConfigArgs
        {
            BucketName = mainBucket.Name,
            BucketRegion = "fr-par",
        },
    });

    var api = new Scaleway.Edgeservices.WafStage("api", new()
    {
        PipelineId = main.Id,
        BackendStageId = @static.Id,
        Mode = "enable",
        ParanoiaLevel = 2,
    });

    var mainRouteStage = new Scaleway.Edgeservices.RouteStage("main", new()
    {
        PipelineId = main.Id,
        BackendStageId = @static.Id,
        Rules = new[]
        {
            new Scaleway.Edgeservices.Inputs.RouteStageRuleArgs
            {
                WafStageId = api.Id,
                RuleHttpMatch = new Scaleway.Edgeservices.Inputs.RouteStageRuleRuleHttpMatchArgs
                {
                    MethodFilters = new[]
                    {
                        "get",
                        "post",
                        "put",
                        "patch",
                        "delete",
                    },
                    PathFilter = new Scaleway.Edgeservices.Inputs.RouteStageRuleRuleHttpMatchPathFilterArgs
                    {
                        PathFilterType = "regex",
                        Value = "/api/.*",
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.edgeservices.Pipeline;
import com.pulumi.scaleway.edgeservices.PipelineArgs;
import com.pulumi.scaleway.object.Bucket;
import com.pulumi.scaleway.object.BucketArgs;
import com.pulumi.scaleway.edgeservices.BackendStage;
import com.pulumi.scaleway.edgeservices.BackendStageArgs;
import com.pulumi.scaleway.edgeservices.inputs.BackendStageS3BackendConfigArgs;
import com.pulumi.scaleway.edgeservices.WafStage;
import com.pulumi.scaleway.edgeservices.WafStageArgs;
import com.pulumi.scaleway.edgeservices.RouteStage;
import com.pulumi.scaleway.edgeservices.RouteStageArgs;
import com.pulumi.scaleway.edgeservices.inputs.RouteStageRuleArgs;
import com.pulumi.scaleway.edgeservices.inputs.RouteStageRuleRuleHttpMatchArgs;
import com.pulumi.scaleway.edgeservices.inputs.RouteStageRuleRuleHttpMatchPathFilterArgs;
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 main = new Pipeline("main", PipelineArgs.builder()
            .name("my-pipeline")
            .description("Static site with WAF-protected API")
            .build());

        var mainBucket = new Bucket("mainBucket", BucketArgs.builder()
            .name("my-static-site")
            .build());

        var static_ = new BackendStage("static", BackendStageArgs.builder()
            .pipelineId(main.id())
            .s3BackendConfig(BackendStageS3BackendConfigArgs.builder()
                .bucketName(mainBucket.name())
                .bucketRegion("fr-par")
                .build())
            .build());

        var api = new WafStage("api", WafStageArgs.builder()
            .pipelineId(main.id())
            .backendStageId(static_.id())
            .mode("enable")
            .paranoiaLevel(2)
            .build());

        var mainRouteStage = new RouteStage("mainRouteStage", RouteStageArgs.builder()
            .pipelineId(main.id())
            .backendStageId(static_.id())
            .rules(RouteStageRuleArgs.builder()
                .wafStageId(api.id())
                .ruleHttpMatch(RouteStageRuleRuleHttpMatchArgs.builder()
                    .methodFilters(                    
                        "get",
                        "post",
                        "put",
                        "patch",
                        "delete")
                    .pathFilter(RouteStageRuleRuleHttpMatchPathFilterArgs.builder()
                        .pathFilterType("regex")
                        .value("/api/.*")
                        .build())
                    .build())
                .build())
            .build());

    }
}

    resources:
  main:
    type: scaleway:edgeservices:Pipeline
    properties:
      name: my-pipeline
      description: Static site with WAF-protected API
  mainBucket:
    type: scaleway:object:Bucket
    name: main
    properties:
      name: my-static-site
  static:
    type: scaleway:edgeservices:BackendStage
    properties:
      pipelineId: ${main.id}
      s3BackendConfig:
        bucketName: ${mainBucket.name}
        bucketRegion: fr-par
  api:
    type: scaleway:edgeservices:WafStage
    properties:
      pipelineId: ${main.id}
      backendStageId: ${static.id}
      mode: enable
      paranoiaLevel: 2
  mainRouteStage:
    type: scaleway:edgeservices:RouteStage
    name: main
    properties:
      pipelineId: ${main.id}
      backendStageId: ${static.id}
      rules:
        - wafStageId: ${api.id}
          ruleHttpMatch:
            methodFilters:
              - get
              - post
              - put
              - patch
              - delete
            pathFilter:
              pathFilterType: regex
              value: /api/.*

    Create EdgeServicesRouteStage Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new EdgeServicesRouteStage(name: string, args: EdgeServicesRouteStageArgs, opts?: CustomResourceOptions);
    @overload
def EdgeServicesRouteStage(resource_name: str,
                           args: EdgeServicesRouteStageArgs,
                           opts: Optional[ResourceOptions] = None)

@overload
def EdgeServicesRouteStage(resource_name: str,
                           opts: Optional[ResourceOptions] = None,
                           backend_stage_id: Optional[str] = None,
                           pipeline_id: Optional[str] = None,
                           project_id: Optional[str] = None,
                           rules: Optional[Sequence[EdgeServicesRouteStageRuleArgs]] = None,
                           waf_stage_id: Optional[str] = None)
    func NewEdgeServicesRouteStage(ctx *Context, name string, args EdgeServicesRouteStageArgs, opts ...ResourceOption) (*EdgeServicesRouteStage, error)
    public EdgeServicesRouteStage(string name, EdgeServicesRouteStageArgs args, CustomResourceOptions? opts = null)
    public EdgeServicesRouteStage(String name, EdgeServicesRouteStageArgs args)
public EdgeServicesRouteStage(String name, EdgeServicesRouteStageArgs args, CustomResourceOptions options)

    type: scaleway:EdgeServicesRouteStage
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args EdgeServicesRouteStageArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args EdgeServicesRouteStageArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args EdgeServicesRouteStageArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args EdgeServicesRouteStageArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args EdgeServicesRouteStageArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    EdgeServicesRouteStage Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The EdgeServicesRouteStage resource accepts the following input properties:

    PipelineId string
    The ID of the pipeline.
    BackendStageId string
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    ProjectId string
    projectId) The ID of the project the route stage is associated with.
    Rules List<Pulumiverse.Scaleway.Inputs.EdgeServicesRouteStageRule>
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    WafStageId string
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.
    PipelineId string
    The ID of the pipeline.
    BackendStageId string
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    ProjectId string
    projectId) The ID of the project the route stage is associated with.
    Rules []EdgeServicesRouteStageRuleArgs
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    WafStageId string
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.
    pipelineId String
    The ID of the pipeline.
    backendStageId String
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    projectId String
    projectId) The ID of the project the route stage is associated with.
    rules List<EdgeServicesRouteStageRule>
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    wafStageId String
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.
    pipelineId string
    The ID of the pipeline.
    backendStageId string
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    projectId string
    projectId) The ID of the project the route stage is associated with.
    rules EdgeServicesRouteStageRule[]
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    wafStageId string
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.
    pipeline_id str
    The ID of the pipeline.
    backend_stage_id str
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    project_id str
    projectId) The ID of the project the route stage is associated with.
    rules Sequence[EdgeServicesRouteStageRuleArgs]
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    waf_stage_id str
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.
    pipelineId String
    The ID of the pipeline.
    backendStageId String
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    projectId String
    projectId) The ID of the project the route stage is associated with.
    rules List<Property Map>
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    wafStageId String
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the EdgeServicesRouteStage resource produces the following output properties:

    CreatedAt string
    The date and time of the creation of the route stage.
    Id string
    The provider-assigned unique ID for this managed resource.
    UpdatedAt string
    The date and time of the last update of the route stage.
    CreatedAt string
    The date and time of the creation of the route stage.
    Id string
    The provider-assigned unique ID for this managed resource.
    UpdatedAt string
    The date and time of the last update of the route stage.
    createdAt String
    The date and time of the creation of the route stage.
    id String
    The provider-assigned unique ID for this managed resource.
    updatedAt String
    The date and time of the last update of the route stage.
    createdAt string
    The date and time of the creation of the route stage.
    id string
    The provider-assigned unique ID for this managed resource.
    updatedAt string
    The date and time of the last update of the route stage.
    created_at str
    The date and time of the creation of the route stage.
    id str
    The provider-assigned unique ID for this managed resource.
    updated_at str
    The date and time of the last update of the route stage.
    createdAt String
    The date and time of the creation of the route stage.
    id String
    The provider-assigned unique ID for this managed resource.
    updatedAt String
    The date and time of the last update of the route stage.

    Look up Existing EdgeServicesRouteStage Resource

    Get an existing EdgeServicesRouteStage resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: EdgeServicesRouteStageState, opts?: CustomResourceOptions): EdgeServicesRouteStage
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        backend_stage_id: Optional[str] = None,
        created_at: Optional[str] = None,
        pipeline_id: Optional[str] = None,
        project_id: Optional[str] = None,
        rules: Optional[Sequence[EdgeServicesRouteStageRuleArgs]] = None,
        updated_at: Optional[str] = None,
        waf_stage_id: Optional[str] = None) -> EdgeServicesRouteStage
    func GetEdgeServicesRouteStage(ctx *Context, name string, id IDInput, state *EdgeServicesRouteStageState, opts ...ResourceOption) (*EdgeServicesRouteStage, error)
    public static EdgeServicesRouteStage Get(string name, Input<string> id, EdgeServicesRouteStageState? state, CustomResourceOptions? opts = null)
    public static EdgeServicesRouteStage get(String name, Output<String> id, EdgeServicesRouteStageState state, CustomResourceOptions options)
    resources:  _:    type: scaleway:EdgeServicesRouteStage    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    BackendStageId string
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    CreatedAt string
    The date and time of the creation of the route stage.
    PipelineId string
    The ID of the pipeline.
    ProjectId string
    projectId) The ID of the project the route stage is associated with.
    Rules List<Pulumiverse.Scaleway.Inputs.EdgeServicesRouteStageRule>
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    UpdatedAt string
    The date and time of the last update of the route stage.
    WafStageId string
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.
    BackendStageId string
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    CreatedAt string
    The date and time of the creation of the route stage.
    PipelineId string
    The ID of the pipeline.
    ProjectId string
    projectId) The ID of the project the route stage is associated with.
    Rules []EdgeServicesRouteStageRuleArgs
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    UpdatedAt string
    The date and time of the last update of the route stage.
    WafStageId string
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.
    backendStageId String
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    createdAt String
    The date and time of the creation of the route stage.
    pipelineId String
    The ID of the pipeline.
    projectId String
    projectId) The ID of the project the route stage is associated with.
    rules List<EdgeServicesRouteStageRule>
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    updatedAt String
    The date and time of the last update of the route stage.
    wafStageId String
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.
    backendStageId string
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    createdAt string
    The date and time of the creation of the route stage.
    pipelineId string
    The ID of the pipeline.
    projectId string
    projectId) The ID of the project the route stage is associated with.
    rules EdgeServicesRouteStageRule[]
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    updatedAt string
    The date and time of the last update of the route stage.
    wafStageId string
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.
    backend_stage_id str
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    created_at str
    The date and time of the creation of the route stage.
    pipeline_id str
    The ID of the pipeline.
    project_id str
    projectId) The ID of the project the route stage is associated with.
    rules Sequence[EdgeServicesRouteStageRuleArgs]
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    updated_at str
    The date and time of the last update of the route stage.
    waf_stage_id str
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.
    backendStageId String
    The ID of the backend stage HTTP requests should be forwarded to when no rules are matched. Conflicts with wafStageId.
    createdAt String
    The date and time of the creation of the route stage.
    pipelineId String
    The ID of the pipeline.
    projectId String
    projectId) The ID of the project the route stage is associated with.
    rules List<Property Map>
    List of rules to be checked against every HTTP request. The first matching rule will forward the request to its specified target stage. If no rules are matched, the request is forwarded to the default stage defined by wafStageId or backendStageId.
    updatedAt String
    The date and time of the last update of the route stage.
    wafStageId String
    The ID of the WAF stage HTTP requests should be forwarded to when no rules are matched. Conflicts with backendStageId.

    Supporting Types

    EdgeServicesRouteStageRule, EdgeServicesRouteStageRuleArgs

    BackendStageId string
    The ID of the backend stage that requests matching the rule should be forwarded to. Conflicts with wafStageId within the same rule.
    RuleHttpMatch Pulumiverse.Scaleway.Inputs.EdgeServicesRouteStageRuleRuleHttpMatch
    The rule condition to be matched. Requests matching the condition defined here will be forwarded to the stage specified by backendStageId or wafStageId. Requests that do not match will be checked by the next rule's condition.
    WafStageId string
    The ID of the WAF stage that requests matching the rule should be forwarded to. Conflicts with backendStageId within the same rule.
    BackendStageId string
    The ID of the backend stage that requests matching the rule should be forwarded to. Conflicts with wafStageId within the same rule.
    RuleHttpMatch EdgeServicesRouteStageRuleRuleHttpMatch
    The rule condition to be matched. Requests matching the condition defined here will be forwarded to the stage specified by backendStageId or wafStageId. Requests that do not match will be checked by the next rule's condition.
    WafStageId string
    The ID of the WAF stage that requests matching the rule should be forwarded to. Conflicts with backendStageId within the same rule.
    backendStageId String
    The ID of the backend stage that requests matching the rule should be forwarded to. Conflicts with wafStageId within the same rule.
    ruleHttpMatch EdgeServicesRouteStageRuleRuleHttpMatch
    The rule condition to be matched. Requests matching the condition defined here will be forwarded to the stage specified by backendStageId or wafStageId. Requests that do not match will be checked by the next rule's condition.
    wafStageId String
    The ID of the WAF stage that requests matching the rule should be forwarded to. Conflicts with backendStageId within the same rule.
    backendStageId string
    The ID of the backend stage that requests matching the rule should be forwarded to. Conflicts with wafStageId within the same rule.
    ruleHttpMatch EdgeServicesRouteStageRuleRuleHttpMatch
    The rule condition to be matched. Requests matching the condition defined here will be forwarded to the stage specified by backendStageId or wafStageId. Requests that do not match will be checked by the next rule's condition.
    wafStageId string
    The ID of the WAF stage that requests matching the rule should be forwarded to. Conflicts with backendStageId within the same rule.
    backend_stage_id str
    The ID of the backend stage that requests matching the rule should be forwarded to. Conflicts with wafStageId within the same rule.
    rule_http_match EdgeServicesRouteStageRuleRuleHttpMatch
    The rule condition to be matched. Requests matching the condition defined here will be forwarded to the stage specified by backendStageId or wafStageId. Requests that do not match will be checked by the next rule's condition.
    waf_stage_id str
    The ID of the WAF stage that requests matching the rule should be forwarded to. Conflicts with backendStageId within the same rule.
    backendStageId String
    The ID of the backend stage that requests matching the rule should be forwarded to. Conflicts with wafStageId within the same rule.
    ruleHttpMatch Property Map
    The rule condition to be matched. Requests matching the condition defined here will be forwarded to the stage specified by backendStageId or wafStageId. Requests that do not match will be checked by the next rule's condition.
    wafStageId String
    The ID of the WAF stage that requests matching the rule should be forwarded to. Conflicts with backendStageId within the same rule.

    EdgeServicesRouteStageRuleRuleHttpMatch, EdgeServicesRouteStageRuleRuleHttpMatchArgs

    HostFilter Pulumiverse.Scaleway.Inputs.EdgeServicesRouteStageRuleRuleHttpMatchHostFilter
    Host to filter for. A request whose host matches the given filter will be considered to match the rule. All hosts will match if none is provided.
    MethodFilters List<string>
    HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are get, post, put, patch, delete, head, options. All methods will match if none is provided.
    PathFilter Pulumiverse.Scaleway.Inputs.EdgeServicesRouteStageRuleRuleHttpMatchPathFilter
    HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.
    HostFilter EdgeServicesRouteStageRuleRuleHttpMatchHostFilter
    Host to filter for. A request whose host matches the given filter will be considered to match the rule. All hosts will match if none is provided.
    MethodFilters []string
    HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are get, post, put, patch, delete, head, options. All methods will match if none is provided.
    PathFilter EdgeServicesRouteStageRuleRuleHttpMatchPathFilter
    HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.
    hostFilter EdgeServicesRouteStageRuleRuleHttpMatchHostFilter
    Host to filter for. A request whose host matches the given filter will be considered to match the rule. All hosts will match if none is provided.
    methodFilters List<String>
    HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are get, post, put, patch, delete, head, options. All methods will match if none is provided.
    pathFilter EdgeServicesRouteStageRuleRuleHttpMatchPathFilter
    HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.
    hostFilter EdgeServicesRouteStageRuleRuleHttpMatchHostFilter
    Host to filter for. A request whose host matches the given filter will be considered to match the rule. All hosts will match if none is provided.
    methodFilters string[]
    HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are get, post, put, patch, delete, head, options. All methods will match if none is provided.
    pathFilter EdgeServicesRouteStageRuleRuleHttpMatchPathFilter
    HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.
    host_filter EdgeServicesRouteStageRuleRuleHttpMatchHostFilter
    Host to filter for. A request whose host matches the given filter will be considered to match the rule. All hosts will match if none is provided.
    method_filters Sequence[str]
    HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are get, post, put, patch, delete, head, options. All methods will match if none is provided.
    path_filter EdgeServicesRouteStageRuleRuleHttpMatchPathFilter
    HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.
    hostFilter Property Map
    Host to filter for. A request whose host matches the given filter will be considered to match the rule. All hosts will match if none is provided.
    methodFilters List<String>
    HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are get, post, put, patch, delete, head, options. All methods will match if none is provided.
    pathFilter Property Map
    HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.

    EdgeServicesRouteStageRuleRuleHttpMatchHostFilter, EdgeServicesRouteStageRuleRuleHttpMatchHostFilterArgs

    HostFilterType string
    The type of filter to match for the host. Use the regex type.
    Value string
    The value to be matched for the host.
    HostFilterType string
    The type of filter to match for the host. Use the regex type.
    Value string
    The value to be matched for the host.
    hostFilterType String
    The type of filter to match for the host. Use the regex type.
    value String
    The value to be matched for the host.
    hostFilterType string
    The type of filter to match for the host. Use the regex type.
    value string
    The value to be matched for the host.
    host_filter_type str
    The type of filter to match for the host. Use the regex type.
    value str
    The value to be matched for the host.
    hostFilterType String
    The type of filter to match for the host. Use the regex type.
    value String
    The value to be matched for the host.

    EdgeServicesRouteStageRuleRuleHttpMatchPathFilter, EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgs

    PathFilterType string
    The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the regex type.
    Value string
    The value to be matched for the HTTP URL path.
    PathFilterType string
    The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the regex type.
    Value string
    The value to be matched for the HTTP URL path.
    pathFilterType String
    The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the regex type.
    value String
    The value to be matched for the HTTP URL path.
    pathFilterType string
    The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the regex type.
    value string
    The value to be matched for the HTTP URL path.
    path_filter_type str
    The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the regex type.
    value str
    The value to be matched for the HTTP URL path.
    pathFilterType String
    The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the regex type.
    value String
    The value to be matched for the HTTP URL path.

    Import

    Route stages can be imported using the {id}, e.g.

    $ pulumi import scaleway:index/edgeServicesRouteStage:EdgeServicesRouteStage basic 11111111-1111-1111-1111-111111111111

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    scaleway pulumiverse/pulumi-scaleway
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the scaleway Terraform Provider.
    scaleway logo
    Viewing docs for Scaleway v1.48.0
    published on Wednesday, Apr 29, 2026 by pulumiverse
    Schema (JSON)
    pulumiverse/pulumi-scaleway
      Try Pulumi Cloud free. Your team will thank you.