gcp.apigateway.Gateway

using System;
using System.Collections.Generic;
using System.IO;
using Pulumi;
using Gcp = Pulumi.Gcp;

	private static string ReadFileBase64(string path) {
		return Convert.ToBase64String(Encoding.UTF8.GetBytes(File.ReadAllText(path)))
	}

return await Deployment.RunAsync(() => 
{
    var apiGwApi = new Gcp.ApiGateway.Api("apiGwApi", new()
    {
        ApiId = "api-gw",
    }, new CustomResourceOptions
    {
        Provider = google_beta,
    });

    var apiGwApiConfig = new Gcp.ApiGateway.ApiConfig("apiGwApiConfig", new()
    {
        Api = apiGwApi.ApiId,
        ApiConfigId = "config",
        OpenapiDocuments = new[]
        {
            new Gcp.ApiGateway.Inputs.ApiConfigOpenapiDocumentArgs
            {
                Document = new Gcp.ApiGateway.Inputs.ApiConfigOpenapiDocumentDocumentArgs
                {
                    Path = "spec.yaml",
                    Contents = ReadFileBase64("test-fixtures/apigateway/openapi.yaml"),
                },
            },
        },
    }, new CustomResourceOptions
    {
        Provider = google_beta,
    });

    var apiGwGateway = new Gcp.ApiGateway.Gateway("apiGwGateway", new()
    {
        ApiConfig = apiGwApiConfig.Id,
        GatewayId = "api-gw",
    }, new CustomResourceOptions
    {
        Provider = google_beta,
    });

});

package main

import (
	"encoding/base64"
	"os"

	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/apigateway"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func filebase64OrPanic(path string) pulumi.StringPtrInput {
	if fileData, err := os.ReadFile(path); err == nil {
		return pulumi.String(base64.StdEncoding.EncodeToString(fileData[:]))
	} else {
		panic(err.Error())
	}
}

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		apiGwApi, err := apigateway.NewApi(ctx, "apiGwApi", &apigateway.ApiArgs{
			ApiId: pulumi.String("api-gw"),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		apiGwApiConfig, err := apigateway.NewApiConfig(ctx, "apiGwApiConfig", &apigateway.ApiConfigArgs{
			Api:         apiGwApi.ApiId,
			ApiConfigId: pulumi.String("config"),
			OpenapiDocuments: apigateway.ApiConfigOpenapiDocumentArray{
				&apigateway.ApiConfigOpenapiDocumentArgs{
					Document: &apigateway.ApiConfigOpenapiDocumentDocumentArgs{
						Path:     pulumi.String("spec.yaml"),
						Contents: filebase64OrPanic("test-fixtures/apigateway/openapi.yaml"),
					},
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		_, err = apigateway.NewGateway(ctx, "apiGwGateway", &apigateway.GatewayArgs{
			ApiConfig: apiGwApiConfig.ID(),
			GatewayId: pulumi.String("api-gw"),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.apigateway.Api;
import com.pulumi.gcp.apigateway.ApiArgs;
import com.pulumi.gcp.apigateway.ApiConfig;
import com.pulumi.gcp.apigateway.ApiConfigArgs;
import com.pulumi.gcp.apigateway.inputs.ApiConfigOpenapiDocumentArgs;
import com.pulumi.gcp.apigateway.inputs.ApiConfigOpenapiDocumentDocumentArgs;
import com.pulumi.gcp.apigateway.Gateway;
import com.pulumi.gcp.apigateway.GatewayArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var apiGwApi = new Api("apiGwApi", ApiArgs.builder()        
            .apiId("api-gw")
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());

        var apiGwApiConfig = new ApiConfig("apiGwApiConfig", ApiConfigArgs.builder()        
            .api(apiGwApi.apiId())
            .apiConfigId("config")
            .openapiDocuments(ApiConfigOpenapiDocumentArgs.builder()
                .document(ApiConfigOpenapiDocumentDocumentArgs.builder()
                    .path("spec.yaml")
                    .contents(Base64.getEncoder().encodeToString(Files.readAllBytes(Paths.get("test-fixtures/apigateway/openapi.yaml"))))
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());

        var apiGwGateway = new Gateway("apiGwGateway", GatewayArgs.builder()        
            .apiConfig(apiGwApiConfig.id())
            .gatewayId("api-gw")
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());

    }
}

import pulumi
import base64
import pulumi_gcp as gcp

api_gw_api = gcp.apigateway.Api("apiGwApi", api_id="api-gw",
opts=pulumi.ResourceOptions(provider=google_beta))
api_gw_api_config = gcp.apigateway.ApiConfig("apiGwApiConfig",
    api=api_gw_api.api_id,
    api_config_id="config",
    openapi_documents=[gcp.apigateway.ApiConfigOpenapiDocumentArgs(
        document=gcp.apigateway.ApiConfigOpenapiDocumentDocumentArgs(
            path="spec.yaml",
            contents=(lambda path: base64.b64encode(open(path).read().encode()).decode())("test-fixtures/apigateway/openapi.yaml"),
        ),
    )],
    opts=pulumi.ResourceOptions(provider=google_beta))
api_gw_gateway = gcp.apigateway.Gateway("apiGwGateway",
    api_config=api_gw_api_config.id,
    gateway_id="api-gw",
    opts=pulumi.ResourceOptions(provider=google_beta))

import * as pulumi from "@pulumi/pulumi";
import * as fs from "fs";
import * as gcp from "@pulumi/gcp";

const apiGwApi = new gcp.apigateway.Api("apiGwApi", {apiId: "api-gw"}, {
    provider: google_beta,
});
const apiGwApiConfig = new gcp.apigateway.ApiConfig("apiGwApiConfig", {
    api: apiGwApi.apiId,
    apiConfigId: "config",
    openapiDocuments: [{
        document: {
            path: "spec.yaml",
            contents: Buffer.from(fs.readFileSync("test-fixtures/apigateway/openapi.yaml"), 'binary').toString('base64'),
        },
    }],
}, {
    provider: google_beta,
});
const apiGwGateway = new gcp.apigateway.Gateway("apiGwGateway", {
    apiConfig: apiGwApiConfig.id,
    gatewayId: "api-gw",
}, {
    provider: google_beta,
});