apigateway

package
v5.26.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 1, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Api 

type Api struct {
	pulumi.CustomResourceState

	// Identifier to assign to the API. Must be unique within scope of the parent resource(project)
	ApiId pulumi.StringOutput `pulumi:"apiId"`
	// Creation timestamp in RFC3339 text format.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// A user-visible name for the API.
	DisplayName pulumi.StringOutput `pulumi:"displayName"`
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Immutable. The name of a Google Managed Service ( https://cloud.google.com/service-infrastructure/docs/glossary#managed).
	// If not specified, a new Service will automatically be created in the same project as this API.
	ManagedService pulumi.StringOutput `pulumi:"managedService"`
	// The resource name of the API. Format 'projects/{{project}}/locations/global/apis/{{apiId}}'
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
}

A consumable API that can be used by multiple Gateways.

To get more information about Api, see:

* [API documentation](https://cloud.google.com/api-gateway/docs/reference/rest/v1beta/projects.locations.apis) * How-to Guides

## Example Usage ### Apigateway Api Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApi(ctx, "api", &apigateway.ApiArgs{
			ApiId: pulumi.String("api"),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Api can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:apigateway/api:Api default projects/{{project}}/locations/global/apis/{{api_id}}

```

```sh 

$ pulumi import gcp:apigateway/api:Api default {{project}}/{{api_id}}

```

```sh 

$ pulumi import gcp:apigateway/api:Api default {{api_id}}

```

func GetApi 

func GetApi(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApiState, opts ...pulumi.ResourceOption) (*Api, error)

GetApi gets an existing Api resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewApi 

func NewApi(ctx *pulumi.Context,
	name string, args *ApiArgs, opts ...pulumi.ResourceOption) (*Api, error)

NewApi registers a new resource with the given unique name, arguments, and options.

func (*Api) ElementType 

func (*Api) ElementType() reflect.Type

func (*Api) ToApiOutput 

func (i *Api) ToApiOutput() ApiOutput

func (*Api) ToApiOutputWithContext 

func (i *Api) ToApiOutputWithContext(ctx context.Context) ApiOutput

func (*Api) ToApiPtrOutput 

func (i *Api) ToApiPtrOutput() ApiPtrOutput

func (*Api) ToApiPtrOutputWithContext 

func (i *Api) ToApiPtrOutputWithContext(ctx context.Context) ApiPtrOutput

type ApiArgs 

type ApiArgs struct {
	// Identifier to assign to the API. Must be unique within scope of the parent resource(project)
	ApiId pulumi.StringInput
	// A user-visible name for the API.
	DisplayName pulumi.StringPtrInput
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapInput
	// Immutable. The name of a Google Managed Service ( https://cloud.google.com/service-infrastructure/docs/glossary#managed).
	// If not specified, a new Service will automatically be created in the same project as this API.
	ManagedService pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a Api resource.

func (ApiArgs) ElementType 

func (ApiArgs) ElementType() reflect.Type

type ApiArray 

type ApiArray []ApiInput

func (ApiArray) ElementType 

func (ApiArray) ElementType() reflect.Type

func (ApiArray) ToApiArrayOutput 

func (i ApiArray) ToApiArrayOutput() ApiArrayOutput

func (ApiArray) ToApiArrayOutputWithContext 

func (i ApiArray) ToApiArrayOutputWithContext(ctx context.Context) ApiArrayOutput

type ApiArrayInput 

type ApiArrayInput interface {
	pulumi.Input

	ToApiArrayOutput() ApiArrayOutput
	ToApiArrayOutputWithContext(context.Context) ApiArrayOutput
}

ApiArrayInput is an input type that accepts ApiArray and ApiArrayOutput values. You can construct a concrete instance of `ApiArrayInput` via: 

ApiArray{ ApiArgs{...} }

type ApiArrayOutput 

type ApiArrayOutput struct{ *pulumi.OutputState }

func (ApiArrayOutput) ElementType 

func (ApiArrayOutput) ElementType() reflect.Type

func (ApiArrayOutput) Index 

func (o ApiArrayOutput) Index(i pulumi.IntInput) ApiOutput

func (ApiArrayOutput) ToApiArrayOutput 

func (o ApiArrayOutput) ToApiArrayOutput() ApiArrayOutput

func (ApiArrayOutput) ToApiArrayOutputWithContext 

func (o ApiArrayOutput) ToApiArrayOutputWithContext(ctx context.Context) ApiArrayOutput

type ApiConfig 

type ApiConfig struct {
	pulumi.CustomResourceState

	// The API to attach the config to.
	Api pulumi.StringOutput `pulumi:"api"`
	// Identifier to assign to the API Config. Must be unique within scope of the parent resource(api).
	ApiConfigId pulumi.StringOutput `pulumi:"apiConfigId"`
	// Creates a unique name beginning with the
	// specified prefix. If this and apiConfigId are unspecified, a random value is chosen for the name.
	ApiConfigIdPrefix pulumi.StringOutput `pulumi:"apiConfigIdPrefix"`
	// A user-visible name for the API.
	DisplayName pulumi.StringOutput `pulumi:"displayName"`
	// Immutable. Gateway specific configuration.
	// If not specified, backend authentication will be set to use OIDC authentication using the default compute service account
	// Structure is documented below.
	GatewayConfig ApiConfigGatewayConfigPtrOutput `pulumi:"gatewayConfig"`
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// The resource name of the API Config.
	Name pulumi.StringOutput `pulumi:"name"`
	// An OpenAPI Specification Document describing an API.
	// Structure is documented below.
	OpenapiDocuments ApiConfigOpenapiDocumentArrayOutput `pulumi:"openapiDocuments"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The ID of the associated Service Config (https://cloud.google.com/service-infrastructure/docs/glossary#config).
	ServiceConfigId pulumi.StringOutput `pulumi:"serviceConfigId"`
}

An API Configuration is an association of an API Controller Config and a Gateway Config

To get more information about ApiConfig, see:

* [API documentation](https://cloud.google.com/api-gateway/docs/reference/rest/v1beta/projects.locations.apis.configs) * How-to Guides

## Example Usage ### Apigateway Api Config Basic

```go package main

import ( 

"encoding/base64"
"io/ioutil"

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

) 

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		apiCfgApi, err := apigateway.NewApi(ctx, "apiCfgApi", &apigateway.ApiArgs{
			ApiId: pulumi.String("api-cfg"),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		_, err = apigateway.NewApiConfig(ctx, "apiCfgApiConfig", &apigateway.ApiConfigArgs{
			Api:         apiCfgApi.ApiId,
			ApiConfigId: pulumi.String("cfg"),
			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
		}
		return nil
	})
}

```

## Import

ApiConfig can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:apigateway/apiConfig:ApiConfig default projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config_id}}

```

```sh 

$ pulumi import gcp:apigateway/apiConfig:ApiConfig default {{project}}/{{api}}/{{api_config_id}}

```

```sh 

$ pulumi import gcp:apigateway/apiConfig:ApiConfig default {{api}}/{{api_config_id}}

```

func GetApiConfig 

func GetApiConfig(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApiConfigState, opts ...pulumi.ResourceOption) (*ApiConfig, error)

GetApiConfig gets an existing ApiConfig resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewApiConfig 

func NewApiConfig(ctx *pulumi.Context,
	name string, args *ApiConfigArgs, opts ...pulumi.ResourceOption) (*ApiConfig, error)

NewApiConfig registers a new resource with the given unique name, arguments, and options.

func (*ApiConfig) ElementType 

func (*ApiConfig) ElementType() reflect.Type

func (*ApiConfig) ToApiConfigOutput 

func (i *ApiConfig) ToApiConfigOutput() ApiConfigOutput

func (*ApiConfig) ToApiConfigOutputWithContext 

func (i *ApiConfig) ToApiConfigOutputWithContext(ctx context.Context) ApiConfigOutput

func (*ApiConfig) ToApiConfigPtrOutput 

func (i *ApiConfig) ToApiConfigPtrOutput() ApiConfigPtrOutput

func (*ApiConfig) ToApiConfigPtrOutputWithContext 

func (i *ApiConfig) ToApiConfigPtrOutputWithContext(ctx context.Context) ApiConfigPtrOutput

type ApiConfigArgs 

type ApiConfigArgs struct {
	// The API to attach the config to.
	Api pulumi.StringInput
	// Identifier to assign to the API Config. Must be unique within scope of the parent resource(api).
	ApiConfigId pulumi.StringPtrInput
	// Creates a unique name beginning with the
	// specified prefix. If this and apiConfigId are unspecified, a random value is chosen for the name.
	ApiConfigIdPrefix pulumi.StringPtrInput
	// A user-visible name for the API.
	DisplayName pulumi.StringPtrInput
	// Immutable. Gateway specific configuration.
	// If not specified, backend authentication will be set to use OIDC authentication using the default compute service account
	// Structure is documented below.
	GatewayConfig ApiConfigGatewayConfigPtrInput
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapInput
	// An OpenAPI Specification Document describing an API.
	// Structure is documented below.
	OpenapiDocuments ApiConfigOpenapiDocumentArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a ApiConfig resource.

func (ApiConfigArgs) ElementType 

func (ApiConfigArgs) ElementType() reflect.Type

type ApiConfigArray 

type ApiConfigArray []ApiConfigInput

func (ApiConfigArray) ElementType 

func (ApiConfigArray) ElementType() reflect.Type

func (ApiConfigArray) ToApiConfigArrayOutput 

func (i ApiConfigArray) ToApiConfigArrayOutput() ApiConfigArrayOutput

func (ApiConfigArray) ToApiConfigArrayOutputWithContext 

func (i ApiConfigArray) ToApiConfigArrayOutputWithContext(ctx context.Context) ApiConfigArrayOutput

type ApiConfigArrayInput 

type ApiConfigArrayInput interface {
	pulumi.Input

	ToApiConfigArrayOutput() ApiConfigArrayOutput
	ToApiConfigArrayOutputWithContext(context.Context) ApiConfigArrayOutput
}

ApiConfigArrayInput is an input type that accepts ApiConfigArray and ApiConfigArrayOutput values. You can construct a concrete instance of `ApiConfigArrayInput` via: 

ApiConfigArray{ ApiConfigArgs{...} }

type ApiConfigArrayOutput 

type ApiConfigArrayOutput struct{ *pulumi.OutputState }

func (ApiConfigArrayOutput) ElementType 

func (ApiConfigArrayOutput) ElementType() reflect.Type

func (ApiConfigArrayOutput) Index 

func (o ApiConfigArrayOutput) Index(i pulumi.IntInput) ApiConfigOutput

func (ApiConfigArrayOutput) ToApiConfigArrayOutput 

func (o ApiConfigArrayOutput) ToApiConfigArrayOutput() ApiConfigArrayOutput

func (ApiConfigArrayOutput) ToApiConfigArrayOutputWithContext 

func (o ApiConfigArrayOutput) ToApiConfigArrayOutputWithContext(ctx context.Context) ApiConfigArrayOutput

type ApiConfigGatewayConfig 

type ApiConfigGatewayConfig struct {
	// Backend settings that are applied to all backends of the Gateway.
	// Structure is documented below.
	BackendConfig ApiConfigGatewayConfigBackendConfig `pulumi:"backendConfig"`
}

type ApiConfigGatewayConfigArgs 

type ApiConfigGatewayConfigArgs struct {
	// Backend settings that are applied to all backends of the Gateway.
	// Structure is documented below.
	BackendConfig ApiConfigGatewayConfigBackendConfigInput `pulumi:"backendConfig"`
}

func (ApiConfigGatewayConfigArgs) ElementType 

func (ApiConfigGatewayConfigArgs) ElementType() reflect.Type

func (ApiConfigGatewayConfigArgs) ToApiConfigGatewayConfigOutput 

func (i ApiConfigGatewayConfigArgs) ToApiConfigGatewayConfigOutput() ApiConfigGatewayConfigOutput

func (ApiConfigGatewayConfigArgs) ToApiConfigGatewayConfigOutputWithContext 

func (i ApiConfigGatewayConfigArgs) ToApiConfigGatewayConfigOutputWithContext(ctx context.Context) ApiConfigGatewayConfigOutput

func (ApiConfigGatewayConfigArgs) ToApiConfigGatewayConfigPtrOutput 

func (i ApiConfigGatewayConfigArgs) ToApiConfigGatewayConfigPtrOutput() ApiConfigGatewayConfigPtrOutput

func (ApiConfigGatewayConfigArgs) ToApiConfigGatewayConfigPtrOutputWithContext 

func (i ApiConfigGatewayConfigArgs) ToApiConfigGatewayConfigPtrOutputWithContext(ctx context.Context) ApiConfigGatewayConfigPtrOutput

type ApiConfigGatewayConfigBackendConfig 

type ApiConfigGatewayConfigBackendConfig struct {
	// Google Cloud IAM service account used to sign OIDC tokens for backends that have authentication configured
	// (https://cloud.google.com/service-infrastructure/docs/service-management/reference/rest/v1/services.configs#backend).
	GoogleServiceAccount string `pulumi:"googleServiceAccount"`
}

type ApiConfigGatewayConfigBackendConfigArgs 

type ApiConfigGatewayConfigBackendConfigArgs struct {
	// Google Cloud IAM service account used to sign OIDC tokens for backends that have authentication configured
	// (https://cloud.google.com/service-infrastructure/docs/service-management/reference/rest/v1/services.configs#backend).
	GoogleServiceAccount pulumi.StringInput `pulumi:"googleServiceAccount"`
}

func (ApiConfigGatewayConfigBackendConfigArgs) ElementType 

func (ApiConfigGatewayConfigBackendConfigArgs) ElementType() reflect.Type

func (ApiConfigGatewayConfigBackendConfigArgs) ToApiConfigGatewayConfigBackendConfigOutput 

func (i ApiConfigGatewayConfigBackendConfigArgs) ToApiConfigGatewayConfigBackendConfigOutput() ApiConfigGatewayConfigBackendConfigOutput

func (ApiConfigGatewayConfigBackendConfigArgs) ToApiConfigGatewayConfigBackendConfigOutputWithContext 

func (i ApiConfigGatewayConfigBackendConfigArgs) ToApiConfigGatewayConfigBackendConfigOutputWithContext(ctx context.Context) ApiConfigGatewayConfigBackendConfigOutput

func (ApiConfigGatewayConfigBackendConfigArgs) ToApiConfigGatewayConfigBackendConfigPtrOutput 

func (i ApiConfigGatewayConfigBackendConfigArgs) ToApiConfigGatewayConfigBackendConfigPtrOutput() ApiConfigGatewayConfigBackendConfigPtrOutput

func (ApiConfigGatewayConfigBackendConfigArgs) ToApiConfigGatewayConfigBackendConfigPtrOutputWithContext 

func (i ApiConfigGatewayConfigBackendConfigArgs) ToApiConfigGatewayConfigBackendConfigPtrOutputWithContext(ctx context.Context) ApiConfigGatewayConfigBackendConfigPtrOutput

type ApiConfigGatewayConfigBackendConfigInput 

type ApiConfigGatewayConfigBackendConfigInput interface {
	pulumi.Input

	ToApiConfigGatewayConfigBackendConfigOutput() ApiConfigGatewayConfigBackendConfigOutput
	ToApiConfigGatewayConfigBackendConfigOutputWithContext(context.Context) ApiConfigGatewayConfigBackendConfigOutput
}

ApiConfigGatewayConfigBackendConfigInput is an input type that accepts ApiConfigGatewayConfigBackendConfigArgs and ApiConfigGatewayConfigBackendConfigOutput values. You can construct a concrete instance of `ApiConfigGatewayConfigBackendConfigInput` via: 

ApiConfigGatewayConfigBackendConfigArgs{...}

type ApiConfigGatewayConfigBackendConfigOutput 

type ApiConfigGatewayConfigBackendConfigOutput struct{ *pulumi.OutputState }

func (ApiConfigGatewayConfigBackendConfigOutput) ElementType 

func (ApiConfigGatewayConfigBackendConfigOutput) ElementType() reflect.Type

func (ApiConfigGatewayConfigBackendConfigOutput) GoogleServiceAccount 

func (o ApiConfigGatewayConfigBackendConfigOutput) GoogleServiceAccount() pulumi.StringOutput

Google Cloud IAM service account used to sign OIDC tokens for backends that have authentication configured (https://cloud.google.com/service-infrastructure/docs/service-management/reference/rest/v1/services.configs#backend).

func (ApiConfigGatewayConfigBackendConfigOutput) ToApiConfigGatewayConfigBackendConfigOutput 

func (o ApiConfigGatewayConfigBackendConfigOutput) ToApiConfigGatewayConfigBackendConfigOutput() ApiConfigGatewayConfigBackendConfigOutput

func (ApiConfigGatewayConfigBackendConfigOutput) ToApiConfigGatewayConfigBackendConfigOutputWithContext 

func (o ApiConfigGatewayConfigBackendConfigOutput) ToApiConfigGatewayConfigBackendConfigOutputWithContext(ctx context.Context) ApiConfigGatewayConfigBackendConfigOutput

func (ApiConfigGatewayConfigBackendConfigOutput) ToApiConfigGatewayConfigBackendConfigPtrOutput 

func (o ApiConfigGatewayConfigBackendConfigOutput) ToApiConfigGatewayConfigBackendConfigPtrOutput() ApiConfigGatewayConfigBackendConfigPtrOutput

func (ApiConfigGatewayConfigBackendConfigOutput) ToApiConfigGatewayConfigBackendConfigPtrOutputWithContext 

func (o ApiConfigGatewayConfigBackendConfigOutput) ToApiConfigGatewayConfigBackendConfigPtrOutputWithContext(ctx context.Context) ApiConfigGatewayConfigBackendConfigPtrOutput

type ApiConfigGatewayConfigBackendConfigPtrInput 

type ApiConfigGatewayConfigBackendConfigPtrInput interface {
	pulumi.Input

	ToApiConfigGatewayConfigBackendConfigPtrOutput() ApiConfigGatewayConfigBackendConfigPtrOutput
	ToApiConfigGatewayConfigBackendConfigPtrOutputWithContext(context.Context) ApiConfigGatewayConfigBackendConfigPtrOutput
}

ApiConfigGatewayConfigBackendConfigPtrInput is an input type that accepts ApiConfigGatewayConfigBackendConfigArgs, ApiConfigGatewayConfigBackendConfigPtr and ApiConfigGatewayConfigBackendConfigPtrOutput values. You can construct a concrete instance of `ApiConfigGatewayConfigBackendConfigPtrInput` via: 

        ApiConfigGatewayConfigBackendConfigArgs{...}

or:

        nil

func ApiConfigGatewayConfigBackendConfigPtr 

func ApiConfigGatewayConfigBackendConfigPtr(v *ApiConfigGatewayConfigBackendConfigArgs) ApiConfigGatewayConfigBackendConfigPtrInput

type ApiConfigGatewayConfigBackendConfigPtrOutput 

type ApiConfigGatewayConfigBackendConfigPtrOutput struct{ *pulumi.OutputState }

func (ApiConfigGatewayConfigBackendConfigPtrOutput) Elem 

func (o ApiConfigGatewayConfigBackendConfigPtrOutput) Elem() ApiConfigGatewayConfigBackendConfigOutput

func (ApiConfigGatewayConfigBackendConfigPtrOutput) ElementType 

func (ApiConfigGatewayConfigBackendConfigPtrOutput) ElementType() reflect.Type

func (ApiConfigGatewayConfigBackendConfigPtrOutput) GoogleServiceAccount 

func (o ApiConfigGatewayConfigBackendConfigPtrOutput) GoogleServiceAccount() pulumi.StringPtrOutput

Google Cloud IAM service account used to sign OIDC tokens for backends that have authentication configured (https://cloud.google.com/service-infrastructure/docs/service-management/reference/rest/v1/services.configs#backend).

func (ApiConfigGatewayConfigBackendConfigPtrOutput) ToApiConfigGatewayConfigBackendConfigPtrOutput 

func (o ApiConfigGatewayConfigBackendConfigPtrOutput) ToApiConfigGatewayConfigBackendConfigPtrOutput() ApiConfigGatewayConfigBackendConfigPtrOutput

func (ApiConfigGatewayConfigBackendConfigPtrOutput) ToApiConfigGatewayConfigBackendConfigPtrOutputWithContext 

func (o ApiConfigGatewayConfigBackendConfigPtrOutput) ToApiConfigGatewayConfigBackendConfigPtrOutputWithContext(ctx context.Context) ApiConfigGatewayConfigBackendConfigPtrOutput

type ApiConfigGatewayConfigInput 

type ApiConfigGatewayConfigInput interface {
	pulumi.Input

	ToApiConfigGatewayConfigOutput() ApiConfigGatewayConfigOutput
	ToApiConfigGatewayConfigOutputWithContext(context.Context) ApiConfigGatewayConfigOutput
}

ApiConfigGatewayConfigInput is an input type that accepts ApiConfigGatewayConfigArgs and ApiConfigGatewayConfigOutput values. You can construct a concrete instance of `ApiConfigGatewayConfigInput` via: 

ApiConfigGatewayConfigArgs{...}

type ApiConfigGatewayConfigOutput 

type ApiConfigGatewayConfigOutput struct{ *pulumi.OutputState }

func (ApiConfigGatewayConfigOutput) BackendConfig 

func (o ApiConfigGatewayConfigOutput) BackendConfig() ApiConfigGatewayConfigBackendConfigOutput

Backend settings that are applied to all backends of the Gateway. Structure is documented below.

func (ApiConfigGatewayConfigOutput) ElementType 

func (ApiConfigGatewayConfigOutput) ElementType() reflect.Type

func (ApiConfigGatewayConfigOutput) ToApiConfigGatewayConfigOutput 

func (o ApiConfigGatewayConfigOutput) ToApiConfigGatewayConfigOutput() ApiConfigGatewayConfigOutput

func (ApiConfigGatewayConfigOutput) ToApiConfigGatewayConfigOutputWithContext 

func (o ApiConfigGatewayConfigOutput) ToApiConfigGatewayConfigOutputWithContext(ctx context.Context) ApiConfigGatewayConfigOutput

func (ApiConfigGatewayConfigOutput) ToApiConfigGatewayConfigPtrOutput 

func (o ApiConfigGatewayConfigOutput) ToApiConfigGatewayConfigPtrOutput() ApiConfigGatewayConfigPtrOutput

func (ApiConfigGatewayConfigOutput) ToApiConfigGatewayConfigPtrOutputWithContext 

func (o ApiConfigGatewayConfigOutput) ToApiConfigGatewayConfigPtrOutputWithContext(ctx context.Context) ApiConfigGatewayConfigPtrOutput

type ApiConfigGatewayConfigPtrInput 

type ApiConfigGatewayConfigPtrInput interface {
	pulumi.Input

	ToApiConfigGatewayConfigPtrOutput() ApiConfigGatewayConfigPtrOutput
	ToApiConfigGatewayConfigPtrOutputWithContext(context.Context) ApiConfigGatewayConfigPtrOutput
}

ApiConfigGatewayConfigPtrInput is an input type that accepts ApiConfigGatewayConfigArgs, ApiConfigGatewayConfigPtr and ApiConfigGatewayConfigPtrOutput values. You can construct a concrete instance of `ApiConfigGatewayConfigPtrInput` via: 

        ApiConfigGatewayConfigArgs{...}

or:

        nil

func ApiConfigGatewayConfigPtr 

func ApiConfigGatewayConfigPtr(v *ApiConfigGatewayConfigArgs) ApiConfigGatewayConfigPtrInput

type ApiConfigGatewayConfigPtrOutput 

type ApiConfigGatewayConfigPtrOutput struct{ *pulumi.OutputState }

func (ApiConfigGatewayConfigPtrOutput) BackendConfig 

func (o ApiConfigGatewayConfigPtrOutput) BackendConfig() ApiConfigGatewayConfigBackendConfigPtrOutput

Backend settings that are applied to all backends of the Gateway. Structure is documented below.

func (ApiConfigGatewayConfigPtrOutput) Elem 

func (o ApiConfigGatewayConfigPtrOutput) Elem() ApiConfigGatewayConfigOutput

func (ApiConfigGatewayConfigPtrOutput) ElementType 

func (ApiConfigGatewayConfigPtrOutput) ElementType() reflect.Type

func (ApiConfigGatewayConfigPtrOutput) ToApiConfigGatewayConfigPtrOutput 

func (o ApiConfigGatewayConfigPtrOutput) ToApiConfigGatewayConfigPtrOutput() ApiConfigGatewayConfigPtrOutput

func (ApiConfigGatewayConfigPtrOutput) ToApiConfigGatewayConfigPtrOutputWithContext 

func (o ApiConfigGatewayConfigPtrOutput) ToApiConfigGatewayConfigPtrOutputWithContext(ctx context.Context) ApiConfigGatewayConfigPtrOutput

type ApiConfigIamBinding 

type ApiConfigIamBinding struct {
	pulumi.CustomResourceState

	// The API to attach the config to.
	// Used to find the parent resource to bind the IAM policy to
	Api       pulumi.StringOutput                   `pulumi:"api"`
	ApiConfig pulumi.StringOutput                   `pulumi:"apiConfig"`
	Condition ApiConfigIamBindingConditionPtrOutput `pulumi:"condition"`
	// (Computed) The etag of the IAM policy.
	Etag    pulumi.StringOutput      `pulumi:"etag"`
	Members pulumi.StringArrayOutput `pulumi:"members"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The role that should be applied. Only one
	// `apigateway.ApiConfigIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for API Gateway ApiConfig. Each of these resources serves a different use case:

* `apigateway.ApiConfigIamPolicy`: Authoritative. Sets the IAM policy for the apiconfig and replaces any existing policy already attached. * `apigateway.ApiConfigIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the apiconfig are preserved. * `apigateway.ApiConfigIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the apiconfig are preserved.

> **Note:** `apigateway.ApiConfigIamPolicy` **cannot** be used in conjunction with `apigateway.ApiConfigIamBinding` and `apigateway.ApiConfigIamMember` or they will fight over what your policy should be.

> **Note:** `apigateway.ApiConfigIamBinding` resources **can be** used in conjunction with `apigateway.ApiConfigIamMember` resources **only if** they do not grant privilege to the same role.

## google\_api\_gateway\_api\_config\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/apigateway"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				organizations.GetIAMPolicyBinding{
					Role: "roles/apigateway.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = apigateway.NewApiConfigIamPolicy(ctx, "policy", &apigateway.ApiConfigIamPolicyArgs{
			Api:        pulumi.Any(google_api_gateway_api_config.Api_cfg.Api),
			ApiConfig:  pulumi.Any(google_api_gateway_api_config.Api_cfg.Api_config_id),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_config\_iam\_binding

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiConfigIamBinding(ctx, "binding", &apigateway.ApiConfigIamBindingArgs{
			Api:       pulumi.Any(google_api_gateway_api_config.Api_cfg.Api),
			ApiConfig: pulumi.Any(google_api_gateway_api_config.Api_cfg.Api_config_id),
			Role:      pulumi.String("roles/apigateway.viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_config\_iam\_member

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiConfigIamMember(ctx, "member", &apigateway.ApiConfigIamMemberArgs{
			Api:       pulumi.Any(google_api_gateway_api_config.Api_cfg.Api),
			ApiConfig: pulumi.Any(google_api_gateway_api_config.Api_cfg.Api_config_id),
			Role:      pulumi.String("roles/apigateway.viewer"),
			Member:    pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms* projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}} * {{project}}/{{api}}/{{api_config}} * {{api}}/{{api_config}} * {{api_config}} Any variables not passed in the import command will be taken from the provider configuration. API Gateway apiconfig IAM resources can be imported using the resource identifiers, role, and member. IAM member imports use space-delimited identifiersthe resource in question, the role, and the member identity, e.g.

```sh 

$ pulumi import gcp:apigateway/apiConfigIamBinding:ApiConfigIamBinding editor "projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}} roles/apigateway.viewer user:jane@example.com"

``` 

IAM binding imports use space-delimited identifiersthe resource in question and the role, e.g.

```sh 

$ pulumi import gcp:apigateway/apiConfigIamBinding:ApiConfigIamBinding editor "projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}} roles/apigateway.viewer"

``` 

IAM policy imports use the identifier of the resource in question, e.g.

```sh 

$ pulumi import gcp:apigateway/apiConfigIamBinding:ApiConfigIamBinding editor projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}}

``` 

-> **Custom Roles**If you're importing a IAM resource with a custom role, make sure to use the

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetApiConfigIamBinding 

func GetApiConfigIamBinding(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApiConfigIamBindingState, opts ...pulumi.ResourceOption) (*ApiConfigIamBinding, error)

GetApiConfigIamBinding gets an existing ApiConfigIamBinding resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewApiConfigIamBinding 

func NewApiConfigIamBinding(ctx *pulumi.Context,
	name string, args *ApiConfigIamBindingArgs, opts ...pulumi.ResourceOption) (*ApiConfigIamBinding, error)

NewApiConfigIamBinding registers a new resource with the given unique name, arguments, and options.

func (*ApiConfigIamBinding) ElementType 

func (*ApiConfigIamBinding) ElementType() reflect.Type

func (*ApiConfigIamBinding) ToApiConfigIamBindingOutput 

func (i *ApiConfigIamBinding) ToApiConfigIamBindingOutput() ApiConfigIamBindingOutput

func (*ApiConfigIamBinding) ToApiConfigIamBindingOutputWithContext 

func (i *ApiConfigIamBinding) ToApiConfigIamBindingOutputWithContext(ctx context.Context) ApiConfigIamBindingOutput

func (*ApiConfigIamBinding) ToApiConfigIamBindingPtrOutput 

func (i *ApiConfigIamBinding) ToApiConfigIamBindingPtrOutput() ApiConfigIamBindingPtrOutput

func (*ApiConfigIamBinding) ToApiConfigIamBindingPtrOutputWithContext 

func (i *ApiConfigIamBinding) ToApiConfigIamBindingPtrOutputWithContext(ctx context.Context) ApiConfigIamBindingPtrOutput

type ApiConfigIamBindingArgs 

type ApiConfigIamBindingArgs struct {
	// The API to attach the config to.
	// Used to find the parent resource to bind the IAM policy to
	Api       pulumi.StringInput
	ApiConfig pulumi.StringInput
	Condition ApiConfigIamBindingConditionPtrInput
	Members   pulumi.StringArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.ApiConfigIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a ApiConfigIamBinding resource.

func (ApiConfigIamBindingArgs) ElementType 

func (ApiConfigIamBindingArgs) ElementType() reflect.Type

type ApiConfigIamBindingArray 

type ApiConfigIamBindingArray []ApiConfigIamBindingInput

func (ApiConfigIamBindingArray) ElementType 

func (ApiConfigIamBindingArray) ElementType() reflect.Type

func (ApiConfigIamBindingArray) ToApiConfigIamBindingArrayOutput 

func (i ApiConfigIamBindingArray) ToApiConfigIamBindingArrayOutput() ApiConfigIamBindingArrayOutput

func (ApiConfigIamBindingArray) ToApiConfigIamBindingArrayOutputWithContext 

func (i ApiConfigIamBindingArray) ToApiConfigIamBindingArrayOutputWithContext(ctx context.Context) ApiConfigIamBindingArrayOutput

type ApiConfigIamBindingArrayInput 

type ApiConfigIamBindingArrayInput interface {
	pulumi.Input

	ToApiConfigIamBindingArrayOutput() ApiConfigIamBindingArrayOutput
	ToApiConfigIamBindingArrayOutputWithContext(context.Context) ApiConfigIamBindingArrayOutput
}

ApiConfigIamBindingArrayInput is an input type that accepts ApiConfigIamBindingArray and ApiConfigIamBindingArrayOutput values. You can construct a concrete instance of `ApiConfigIamBindingArrayInput` via: 

ApiConfigIamBindingArray{ ApiConfigIamBindingArgs{...} }

type ApiConfigIamBindingArrayOutput 

type ApiConfigIamBindingArrayOutput struct{ *pulumi.OutputState }

func (ApiConfigIamBindingArrayOutput) ElementType 

func (ApiConfigIamBindingArrayOutput) ElementType() reflect.Type

func (ApiConfigIamBindingArrayOutput) Index 

func (o ApiConfigIamBindingArrayOutput) Index(i pulumi.IntInput) ApiConfigIamBindingOutput

func (ApiConfigIamBindingArrayOutput) ToApiConfigIamBindingArrayOutput 

func (o ApiConfigIamBindingArrayOutput) ToApiConfigIamBindingArrayOutput() ApiConfigIamBindingArrayOutput

func (ApiConfigIamBindingArrayOutput) ToApiConfigIamBindingArrayOutputWithContext 

func (o ApiConfigIamBindingArrayOutput) ToApiConfigIamBindingArrayOutputWithContext(ctx context.Context) ApiConfigIamBindingArrayOutput

type ApiConfigIamBindingCondition 

type ApiConfigIamBindingCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type ApiConfigIamBindingConditionArgs 

type ApiConfigIamBindingConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (ApiConfigIamBindingConditionArgs) ElementType 

func (ApiConfigIamBindingConditionArgs) ElementType() reflect.Type

func (ApiConfigIamBindingConditionArgs) ToApiConfigIamBindingConditionOutput 

func (i ApiConfigIamBindingConditionArgs) ToApiConfigIamBindingConditionOutput() ApiConfigIamBindingConditionOutput

func (ApiConfigIamBindingConditionArgs) ToApiConfigIamBindingConditionOutputWithContext 

func (i ApiConfigIamBindingConditionArgs) ToApiConfigIamBindingConditionOutputWithContext(ctx context.Context) ApiConfigIamBindingConditionOutput

func (ApiConfigIamBindingConditionArgs) ToApiConfigIamBindingConditionPtrOutput 

func (i ApiConfigIamBindingConditionArgs) ToApiConfigIamBindingConditionPtrOutput() ApiConfigIamBindingConditionPtrOutput

func (ApiConfigIamBindingConditionArgs) ToApiConfigIamBindingConditionPtrOutputWithContext 

func (i ApiConfigIamBindingConditionArgs) ToApiConfigIamBindingConditionPtrOutputWithContext(ctx context.Context) ApiConfigIamBindingConditionPtrOutput

type ApiConfigIamBindingConditionInput 

type ApiConfigIamBindingConditionInput interface {
	pulumi.Input

	ToApiConfigIamBindingConditionOutput() ApiConfigIamBindingConditionOutput
	ToApiConfigIamBindingConditionOutputWithContext(context.Context) ApiConfigIamBindingConditionOutput
}

ApiConfigIamBindingConditionInput is an input type that accepts ApiConfigIamBindingConditionArgs and ApiConfigIamBindingConditionOutput values. You can construct a concrete instance of `ApiConfigIamBindingConditionInput` via: 

ApiConfigIamBindingConditionArgs{...}

type ApiConfigIamBindingConditionOutput 

type ApiConfigIamBindingConditionOutput struct{ *pulumi.OutputState }

func (ApiConfigIamBindingConditionOutput) Description 

func (o ApiConfigIamBindingConditionOutput) Description() pulumi.StringPtrOutput

func (ApiConfigIamBindingConditionOutput) ElementType 

func (ApiConfigIamBindingConditionOutput) ElementType() reflect.Type

func (ApiConfigIamBindingConditionOutput) Expression 

func (o ApiConfigIamBindingConditionOutput) Expression() pulumi.StringOutput

func (ApiConfigIamBindingConditionOutput) Title 

func (o ApiConfigIamBindingConditionOutput) Title() pulumi.StringOutput

func (ApiConfigIamBindingConditionOutput) ToApiConfigIamBindingConditionOutput 

func (o ApiConfigIamBindingConditionOutput) ToApiConfigIamBindingConditionOutput() ApiConfigIamBindingConditionOutput

func (ApiConfigIamBindingConditionOutput) ToApiConfigIamBindingConditionOutputWithContext 

func (o ApiConfigIamBindingConditionOutput) ToApiConfigIamBindingConditionOutputWithContext(ctx context.Context) ApiConfigIamBindingConditionOutput

func (ApiConfigIamBindingConditionOutput) ToApiConfigIamBindingConditionPtrOutput 

func (o ApiConfigIamBindingConditionOutput) ToApiConfigIamBindingConditionPtrOutput() ApiConfigIamBindingConditionPtrOutput

func (ApiConfigIamBindingConditionOutput) ToApiConfigIamBindingConditionPtrOutputWithContext 

func (o ApiConfigIamBindingConditionOutput) ToApiConfigIamBindingConditionPtrOutputWithContext(ctx context.Context) ApiConfigIamBindingConditionPtrOutput

type ApiConfigIamBindingConditionPtrInput 

type ApiConfigIamBindingConditionPtrInput interface {
	pulumi.Input

	ToApiConfigIamBindingConditionPtrOutput() ApiConfigIamBindingConditionPtrOutput
	ToApiConfigIamBindingConditionPtrOutputWithContext(context.Context) ApiConfigIamBindingConditionPtrOutput
}

ApiConfigIamBindingConditionPtrInput is an input type that accepts ApiConfigIamBindingConditionArgs, ApiConfigIamBindingConditionPtr and ApiConfigIamBindingConditionPtrOutput values. You can construct a concrete instance of `ApiConfigIamBindingConditionPtrInput` via: 

        ApiConfigIamBindingConditionArgs{...}

or:

        nil

func ApiConfigIamBindingConditionPtr 

func ApiConfigIamBindingConditionPtr(v *ApiConfigIamBindingConditionArgs) ApiConfigIamBindingConditionPtrInput

type ApiConfigIamBindingConditionPtrOutput 

type ApiConfigIamBindingConditionPtrOutput struct{ *pulumi.OutputState }

func (ApiConfigIamBindingConditionPtrOutput) Description 

func (o ApiConfigIamBindingConditionPtrOutput) Description() pulumi.StringPtrOutput

func (ApiConfigIamBindingConditionPtrOutput) Elem 

func (o ApiConfigIamBindingConditionPtrOutput) Elem() ApiConfigIamBindingConditionOutput

func (ApiConfigIamBindingConditionPtrOutput) ElementType 

func (ApiConfigIamBindingConditionPtrOutput) ElementType() reflect.Type

func (ApiConfigIamBindingConditionPtrOutput) Expression 

func (o ApiConfigIamBindingConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (ApiConfigIamBindingConditionPtrOutput) Title 

func (o ApiConfigIamBindingConditionPtrOutput) Title() pulumi.StringPtrOutput

func (ApiConfigIamBindingConditionPtrOutput) ToApiConfigIamBindingConditionPtrOutput 

func (o ApiConfigIamBindingConditionPtrOutput) ToApiConfigIamBindingConditionPtrOutput() ApiConfigIamBindingConditionPtrOutput

func (ApiConfigIamBindingConditionPtrOutput) ToApiConfigIamBindingConditionPtrOutputWithContext 

func (o ApiConfigIamBindingConditionPtrOutput) ToApiConfigIamBindingConditionPtrOutputWithContext(ctx context.Context) ApiConfigIamBindingConditionPtrOutput

type ApiConfigIamBindingInput 

type ApiConfigIamBindingInput interface {
	pulumi.Input

	ToApiConfigIamBindingOutput() ApiConfigIamBindingOutput
	ToApiConfigIamBindingOutputWithContext(ctx context.Context) ApiConfigIamBindingOutput
}

type ApiConfigIamBindingMap 

type ApiConfigIamBindingMap map[string]ApiConfigIamBindingInput

func (ApiConfigIamBindingMap) ElementType 

func (ApiConfigIamBindingMap) ElementType() reflect.Type

func (ApiConfigIamBindingMap) ToApiConfigIamBindingMapOutput 

func (i ApiConfigIamBindingMap) ToApiConfigIamBindingMapOutput() ApiConfigIamBindingMapOutput

func (ApiConfigIamBindingMap) ToApiConfigIamBindingMapOutputWithContext 

func (i ApiConfigIamBindingMap) ToApiConfigIamBindingMapOutputWithContext(ctx context.Context) ApiConfigIamBindingMapOutput

type ApiConfigIamBindingMapInput 

type ApiConfigIamBindingMapInput interface {
	pulumi.Input

	ToApiConfigIamBindingMapOutput() ApiConfigIamBindingMapOutput
	ToApiConfigIamBindingMapOutputWithContext(context.Context) ApiConfigIamBindingMapOutput
}

ApiConfigIamBindingMapInput is an input type that accepts ApiConfigIamBindingMap and ApiConfigIamBindingMapOutput values. You can construct a concrete instance of `ApiConfigIamBindingMapInput` via: 

ApiConfigIamBindingMap{ "key": ApiConfigIamBindingArgs{...} }

type ApiConfigIamBindingMapOutput 

type ApiConfigIamBindingMapOutput struct{ *pulumi.OutputState }

func (ApiConfigIamBindingMapOutput) ElementType 

func (ApiConfigIamBindingMapOutput) ElementType() reflect.Type

func (ApiConfigIamBindingMapOutput) MapIndex 

func (o ApiConfigIamBindingMapOutput) MapIndex(k pulumi.StringInput) ApiConfigIamBindingOutput

func (ApiConfigIamBindingMapOutput) ToApiConfigIamBindingMapOutput 

func (o ApiConfigIamBindingMapOutput) ToApiConfigIamBindingMapOutput() ApiConfigIamBindingMapOutput

func (ApiConfigIamBindingMapOutput) ToApiConfigIamBindingMapOutputWithContext 

func (o ApiConfigIamBindingMapOutput) ToApiConfigIamBindingMapOutputWithContext(ctx context.Context) ApiConfigIamBindingMapOutput

type ApiConfigIamBindingOutput 

type ApiConfigIamBindingOutput struct{ *pulumi.OutputState }

func (ApiConfigIamBindingOutput) ElementType 

func (ApiConfigIamBindingOutput) ElementType() reflect.Type

func (ApiConfigIamBindingOutput) ToApiConfigIamBindingOutput 

func (o ApiConfigIamBindingOutput) ToApiConfigIamBindingOutput() ApiConfigIamBindingOutput

func (ApiConfigIamBindingOutput) ToApiConfigIamBindingOutputWithContext 

func (o ApiConfigIamBindingOutput) ToApiConfigIamBindingOutputWithContext(ctx context.Context) ApiConfigIamBindingOutput

func (ApiConfigIamBindingOutput) ToApiConfigIamBindingPtrOutput 

func (o ApiConfigIamBindingOutput) ToApiConfigIamBindingPtrOutput() ApiConfigIamBindingPtrOutput

func (ApiConfigIamBindingOutput) ToApiConfigIamBindingPtrOutputWithContext 

func (o ApiConfigIamBindingOutput) ToApiConfigIamBindingPtrOutputWithContext(ctx context.Context) ApiConfigIamBindingPtrOutput

type ApiConfigIamBindingPtrInput 

type ApiConfigIamBindingPtrInput interface {
	pulumi.Input

	ToApiConfigIamBindingPtrOutput() ApiConfigIamBindingPtrOutput
	ToApiConfigIamBindingPtrOutputWithContext(ctx context.Context) ApiConfigIamBindingPtrOutput
}

type ApiConfigIamBindingPtrOutput 

type ApiConfigIamBindingPtrOutput struct{ *pulumi.OutputState }

func (ApiConfigIamBindingPtrOutput) Elem added in v5.21.0 

func (o ApiConfigIamBindingPtrOutput) Elem() ApiConfigIamBindingOutput

func (ApiConfigIamBindingPtrOutput) ElementType 

func (ApiConfigIamBindingPtrOutput) ElementType() reflect.Type

func (ApiConfigIamBindingPtrOutput) ToApiConfigIamBindingPtrOutput 

func (o ApiConfigIamBindingPtrOutput) ToApiConfigIamBindingPtrOutput() ApiConfigIamBindingPtrOutput

func (ApiConfigIamBindingPtrOutput) ToApiConfigIamBindingPtrOutputWithContext 

func (o ApiConfigIamBindingPtrOutput) ToApiConfigIamBindingPtrOutputWithContext(ctx context.Context) ApiConfigIamBindingPtrOutput

type ApiConfigIamBindingState 

type ApiConfigIamBindingState struct {
	// The API to attach the config to.
	// Used to find the parent resource to bind the IAM policy to
	Api       pulumi.StringPtrInput
	ApiConfig pulumi.StringPtrInput
	Condition ApiConfigIamBindingConditionPtrInput
	// (Computed) The etag of the IAM policy.
	Etag    pulumi.StringPtrInput
	Members pulumi.StringArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.ApiConfigIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (ApiConfigIamBindingState) ElementType 

func (ApiConfigIamBindingState) ElementType() reflect.Type

type ApiConfigIamMember 

type ApiConfigIamMember struct {
	pulumi.CustomResourceState

	// The API to attach the config to.
	// Used to find the parent resource to bind the IAM policy to
	Api       pulumi.StringOutput                  `pulumi:"api"`
	ApiConfig pulumi.StringOutput                  `pulumi:"apiConfig"`
	Condition ApiConfigIamMemberConditionPtrOutput `pulumi:"condition"`
	// (Computed) The etag of the IAM policy.
	Etag   pulumi.StringOutput `pulumi:"etag"`
	Member pulumi.StringOutput `pulumi:"member"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The role that should be applied. Only one
	// `apigateway.ApiConfigIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for API Gateway ApiConfig. Each of these resources serves a different use case:

* `apigateway.ApiConfigIamPolicy`: Authoritative. Sets the IAM policy for the apiconfig and replaces any existing policy already attached. * `apigateway.ApiConfigIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the apiconfig are preserved. * `apigateway.ApiConfigIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the apiconfig are preserved.

> **Note:** `apigateway.ApiConfigIamPolicy` **cannot** be used in conjunction with `apigateway.ApiConfigIamBinding` and `apigateway.ApiConfigIamMember` or they will fight over what your policy should be.

> **Note:** `apigateway.ApiConfigIamBinding` resources **can be** used in conjunction with `apigateway.ApiConfigIamMember` resources **only if** they do not grant privilege to the same role.

## google\_api\_gateway\_api\_config\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/apigateway"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				organizations.GetIAMPolicyBinding{
					Role: "roles/apigateway.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = apigateway.NewApiConfigIamPolicy(ctx, "policy", &apigateway.ApiConfigIamPolicyArgs{
			Api:        pulumi.Any(google_api_gateway_api_config.Api_cfg.Api),
			ApiConfig:  pulumi.Any(google_api_gateway_api_config.Api_cfg.Api_config_id),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_config\_iam\_binding

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiConfigIamBinding(ctx, "binding", &apigateway.ApiConfigIamBindingArgs{
			Api:       pulumi.Any(google_api_gateway_api_config.Api_cfg.Api),
			ApiConfig: pulumi.Any(google_api_gateway_api_config.Api_cfg.Api_config_id),
			Role:      pulumi.String("roles/apigateway.viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_config\_iam\_member

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiConfigIamMember(ctx, "member", &apigateway.ApiConfigIamMemberArgs{
			Api:       pulumi.Any(google_api_gateway_api_config.Api_cfg.Api),
			ApiConfig: pulumi.Any(google_api_gateway_api_config.Api_cfg.Api_config_id),
			Role:      pulumi.String("roles/apigateway.viewer"),
			Member:    pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms* projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}} * {{project}}/{{api}}/{{api_config}} * {{api}}/{{api_config}} * {{api_config}} Any variables not passed in the import command will be taken from the provider configuration. API Gateway apiconfig IAM resources can be imported using the resource identifiers, role, and member. IAM member imports use space-delimited identifiersthe resource in question, the role, and the member identity, e.g.

```sh 

$ pulumi import gcp:apigateway/apiConfigIamMember:ApiConfigIamMember editor "projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}} roles/apigateway.viewer user:jane@example.com"

``` 

IAM binding imports use space-delimited identifiersthe resource in question and the role, e.g.

```sh 

$ pulumi import gcp:apigateway/apiConfigIamMember:ApiConfigIamMember editor "projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}} roles/apigateway.viewer"

``` 

IAM policy imports use the identifier of the resource in question, e.g.

```sh 

$ pulumi import gcp:apigateway/apiConfigIamMember:ApiConfigIamMember editor projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}}

``` 

-> **Custom Roles**If you're importing a IAM resource with a custom role, make sure to use the

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetApiConfigIamMember 

func GetApiConfigIamMember(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApiConfigIamMemberState, opts ...pulumi.ResourceOption) (*ApiConfigIamMember, error)

GetApiConfigIamMember gets an existing ApiConfigIamMember resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewApiConfigIamMember 

func NewApiConfigIamMember(ctx *pulumi.Context,
	name string, args *ApiConfigIamMemberArgs, opts ...pulumi.ResourceOption) (*ApiConfigIamMember, error)

NewApiConfigIamMember registers a new resource with the given unique name, arguments, and options.

func (*ApiConfigIamMember) ElementType 

func (*ApiConfigIamMember) ElementType() reflect.Type

func (*ApiConfigIamMember) ToApiConfigIamMemberOutput 

func (i *ApiConfigIamMember) ToApiConfigIamMemberOutput() ApiConfigIamMemberOutput

func (*ApiConfigIamMember) ToApiConfigIamMemberOutputWithContext 

func (i *ApiConfigIamMember) ToApiConfigIamMemberOutputWithContext(ctx context.Context) ApiConfigIamMemberOutput

func (*ApiConfigIamMember) ToApiConfigIamMemberPtrOutput 

func (i *ApiConfigIamMember) ToApiConfigIamMemberPtrOutput() ApiConfigIamMemberPtrOutput

func (*ApiConfigIamMember) ToApiConfigIamMemberPtrOutputWithContext 

func (i *ApiConfigIamMember) ToApiConfigIamMemberPtrOutputWithContext(ctx context.Context) ApiConfigIamMemberPtrOutput

type ApiConfigIamMemberArgs 

type ApiConfigIamMemberArgs struct {
	// The API to attach the config to.
	// Used to find the parent resource to bind the IAM policy to
	Api       pulumi.StringInput
	ApiConfig pulumi.StringInput
	Condition ApiConfigIamMemberConditionPtrInput
	Member    pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.ApiConfigIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a ApiConfigIamMember resource.

func (ApiConfigIamMemberArgs) ElementType 

func (ApiConfigIamMemberArgs) ElementType() reflect.Type

type ApiConfigIamMemberArray 

type ApiConfigIamMemberArray []ApiConfigIamMemberInput

func (ApiConfigIamMemberArray) ElementType 

func (ApiConfigIamMemberArray) ElementType() reflect.Type

func (ApiConfigIamMemberArray) ToApiConfigIamMemberArrayOutput 

func (i ApiConfigIamMemberArray) ToApiConfigIamMemberArrayOutput() ApiConfigIamMemberArrayOutput

func (ApiConfigIamMemberArray) ToApiConfigIamMemberArrayOutputWithContext 

func (i ApiConfigIamMemberArray) ToApiConfigIamMemberArrayOutputWithContext(ctx context.Context) ApiConfigIamMemberArrayOutput

type ApiConfigIamMemberArrayInput 

type ApiConfigIamMemberArrayInput interface {
	pulumi.Input

	ToApiConfigIamMemberArrayOutput() ApiConfigIamMemberArrayOutput
	ToApiConfigIamMemberArrayOutputWithContext(context.Context) ApiConfigIamMemberArrayOutput
}

ApiConfigIamMemberArrayInput is an input type that accepts ApiConfigIamMemberArray and ApiConfigIamMemberArrayOutput values. You can construct a concrete instance of `ApiConfigIamMemberArrayInput` via: 

ApiConfigIamMemberArray{ ApiConfigIamMemberArgs{...} }

type ApiConfigIamMemberArrayOutput 

type ApiConfigIamMemberArrayOutput struct{ *pulumi.OutputState }

func (ApiConfigIamMemberArrayOutput) ElementType 

func (ApiConfigIamMemberArrayOutput) ElementType() reflect.Type

func (ApiConfigIamMemberArrayOutput) Index 

func (o ApiConfigIamMemberArrayOutput) Index(i pulumi.IntInput) ApiConfigIamMemberOutput

func (ApiConfigIamMemberArrayOutput) ToApiConfigIamMemberArrayOutput 

func (o ApiConfigIamMemberArrayOutput) ToApiConfigIamMemberArrayOutput() ApiConfigIamMemberArrayOutput

func (ApiConfigIamMemberArrayOutput) ToApiConfigIamMemberArrayOutputWithContext 

func (o ApiConfigIamMemberArrayOutput) ToApiConfigIamMemberArrayOutputWithContext(ctx context.Context) ApiConfigIamMemberArrayOutput

type ApiConfigIamMemberCondition 

type ApiConfigIamMemberCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type ApiConfigIamMemberConditionArgs 

type ApiConfigIamMemberConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (ApiConfigIamMemberConditionArgs) ElementType 

func (ApiConfigIamMemberConditionArgs) ElementType() reflect.Type

func (ApiConfigIamMemberConditionArgs) ToApiConfigIamMemberConditionOutput 

func (i ApiConfigIamMemberConditionArgs) ToApiConfigIamMemberConditionOutput() ApiConfigIamMemberConditionOutput

func (ApiConfigIamMemberConditionArgs) ToApiConfigIamMemberConditionOutputWithContext 

func (i ApiConfigIamMemberConditionArgs) ToApiConfigIamMemberConditionOutputWithContext(ctx context.Context) ApiConfigIamMemberConditionOutput

func (ApiConfigIamMemberConditionArgs) ToApiConfigIamMemberConditionPtrOutput 

func (i ApiConfigIamMemberConditionArgs) ToApiConfigIamMemberConditionPtrOutput() ApiConfigIamMemberConditionPtrOutput

func (ApiConfigIamMemberConditionArgs) ToApiConfigIamMemberConditionPtrOutputWithContext 

func (i ApiConfigIamMemberConditionArgs) ToApiConfigIamMemberConditionPtrOutputWithContext(ctx context.Context) ApiConfigIamMemberConditionPtrOutput

type ApiConfigIamMemberConditionInput 

type ApiConfigIamMemberConditionInput interface {
	pulumi.Input

	ToApiConfigIamMemberConditionOutput() ApiConfigIamMemberConditionOutput
	ToApiConfigIamMemberConditionOutputWithContext(context.Context) ApiConfigIamMemberConditionOutput
}

ApiConfigIamMemberConditionInput is an input type that accepts ApiConfigIamMemberConditionArgs and ApiConfigIamMemberConditionOutput values. You can construct a concrete instance of `ApiConfigIamMemberConditionInput` via: 

ApiConfigIamMemberConditionArgs{...}

type ApiConfigIamMemberConditionOutput 

type ApiConfigIamMemberConditionOutput struct{ *pulumi.OutputState }

func (ApiConfigIamMemberConditionOutput) Description 

func (o ApiConfigIamMemberConditionOutput) Description() pulumi.StringPtrOutput

func (ApiConfigIamMemberConditionOutput) ElementType 

func (ApiConfigIamMemberConditionOutput) ElementType() reflect.Type

func (ApiConfigIamMemberConditionOutput) Expression 

func (o ApiConfigIamMemberConditionOutput) Expression() pulumi.StringOutput

func (ApiConfigIamMemberConditionOutput) Title 

func (o ApiConfigIamMemberConditionOutput) Title() pulumi.StringOutput

func (ApiConfigIamMemberConditionOutput) ToApiConfigIamMemberConditionOutput 

func (o ApiConfigIamMemberConditionOutput) ToApiConfigIamMemberConditionOutput() ApiConfigIamMemberConditionOutput

func (ApiConfigIamMemberConditionOutput) ToApiConfigIamMemberConditionOutputWithContext 

func (o ApiConfigIamMemberConditionOutput) ToApiConfigIamMemberConditionOutputWithContext(ctx context.Context) ApiConfigIamMemberConditionOutput

func (ApiConfigIamMemberConditionOutput) ToApiConfigIamMemberConditionPtrOutput 

func (o ApiConfigIamMemberConditionOutput) ToApiConfigIamMemberConditionPtrOutput() ApiConfigIamMemberConditionPtrOutput

func (ApiConfigIamMemberConditionOutput) ToApiConfigIamMemberConditionPtrOutputWithContext 

func (o ApiConfigIamMemberConditionOutput) ToApiConfigIamMemberConditionPtrOutputWithContext(ctx context.Context) ApiConfigIamMemberConditionPtrOutput

type ApiConfigIamMemberConditionPtrInput 

type ApiConfigIamMemberConditionPtrInput interface {
	pulumi.Input

	ToApiConfigIamMemberConditionPtrOutput() ApiConfigIamMemberConditionPtrOutput
	ToApiConfigIamMemberConditionPtrOutputWithContext(context.Context) ApiConfigIamMemberConditionPtrOutput
}

ApiConfigIamMemberConditionPtrInput is an input type that accepts ApiConfigIamMemberConditionArgs, ApiConfigIamMemberConditionPtr and ApiConfigIamMemberConditionPtrOutput values. You can construct a concrete instance of `ApiConfigIamMemberConditionPtrInput` via: 

        ApiConfigIamMemberConditionArgs{...}

or:

        nil

func ApiConfigIamMemberConditionPtr 

func ApiConfigIamMemberConditionPtr(v *ApiConfigIamMemberConditionArgs) ApiConfigIamMemberConditionPtrInput

type ApiConfigIamMemberConditionPtrOutput 

type ApiConfigIamMemberConditionPtrOutput struct{ *pulumi.OutputState }

func (ApiConfigIamMemberConditionPtrOutput) Description 

func (o ApiConfigIamMemberConditionPtrOutput) Description() pulumi.StringPtrOutput

func (ApiConfigIamMemberConditionPtrOutput) Elem 

func (o ApiConfigIamMemberConditionPtrOutput) Elem() ApiConfigIamMemberConditionOutput

func (ApiConfigIamMemberConditionPtrOutput) ElementType 

func (ApiConfigIamMemberConditionPtrOutput) ElementType() reflect.Type

func (ApiConfigIamMemberConditionPtrOutput) Expression 

func (o ApiConfigIamMemberConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (ApiConfigIamMemberConditionPtrOutput) Title 

func (o ApiConfigIamMemberConditionPtrOutput) Title() pulumi.StringPtrOutput

func (ApiConfigIamMemberConditionPtrOutput) ToApiConfigIamMemberConditionPtrOutput 

func (o ApiConfigIamMemberConditionPtrOutput) ToApiConfigIamMemberConditionPtrOutput() ApiConfigIamMemberConditionPtrOutput

func (ApiConfigIamMemberConditionPtrOutput) ToApiConfigIamMemberConditionPtrOutputWithContext 

func (o ApiConfigIamMemberConditionPtrOutput) ToApiConfigIamMemberConditionPtrOutputWithContext(ctx context.Context) ApiConfigIamMemberConditionPtrOutput

type ApiConfigIamMemberInput 

type ApiConfigIamMemberInput interface {
	pulumi.Input

	ToApiConfigIamMemberOutput() ApiConfigIamMemberOutput
	ToApiConfigIamMemberOutputWithContext(ctx context.Context) ApiConfigIamMemberOutput
}

type ApiConfigIamMemberMap 

type ApiConfigIamMemberMap map[string]ApiConfigIamMemberInput

func (ApiConfigIamMemberMap) ElementType 

func (ApiConfigIamMemberMap) ElementType() reflect.Type

func (ApiConfigIamMemberMap) ToApiConfigIamMemberMapOutput 

func (i ApiConfigIamMemberMap) ToApiConfigIamMemberMapOutput() ApiConfigIamMemberMapOutput

func (ApiConfigIamMemberMap) ToApiConfigIamMemberMapOutputWithContext 

func (i ApiConfigIamMemberMap) ToApiConfigIamMemberMapOutputWithContext(ctx context.Context) ApiConfigIamMemberMapOutput

type ApiConfigIamMemberMapInput 

type ApiConfigIamMemberMapInput interface {
	pulumi.Input

	ToApiConfigIamMemberMapOutput() ApiConfigIamMemberMapOutput
	ToApiConfigIamMemberMapOutputWithContext(context.Context) ApiConfigIamMemberMapOutput
}

ApiConfigIamMemberMapInput is an input type that accepts ApiConfigIamMemberMap and ApiConfigIamMemberMapOutput values. You can construct a concrete instance of `ApiConfigIamMemberMapInput` via: 

ApiConfigIamMemberMap{ "key": ApiConfigIamMemberArgs{...} }

type ApiConfigIamMemberMapOutput 

type ApiConfigIamMemberMapOutput struct{ *pulumi.OutputState }

func (ApiConfigIamMemberMapOutput) ElementType 

func (ApiConfigIamMemberMapOutput) ElementType() reflect.Type

func (ApiConfigIamMemberMapOutput) MapIndex 

func (o ApiConfigIamMemberMapOutput) MapIndex(k pulumi.StringInput) ApiConfigIamMemberOutput

func (ApiConfigIamMemberMapOutput) ToApiConfigIamMemberMapOutput 

func (o ApiConfigIamMemberMapOutput) ToApiConfigIamMemberMapOutput() ApiConfigIamMemberMapOutput

func (ApiConfigIamMemberMapOutput) ToApiConfigIamMemberMapOutputWithContext 

func (o ApiConfigIamMemberMapOutput) ToApiConfigIamMemberMapOutputWithContext(ctx context.Context) ApiConfigIamMemberMapOutput

type ApiConfigIamMemberOutput 

type ApiConfigIamMemberOutput struct{ *pulumi.OutputState }

func (ApiConfigIamMemberOutput) ElementType 

func (ApiConfigIamMemberOutput) ElementType() reflect.Type

func (ApiConfigIamMemberOutput) ToApiConfigIamMemberOutput 

func (o ApiConfigIamMemberOutput) ToApiConfigIamMemberOutput() ApiConfigIamMemberOutput

func (ApiConfigIamMemberOutput) ToApiConfigIamMemberOutputWithContext 

func (o ApiConfigIamMemberOutput) ToApiConfigIamMemberOutputWithContext(ctx context.Context) ApiConfigIamMemberOutput

func (ApiConfigIamMemberOutput) ToApiConfigIamMemberPtrOutput 

func (o ApiConfigIamMemberOutput) ToApiConfigIamMemberPtrOutput() ApiConfigIamMemberPtrOutput

func (ApiConfigIamMemberOutput) ToApiConfigIamMemberPtrOutputWithContext 

func (o ApiConfigIamMemberOutput) ToApiConfigIamMemberPtrOutputWithContext(ctx context.Context) ApiConfigIamMemberPtrOutput

type ApiConfigIamMemberPtrInput 

type ApiConfigIamMemberPtrInput interface {
	pulumi.Input

	ToApiConfigIamMemberPtrOutput() ApiConfigIamMemberPtrOutput
	ToApiConfigIamMemberPtrOutputWithContext(ctx context.Context) ApiConfigIamMemberPtrOutput
}

type ApiConfigIamMemberPtrOutput 

type ApiConfigIamMemberPtrOutput struct{ *pulumi.OutputState }

func (ApiConfigIamMemberPtrOutput) Elem added in v5.21.0 

func (o ApiConfigIamMemberPtrOutput) Elem() ApiConfigIamMemberOutput

func (ApiConfigIamMemberPtrOutput) ElementType 

func (ApiConfigIamMemberPtrOutput) ElementType() reflect.Type

func (ApiConfigIamMemberPtrOutput) ToApiConfigIamMemberPtrOutput 

func (o ApiConfigIamMemberPtrOutput) ToApiConfigIamMemberPtrOutput() ApiConfigIamMemberPtrOutput

func (ApiConfigIamMemberPtrOutput) ToApiConfigIamMemberPtrOutputWithContext 

func (o ApiConfigIamMemberPtrOutput) ToApiConfigIamMemberPtrOutputWithContext(ctx context.Context) ApiConfigIamMemberPtrOutput

type ApiConfigIamMemberState 

type ApiConfigIamMemberState struct {
	// The API to attach the config to.
	// Used to find the parent resource to bind the IAM policy to
	Api       pulumi.StringPtrInput
	ApiConfig pulumi.StringPtrInput
	Condition ApiConfigIamMemberConditionPtrInput
	// (Computed) The etag of the IAM policy.
	Etag   pulumi.StringPtrInput
	Member pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.ApiConfigIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (ApiConfigIamMemberState) ElementType 

func (ApiConfigIamMemberState) ElementType() reflect.Type

type ApiConfigIamPolicy 

type ApiConfigIamPolicy struct {
	pulumi.CustomResourceState

	// The API to attach the config to.
	// Used to find the parent resource to bind the IAM policy to
	Api       pulumi.StringOutput `pulumi:"api"`
	ApiConfig pulumi.StringOutput `pulumi:"apiConfig"`
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringOutput `pulumi:"policyData"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
}

Three different resources help you manage your IAM policy for API Gateway ApiConfig. Each of these resources serves a different use case:

* `apigateway.ApiConfigIamPolicy`: Authoritative. Sets the IAM policy for the apiconfig and replaces any existing policy already attached. * `apigateway.ApiConfigIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the apiconfig are preserved. * `apigateway.ApiConfigIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the apiconfig are preserved.

> **Note:** `apigateway.ApiConfigIamPolicy` **cannot** be used in conjunction with `apigateway.ApiConfigIamBinding` and `apigateway.ApiConfigIamMember` or they will fight over what your policy should be.

> **Note:** `apigateway.ApiConfigIamBinding` resources **can be** used in conjunction with `apigateway.ApiConfigIamMember` resources **only if** they do not grant privilege to the same role.

## google\_api\_gateway\_api\_config\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/apigateway"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				organizations.GetIAMPolicyBinding{
					Role: "roles/apigateway.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = apigateway.NewApiConfigIamPolicy(ctx, "policy", &apigateway.ApiConfigIamPolicyArgs{
			Api:        pulumi.Any(google_api_gateway_api_config.Api_cfg.Api),
			ApiConfig:  pulumi.Any(google_api_gateway_api_config.Api_cfg.Api_config_id),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_config\_iam\_binding

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiConfigIamBinding(ctx, "binding", &apigateway.ApiConfigIamBindingArgs{
			Api:       pulumi.Any(google_api_gateway_api_config.Api_cfg.Api),
			ApiConfig: pulumi.Any(google_api_gateway_api_config.Api_cfg.Api_config_id),
			Role:      pulumi.String("roles/apigateway.viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_config\_iam\_member

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiConfigIamMember(ctx, "member", &apigateway.ApiConfigIamMemberArgs{
			Api:       pulumi.Any(google_api_gateway_api_config.Api_cfg.Api),
			ApiConfig: pulumi.Any(google_api_gateway_api_config.Api_cfg.Api_config_id),
			Role:      pulumi.String("roles/apigateway.viewer"),
			Member:    pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms* projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}} * {{project}}/{{api}}/{{api_config}} * {{api}}/{{api_config}} * {{api_config}} Any variables not passed in the import command will be taken from the provider configuration. API Gateway apiconfig IAM resources can be imported using the resource identifiers, role, and member. IAM member imports use space-delimited identifiersthe resource in question, the role, and the member identity, e.g.

```sh 

$ pulumi import gcp:apigateway/apiConfigIamPolicy:ApiConfigIamPolicy editor "projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}} roles/apigateway.viewer user:jane@example.com"

``` 

IAM binding imports use space-delimited identifiersthe resource in question and the role, e.g.

```sh 

$ pulumi import gcp:apigateway/apiConfigIamPolicy:ApiConfigIamPolicy editor "projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}} roles/apigateway.viewer"

``` 

IAM policy imports use the identifier of the resource in question, e.g.

```sh 

$ pulumi import gcp:apigateway/apiConfigIamPolicy:ApiConfigIamPolicy editor projects/{{project}}/locations/global/apis/{{api}}/configs/{{api_config}}

``` 

-> **Custom Roles**If you're importing a IAM resource with a custom role, make sure to use the

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetApiConfigIamPolicy 

func GetApiConfigIamPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApiConfigIamPolicyState, opts ...pulumi.ResourceOption) (*ApiConfigIamPolicy, error)

GetApiConfigIamPolicy gets an existing ApiConfigIamPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewApiConfigIamPolicy 

func NewApiConfigIamPolicy(ctx *pulumi.Context,
	name string, args *ApiConfigIamPolicyArgs, opts ...pulumi.ResourceOption) (*ApiConfigIamPolicy, error)

NewApiConfigIamPolicy registers a new resource with the given unique name, arguments, and options.

func (*ApiConfigIamPolicy) ElementType 

func (*ApiConfigIamPolicy) ElementType() reflect.Type

func (*ApiConfigIamPolicy) ToApiConfigIamPolicyOutput 

func (i *ApiConfigIamPolicy) ToApiConfigIamPolicyOutput() ApiConfigIamPolicyOutput

func (*ApiConfigIamPolicy) ToApiConfigIamPolicyOutputWithContext 

func (i *ApiConfigIamPolicy) ToApiConfigIamPolicyOutputWithContext(ctx context.Context) ApiConfigIamPolicyOutput

func (*ApiConfigIamPolicy) ToApiConfigIamPolicyPtrOutput 

func (i *ApiConfigIamPolicy) ToApiConfigIamPolicyPtrOutput() ApiConfigIamPolicyPtrOutput

func (*ApiConfigIamPolicy) ToApiConfigIamPolicyPtrOutputWithContext 

func (i *ApiConfigIamPolicy) ToApiConfigIamPolicyPtrOutputWithContext(ctx context.Context) ApiConfigIamPolicyPtrOutput

type ApiConfigIamPolicyArgs 

type ApiConfigIamPolicyArgs struct {
	// The API to attach the config to.
	// Used to find the parent resource to bind the IAM policy to
	Api       pulumi.StringInput
	ApiConfig pulumi.StringInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a ApiConfigIamPolicy resource.

func (ApiConfigIamPolicyArgs) ElementType 

func (ApiConfigIamPolicyArgs) ElementType() reflect.Type

type ApiConfigIamPolicyArray 

type ApiConfigIamPolicyArray []ApiConfigIamPolicyInput

func (ApiConfigIamPolicyArray) ElementType 

func (ApiConfigIamPolicyArray) ElementType() reflect.Type

func (ApiConfigIamPolicyArray) ToApiConfigIamPolicyArrayOutput 

func (i ApiConfigIamPolicyArray) ToApiConfigIamPolicyArrayOutput() ApiConfigIamPolicyArrayOutput

func (ApiConfigIamPolicyArray) ToApiConfigIamPolicyArrayOutputWithContext 

func (i ApiConfigIamPolicyArray) ToApiConfigIamPolicyArrayOutputWithContext(ctx context.Context) ApiConfigIamPolicyArrayOutput

type ApiConfigIamPolicyArrayInput 

type ApiConfigIamPolicyArrayInput interface {
	pulumi.Input

	ToApiConfigIamPolicyArrayOutput() ApiConfigIamPolicyArrayOutput
	ToApiConfigIamPolicyArrayOutputWithContext(context.Context) ApiConfigIamPolicyArrayOutput
}

ApiConfigIamPolicyArrayInput is an input type that accepts ApiConfigIamPolicyArray and ApiConfigIamPolicyArrayOutput values. You can construct a concrete instance of `ApiConfigIamPolicyArrayInput` via: 

ApiConfigIamPolicyArray{ ApiConfigIamPolicyArgs{...} }

type ApiConfigIamPolicyArrayOutput 

type ApiConfigIamPolicyArrayOutput struct{ *pulumi.OutputState }

func (ApiConfigIamPolicyArrayOutput) ElementType 

func (ApiConfigIamPolicyArrayOutput) ElementType() reflect.Type

func (ApiConfigIamPolicyArrayOutput) Index 

func (o ApiConfigIamPolicyArrayOutput) Index(i pulumi.IntInput) ApiConfigIamPolicyOutput

func (ApiConfigIamPolicyArrayOutput) ToApiConfigIamPolicyArrayOutput 

func (o ApiConfigIamPolicyArrayOutput) ToApiConfigIamPolicyArrayOutput() ApiConfigIamPolicyArrayOutput

func (ApiConfigIamPolicyArrayOutput) ToApiConfigIamPolicyArrayOutputWithContext 

func (o ApiConfigIamPolicyArrayOutput) ToApiConfigIamPolicyArrayOutputWithContext(ctx context.Context) ApiConfigIamPolicyArrayOutput

type ApiConfigIamPolicyInput 

type ApiConfigIamPolicyInput interface {
	pulumi.Input

	ToApiConfigIamPolicyOutput() ApiConfigIamPolicyOutput
	ToApiConfigIamPolicyOutputWithContext(ctx context.Context) ApiConfigIamPolicyOutput
}

type ApiConfigIamPolicyMap 

type ApiConfigIamPolicyMap map[string]ApiConfigIamPolicyInput

func (ApiConfigIamPolicyMap) ElementType 

func (ApiConfigIamPolicyMap) ElementType() reflect.Type

func (ApiConfigIamPolicyMap) ToApiConfigIamPolicyMapOutput 

func (i ApiConfigIamPolicyMap) ToApiConfigIamPolicyMapOutput() ApiConfigIamPolicyMapOutput

func (ApiConfigIamPolicyMap) ToApiConfigIamPolicyMapOutputWithContext 

func (i ApiConfigIamPolicyMap) ToApiConfigIamPolicyMapOutputWithContext(ctx context.Context) ApiConfigIamPolicyMapOutput

type ApiConfigIamPolicyMapInput 

type ApiConfigIamPolicyMapInput interface {
	pulumi.Input

	ToApiConfigIamPolicyMapOutput() ApiConfigIamPolicyMapOutput
	ToApiConfigIamPolicyMapOutputWithContext(context.Context) ApiConfigIamPolicyMapOutput
}

ApiConfigIamPolicyMapInput is an input type that accepts ApiConfigIamPolicyMap and ApiConfigIamPolicyMapOutput values. You can construct a concrete instance of `ApiConfigIamPolicyMapInput` via: 

ApiConfigIamPolicyMap{ "key": ApiConfigIamPolicyArgs{...} }

type ApiConfigIamPolicyMapOutput 

type ApiConfigIamPolicyMapOutput struct{ *pulumi.OutputState }

func (ApiConfigIamPolicyMapOutput) ElementType 

func (ApiConfigIamPolicyMapOutput) ElementType() reflect.Type

func (ApiConfigIamPolicyMapOutput) MapIndex 

func (o ApiConfigIamPolicyMapOutput) MapIndex(k pulumi.StringInput) ApiConfigIamPolicyOutput

func (ApiConfigIamPolicyMapOutput) ToApiConfigIamPolicyMapOutput 

func (o ApiConfigIamPolicyMapOutput) ToApiConfigIamPolicyMapOutput() ApiConfigIamPolicyMapOutput

func (ApiConfigIamPolicyMapOutput) ToApiConfigIamPolicyMapOutputWithContext 

func (o ApiConfigIamPolicyMapOutput) ToApiConfigIamPolicyMapOutputWithContext(ctx context.Context) ApiConfigIamPolicyMapOutput

type ApiConfigIamPolicyOutput 

type ApiConfigIamPolicyOutput struct{ *pulumi.OutputState }

func (ApiConfigIamPolicyOutput) ElementType 

func (ApiConfigIamPolicyOutput) ElementType() reflect.Type

func (ApiConfigIamPolicyOutput) ToApiConfigIamPolicyOutput 

func (o ApiConfigIamPolicyOutput) ToApiConfigIamPolicyOutput() ApiConfigIamPolicyOutput

func (ApiConfigIamPolicyOutput) ToApiConfigIamPolicyOutputWithContext 

func (o ApiConfigIamPolicyOutput) ToApiConfigIamPolicyOutputWithContext(ctx context.Context) ApiConfigIamPolicyOutput

func (ApiConfigIamPolicyOutput) ToApiConfigIamPolicyPtrOutput 

func (o ApiConfigIamPolicyOutput) ToApiConfigIamPolicyPtrOutput() ApiConfigIamPolicyPtrOutput

func (ApiConfigIamPolicyOutput) ToApiConfigIamPolicyPtrOutputWithContext 

func (o ApiConfigIamPolicyOutput) ToApiConfigIamPolicyPtrOutputWithContext(ctx context.Context) ApiConfigIamPolicyPtrOutput

type ApiConfigIamPolicyPtrInput 

type ApiConfigIamPolicyPtrInput interface {
	pulumi.Input

	ToApiConfigIamPolicyPtrOutput() ApiConfigIamPolicyPtrOutput
	ToApiConfigIamPolicyPtrOutputWithContext(ctx context.Context) ApiConfigIamPolicyPtrOutput
}

type ApiConfigIamPolicyPtrOutput 

type ApiConfigIamPolicyPtrOutput struct{ *pulumi.OutputState }

func (ApiConfigIamPolicyPtrOutput) Elem added in v5.21.0 

func (o ApiConfigIamPolicyPtrOutput) Elem() ApiConfigIamPolicyOutput

func (ApiConfigIamPolicyPtrOutput) ElementType 

func (ApiConfigIamPolicyPtrOutput) ElementType() reflect.Type

func (ApiConfigIamPolicyPtrOutput) ToApiConfigIamPolicyPtrOutput 

func (o ApiConfigIamPolicyPtrOutput) ToApiConfigIamPolicyPtrOutput() ApiConfigIamPolicyPtrOutput

func (ApiConfigIamPolicyPtrOutput) ToApiConfigIamPolicyPtrOutputWithContext 

func (o ApiConfigIamPolicyPtrOutput) ToApiConfigIamPolicyPtrOutputWithContext(ctx context.Context) ApiConfigIamPolicyPtrOutput

type ApiConfigIamPolicyState 

type ApiConfigIamPolicyState struct {
	// The API to attach the config to.
	// Used to find the parent resource to bind the IAM policy to
	Api       pulumi.StringPtrInput
	ApiConfig pulumi.StringPtrInput
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
}

func (ApiConfigIamPolicyState) ElementType 

func (ApiConfigIamPolicyState) ElementType() reflect.Type

type ApiConfigInput 

type ApiConfigInput interface {
	pulumi.Input

	ToApiConfigOutput() ApiConfigOutput
	ToApiConfigOutputWithContext(ctx context.Context) ApiConfigOutput
}

type ApiConfigMap 

type ApiConfigMap map[string]ApiConfigInput

func (ApiConfigMap) ElementType 

func (ApiConfigMap) ElementType() reflect.Type

func (ApiConfigMap) ToApiConfigMapOutput 

func (i ApiConfigMap) ToApiConfigMapOutput() ApiConfigMapOutput

func (ApiConfigMap) ToApiConfigMapOutputWithContext 

func (i ApiConfigMap) ToApiConfigMapOutputWithContext(ctx context.Context) ApiConfigMapOutput

type ApiConfigMapInput 

type ApiConfigMapInput interface {
	pulumi.Input

	ToApiConfigMapOutput() ApiConfigMapOutput
	ToApiConfigMapOutputWithContext(context.Context) ApiConfigMapOutput
}

ApiConfigMapInput is an input type that accepts ApiConfigMap and ApiConfigMapOutput values. You can construct a concrete instance of `ApiConfigMapInput` via: 

ApiConfigMap{ "key": ApiConfigArgs{...} }

type ApiConfigMapOutput 

type ApiConfigMapOutput struct{ *pulumi.OutputState }

func (ApiConfigMapOutput) ElementType 

func (ApiConfigMapOutput) ElementType() reflect.Type

func (ApiConfigMapOutput) MapIndex 

func (o ApiConfigMapOutput) MapIndex(k pulumi.StringInput) ApiConfigOutput

func (ApiConfigMapOutput) ToApiConfigMapOutput 

func (o ApiConfigMapOutput) ToApiConfigMapOutput() ApiConfigMapOutput

func (ApiConfigMapOutput) ToApiConfigMapOutputWithContext 

func (o ApiConfigMapOutput) ToApiConfigMapOutputWithContext(ctx context.Context) ApiConfigMapOutput

type ApiConfigOpenapiDocument 

type ApiConfigOpenapiDocument struct {
	// The OpenAPI Specification document file.
	// Structure is documented below.
	Document ApiConfigOpenapiDocumentDocument `pulumi:"document"`
}

type ApiConfigOpenapiDocumentArgs 

type ApiConfigOpenapiDocumentArgs struct {
	// The OpenAPI Specification document file.
	// Structure is documented below.
	Document ApiConfigOpenapiDocumentDocumentInput `pulumi:"document"`
}

func (ApiConfigOpenapiDocumentArgs) ElementType 

func (ApiConfigOpenapiDocumentArgs) ElementType() reflect.Type

func (ApiConfigOpenapiDocumentArgs) ToApiConfigOpenapiDocumentOutput 

func (i ApiConfigOpenapiDocumentArgs) ToApiConfigOpenapiDocumentOutput() ApiConfigOpenapiDocumentOutput

func (ApiConfigOpenapiDocumentArgs) ToApiConfigOpenapiDocumentOutputWithContext 

func (i ApiConfigOpenapiDocumentArgs) ToApiConfigOpenapiDocumentOutputWithContext(ctx context.Context) ApiConfigOpenapiDocumentOutput

type ApiConfigOpenapiDocumentArray 

type ApiConfigOpenapiDocumentArray []ApiConfigOpenapiDocumentInput

func (ApiConfigOpenapiDocumentArray) ElementType 

func (ApiConfigOpenapiDocumentArray) ElementType() reflect.Type

func (ApiConfigOpenapiDocumentArray) ToApiConfigOpenapiDocumentArrayOutput 

func (i ApiConfigOpenapiDocumentArray) ToApiConfigOpenapiDocumentArrayOutput() ApiConfigOpenapiDocumentArrayOutput

func (ApiConfigOpenapiDocumentArray) ToApiConfigOpenapiDocumentArrayOutputWithContext 

func (i ApiConfigOpenapiDocumentArray) ToApiConfigOpenapiDocumentArrayOutputWithContext(ctx context.Context) ApiConfigOpenapiDocumentArrayOutput

type ApiConfigOpenapiDocumentArrayInput 

type ApiConfigOpenapiDocumentArrayInput interface {
	pulumi.Input

	ToApiConfigOpenapiDocumentArrayOutput() ApiConfigOpenapiDocumentArrayOutput
	ToApiConfigOpenapiDocumentArrayOutputWithContext(context.Context) ApiConfigOpenapiDocumentArrayOutput
}

ApiConfigOpenapiDocumentArrayInput is an input type that accepts ApiConfigOpenapiDocumentArray and ApiConfigOpenapiDocumentArrayOutput values. You can construct a concrete instance of `ApiConfigOpenapiDocumentArrayInput` via: 

ApiConfigOpenapiDocumentArray{ ApiConfigOpenapiDocumentArgs{...} }

type ApiConfigOpenapiDocumentArrayOutput 

type ApiConfigOpenapiDocumentArrayOutput struct{ *pulumi.OutputState }

func (ApiConfigOpenapiDocumentArrayOutput) ElementType 

func (ApiConfigOpenapiDocumentArrayOutput) ElementType() reflect.Type

func (ApiConfigOpenapiDocumentArrayOutput) Index 

func (o ApiConfigOpenapiDocumentArrayOutput) Index(i pulumi.IntInput) ApiConfigOpenapiDocumentOutput

func (ApiConfigOpenapiDocumentArrayOutput) ToApiConfigOpenapiDocumentArrayOutput 

func (o ApiConfigOpenapiDocumentArrayOutput) ToApiConfigOpenapiDocumentArrayOutput() ApiConfigOpenapiDocumentArrayOutput

func (ApiConfigOpenapiDocumentArrayOutput) ToApiConfigOpenapiDocumentArrayOutputWithContext 

func (o ApiConfigOpenapiDocumentArrayOutput) ToApiConfigOpenapiDocumentArrayOutputWithContext(ctx context.Context) ApiConfigOpenapiDocumentArrayOutput

type ApiConfigOpenapiDocumentDocument 

type ApiConfigOpenapiDocumentDocument struct {
	// Base64 encoded content of the file.
	Contents string `pulumi:"contents"`
	// The file path (full or relative path). This is typically the path of the file when it is uploaded.
	Path string `pulumi:"path"`
}

type ApiConfigOpenapiDocumentDocumentArgs 

type ApiConfigOpenapiDocumentDocumentArgs struct {
	// Base64 encoded content of the file.
	Contents pulumi.StringInput `pulumi:"contents"`
	// The file path (full or relative path). This is typically the path of the file when it is uploaded.
	Path pulumi.StringInput `pulumi:"path"`
}

func (ApiConfigOpenapiDocumentDocumentArgs) ElementType 

func (ApiConfigOpenapiDocumentDocumentArgs) ElementType() reflect.Type

func (ApiConfigOpenapiDocumentDocumentArgs) ToApiConfigOpenapiDocumentDocumentOutput 

func (i ApiConfigOpenapiDocumentDocumentArgs) ToApiConfigOpenapiDocumentDocumentOutput() ApiConfigOpenapiDocumentDocumentOutput

func (ApiConfigOpenapiDocumentDocumentArgs) ToApiConfigOpenapiDocumentDocumentOutputWithContext 

func (i ApiConfigOpenapiDocumentDocumentArgs) ToApiConfigOpenapiDocumentDocumentOutputWithContext(ctx context.Context) ApiConfigOpenapiDocumentDocumentOutput

type ApiConfigOpenapiDocumentDocumentInput 

type ApiConfigOpenapiDocumentDocumentInput interface {
	pulumi.Input

	ToApiConfigOpenapiDocumentDocumentOutput() ApiConfigOpenapiDocumentDocumentOutput
	ToApiConfigOpenapiDocumentDocumentOutputWithContext(context.Context) ApiConfigOpenapiDocumentDocumentOutput
}

ApiConfigOpenapiDocumentDocumentInput is an input type that accepts ApiConfigOpenapiDocumentDocumentArgs and ApiConfigOpenapiDocumentDocumentOutput values. You can construct a concrete instance of `ApiConfigOpenapiDocumentDocumentInput` via: 

ApiConfigOpenapiDocumentDocumentArgs{...}

type ApiConfigOpenapiDocumentDocumentOutput 

type ApiConfigOpenapiDocumentDocumentOutput struct{ *pulumi.OutputState }

func (ApiConfigOpenapiDocumentDocumentOutput) Contents 

func (o ApiConfigOpenapiDocumentDocumentOutput) Contents() pulumi.StringOutput

Base64 encoded content of the file.

func (ApiConfigOpenapiDocumentDocumentOutput) ElementType 

func (ApiConfigOpenapiDocumentDocumentOutput) ElementType() reflect.Type

func (ApiConfigOpenapiDocumentDocumentOutput) Path 

func (o ApiConfigOpenapiDocumentDocumentOutput) Path() pulumi.StringOutput

The file path (full or relative path). This is typically the path of the file when it is uploaded.

func (ApiConfigOpenapiDocumentDocumentOutput) ToApiConfigOpenapiDocumentDocumentOutput 

func (o ApiConfigOpenapiDocumentDocumentOutput) ToApiConfigOpenapiDocumentDocumentOutput() ApiConfigOpenapiDocumentDocumentOutput

func (ApiConfigOpenapiDocumentDocumentOutput) ToApiConfigOpenapiDocumentDocumentOutputWithContext 

func (o ApiConfigOpenapiDocumentDocumentOutput) ToApiConfigOpenapiDocumentDocumentOutputWithContext(ctx context.Context) ApiConfigOpenapiDocumentDocumentOutput

type ApiConfigOpenapiDocumentInput 

type ApiConfigOpenapiDocumentInput interface {
	pulumi.Input

	ToApiConfigOpenapiDocumentOutput() ApiConfigOpenapiDocumentOutput
	ToApiConfigOpenapiDocumentOutputWithContext(context.Context) ApiConfigOpenapiDocumentOutput
}

ApiConfigOpenapiDocumentInput is an input type that accepts ApiConfigOpenapiDocumentArgs and ApiConfigOpenapiDocumentOutput values. You can construct a concrete instance of `ApiConfigOpenapiDocumentInput` via: 

ApiConfigOpenapiDocumentArgs{...}

type ApiConfigOpenapiDocumentOutput 

type ApiConfigOpenapiDocumentOutput struct{ *pulumi.OutputState }

func (ApiConfigOpenapiDocumentOutput) Document 

func (o ApiConfigOpenapiDocumentOutput) Document() ApiConfigOpenapiDocumentDocumentOutput

The OpenAPI Specification document file. Structure is documented below.

func (ApiConfigOpenapiDocumentOutput) ElementType 

func (ApiConfigOpenapiDocumentOutput) ElementType() reflect.Type

func (ApiConfigOpenapiDocumentOutput) ToApiConfigOpenapiDocumentOutput 

func (o ApiConfigOpenapiDocumentOutput) ToApiConfigOpenapiDocumentOutput() ApiConfigOpenapiDocumentOutput

func (ApiConfigOpenapiDocumentOutput) ToApiConfigOpenapiDocumentOutputWithContext 

func (o ApiConfigOpenapiDocumentOutput) ToApiConfigOpenapiDocumentOutputWithContext(ctx context.Context) ApiConfigOpenapiDocumentOutput

type ApiConfigOutput 

type ApiConfigOutput struct{ *pulumi.OutputState }

func (ApiConfigOutput) ElementType 

func (ApiConfigOutput) ElementType() reflect.Type

func (ApiConfigOutput) ToApiConfigOutput 

func (o ApiConfigOutput) ToApiConfigOutput() ApiConfigOutput

func (ApiConfigOutput) ToApiConfigOutputWithContext 

func (o ApiConfigOutput) ToApiConfigOutputWithContext(ctx context.Context) ApiConfigOutput

func (ApiConfigOutput) ToApiConfigPtrOutput 

func (o ApiConfigOutput) ToApiConfigPtrOutput() ApiConfigPtrOutput

func (ApiConfigOutput) ToApiConfigPtrOutputWithContext 

func (o ApiConfigOutput) ToApiConfigPtrOutputWithContext(ctx context.Context) ApiConfigPtrOutput

type ApiConfigPtrInput 

type ApiConfigPtrInput interface {
	pulumi.Input

	ToApiConfigPtrOutput() ApiConfigPtrOutput
	ToApiConfigPtrOutputWithContext(ctx context.Context) ApiConfigPtrOutput
}

type ApiConfigPtrOutput 

type ApiConfigPtrOutput struct{ *pulumi.OutputState }

func (ApiConfigPtrOutput) Elem added in v5.21.0 

func (o ApiConfigPtrOutput) Elem() ApiConfigOutput

func (ApiConfigPtrOutput) ElementType 

func (ApiConfigPtrOutput) ElementType() reflect.Type

func (ApiConfigPtrOutput) ToApiConfigPtrOutput 

func (o ApiConfigPtrOutput) ToApiConfigPtrOutput() ApiConfigPtrOutput

func (ApiConfigPtrOutput) ToApiConfigPtrOutputWithContext 

func (o ApiConfigPtrOutput) ToApiConfigPtrOutputWithContext(ctx context.Context) ApiConfigPtrOutput

type ApiConfigState 

type ApiConfigState struct {
	// The API to attach the config to.
	Api pulumi.StringPtrInput
	// Identifier to assign to the API Config. Must be unique within scope of the parent resource(api).
	ApiConfigId pulumi.StringPtrInput
	// Creates a unique name beginning with the
	// specified prefix. If this and apiConfigId are unspecified, a random value is chosen for the name.
	ApiConfigIdPrefix pulumi.StringPtrInput
	// A user-visible name for the API.
	DisplayName pulumi.StringPtrInput
	// Immutable. Gateway specific configuration.
	// If not specified, backend authentication will be set to use OIDC authentication using the default compute service account
	// Structure is documented below.
	GatewayConfig ApiConfigGatewayConfigPtrInput
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapInput
	// The resource name of the API Config.
	Name pulumi.StringPtrInput
	// An OpenAPI Specification Document describing an API.
	// Structure is documented below.
	OpenapiDocuments ApiConfigOpenapiDocumentArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// The ID of the associated Service Config (https://cloud.google.com/service-infrastructure/docs/glossary#config).
	ServiceConfigId pulumi.StringPtrInput
}

func (ApiConfigState) ElementType 

func (ApiConfigState) ElementType() reflect.Type

type ApiIamBinding 

type ApiIamBinding struct {
	pulumi.CustomResourceState

	Api       pulumi.StringOutput             `pulumi:"api"`
	Condition ApiIamBindingConditionPtrOutput `pulumi:"condition"`
	// (Computed) The etag of the IAM policy.
	Etag    pulumi.StringOutput      `pulumi:"etag"`
	Members pulumi.StringArrayOutput `pulumi:"members"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The role that should be applied. Only one
	// `apigateway.ApiIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for API Gateway Api. Each of these resources serves a different use case:

* `apigateway.ApiIamPolicy`: Authoritative. Sets the IAM policy for the api and replaces any existing policy already attached. * `apigateway.ApiIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the api are preserved. * `apigateway.ApiIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the api are preserved.

> **Note:** `apigateway.ApiIamPolicy` **cannot** be used in conjunction with `apigateway.ApiIamBinding` and `apigateway.ApiIamMember` or they will fight over what your policy should be.

> **Note:** `apigateway.ApiIamBinding` resources **can be** used in conjunction with `apigateway.ApiIamMember` resources **only if** they do not grant privilege to the same role.

## google\_api\_gateway\_api\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/apigateway"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				organizations.GetIAMPolicyBinding{
					Role: "roles/apigateway.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = apigateway.NewApiIamPolicy(ctx, "policy", &apigateway.ApiIamPolicyArgs{
			Project:    pulumi.Any(google_api_gateway_api.Api.Project),
			Api:        pulumi.Any(google_api_gateway_api.Api.Api_id),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_iam\_binding

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiIamBinding(ctx, "binding", &apigateway.ApiIamBindingArgs{
			Project: pulumi.Any(google_api_gateway_api.Api.Project),
			Api:     pulumi.Any(google_api_gateway_api.Api.Api_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_iam\_member

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiIamMember(ctx, "member", &apigateway.ApiIamMemberArgs{
			Project: pulumi.Any(google_api_gateway_api.Api.Project),
			Api:     pulumi.Any(google_api_gateway_api.Api.Api_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Member:  pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms* projects/{{project}}/locations/global/apis/{{api}} * {{project}}/{{api}} * {{api}} Any variables not passed in the import command will be taken from the provider configuration. API Gateway api IAM resources can be imported using the resource identifiers, role, and member. IAM member imports use space-delimited identifiersthe resource in question, the role, and the member identity, e.g.

```sh 

$ pulumi import gcp:apigateway/apiIamBinding:ApiIamBinding editor "projects/{{project}}/locations/global/apis/{{api}} roles/apigateway.viewer user:jane@example.com"

``` 

IAM binding imports use space-delimited identifiersthe resource in question and the role, e.g.

```sh 

$ pulumi import gcp:apigateway/apiIamBinding:ApiIamBinding editor "projects/{{project}}/locations/global/apis/{{api}} roles/apigateway.viewer"

``` 

IAM policy imports use the identifier of the resource in question, e.g.

```sh 

$ pulumi import gcp:apigateway/apiIamBinding:ApiIamBinding editor projects/{{project}}/locations/global/apis/{{api}}

``` 

-> **Custom Roles**If you're importing a IAM resource with a custom role, make sure to use the

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetApiIamBinding 

func GetApiIamBinding(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApiIamBindingState, opts ...pulumi.ResourceOption) (*ApiIamBinding, error)

GetApiIamBinding gets an existing ApiIamBinding resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewApiIamBinding 

func NewApiIamBinding(ctx *pulumi.Context,
	name string, args *ApiIamBindingArgs, opts ...pulumi.ResourceOption) (*ApiIamBinding, error)

NewApiIamBinding registers a new resource with the given unique name, arguments, and options.

func (*ApiIamBinding) ElementType 

func (*ApiIamBinding) ElementType() reflect.Type

func (*ApiIamBinding) ToApiIamBindingOutput 

func (i *ApiIamBinding) ToApiIamBindingOutput() ApiIamBindingOutput

func (*ApiIamBinding) ToApiIamBindingOutputWithContext 

func (i *ApiIamBinding) ToApiIamBindingOutputWithContext(ctx context.Context) ApiIamBindingOutput

func (*ApiIamBinding) ToApiIamBindingPtrOutput 

func (i *ApiIamBinding) ToApiIamBindingPtrOutput() ApiIamBindingPtrOutput

func (*ApiIamBinding) ToApiIamBindingPtrOutputWithContext 

func (i *ApiIamBinding) ToApiIamBindingPtrOutputWithContext(ctx context.Context) ApiIamBindingPtrOutput

type ApiIamBindingArgs 

type ApiIamBindingArgs struct {
	Api       pulumi.StringInput
	Condition ApiIamBindingConditionPtrInput
	Members   pulumi.StringArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.ApiIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a ApiIamBinding resource.

func (ApiIamBindingArgs) ElementType 

func (ApiIamBindingArgs) ElementType() reflect.Type

type ApiIamBindingArray 

type ApiIamBindingArray []ApiIamBindingInput

func (ApiIamBindingArray) ElementType 

func (ApiIamBindingArray) ElementType() reflect.Type

func (ApiIamBindingArray) ToApiIamBindingArrayOutput 

func (i ApiIamBindingArray) ToApiIamBindingArrayOutput() ApiIamBindingArrayOutput

func (ApiIamBindingArray) ToApiIamBindingArrayOutputWithContext 

func (i ApiIamBindingArray) ToApiIamBindingArrayOutputWithContext(ctx context.Context) ApiIamBindingArrayOutput

type ApiIamBindingArrayInput 

type ApiIamBindingArrayInput interface {
	pulumi.Input

	ToApiIamBindingArrayOutput() ApiIamBindingArrayOutput
	ToApiIamBindingArrayOutputWithContext(context.Context) ApiIamBindingArrayOutput
}

ApiIamBindingArrayInput is an input type that accepts ApiIamBindingArray and ApiIamBindingArrayOutput values. You can construct a concrete instance of `ApiIamBindingArrayInput` via: 

ApiIamBindingArray{ ApiIamBindingArgs{...} }

type ApiIamBindingArrayOutput 

type ApiIamBindingArrayOutput struct{ *pulumi.OutputState }

func (ApiIamBindingArrayOutput) ElementType 

func (ApiIamBindingArrayOutput) ElementType() reflect.Type

func (ApiIamBindingArrayOutput) Index 

func (o ApiIamBindingArrayOutput) Index(i pulumi.IntInput) ApiIamBindingOutput

func (ApiIamBindingArrayOutput) ToApiIamBindingArrayOutput 

func (o ApiIamBindingArrayOutput) ToApiIamBindingArrayOutput() ApiIamBindingArrayOutput

func (ApiIamBindingArrayOutput) ToApiIamBindingArrayOutputWithContext 

func (o ApiIamBindingArrayOutput) ToApiIamBindingArrayOutputWithContext(ctx context.Context) ApiIamBindingArrayOutput

type ApiIamBindingCondition 

type ApiIamBindingCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type ApiIamBindingConditionArgs 

type ApiIamBindingConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (ApiIamBindingConditionArgs) ElementType 

func (ApiIamBindingConditionArgs) ElementType() reflect.Type

func (ApiIamBindingConditionArgs) ToApiIamBindingConditionOutput 

func (i ApiIamBindingConditionArgs) ToApiIamBindingConditionOutput() ApiIamBindingConditionOutput

func (ApiIamBindingConditionArgs) ToApiIamBindingConditionOutputWithContext 

func (i ApiIamBindingConditionArgs) ToApiIamBindingConditionOutputWithContext(ctx context.Context) ApiIamBindingConditionOutput

func (ApiIamBindingConditionArgs) ToApiIamBindingConditionPtrOutput 

func (i ApiIamBindingConditionArgs) ToApiIamBindingConditionPtrOutput() ApiIamBindingConditionPtrOutput

func (ApiIamBindingConditionArgs) ToApiIamBindingConditionPtrOutputWithContext 

func (i ApiIamBindingConditionArgs) ToApiIamBindingConditionPtrOutputWithContext(ctx context.Context) ApiIamBindingConditionPtrOutput

type ApiIamBindingConditionInput 

type ApiIamBindingConditionInput interface {
	pulumi.Input

	ToApiIamBindingConditionOutput() ApiIamBindingConditionOutput
	ToApiIamBindingConditionOutputWithContext(context.Context) ApiIamBindingConditionOutput
}

ApiIamBindingConditionInput is an input type that accepts ApiIamBindingConditionArgs and ApiIamBindingConditionOutput values. You can construct a concrete instance of `ApiIamBindingConditionInput` via: 

ApiIamBindingConditionArgs{...}

type ApiIamBindingConditionOutput 

type ApiIamBindingConditionOutput struct{ *pulumi.OutputState }

func (ApiIamBindingConditionOutput) Description 

func (o ApiIamBindingConditionOutput) Description() pulumi.StringPtrOutput

func (ApiIamBindingConditionOutput) ElementType 

func (ApiIamBindingConditionOutput) ElementType() reflect.Type

func (ApiIamBindingConditionOutput) Expression 

func (o ApiIamBindingConditionOutput) Expression() pulumi.StringOutput

func (ApiIamBindingConditionOutput) Title 

func (o ApiIamBindingConditionOutput) Title() pulumi.StringOutput

func (ApiIamBindingConditionOutput) ToApiIamBindingConditionOutput 

func (o ApiIamBindingConditionOutput) ToApiIamBindingConditionOutput() ApiIamBindingConditionOutput

func (ApiIamBindingConditionOutput) ToApiIamBindingConditionOutputWithContext 

func (o ApiIamBindingConditionOutput) ToApiIamBindingConditionOutputWithContext(ctx context.Context) ApiIamBindingConditionOutput

func (ApiIamBindingConditionOutput) ToApiIamBindingConditionPtrOutput 

func (o ApiIamBindingConditionOutput) ToApiIamBindingConditionPtrOutput() ApiIamBindingConditionPtrOutput

func (ApiIamBindingConditionOutput) ToApiIamBindingConditionPtrOutputWithContext 

func (o ApiIamBindingConditionOutput) ToApiIamBindingConditionPtrOutputWithContext(ctx context.Context) ApiIamBindingConditionPtrOutput

type ApiIamBindingConditionPtrInput 

type ApiIamBindingConditionPtrInput interface {
	pulumi.Input

	ToApiIamBindingConditionPtrOutput() ApiIamBindingConditionPtrOutput
	ToApiIamBindingConditionPtrOutputWithContext(context.Context) ApiIamBindingConditionPtrOutput
}

ApiIamBindingConditionPtrInput is an input type that accepts ApiIamBindingConditionArgs, ApiIamBindingConditionPtr and ApiIamBindingConditionPtrOutput values. You can construct a concrete instance of `ApiIamBindingConditionPtrInput` via: 

        ApiIamBindingConditionArgs{...}

or:

        nil

func ApiIamBindingConditionPtr 

func ApiIamBindingConditionPtr(v *ApiIamBindingConditionArgs) ApiIamBindingConditionPtrInput

type ApiIamBindingConditionPtrOutput 

type ApiIamBindingConditionPtrOutput struct{ *pulumi.OutputState }

func (ApiIamBindingConditionPtrOutput) Description 

func (o ApiIamBindingConditionPtrOutput) Description() pulumi.StringPtrOutput

func (ApiIamBindingConditionPtrOutput) Elem 

func (o ApiIamBindingConditionPtrOutput) Elem() ApiIamBindingConditionOutput

func (ApiIamBindingConditionPtrOutput) ElementType 

func (ApiIamBindingConditionPtrOutput) ElementType() reflect.Type

func (ApiIamBindingConditionPtrOutput) Expression 

func (o ApiIamBindingConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (ApiIamBindingConditionPtrOutput) Title 

func (o ApiIamBindingConditionPtrOutput) Title() pulumi.StringPtrOutput

func (ApiIamBindingConditionPtrOutput) ToApiIamBindingConditionPtrOutput 

func (o ApiIamBindingConditionPtrOutput) ToApiIamBindingConditionPtrOutput() ApiIamBindingConditionPtrOutput

func (ApiIamBindingConditionPtrOutput) ToApiIamBindingConditionPtrOutputWithContext 

func (o ApiIamBindingConditionPtrOutput) ToApiIamBindingConditionPtrOutputWithContext(ctx context.Context) ApiIamBindingConditionPtrOutput

type ApiIamBindingInput 

type ApiIamBindingInput interface {
	pulumi.Input

	ToApiIamBindingOutput() ApiIamBindingOutput
	ToApiIamBindingOutputWithContext(ctx context.Context) ApiIamBindingOutput
}

type ApiIamBindingMap 

type ApiIamBindingMap map[string]ApiIamBindingInput

func (ApiIamBindingMap) ElementType 

func (ApiIamBindingMap) ElementType() reflect.Type

func (ApiIamBindingMap) ToApiIamBindingMapOutput 

func (i ApiIamBindingMap) ToApiIamBindingMapOutput() ApiIamBindingMapOutput

func (ApiIamBindingMap) ToApiIamBindingMapOutputWithContext 

func (i ApiIamBindingMap) ToApiIamBindingMapOutputWithContext(ctx context.Context) ApiIamBindingMapOutput

type ApiIamBindingMapInput 

type ApiIamBindingMapInput interface {
	pulumi.Input

	ToApiIamBindingMapOutput() ApiIamBindingMapOutput
	ToApiIamBindingMapOutputWithContext(context.Context) ApiIamBindingMapOutput
}

ApiIamBindingMapInput is an input type that accepts ApiIamBindingMap and ApiIamBindingMapOutput values. You can construct a concrete instance of `ApiIamBindingMapInput` via: 

ApiIamBindingMap{ "key": ApiIamBindingArgs{...} }

type ApiIamBindingMapOutput 

type ApiIamBindingMapOutput struct{ *pulumi.OutputState }

func (ApiIamBindingMapOutput) ElementType 

func (ApiIamBindingMapOutput) ElementType() reflect.Type

func (ApiIamBindingMapOutput) MapIndex 

func (o ApiIamBindingMapOutput) MapIndex(k pulumi.StringInput) ApiIamBindingOutput

func (ApiIamBindingMapOutput) ToApiIamBindingMapOutput 

func (o ApiIamBindingMapOutput) ToApiIamBindingMapOutput() ApiIamBindingMapOutput

func (ApiIamBindingMapOutput) ToApiIamBindingMapOutputWithContext 

func (o ApiIamBindingMapOutput) ToApiIamBindingMapOutputWithContext(ctx context.Context) ApiIamBindingMapOutput

type ApiIamBindingOutput 

type ApiIamBindingOutput struct{ *pulumi.OutputState }

func (ApiIamBindingOutput) ElementType 

func (ApiIamBindingOutput) ElementType() reflect.Type

func (ApiIamBindingOutput) ToApiIamBindingOutput 

func (o ApiIamBindingOutput) ToApiIamBindingOutput() ApiIamBindingOutput

func (ApiIamBindingOutput) ToApiIamBindingOutputWithContext 

func (o ApiIamBindingOutput) ToApiIamBindingOutputWithContext(ctx context.Context) ApiIamBindingOutput

func (ApiIamBindingOutput) ToApiIamBindingPtrOutput 

func (o ApiIamBindingOutput) ToApiIamBindingPtrOutput() ApiIamBindingPtrOutput

func (ApiIamBindingOutput) ToApiIamBindingPtrOutputWithContext 

func (o ApiIamBindingOutput) ToApiIamBindingPtrOutputWithContext(ctx context.Context) ApiIamBindingPtrOutput

type ApiIamBindingPtrInput 

type ApiIamBindingPtrInput interface {
	pulumi.Input

	ToApiIamBindingPtrOutput() ApiIamBindingPtrOutput
	ToApiIamBindingPtrOutputWithContext(ctx context.Context) ApiIamBindingPtrOutput
}

type ApiIamBindingPtrOutput 

type ApiIamBindingPtrOutput struct{ *pulumi.OutputState }

func (ApiIamBindingPtrOutput) Elem added in v5.21.0 

func (o ApiIamBindingPtrOutput) Elem() ApiIamBindingOutput

func (ApiIamBindingPtrOutput) ElementType 

func (ApiIamBindingPtrOutput) ElementType() reflect.Type

func (ApiIamBindingPtrOutput) ToApiIamBindingPtrOutput 

func (o ApiIamBindingPtrOutput) ToApiIamBindingPtrOutput() ApiIamBindingPtrOutput

func (ApiIamBindingPtrOutput) ToApiIamBindingPtrOutputWithContext 

func (o ApiIamBindingPtrOutput) ToApiIamBindingPtrOutputWithContext(ctx context.Context) ApiIamBindingPtrOutput

type ApiIamBindingState 

type ApiIamBindingState struct {
	Api       pulumi.StringPtrInput
	Condition ApiIamBindingConditionPtrInput
	// (Computed) The etag of the IAM policy.
	Etag    pulumi.StringPtrInput
	Members pulumi.StringArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.ApiIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (ApiIamBindingState) ElementType 

func (ApiIamBindingState) ElementType() reflect.Type

type ApiIamMember 

type ApiIamMember struct {
	pulumi.CustomResourceState

	Api       pulumi.StringOutput            `pulumi:"api"`
	Condition ApiIamMemberConditionPtrOutput `pulumi:"condition"`
	// (Computed) The etag of the IAM policy.
	Etag   pulumi.StringOutput `pulumi:"etag"`
	Member pulumi.StringOutput `pulumi:"member"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The role that should be applied. Only one
	// `apigateway.ApiIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for API Gateway Api. Each of these resources serves a different use case:

* `apigateway.ApiIamPolicy`: Authoritative. Sets the IAM policy for the api and replaces any existing policy already attached. * `apigateway.ApiIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the api are preserved. * `apigateway.ApiIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the api are preserved.

> **Note:** `apigateway.ApiIamPolicy` **cannot** be used in conjunction with `apigateway.ApiIamBinding` and `apigateway.ApiIamMember` or they will fight over what your policy should be.

> **Note:** `apigateway.ApiIamBinding` resources **can be** used in conjunction with `apigateway.ApiIamMember` resources **only if** they do not grant privilege to the same role.

## google\_api\_gateway\_api\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/apigateway"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				organizations.GetIAMPolicyBinding{
					Role: "roles/apigateway.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = apigateway.NewApiIamPolicy(ctx, "policy", &apigateway.ApiIamPolicyArgs{
			Project:    pulumi.Any(google_api_gateway_api.Api.Project),
			Api:        pulumi.Any(google_api_gateway_api.Api.Api_id),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_iam\_binding

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiIamBinding(ctx, "binding", &apigateway.ApiIamBindingArgs{
			Project: pulumi.Any(google_api_gateway_api.Api.Project),
			Api:     pulumi.Any(google_api_gateway_api.Api.Api_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_iam\_member

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiIamMember(ctx, "member", &apigateway.ApiIamMemberArgs{
			Project: pulumi.Any(google_api_gateway_api.Api.Project),
			Api:     pulumi.Any(google_api_gateway_api.Api.Api_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Member:  pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms* projects/{{project}}/locations/global/apis/{{api}} * {{project}}/{{api}} * {{api}} Any variables not passed in the import command will be taken from the provider configuration. API Gateway api IAM resources can be imported using the resource identifiers, role, and member. IAM member imports use space-delimited identifiersthe resource in question, the role, and the member identity, e.g.

```sh 

$ pulumi import gcp:apigateway/apiIamMember:ApiIamMember editor "projects/{{project}}/locations/global/apis/{{api}} roles/apigateway.viewer user:jane@example.com"

``` 

IAM binding imports use space-delimited identifiersthe resource in question and the role, e.g.

```sh 

$ pulumi import gcp:apigateway/apiIamMember:ApiIamMember editor "projects/{{project}}/locations/global/apis/{{api}} roles/apigateway.viewer"

``` 

IAM policy imports use the identifier of the resource in question, e.g.

```sh 

$ pulumi import gcp:apigateway/apiIamMember:ApiIamMember editor projects/{{project}}/locations/global/apis/{{api}}

``` 

-> **Custom Roles**If you're importing a IAM resource with a custom role, make sure to use the

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetApiIamMember 

func GetApiIamMember(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApiIamMemberState, opts ...pulumi.ResourceOption) (*ApiIamMember, error)

GetApiIamMember gets an existing ApiIamMember resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewApiIamMember 

func NewApiIamMember(ctx *pulumi.Context,
	name string, args *ApiIamMemberArgs, opts ...pulumi.ResourceOption) (*ApiIamMember, error)

NewApiIamMember registers a new resource with the given unique name, arguments, and options.

func (*ApiIamMember) ElementType 

func (*ApiIamMember) ElementType() reflect.Type

func (*ApiIamMember) ToApiIamMemberOutput 

func (i *ApiIamMember) ToApiIamMemberOutput() ApiIamMemberOutput

func (*ApiIamMember) ToApiIamMemberOutputWithContext 

func (i *ApiIamMember) ToApiIamMemberOutputWithContext(ctx context.Context) ApiIamMemberOutput

func (*ApiIamMember) ToApiIamMemberPtrOutput 

func (i *ApiIamMember) ToApiIamMemberPtrOutput() ApiIamMemberPtrOutput

func (*ApiIamMember) ToApiIamMemberPtrOutputWithContext 

func (i *ApiIamMember) ToApiIamMemberPtrOutputWithContext(ctx context.Context) ApiIamMemberPtrOutput

type ApiIamMemberArgs 

type ApiIamMemberArgs struct {
	Api       pulumi.StringInput
	Condition ApiIamMemberConditionPtrInput
	Member    pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.ApiIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a ApiIamMember resource.

func (ApiIamMemberArgs) ElementType 

func (ApiIamMemberArgs) ElementType() reflect.Type

type ApiIamMemberArray 

type ApiIamMemberArray []ApiIamMemberInput

func (ApiIamMemberArray) ElementType 

func (ApiIamMemberArray) ElementType() reflect.Type

func (ApiIamMemberArray) ToApiIamMemberArrayOutput 

func (i ApiIamMemberArray) ToApiIamMemberArrayOutput() ApiIamMemberArrayOutput

func (ApiIamMemberArray) ToApiIamMemberArrayOutputWithContext 

func (i ApiIamMemberArray) ToApiIamMemberArrayOutputWithContext(ctx context.Context) ApiIamMemberArrayOutput

type ApiIamMemberArrayInput 

type ApiIamMemberArrayInput interface {
	pulumi.Input

	ToApiIamMemberArrayOutput() ApiIamMemberArrayOutput
	ToApiIamMemberArrayOutputWithContext(context.Context) ApiIamMemberArrayOutput
}

ApiIamMemberArrayInput is an input type that accepts ApiIamMemberArray and ApiIamMemberArrayOutput values. You can construct a concrete instance of `ApiIamMemberArrayInput` via: 

ApiIamMemberArray{ ApiIamMemberArgs{...} }

type ApiIamMemberArrayOutput 

type ApiIamMemberArrayOutput struct{ *pulumi.OutputState }

func (ApiIamMemberArrayOutput) ElementType 

func (ApiIamMemberArrayOutput) ElementType() reflect.Type

func (ApiIamMemberArrayOutput) Index 

func (o ApiIamMemberArrayOutput) Index(i pulumi.IntInput) ApiIamMemberOutput

func (ApiIamMemberArrayOutput) ToApiIamMemberArrayOutput 

func (o ApiIamMemberArrayOutput) ToApiIamMemberArrayOutput() ApiIamMemberArrayOutput

func (ApiIamMemberArrayOutput) ToApiIamMemberArrayOutputWithContext 

func (o ApiIamMemberArrayOutput) ToApiIamMemberArrayOutputWithContext(ctx context.Context) ApiIamMemberArrayOutput

type ApiIamMemberCondition 

type ApiIamMemberCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type ApiIamMemberConditionArgs 

type ApiIamMemberConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (ApiIamMemberConditionArgs) ElementType 

func (ApiIamMemberConditionArgs) ElementType() reflect.Type

func (ApiIamMemberConditionArgs) ToApiIamMemberConditionOutput 

func (i ApiIamMemberConditionArgs) ToApiIamMemberConditionOutput() ApiIamMemberConditionOutput

func (ApiIamMemberConditionArgs) ToApiIamMemberConditionOutputWithContext 

func (i ApiIamMemberConditionArgs) ToApiIamMemberConditionOutputWithContext(ctx context.Context) ApiIamMemberConditionOutput

func (ApiIamMemberConditionArgs) ToApiIamMemberConditionPtrOutput 

func (i ApiIamMemberConditionArgs) ToApiIamMemberConditionPtrOutput() ApiIamMemberConditionPtrOutput

func (ApiIamMemberConditionArgs) ToApiIamMemberConditionPtrOutputWithContext 

func (i ApiIamMemberConditionArgs) ToApiIamMemberConditionPtrOutputWithContext(ctx context.Context) ApiIamMemberConditionPtrOutput

type ApiIamMemberConditionInput 

type ApiIamMemberConditionInput interface {
	pulumi.Input

	ToApiIamMemberConditionOutput() ApiIamMemberConditionOutput
	ToApiIamMemberConditionOutputWithContext(context.Context) ApiIamMemberConditionOutput
}

ApiIamMemberConditionInput is an input type that accepts ApiIamMemberConditionArgs and ApiIamMemberConditionOutput values. You can construct a concrete instance of `ApiIamMemberConditionInput` via: 

ApiIamMemberConditionArgs{...}

type ApiIamMemberConditionOutput 

type ApiIamMemberConditionOutput struct{ *pulumi.OutputState }

func (ApiIamMemberConditionOutput) Description 

func (o ApiIamMemberConditionOutput) Description() pulumi.StringPtrOutput

func (ApiIamMemberConditionOutput) ElementType 

func (ApiIamMemberConditionOutput) ElementType() reflect.Type

func (ApiIamMemberConditionOutput) Expression 

func (o ApiIamMemberConditionOutput) Expression() pulumi.StringOutput

func (ApiIamMemberConditionOutput) Title 

func (o ApiIamMemberConditionOutput) Title() pulumi.StringOutput

func (ApiIamMemberConditionOutput) ToApiIamMemberConditionOutput 

func (o ApiIamMemberConditionOutput) ToApiIamMemberConditionOutput() ApiIamMemberConditionOutput

func (ApiIamMemberConditionOutput) ToApiIamMemberConditionOutputWithContext 

func (o ApiIamMemberConditionOutput) ToApiIamMemberConditionOutputWithContext(ctx context.Context) ApiIamMemberConditionOutput

func (ApiIamMemberConditionOutput) ToApiIamMemberConditionPtrOutput 

func (o ApiIamMemberConditionOutput) ToApiIamMemberConditionPtrOutput() ApiIamMemberConditionPtrOutput

func (ApiIamMemberConditionOutput) ToApiIamMemberConditionPtrOutputWithContext 

func (o ApiIamMemberConditionOutput) ToApiIamMemberConditionPtrOutputWithContext(ctx context.Context) ApiIamMemberConditionPtrOutput

type ApiIamMemberConditionPtrInput 

type ApiIamMemberConditionPtrInput interface {
	pulumi.Input

	ToApiIamMemberConditionPtrOutput() ApiIamMemberConditionPtrOutput
	ToApiIamMemberConditionPtrOutputWithContext(context.Context) ApiIamMemberConditionPtrOutput
}

ApiIamMemberConditionPtrInput is an input type that accepts ApiIamMemberConditionArgs, ApiIamMemberConditionPtr and ApiIamMemberConditionPtrOutput values. You can construct a concrete instance of `ApiIamMemberConditionPtrInput` via: 

        ApiIamMemberConditionArgs{...}

or:

        nil

func ApiIamMemberConditionPtr 

func ApiIamMemberConditionPtr(v *ApiIamMemberConditionArgs) ApiIamMemberConditionPtrInput

type ApiIamMemberConditionPtrOutput 

type ApiIamMemberConditionPtrOutput struct{ *pulumi.OutputState }

func (ApiIamMemberConditionPtrOutput) Description 

func (o ApiIamMemberConditionPtrOutput) Description() pulumi.StringPtrOutput

func (ApiIamMemberConditionPtrOutput) Elem 

func (o ApiIamMemberConditionPtrOutput) Elem() ApiIamMemberConditionOutput

func (ApiIamMemberConditionPtrOutput) ElementType 

func (ApiIamMemberConditionPtrOutput) ElementType() reflect.Type

func (ApiIamMemberConditionPtrOutput) Expression 

func (o ApiIamMemberConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (ApiIamMemberConditionPtrOutput) Title 

func (o ApiIamMemberConditionPtrOutput) Title() pulumi.StringPtrOutput

func (ApiIamMemberConditionPtrOutput) ToApiIamMemberConditionPtrOutput 

func (o ApiIamMemberConditionPtrOutput) ToApiIamMemberConditionPtrOutput() ApiIamMemberConditionPtrOutput

func (ApiIamMemberConditionPtrOutput) ToApiIamMemberConditionPtrOutputWithContext 

func (o ApiIamMemberConditionPtrOutput) ToApiIamMemberConditionPtrOutputWithContext(ctx context.Context) ApiIamMemberConditionPtrOutput

type ApiIamMemberInput 

type ApiIamMemberInput interface {
	pulumi.Input

	ToApiIamMemberOutput() ApiIamMemberOutput
	ToApiIamMemberOutputWithContext(ctx context.Context) ApiIamMemberOutput
}

type ApiIamMemberMap 

type ApiIamMemberMap map[string]ApiIamMemberInput

func (ApiIamMemberMap) ElementType 

func (ApiIamMemberMap) ElementType() reflect.Type

func (ApiIamMemberMap) ToApiIamMemberMapOutput 

func (i ApiIamMemberMap) ToApiIamMemberMapOutput() ApiIamMemberMapOutput

func (ApiIamMemberMap) ToApiIamMemberMapOutputWithContext 

func (i ApiIamMemberMap) ToApiIamMemberMapOutputWithContext(ctx context.Context) ApiIamMemberMapOutput

type ApiIamMemberMapInput 

type ApiIamMemberMapInput interface {
	pulumi.Input

	ToApiIamMemberMapOutput() ApiIamMemberMapOutput
	ToApiIamMemberMapOutputWithContext(context.Context) ApiIamMemberMapOutput
}

ApiIamMemberMapInput is an input type that accepts ApiIamMemberMap and ApiIamMemberMapOutput values. You can construct a concrete instance of `ApiIamMemberMapInput` via: 

ApiIamMemberMap{ "key": ApiIamMemberArgs{...} }

type ApiIamMemberMapOutput 

type ApiIamMemberMapOutput struct{ *pulumi.OutputState }

func (ApiIamMemberMapOutput) ElementType 

func (ApiIamMemberMapOutput) ElementType() reflect.Type

func (ApiIamMemberMapOutput) MapIndex 

func (o ApiIamMemberMapOutput) MapIndex(k pulumi.StringInput) ApiIamMemberOutput

func (ApiIamMemberMapOutput) ToApiIamMemberMapOutput 

func (o ApiIamMemberMapOutput) ToApiIamMemberMapOutput() ApiIamMemberMapOutput

func (ApiIamMemberMapOutput) ToApiIamMemberMapOutputWithContext 

func (o ApiIamMemberMapOutput) ToApiIamMemberMapOutputWithContext(ctx context.Context) ApiIamMemberMapOutput

type ApiIamMemberOutput 

type ApiIamMemberOutput struct{ *pulumi.OutputState }

func (ApiIamMemberOutput) ElementType 

func (ApiIamMemberOutput) ElementType() reflect.Type

func (ApiIamMemberOutput) ToApiIamMemberOutput 

func (o ApiIamMemberOutput) ToApiIamMemberOutput() ApiIamMemberOutput

func (ApiIamMemberOutput) ToApiIamMemberOutputWithContext 

func (o ApiIamMemberOutput) ToApiIamMemberOutputWithContext(ctx context.Context) ApiIamMemberOutput

func (ApiIamMemberOutput) ToApiIamMemberPtrOutput 

func (o ApiIamMemberOutput) ToApiIamMemberPtrOutput() ApiIamMemberPtrOutput

func (ApiIamMemberOutput) ToApiIamMemberPtrOutputWithContext 

func (o ApiIamMemberOutput) ToApiIamMemberPtrOutputWithContext(ctx context.Context) ApiIamMemberPtrOutput

type ApiIamMemberPtrInput 

type ApiIamMemberPtrInput interface {
	pulumi.Input

	ToApiIamMemberPtrOutput() ApiIamMemberPtrOutput
	ToApiIamMemberPtrOutputWithContext(ctx context.Context) ApiIamMemberPtrOutput
}

type ApiIamMemberPtrOutput 

type ApiIamMemberPtrOutput struct{ *pulumi.OutputState }

func (ApiIamMemberPtrOutput) Elem added in v5.21.0 

func (o ApiIamMemberPtrOutput) Elem() ApiIamMemberOutput

func (ApiIamMemberPtrOutput) ElementType 

func (ApiIamMemberPtrOutput) ElementType() reflect.Type

func (ApiIamMemberPtrOutput) ToApiIamMemberPtrOutput 

func (o ApiIamMemberPtrOutput) ToApiIamMemberPtrOutput() ApiIamMemberPtrOutput

func (ApiIamMemberPtrOutput) ToApiIamMemberPtrOutputWithContext 

func (o ApiIamMemberPtrOutput) ToApiIamMemberPtrOutputWithContext(ctx context.Context) ApiIamMemberPtrOutput

type ApiIamMemberState 

type ApiIamMemberState struct {
	Api       pulumi.StringPtrInput
	Condition ApiIamMemberConditionPtrInput
	// (Computed) The etag of the IAM policy.
	Etag   pulumi.StringPtrInput
	Member pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.ApiIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (ApiIamMemberState) ElementType 

func (ApiIamMemberState) ElementType() reflect.Type

type ApiIamPolicy 

type ApiIamPolicy struct {
	pulumi.CustomResourceState

	Api pulumi.StringOutput `pulumi:"api"`
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringOutput `pulumi:"policyData"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
}

Three different resources help you manage your IAM policy for API Gateway Api. Each of these resources serves a different use case:

* `apigateway.ApiIamPolicy`: Authoritative. Sets the IAM policy for the api and replaces any existing policy already attached. * `apigateway.ApiIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the api are preserved. * `apigateway.ApiIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the api are preserved.

> **Note:** `apigateway.ApiIamPolicy` **cannot** be used in conjunction with `apigateway.ApiIamBinding` and `apigateway.ApiIamMember` or they will fight over what your policy should be.

> **Note:** `apigateway.ApiIamBinding` resources **can be** used in conjunction with `apigateway.ApiIamMember` resources **only if** they do not grant privilege to the same role.

## google\_api\_gateway\_api\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/apigateway"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				organizations.GetIAMPolicyBinding{
					Role: "roles/apigateway.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = apigateway.NewApiIamPolicy(ctx, "policy", &apigateway.ApiIamPolicyArgs{
			Project:    pulumi.Any(google_api_gateway_api.Api.Project),
			Api:        pulumi.Any(google_api_gateway_api.Api.Api_id),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_iam\_binding

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiIamBinding(ctx, "binding", &apigateway.ApiIamBindingArgs{
			Project: pulumi.Any(google_api_gateway_api.Api.Project),
			Api:     pulumi.Any(google_api_gateway_api.Api.Api_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_api\_iam\_member

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewApiIamMember(ctx, "member", &apigateway.ApiIamMemberArgs{
			Project: pulumi.Any(google_api_gateway_api.Api.Project),
			Api:     pulumi.Any(google_api_gateway_api.Api.Api_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Member:  pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms* projects/{{project}}/locations/global/apis/{{api}} * {{project}}/{{api}} * {{api}} Any variables not passed in the import command will be taken from the provider configuration. API Gateway api IAM resources can be imported using the resource identifiers, role, and member. IAM member imports use space-delimited identifiersthe resource in question, the role, and the member identity, e.g.

```sh 

$ pulumi import gcp:apigateway/apiIamPolicy:ApiIamPolicy editor "projects/{{project}}/locations/global/apis/{{api}} roles/apigateway.viewer user:jane@example.com"

``` 

IAM binding imports use space-delimited identifiersthe resource in question and the role, e.g.

```sh 

$ pulumi import gcp:apigateway/apiIamPolicy:ApiIamPolicy editor "projects/{{project}}/locations/global/apis/{{api}} roles/apigateway.viewer"

``` 

IAM policy imports use the identifier of the resource in question, e.g.

```sh 

$ pulumi import gcp:apigateway/apiIamPolicy:ApiIamPolicy editor projects/{{project}}/locations/global/apis/{{api}}

``` 

-> **Custom Roles**If you're importing a IAM resource with a custom role, make sure to use the

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetApiIamPolicy 

func GetApiIamPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApiIamPolicyState, opts ...pulumi.ResourceOption) (*ApiIamPolicy, error)

GetApiIamPolicy gets an existing ApiIamPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewApiIamPolicy 

func NewApiIamPolicy(ctx *pulumi.Context,
	name string, args *ApiIamPolicyArgs, opts ...pulumi.ResourceOption) (*ApiIamPolicy, error)

NewApiIamPolicy registers a new resource with the given unique name, arguments, and options.

func (*ApiIamPolicy) ElementType 

func (*ApiIamPolicy) ElementType() reflect.Type

func (*ApiIamPolicy) ToApiIamPolicyOutput 

func (i *ApiIamPolicy) ToApiIamPolicyOutput() ApiIamPolicyOutput

func (*ApiIamPolicy) ToApiIamPolicyOutputWithContext 

func (i *ApiIamPolicy) ToApiIamPolicyOutputWithContext(ctx context.Context) ApiIamPolicyOutput

func (*ApiIamPolicy) ToApiIamPolicyPtrOutput 

func (i *ApiIamPolicy) ToApiIamPolicyPtrOutput() ApiIamPolicyPtrOutput

func (*ApiIamPolicy) ToApiIamPolicyPtrOutputWithContext 

func (i *ApiIamPolicy) ToApiIamPolicyPtrOutputWithContext(ctx context.Context) ApiIamPolicyPtrOutput

type ApiIamPolicyArgs 

type ApiIamPolicyArgs struct {
	Api pulumi.StringInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a ApiIamPolicy resource.

func (ApiIamPolicyArgs) ElementType 

func (ApiIamPolicyArgs) ElementType() reflect.Type

type ApiIamPolicyArray 

type ApiIamPolicyArray []ApiIamPolicyInput

func (ApiIamPolicyArray) ElementType 

func (ApiIamPolicyArray) ElementType() reflect.Type

func (ApiIamPolicyArray) ToApiIamPolicyArrayOutput 

func (i ApiIamPolicyArray) ToApiIamPolicyArrayOutput() ApiIamPolicyArrayOutput

func (ApiIamPolicyArray) ToApiIamPolicyArrayOutputWithContext 

func (i ApiIamPolicyArray) ToApiIamPolicyArrayOutputWithContext(ctx context.Context) ApiIamPolicyArrayOutput

type ApiIamPolicyArrayInput 

type ApiIamPolicyArrayInput interface {
	pulumi.Input

	ToApiIamPolicyArrayOutput() ApiIamPolicyArrayOutput
	ToApiIamPolicyArrayOutputWithContext(context.Context) ApiIamPolicyArrayOutput
}

ApiIamPolicyArrayInput is an input type that accepts ApiIamPolicyArray and ApiIamPolicyArrayOutput values. You can construct a concrete instance of `ApiIamPolicyArrayInput` via: 

ApiIamPolicyArray{ ApiIamPolicyArgs{...} }

type ApiIamPolicyArrayOutput 

type ApiIamPolicyArrayOutput struct{ *pulumi.OutputState }

func (ApiIamPolicyArrayOutput) ElementType 

func (ApiIamPolicyArrayOutput) ElementType() reflect.Type

func (ApiIamPolicyArrayOutput) Index 

func (o ApiIamPolicyArrayOutput) Index(i pulumi.IntInput) ApiIamPolicyOutput

func (ApiIamPolicyArrayOutput) ToApiIamPolicyArrayOutput 

func (o ApiIamPolicyArrayOutput) ToApiIamPolicyArrayOutput() ApiIamPolicyArrayOutput

func (ApiIamPolicyArrayOutput) ToApiIamPolicyArrayOutputWithContext 

func (o ApiIamPolicyArrayOutput) ToApiIamPolicyArrayOutputWithContext(ctx context.Context) ApiIamPolicyArrayOutput

type ApiIamPolicyInput 

type ApiIamPolicyInput interface {
	pulumi.Input

	ToApiIamPolicyOutput() ApiIamPolicyOutput
	ToApiIamPolicyOutputWithContext(ctx context.Context) ApiIamPolicyOutput
}

type ApiIamPolicyMap 

type ApiIamPolicyMap map[string]ApiIamPolicyInput

func (ApiIamPolicyMap) ElementType 

func (ApiIamPolicyMap) ElementType() reflect.Type

func (ApiIamPolicyMap) ToApiIamPolicyMapOutput 

func (i ApiIamPolicyMap) ToApiIamPolicyMapOutput() ApiIamPolicyMapOutput

func (ApiIamPolicyMap) ToApiIamPolicyMapOutputWithContext 

func (i ApiIamPolicyMap) ToApiIamPolicyMapOutputWithContext(ctx context.Context) ApiIamPolicyMapOutput

type ApiIamPolicyMapInput 

type ApiIamPolicyMapInput interface {
	pulumi.Input

	ToApiIamPolicyMapOutput() ApiIamPolicyMapOutput
	ToApiIamPolicyMapOutputWithContext(context.Context) ApiIamPolicyMapOutput
}

ApiIamPolicyMapInput is an input type that accepts ApiIamPolicyMap and ApiIamPolicyMapOutput values. You can construct a concrete instance of `ApiIamPolicyMapInput` via: 

ApiIamPolicyMap{ "key": ApiIamPolicyArgs{...} }

type ApiIamPolicyMapOutput 

type ApiIamPolicyMapOutput struct{ *pulumi.OutputState }

func (ApiIamPolicyMapOutput) ElementType 

func (ApiIamPolicyMapOutput) ElementType() reflect.Type

func (ApiIamPolicyMapOutput) MapIndex 

func (o ApiIamPolicyMapOutput) MapIndex(k pulumi.StringInput) ApiIamPolicyOutput

func (ApiIamPolicyMapOutput) ToApiIamPolicyMapOutput 

func (o ApiIamPolicyMapOutput) ToApiIamPolicyMapOutput() ApiIamPolicyMapOutput

func (ApiIamPolicyMapOutput) ToApiIamPolicyMapOutputWithContext 

func (o ApiIamPolicyMapOutput) ToApiIamPolicyMapOutputWithContext(ctx context.Context) ApiIamPolicyMapOutput

type ApiIamPolicyOutput 

type ApiIamPolicyOutput struct{ *pulumi.OutputState }

func (ApiIamPolicyOutput) ElementType 

func (ApiIamPolicyOutput) ElementType() reflect.Type

func (ApiIamPolicyOutput) ToApiIamPolicyOutput 

func (o ApiIamPolicyOutput) ToApiIamPolicyOutput() ApiIamPolicyOutput

func (ApiIamPolicyOutput) ToApiIamPolicyOutputWithContext 

func (o ApiIamPolicyOutput) ToApiIamPolicyOutputWithContext(ctx context.Context) ApiIamPolicyOutput

func (ApiIamPolicyOutput) ToApiIamPolicyPtrOutput 

func (o ApiIamPolicyOutput) ToApiIamPolicyPtrOutput() ApiIamPolicyPtrOutput

func (ApiIamPolicyOutput) ToApiIamPolicyPtrOutputWithContext 

func (o ApiIamPolicyOutput) ToApiIamPolicyPtrOutputWithContext(ctx context.Context) ApiIamPolicyPtrOutput

type ApiIamPolicyPtrInput 

type ApiIamPolicyPtrInput interface {
	pulumi.Input

	ToApiIamPolicyPtrOutput() ApiIamPolicyPtrOutput
	ToApiIamPolicyPtrOutputWithContext(ctx context.Context) ApiIamPolicyPtrOutput
}

type ApiIamPolicyPtrOutput 

type ApiIamPolicyPtrOutput struct{ *pulumi.OutputState }

func (ApiIamPolicyPtrOutput) Elem added in v5.21.0 

func (o ApiIamPolicyPtrOutput) Elem() ApiIamPolicyOutput

func (ApiIamPolicyPtrOutput) ElementType 

func (ApiIamPolicyPtrOutput) ElementType() reflect.Type

func (ApiIamPolicyPtrOutput) ToApiIamPolicyPtrOutput 

func (o ApiIamPolicyPtrOutput) ToApiIamPolicyPtrOutput() ApiIamPolicyPtrOutput

func (ApiIamPolicyPtrOutput) ToApiIamPolicyPtrOutputWithContext 

func (o ApiIamPolicyPtrOutput) ToApiIamPolicyPtrOutputWithContext(ctx context.Context) ApiIamPolicyPtrOutput

type ApiIamPolicyState 

type ApiIamPolicyState struct {
	Api pulumi.StringPtrInput
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
}

func (ApiIamPolicyState) ElementType 

func (ApiIamPolicyState) ElementType() reflect.Type

type ApiInput 

type ApiInput interface {
	pulumi.Input

	ToApiOutput() ApiOutput
	ToApiOutputWithContext(ctx context.Context) ApiOutput
}

type ApiMap 

type ApiMap map[string]ApiInput

func (ApiMap) ElementType 

func (ApiMap) ElementType() reflect.Type

func (ApiMap) ToApiMapOutput 

func (i ApiMap) ToApiMapOutput() ApiMapOutput

func (ApiMap) ToApiMapOutputWithContext 

func (i ApiMap) ToApiMapOutputWithContext(ctx context.Context) ApiMapOutput

type ApiMapInput 

type ApiMapInput interface {
	pulumi.Input

	ToApiMapOutput() ApiMapOutput
	ToApiMapOutputWithContext(context.Context) ApiMapOutput
}

ApiMapInput is an input type that accepts ApiMap and ApiMapOutput values. You can construct a concrete instance of `ApiMapInput` via: 

ApiMap{ "key": ApiArgs{...} }

type ApiMapOutput 

type ApiMapOutput struct{ *pulumi.OutputState }

func (ApiMapOutput) ElementType 

func (ApiMapOutput) ElementType() reflect.Type

func (ApiMapOutput) MapIndex 

func (o ApiMapOutput) MapIndex(k pulumi.StringInput) ApiOutput

func (ApiMapOutput) ToApiMapOutput 

func (o ApiMapOutput) ToApiMapOutput() ApiMapOutput

func (ApiMapOutput) ToApiMapOutputWithContext 

func (o ApiMapOutput) ToApiMapOutputWithContext(ctx context.Context) ApiMapOutput

type ApiOutput 

type ApiOutput struct{ *pulumi.OutputState }

func (ApiOutput) ElementType 

func (ApiOutput) ElementType() reflect.Type

func (ApiOutput) ToApiOutput 

func (o ApiOutput) ToApiOutput() ApiOutput

func (ApiOutput) ToApiOutputWithContext 

func (o ApiOutput) ToApiOutputWithContext(ctx context.Context) ApiOutput

func (ApiOutput) ToApiPtrOutput 

func (o ApiOutput) ToApiPtrOutput() ApiPtrOutput

func (ApiOutput) ToApiPtrOutputWithContext 

func (o ApiOutput) ToApiPtrOutputWithContext(ctx context.Context) ApiPtrOutput

type ApiPtrInput 

type ApiPtrInput interface {
	pulumi.Input

	ToApiPtrOutput() ApiPtrOutput
	ToApiPtrOutputWithContext(ctx context.Context) ApiPtrOutput
}

type ApiPtrOutput 

type ApiPtrOutput struct{ *pulumi.OutputState }

func (ApiPtrOutput) Elem added in v5.21.0 

func (o ApiPtrOutput) Elem() ApiOutput

func (ApiPtrOutput) ElementType 

func (ApiPtrOutput) ElementType() reflect.Type

func (ApiPtrOutput) ToApiPtrOutput 

func (o ApiPtrOutput) ToApiPtrOutput() ApiPtrOutput

func (ApiPtrOutput) ToApiPtrOutputWithContext 

func (o ApiPtrOutput) ToApiPtrOutputWithContext(ctx context.Context) ApiPtrOutput

type ApiState 

type ApiState struct {
	// Identifier to assign to the API. Must be unique within scope of the parent resource(project)
	ApiId pulumi.StringPtrInput
	// Creation timestamp in RFC3339 text format.
	CreateTime pulumi.StringPtrInput
	// A user-visible name for the API.
	DisplayName pulumi.StringPtrInput
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapInput
	// Immutable. The name of a Google Managed Service ( https://cloud.google.com/service-infrastructure/docs/glossary#managed).
	// If not specified, a new Service will automatically be created in the same project as this API.
	ManagedService pulumi.StringPtrInput
	// The resource name of the API. Format 'projects/{{project}}/locations/global/apis/{{apiId}}'
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

func (ApiState) ElementType 

func (ApiState) ElementType() reflect.Type

type Gateway 

type Gateway struct {
	pulumi.CustomResourceState

	// Resource name of the API Config for this Gateway. Format: projects/{project}/locations/global/apis/{api}/configs/{apiConfig}.
	// When changing api configs please ensure the new config is a new resource and the lifecycle rule `createBeforeDestroy` is set.
	ApiConfig pulumi.StringOutput `pulumi:"apiConfig"`
	// The default API Gateway host name of the form {gatewayId}-{hash}.{region_code}.gateway.dev.
	DefaultHostname pulumi.StringOutput `pulumi:"defaultHostname"`
	// A user-visible name for the API.
	DisplayName pulumi.StringOutput `pulumi:"displayName"`
	// Identifier to assign to the Gateway. Must be unique within scope of the parent resource(project).
	GatewayId pulumi.StringOutput `pulumi:"gatewayId"`
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Resource name of the Gateway. Format: projects/{project}/locations/{region}/gateways/{gateway}
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The region of the gateway for the API.
	Region pulumi.StringOutput `pulumi:"region"`
}

A consumable API that can be used by multiple Gateways.

To get more information about Gateway, see:

* [API documentation](https://cloud.google.com/api-gateway/docs/reference/rest/v1beta/projects.locations.apis) * How-to Guides

## Example Usage ### Apigateway Gateway Basic

```go package main

import ( 

"encoding/base64"
"io/ioutil"

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

) 

func filebase64OrPanic(path string) pulumi.StringPtrInput {
	if fileData, err := ioutil.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
	})
}

```

## Import

Gateway can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:apigateway/gateway:Gateway default projects/{{project}}/locations/{{region}}/gateways/{{gateway_id}}

```

```sh 

$ pulumi import gcp:apigateway/gateway:Gateway default {{project}}/{{region}}/{{gateway_id}}

```

```sh 

$ pulumi import gcp:apigateway/gateway:Gateway default {{region}}/{{gateway_id}}

```

```sh 

$ pulumi import gcp:apigateway/gateway:Gateway default {{gateway_id}}

```

func GetGateway 

func GetGateway(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GatewayState, opts ...pulumi.ResourceOption) (*Gateway, error)

GetGateway gets an existing Gateway resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGateway 

func NewGateway(ctx *pulumi.Context,
	name string, args *GatewayArgs, opts ...pulumi.ResourceOption) (*Gateway, error)

NewGateway registers a new resource with the given unique name, arguments, and options.

func (*Gateway) ElementType 

func (*Gateway) ElementType() reflect.Type

func (*Gateway) ToGatewayOutput 

func (i *Gateway) ToGatewayOutput() GatewayOutput

func (*Gateway) ToGatewayOutputWithContext 

func (i *Gateway) ToGatewayOutputWithContext(ctx context.Context) GatewayOutput

func (*Gateway) ToGatewayPtrOutput 

func (i *Gateway) ToGatewayPtrOutput() GatewayPtrOutput

func (*Gateway) ToGatewayPtrOutputWithContext 

func (i *Gateway) ToGatewayPtrOutputWithContext(ctx context.Context) GatewayPtrOutput

type GatewayArgs 

type GatewayArgs struct {
	// Resource name of the API Config for this Gateway. Format: projects/{project}/locations/global/apis/{api}/configs/{apiConfig}.
	// When changing api configs please ensure the new config is a new resource and the lifecycle rule `createBeforeDestroy` is set.
	ApiConfig pulumi.StringInput
	// A user-visible name for the API.
	DisplayName pulumi.StringPtrInput
	// Identifier to assign to the Gateway. Must be unique within scope of the parent resource(project).
	GatewayId pulumi.StringInput
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// The region of the gateway for the API.
	Region pulumi.StringPtrInput
}

The set of arguments for constructing a Gateway resource.

func (GatewayArgs) ElementType 

func (GatewayArgs) ElementType() reflect.Type

type GatewayArray 

type GatewayArray []GatewayInput

func (GatewayArray) ElementType 

func (GatewayArray) ElementType() reflect.Type

func (GatewayArray) ToGatewayArrayOutput 

func (i GatewayArray) ToGatewayArrayOutput() GatewayArrayOutput

func (GatewayArray) ToGatewayArrayOutputWithContext 

func (i GatewayArray) ToGatewayArrayOutputWithContext(ctx context.Context) GatewayArrayOutput

type GatewayArrayInput 

type GatewayArrayInput interface {
	pulumi.Input

	ToGatewayArrayOutput() GatewayArrayOutput
	ToGatewayArrayOutputWithContext(context.Context) GatewayArrayOutput
}

GatewayArrayInput is an input type that accepts GatewayArray and GatewayArrayOutput values. You can construct a concrete instance of `GatewayArrayInput` via: 

GatewayArray{ GatewayArgs{...} }

type GatewayArrayOutput 

type GatewayArrayOutput struct{ *pulumi.OutputState }

func (GatewayArrayOutput) ElementType 

func (GatewayArrayOutput) ElementType() reflect.Type

func (GatewayArrayOutput) Index 

func (o GatewayArrayOutput) Index(i pulumi.IntInput) GatewayOutput

func (GatewayArrayOutput) ToGatewayArrayOutput 

func (o GatewayArrayOutput) ToGatewayArrayOutput() GatewayArrayOutput

func (GatewayArrayOutput) ToGatewayArrayOutputWithContext 

func (o GatewayArrayOutput) ToGatewayArrayOutputWithContext(ctx context.Context) GatewayArrayOutput

type GatewayIamBinding 

type GatewayIamBinding struct {
	pulumi.CustomResourceState

	Condition GatewayIamBindingConditionPtrOutput `pulumi:"condition"`
	// (Computed) The etag of the IAM policy.
	Etag    pulumi.StringOutput      `pulumi:"etag"`
	Gateway pulumi.StringOutput      `pulumi:"gateway"`
	Members pulumi.StringArrayOutput `pulumi:"members"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The region of the gateway for the API.
	// Used to find the parent resource to bind the IAM policy to. If not specified,
	// the value will be parsed from the identifier of the parent resource. If no region is provided in the parent identifier and no
	// region is specified, it is taken from the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// The role that should be applied. Only one
	// `apigateway.GatewayIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for API Gateway Gateway. Each of these resources serves a different use case:

* `apigateway.GatewayIamPolicy`: Authoritative. Sets the IAM policy for the gateway and replaces any existing policy already attached. * `apigateway.GatewayIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the gateway are preserved. * `apigateway.GatewayIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the gateway are preserved.

> **Note:** `apigateway.GatewayIamPolicy` **cannot** be used in conjunction with `apigateway.GatewayIamBinding` and `apigateway.GatewayIamMember` or they will fight over what your policy should be.

> **Note:** `apigateway.GatewayIamBinding` resources **can be** used in conjunction with `apigateway.GatewayIamMember` resources **only if** they do not grant privilege to the same role.

## google\_api\_gateway\_gateway\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/apigateway"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				organizations.GetIAMPolicyBinding{
					Role: "roles/apigateway.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = apigateway.NewGatewayIamPolicy(ctx, "policy", &apigateway.GatewayIamPolicyArgs{
			Project:    pulumi.Any(google_api_gateway_gateway.Api_gw.Project),
			Region:     pulumi.Any(google_api_gateway_gateway.Api_gw.Region),
			Gateway:    pulumi.Any(google_api_gateway_gateway.Api_gw.Gateway_id),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_gateway\_iam\_binding

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewGatewayIamBinding(ctx, "binding", &apigateway.GatewayIamBindingArgs{
			Project: pulumi.Any(google_api_gateway_gateway.Api_gw.Project),
			Region:  pulumi.Any(google_api_gateway_gateway.Api_gw.Region),
			Gateway: pulumi.Any(google_api_gateway_gateway.Api_gw.Gateway_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_gateway\_iam\_member

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewGatewayIamMember(ctx, "member", &apigateway.GatewayIamMemberArgs{
			Project: pulumi.Any(google_api_gateway_gateway.Api_gw.Project),
			Region:  pulumi.Any(google_api_gateway_gateway.Api_gw.Region),
			Gateway: pulumi.Any(google_api_gateway_gateway.Api_gw.Gateway_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Member:  pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms* projects/{{project}}/locations/{{region}}/gateways/{{gateway}} * {{project}}/{{region}}/{{gateway}} * {{region}}/{{gateway}} * {{gateway}} Any variables not passed in the import command will be taken from the provider configuration. API Gateway gateway IAM resources can be imported using the resource identifiers, role, and member. IAM member imports use space-delimited identifiersthe resource in question, the role, and the member identity, e.g.

```sh 

$ pulumi import gcp:apigateway/gatewayIamBinding:GatewayIamBinding editor "projects/{{project}}/locations/{{region}}/gateways/{{gateway}} roles/apigateway.viewer user:jane@example.com"

``` 

IAM binding imports use space-delimited identifiersthe resource in question and the role, e.g.

```sh 

$ pulumi import gcp:apigateway/gatewayIamBinding:GatewayIamBinding editor "projects/{{project}}/locations/{{region}}/gateways/{{gateway}} roles/apigateway.viewer"

``` 

IAM policy imports use the identifier of the resource in question, e.g.

```sh 

$ pulumi import gcp:apigateway/gatewayIamBinding:GatewayIamBinding editor projects/{{project}}/locations/{{region}}/gateways/{{gateway}}

``` 

-> **Custom Roles**If you're importing a IAM resource with a custom role, make sure to use the

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetGatewayIamBinding 

func GetGatewayIamBinding(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GatewayIamBindingState, opts ...pulumi.ResourceOption) (*GatewayIamBinding, error)

GetGatewayIamBinding gets an existing GatewayIamBinding resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGatewayIamBinding 

func NewGatewayIamBinding(ctx *pulumi.Context,
	name string, args *GatewayIamBindingArgs, opts ...pulumi.ResourceOption) (*GatewayIamBinding, error)

NewGatewayIamBinding registers a new resource with the given unique name, arguments, and options.

func (*GatewayIamBinding) ElementType 

func (*GatewayIamBinding) ElementType() reflect.Type

func (*GatewayIamBinding) ToGatewayIamBindingOutput 

func (i *GatewayIamBinding) ToGatewayIamBindingOutput() GatewayIamBindingOutput

func (*GatewayIamBinding) ToGatewayIamBindingOutputWithContext 

func (i *GatewayIamBinding) ToGatewayIamBindingOutputWithContext(ctx context.Context) GatewayIamBindingOutput

func (*GatewayIamBinding) ToGatewayIamBindingPtrOutput 

func (i *GatewayIamBinding) ToGatewayIamBindingPtrOutput() GatewayIamBindingPtrOutput

func (*GatewayIamBinding) ToGatewayIamBindingPtrOutputWithContext 

func (i *GatewayIamBinding) ToGatewayIamBindingPtrOutputWithContext(ctx context.Context) GatewayIamBindingPtrOutput

type GatewayIamBindingArgs 

type GatewayIamBindingArgs struct {
	Condition GatewayIamBindingConditionPtrInput
	Gateway   pulumi.StringInput
	Members   pulumi.StringArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The region of the gateway for the API.
	// Used to find the parent resource to bind the IAM policy to. If not specified,
	// the value will be parsed from the identifier of the parent resource. If no region is provided in the parent identifier and no
	// region is specified, it is taken from the provider configuration.
	Region pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.GatewayIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a GatewayIamBinding resource.

func (GatewayIamBindingArgs) ElementType 

func (GatewayIamBindingArgs) ElementType() reflect.Type

type GatewayIamBindingArray 

type GatewayIamBindingArray []GatewayIamBindingInput

func (GatewayIamBindingArray) ElementType 

func (GatewayIamBindingArray) ElementType() reflect.Type

func (GatewayIamBindingArray) ToGatewayIamBindingArrayOutput 

func (i GatewayIamBindingArray) ToGatewayIamBindingArrayOutput() GatewayIamBindingArrayOutput

func (GatewayIamBindingArray) ToGatewayIamBindingArrayOutputWithContext 

func (i GatewayIamBindingArray) ToGatewayIamBindingArrayOutputWithContext(ctx context.Context) GatewayIamBindingArrayOutput

type GatewayIamBindingArrayInput 

type GatewayIamBindingArrayInput interface {
	pulumi.Input

	ToGatewayIamBindingArrayOutput() GatewayIamBindingArrayOutput
	ToGatewayIamBindingArrayOutputWithContext(context.Context) GatewayIamBindingArrayOutput
}

GatewayIamBindingArrayInput is an input type that accepts GatewayIamBindingArray and GatewayIamBindingArrayOutput values. You can construct a concrete instance of `GatewayIamBindingArrayInput` via: 

GatewayIamBindingArray{ GatewayIamBindingArgs{...} }

type GatewayIamBindingArrayOutput 

type GatewayIamBindingArrayOutput struct{ *pulumi.OutputState }

func (GatewayIamBindingArrayOutput) ElementType 

func (GatewayIamBindingArrayOutput) ElementType() reflect.Type

func (GatewayIamBindingArrayOutput) Index 

func (o GatewayIamBindingArrayOutput) Index(i pulumi.IntInput) GatewayIamBindingOutput

func (GatewayIamBindingArrayOutput) ToGatewayIamBindingArrayOutput 

func (o GatewayIamBindingArrayOutput) ToGatewayIamBindingArrayOutput() GatewayIamBindingArrayOutput

func (GatewayIamBindingArrayOutput) ToGatewayIamBindingArrayOutputWithContext 

func (o GatewayIamBindingArrayOutput) ToGatewayIamBindingArrayOutputWithContext(ctx context.Context) GatewayIamBindingArrayOutput

type GatewayIamBindingCondition 

type GatewayIamBindingCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type GatewayIamBindingConditionArgs 

type GatewayIamBindingConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (GatewayIamBindingConditionArgs) ElementType 

func (GatewayIamBindingConditionArgs) ElementType() reflect.Type

func (GatewayIamBindingConditionArgs) ToGatewayIamBindingConditionOutput 

func (i GatewayIamBindingConditionArgs) ToGatewayIamBindingConditionOutput() GatewayIamBindingConditionOutput

func (GatewayIamBindingConditionArgs) ToGatewayIamBindingConditionOutputWithContext 

func (i GatewayIamBindingConditionArgs) ToGatewayIamBindingConditionOutputWithContext(ctx context.Context) GatewayIamBindingConditionOutput

func (GatewayIamBindingConditionArgs) ToGatewayIamBindingConditionPtrOutput 

func (i GatewayIamBindingConditionArgs) ToGatewayIamBindingConditionPtrOutput() GatewayIamBindingConditionPtrOutput

func (GatewayIamBindingConditionArgs) ToGatewayIamBindingConditionPtrOutputWithContext 

func (i GatewayIamBindingConditionArgs) ToGatewayIamBindingConditionPtrOutputWithContext(ctx context.Context) GatewayIamBindingConditionPtrOutput

type GatewayIamBindingConditionInput 

type GatewayIamBindingConditionInput interface {
	pulumi.Input

	ToGatewayIamBindingConditionOutput() GatewayIamBindingConditionOutput
	ToGatewayIamBindingConditionOutputWithContext(context.Context) GatewayIamBindingConditionOutput
}

GatewayIamBindingConditionInput is an input type that accepts GatewayIamBindingConditionArgs and GatewayIamBindingConditionOutput values. You can construct a concrete instance of `GatewayIamBindingConditionInput` via: 

GatewayIamBindingConditionArgs{...}

type GatewayIamBindingConditionOutput 

type GatewayIamBindingConditionOutput struct{ *pulumi.OutputState }

func (GatewayIamBindingConditionOutput) Description 

func (o GatewayIamBindingConditionOutput) Description() pulumi.StringPtrOutput

func (GatewayIamBindingConditionOutput) ElementType 

func (GatewayIamBindingConditionOutput) ElementType() reflect.Type

func (GatewayIamBindingConditionOutput) Expression 

func (o GatewayIamBindingConditionOutput) Expression() pulumi.StringOutput

func (GatewayIamBindingConditionOutput) Title 

func (o GatewayIamBindingConditionOutput) Title() pulumi.StringOutput

func (GatewayIamBindingConditionOutput) ToGatewayIamBindingConditionOutput 

func (o GatewayIamBindingConditionOutput) ToGatewayIamBindingConditionOutput() GatewayIamBindingConditionOutput

func (GatewayIamBindingConditionOutput) ToGatewayIamBindingConditionOutputWithContext 

func (o GatewayIamBindingConditionOutput) ToGatewayIamBindingConditionOutputWithContext(ctx context.Context) GatewayIamBindingConditionOutput

func (GatewayIamBindingConditionOutput) ToGatewayIamBindingConditionPtrOutput 

func (o GatewayIamBindingConditionOutput) ToGatewayIamBindingConditionPtrOutput() GatewayIamBindingConditionPtrOutput

func (GatewayIamBindingConditionOutput) ToGatewayIamBindingConditionPtrOutputWithContext 

func (o GatewayIamBindingConditionOutput) ToGatewayIamBindingConditionPtrOutputWithContext(ctx context.Context) GatewayIamBindingConditionPtrOutput

type GatewayIamBindingConditionPtrInput 

type GatewayIamBindingConditionPtrInput interface {
	pulumi.Input

	ToGatewayIamBindingConditionPtrOutput() GatewayIamBindingConditionPtrOutput
	ToGatewayIamBindingConditionPtrOutputWithContext(context.Context) GatewayIamBindingConditionPtrOutput
}

GatewayIamBindingConditionPtrInput is an input type that accepts GatewayIamBindingConditionArgs, GatewayIamBindingConditionPtr and GatewayIamBindingConditionPtrOutput values. You can construct a concrete instance of `GatewayIamBindingConditionPtrInput` via: 

        GatewayIamBindingConditionArgs{...}

or:

        nil

func GatewayIamBindingConditionPtr 

func GatewayIamBindingConditionPtr(v *GatewayIamBindingConditionArgs) GatewayIamBindingConditionPtrInput

type GatewayIamBindingConditionPtrOutput 

type GatewayIamBindingConditionPtrOutput struct{ *pulumi.OutputState }

func (GatewayIamBindingConditionPtrOutput) Description 

func (o GatewayIamBindingConditionPtrOutput) Description() pulumi.StringPtrOutput

func (GatewayIamBindingConditionPtrOutput) Elem 

func (o GatewayIamBindingConditionPtrOutput) Elem() GatewayIamBindingConditionOutput

func (GatewayIamBindingConditionPtrOutput) ElementType 

func (GatewayIamBindingConditionPtrOutput) ElementType() reflect.Type

func (GatewayIamBindingConditionPtrOutput) Expression 

func (o GatewayIamBindingConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (GatewayIamBindingConditionPtrOutput) Title 

func (o GatewayIamBindingConditionPtrOutput) Title() pulumi.StringPtrOutput

func (GatewayIamBindingConditionPtrOutput) ToGatewayIamBindingConditionPtrOutput 

func (o GatewayIamBindingConditionPtrOutput) ToGatewayIamBindingConditionPtrOutput() GatewayIamBindingConditionPtrOutput

func (GatewayIamBindingConditionPtrOutput) ToGatewayIamBindingConditionPtrOutputWithContext 

func (o GatewayIamBindingConditionPtrOutput) ToGatewayIamBindingConditionPtrOutputWithContext(ctx context.Context) GatewayIamBindingConditionPtrOutput

type GatewayIamBindingInput 

type GatewayIamBindingInput interface {
	pulumi.Input

	ToGatewayIamBindingOutput() GatewayIamBindingOutput
	ToGatewayIamBindingOutputWithContext(ctx context.Context) GatewayIamBindingOutput
}

type GatewayIamBindingMap 

type GatewayIamBindingMap map[string]GatewayIamBindingInput

func (GatewayIamBindingMap) ElementType 

func (GatewayIamBindingMap) ElementType() reflect.Type

func (GatewayIamBindingMap) ToGatewayIamBindingMapOutput 

func (i GatewayIamBindingMap) ToGatewayIamBindingMapOutput() GatewayIamBindingMapOutput

func (GatewayIamBindingMap) ToGatewayIamBindingMapOutputWithContext 

func (i GatewayIamBindingMap) ToGatewayIamBindingMapOutputWithContext(ctx context.Context) GatewayIamBindingMapOutput

type GatewayIamBindingMapInput 

type GatewayIamBindingMapInput interface {
	pulumi.Input

	ToGatewayIamBindingMapOutput() GatewayIamBindingMapOutput
	ToGatewayIamBindingMapOutputWithContext(context.Context) GatewayIamBindingMapOutput
}

GatewayIamBindingMapInput is an input type that accepts GatewayIamBindingMap and GatewayIamBindingMapOutput values. You can construct a concrete instance of `GatewayIamBindingMapInput` via: 

GatewayIamBindingMap{ "key": GatewayIamBindingArgs{...} }

type GatewayIamBindingMapOutput 

type GatewayIamBindingMapOutput struct{ *pulumi.OutputState }

func (GatewayIamBindingMapOutput) ElementType 

func (GatewayIamBindingMapOutput) ElementType() reflect.Type

func (GatewayIamBindingMapOutput) MapIndex 

func (o GatewayIamBindingMapOutput) MapIndex(k pulumi.StringInput) GatewayIamBindingOutput

func (GatewayIamBindingMapOutput) ToGatewayIamBindingMapOutput 

func (o GatewayIamBindingMapOutput) ToGatewayIamBindingMapOutput() GatewayIamBindingMapOutput

func (GatewayIamBindingMapOutput) ToGatewayIamBindingMapOutputWithContext 

func (o GatewayIamBindingMapOutput) ToGatewayIamBindingMapOutputWithContext(ctx context.Context) GatewayIamBindingMapOutput

type GatewayIamBindingOutput 

type GatewayIamBindingOutput struct{ *pulumi.OutputState }

func (GatewayIamBindingOutput) ElementType 

func (GatewayIamBindingOutput) ElementType() reflect.Type

func (GatewayIamBindingOutput) ToGatewayIamBindingOutput 

func (o GatewayIamBindingOutput) ToGatewayIamBindingOutput() GatewayIamBindingOutput

func (GatewayIamBindingOutput) ToGatewayIamBindingOutputWithContext 

func (o GatewayIamBindingOutput) ToGatewayIamBindingOutputWithContext(ctx context.Context) GatewayIamBindingOutput

func (GatewayIamBindingOutput) ToGatewayIamBindingPtrOutput 

func (o GatewayIamBindingOutput) ToGatewayIamBindingPtrOutput() GatewayIamBindingPtrOutput

func (GatewayIamBindingOutput) ToGatewayIamBindingPtrOutputWithContext 

func (o GatewayIamBindingOutput) ToGatewayIamBindingPtrOutputWithContext(ctx context.Context) GatewayIamBindingPtrOutput

type GatewayIamBindingPtrInput 

type GatewayIamBindingPtrInput interface {
	pulumi.Input

	ToGatewayIamBindingPtrOutput() GatewayIamBindingPtrOutput
	ToGatewayIamBindingPtrOutputWithContext(ctx context.Context) GatewayIamBindingPtrOutput
}

type GatewayIamBindingPtrOutput 

type GatewayIamBindingPtrOutput struct{ *pulumi.OutputState }

func (GatewayIamBindingPtrOutput) Elem added in v5.21.0 

func (o GatewayIamBindingPtrOutput) Elem() GatewayIamBindingOutput

func (GatewayIamBindingPtrOutput) ElementType 

func (GatewayIamBindingPtrOutput) ElementType() reflect.Type

func (GatewayIamBindingPtrOutput) ToGatewayIamBindingPtrOutput 

func (o GatewayIamBindingPtrOutput) ToGatewayIamBindingPtrOutput() GatewayIamBindingPtrOutput

func (GatewayIamBindingPtrOutput) ToGatewayIamBindingPtrOutputWithContext 

func (o GatewayIamBindingPtrOutput) ToGatewayIamBindingPtrOutputWithContext(ctx context.Context) GatewayIamBindingPtrOutput

type GatewayIamBindingState 

type GatewayIamBindingState struct {
	Condition GatewayIamBindingConditionPtrInput
	// (Computed) The etag of the IAM policy.
	Etag    pulumi.StringPtrInput
	Gateway pulumi.StringPtrInput
	Members pulumi.StringArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The region of the gateway for the API.
	// Used to find the parent resource to bind the IAM policy to. If not specified,
	// the value will be parsed from the identifier of the parent resource. If no region is provided in the parent identifier and no
	// region is specified, it is taken from the provider configuration.
	Region pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.GatewayIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (GatewayIamBindingState) ElementType 

func (GatewayIamBindingState) ElementType() reflect.Type

type GatewayIamMember 

type GatewayIamMember struct {
	pulumi.CustomResourceState

	Condition GatewayIamMemberConditionPtrOutput `pulumi:"condition"`
	// (Computed) The etag of the IAM policy.
	Etag    pulumi.StringOutput `pulumi:"etag"`
	Gateway pulumi.StringOutput `pulumi:"gateway"`
	Member  pulumi.StringOutput `pulumi:"member"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The region of the gateway for the API.
	// Used to find the parent resource to bind the IAM policy to. If not specified,
	// the value will be parsed from the identifier of the parent resource. If no region is provided in the parent identifier and no
	// region is specified, it is taken from the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// The role that should be applied. Only one
	// `apigateway.GatewayIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for API Gateway Gateway. Each of these resources serves a different use case:

* `apigateway.GatewayIamPolicy`: Authoritative. Sets the IAM policy for the gateway and replaces any existing policy already attached. * `apigateway.GatewayIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the gateway are preserved. * `apigateway.GatewayIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the gateway are preserved.

> **Note:** `apigateway.GatewayIamPolicy` **cannot** be used in conjunction with `apigateway.GatewayIamBinding` and `apigateway.GatewayIamMember` or they will fight over what your policy should be.

> **Note:** `apigateway.GatewayIamBinding` resources **can be** used in conjunction with `apigateway.GatewayIamMember` resources **only if** they do not grant privilege to the same role.

## google\_api\_gateway\_gateway\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/apigateway"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				organizations.GetIAMPolicyBinding{
					Role: "roles/apigateway.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = apigateway.NewGatewayIamPolicy(ctx, "policy", &apigateway.GatewayIamPolicyArgs{
			Project:    pulumi.Any(google_api_gateway_gateway.Api_gw.Project),
			Region:     pulumi.Any(google_api_gateway_gateway.Api_gw.Region),
			Gateway:    pulumi.Any(google_api_gateway_gateway.Api_gw.Gateway_id),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_gateway\_iam\_binding

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewGatewayIamBinding(ctx, "binding", &apigateway.GatewayIamBindingArgs{
			Project: pulumi.Any(google_api_gateway_gateway.Api_gw.Project),
			Region:  pulumi.Any(google_api_gateway_gateway.Api_gw.Region),
			Gateway: pulumi.Any(google_api_gateway_gateway.Api_gw.Gateway_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_gateway\_iam\_member

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewGatewayIamMember(ctx, "member", &apigateway.GatewayIamMemberArgs{
			Project: pulumi.Any(google_api_gateway_gateway.Api_gw.Project),
			Region:  pulumi.Any(google_api_gateway_gateway.Api_gw.Region),
			Gateway: pulumi.Any(google_api_gateway_gateway.Api_gw.Gateway_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Member:  pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms* projects/{{project}}/locations/{{region}}/gateways/{{gateway}} * {{project}}/{{region}}/{{gateway}} * {{region}}/{{gateway}} * {{gateway}} Any variables not passed in the import command will be taken from the provider configuration. API Gateway gateway IAM resources can be imported using the resource identifiers, role, and member. IAM member imports use space-delimited identifiersthe resource in question, the role, and the member identity, e.g.

```sh 

$ pulumi import gcp:apigateway/gatewayIamMember:GatewayIamMember editor "projects/{{project}}/locations/{{region}}/gateways/{{gateway}} roles/apigateway.viewer user:jane@example.com"

``` 

IAM binding imports use space-delimited identifiersthe resource in question and the role, e.g.

```sh 

$ pulumi import gcp:apigateway/gatewayIamMember:GatewayIamMember editor "projects/{{project}}/locations/{{region}}/gateways/{{gateway}} roles/apigateway.viewer"

``` 

IAM policy imports use the identifier of the resource in question, e.g.

```sh 

$ pulumi import gcp:apigateway/gatewayIamMember:GatewayIamMember editor projects/{{project}}/locations/{{region}}/gateways/{{gateway}}

``` 

-> **Custom Roles**If you're importing a IAM resource with a custom role, make sure to use the

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetGatewayIamMember 

func GetGatewayIamMember(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GatewayIamMemberState, opts ...pulumi.ResourceOption) (*GatewayIamMember, error)

GetGatewayIamMember gets an existing GatewayIamMember resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGatewayIamMember 

func NewGatewayIamMember(ctx *pulumi.Context,
	name string, args *GatewayIamMemberArgs, opts ...pulumi.ResourceOption) (*GatewayIamMember, error)

NewGatewayIamMember registers a new resource with the given unique name, arguments, and options.

func (*GatewayIamMember) ElementType 

func (*GatewayIamMember) ElementType() reflect.Type

func (*GatewayIamMember) ToGatewayIamMemberOutput 

func (i *GatewayIamMember) ToGatewayIamMemberOutput() GatewayIamMemberOutput

func (*GatewayIamMember) ToGatewayIamMemberOutputWithContext 

func (i *GatewayIamMember) ToGatewayIamMemberOutputWithContext(ctx context.Context) GatewayIamMemberOutput

func (*GatewayIamMember) ToGatewayIamMemberPtrOutput 

func (i *GatewayIamMember) ToGatewayIamMemberPtrOutput() GatewayIamMemberPtrOutput

func (*GatewayIamMember) ToGatewayIamMemberPtrOutputWithContext 

func (i *GatewayIamMember) ToGatewayIamMemberPtrOutputWithContext(ctx context.Context) GatewayIamMemberPtrOutput

type GatewayIamMemberArgs 

type GatewayIamMemberArgs struct {
	Condition GatewayIamMemberConditionPtrInput
	Gateway   pulumi.StringInput
	Member    pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The region of the gateway for the API.
	// Used to find the parent resource to bind the IAM policy to. If not specified,
	// the value will be parsed from the identifier of the parent resource. If no region is provided in the parent identifier and no
	// region is specified, it is taken from the provider configuration.
	Region pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.GatewayIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a GatewayIamMember resource.

func (GatewayIamMemberArgs) ElementType 

func (GatewayIamMemberArgs) ElementType() reflect.Type

type GatewayIamMemberArray 

type GatewayIamMemberArray []GatewayIamMemberInput

func (GatewayIamMemberArray) ElementType 

func (GatewayIamMemberArray) ElementType() reflect.Type

func (GatewayIamMemberArray) ToGatewayIamMemberArrayOutput 

func (i GatewayIamMemberArray) ToGatewayIamMemberArrayOutput() GatewayIamMemberArrayOutput

func (GatewayIamMemberArray) ToGatewayIamMemberArrayOutputWithContext 

func (i GatewayIamMemberArray) ToGatewayIamMemberArrayOutputWithContext(ctx context.Context) GatewayIamMemberArrayOutput

type GatewayIamMemberArrayInput 

type GatewayIamMemberArrayInput interface {
	pulumi.Input

	ToGatewayIamMemberArrayOutput() GatewayIamMemberArrayOutput
	ToGatewayIamMemberArrayOutputWithContext(context.Context) GatewayIamMemberArrayOutput
}

GatewayIamMemberArrayInput is an input type that accepts GatewayIamMemberArray and GatewayIamMemberArrayOutput values. You can construct a concrete instance of `GatewayIamMemberArrayInput` via: 

GatewayIamMemberArray{ GatewayIamMemberArgs{...} }

type GatewayIamMemberArrayOutput 

type GatewayIamMemberArrayOutput struct{ *pulumi.OutputState }

func (GatewayIamMemberArrayOutput) ElementType 

func (GatewayIamMemberArrayOutput) ElementType() reflect.Type

func (GatewayIamMemberArrayOutput) Index 

func (o GatewayIamMemberArrayOutput) Index(i pulumi.IntInput) GatewayIamMemberOutput

func (GatewayIamMemberArrayOutput) ToGatewayIamMemberArrayOutput 

func (o GatewayIamMemberArrayOutput) ToGatewayIamMemberArrayOutput() GatewayIamMemberArrayOutput

func (GatewayIamMemberArrayOutput) ToGatewayIamMemberArrayOutputWithContext 

func (o GatewayIamMemberArrayOutput) ToGatewayIamMemberArrayOutputWithContext(ctx context.Context) GatewayIamMemberArrayOutput

type GatewayIamMemberCondition 

type GatewayIamMemberCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type GatewayIamMemberConditionArgs 

type GatewayIamMemberConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (GatewayIamMemberConditionArgs) ElementType 

func (GatewayIamMemberConditionArgs) ElementType() reflect.Type

func (GatewayIamMemberConditionArgs) ToGatewayIamMemberConditionOutput 

func (i GatewayIamMemberConditionArgs) ToGatewayIamMemberConditionOutput() GatewayIamMemberConditionOutput

func (GatewayIamMemberConditionArgs) ToGatewayIamMemberConditionOutputWithContext 

func (i GatewayIamMemberConditionArgs) ToGatewayIamMemberConditionOutputWithContext(ctx context.Context) GatewayIamMemberConditionOutput

func (GatewayIamMemberConditionArgs) ToGatewayIamMemberConditionPtrOutput 

func (i GatewayIamMemberConditionArgs) ToGatewayIamMemberConditionPtrOutput() GatewayIamMemberConditionPtrOutput

func (GatewayIamMemberConditionArgs) ToGatewayIamMemberConditionPtrOutputWithContext 

func (i GatewayIamMemberConditionArgs) ToGatewayIamMemberConditionPtrOutputWithContext(ctx context.Context) GatewayIamMemberConditionPtrOutput

type GatewayIamMemberConditionInput 

type GatewayIamMemberConditionInput interface {
	pulumi.Input

	ToGatewayIamMemberConditionOutput() GatewayIamMemberConditionOutput
	ToGatewayIamMemberConditionOutputWithContext(context.Context) GatewayIamMemberConditionOutput
}

GatewayIamMemberConditionInput is an input type that accepts GatewayIamMemberConditionArgs and GatewayIamMemberConditionOutput values. You can construct a concrete instance of `GatewayIamMemberConditionInput` via: 

GatewayIamMemberConditionArgs{...}

type GatewayIamMemberConditionOutput 

type GatewayIamMemberConditionOutput struct{ *pulumi.OutputState }

func (GatewayIamMemberConditionOutput) Description 

func (o GatewayIamMemberConditionOutput) Description() pulumi.StringPtrOutput

func (GatewayIamMemberConditionOutput) ElementType 

func (GatewayIamMemberConditionOutput) ElementType() reflect.Type

func (GatewayIamMemberConditionOutput) Expression 

func (o GatewayIamMemberConditionOutput) Expression() pulumi.StringOutput

func (GatewayIamMemberConditionOutput) Title 

func (o GatewayIamMemberConditionOutput) Title() pulumi.StringOutput

func (GatewayIamMemberConditionOutput) ToGatewayIamMemberConditionOutput 

func (o GatewayIamMemberConditionOutput) ToGatewayIamMemberConditionOutput() GatewayIamMemberConditionOutput

func (GatewayIamMemberConditionOutput) ToGatewayIamMemberConditionOutputWithContext 

func (o GatewayIamMemberConditionOutput) ToGatewayIamMemberConditionOutputWithContext(ctx context.Context) GatewayIamMemberConditionOutput

func (GatewayIamMemberConditionOutput) ToGatewayIamMemberConditionPtrOutput 

func (o GatewayIamMemberConditionOutput) ToGatewayIamMemberConditionPtrOutput() GatewayIamMemberConditionPtrOutput

func (GatewayIamMemberConditionOutput) ToGatewayIamMemberConditionPtrOutputWithContext 

func (o GatewayIamMemberConditionOutput) ToGatewayIamMemberConditionPtrOutputWithContext(ctx context.Context) GatewayIamMemberConditionPtrOutput

type GatewayIamMemberConditionPtrInput 

type GatewayIamMemberConditionPtrInput interface {
	pulumi.Input

	ToGatewayIamMemberConditionPtrOutput() GatewayIamMemberConditionPtrOutput
	ToGatewayIamMemberConditionPtrOutputWithContext(context.Context) GatewayIamMemberConditionPtrOutput
}

GatewayIamMemberConditionPtrInput is an input type that accepts GatewayIamMemberConditionArgs, GatewayIamMemberConditionPtr and GatewayIamMemberConditionPtrOutput values. You can construct a concrete instance of `GatewayIamMemberConditionPtrInput` via: 

        GatewayIamMemberConditionArgs{...}

or:

        nil

func GatewayIamMemberConditionPtr 

func GatewayIamMemberConditionPtr(v *GatewayIamMemberConditionArgs) GatewayIamMemberConditionPtrInput

type GatewayIamMemberConditionPtrOutput 

type GatewayIamMemberConditionPtrOutput struct{ *pulumi.OutputState }

func (GatewayIamMemberConditionPtrOutput) Description 

func (o GatewayIamMemberConditionPtrOutput) Description() pulumi.StringPtrOutput

func (GatewayIamMemberConditionPtrOutput) Elem 

func (o GatewayIamMemberConditionPtrOutput) Elem() GatewayIamMemberConditionOutput

func (GatewayIamMemberConditionPtrOutput) ElementType 

func (GatewayIamMemberConditionPtrOutput) ElementType() reflect.Type

func (GatewayIamMemberConditionPtrOutput) Expression 

func (o GatewayIamMemberConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (GatewayIamMemberConditionPtrOutput) Title 

func (o GatewayIamMemberConditionPtrOutput) Title() pulumi.StringPtrOutput

func (GatewayIamMemberConditionPtrOutput) ToGatewayIamMemberConditionPtrOutput 

func (o GatewayIamMemberConditionPtrOutput) ToGatewayIamMemberConditionPtrOutput() GatewayIamMemberConditionPtrOutput

func (GatewayIamMemberConditionPtrOutput) ToGatewayIamMemberConditionPtrOutputWithContext 

func (o GatewayIamMemberConditionPtrOutput) ToGatewayIamMemberConditionPtrOutputWithContext(ctx context.Context) GatewayIamMemberConditionPtrOutput

type GatewayIamMemberInput 

type GatewayIamMemberInput interface {
	pulumi.Input

	ToGatewayIamMemberOutput() GatewayIamMemberOutput
	ToGatewayIamMemberOutputWithContext(ctx context.Context) GatewayIamMemberOutput
}

type GatewayIamMemberMap 

type GatewayIamMemberMap map[string]GatewayIamMemberInput

func (GatewayIamMemberMap) ElementType 

func (GatewayIamMemberMap) ElementType() reflect.Type

func (GatewayIamMemberMap) ToGatewayIamMemberMapOutput 

func (i GatewayIamMemberMap) ToGatewayIamMemberMapOutput() GatewayIamMemberMapOutput

func (GatewayIamMemberMap) ToGatewayIamMemberMapOutputWithContext 

func (i GatewayIamMemberMap) ToGatewayIamMemberMapOutputWithContext(ctx context.Context) GatewayIamMemberMapOutput

type GatewayIamMemberMapInput 

type GatewayIamMemberMapInput interface {
	pulumi.Input

	ToGatewayIamMemberMapOutput() GatewayIamMemberMapOutput
	ToGatewayIamMemberMapOutputWithContext(context.Context) GatewayIamMemberMapOutput
}

GatewayIamMemberMapInput is an input type that accepts GatewayIamMemberMap and GatewayIamMemberMapOutput values. You can construct a concrete instance of `GatewayIamMemberMapInput` via: 

GatewayIamMemberMap{ "key": GatewayIamMemberArgs{...} }

type GatewayIamMemberMapOutput 

type GatewayIamMemberMapOutput struct{ *pulumi.OutputState }

func (GatewayIamMemberMapOutput) ElementType 

func (GatewayIamMemberMapOutput) ElementType() reflect.Type

func (GatewayIamMemberMapOutput) MapIndex 

func (o GatewayIamMemberMapOutput) MapIndex(k pulumi.StringInput) GatewayIamMemberOutput

func (GatewayIamMemberMapOutput) ToGatewayIamMemberMapOutput 

func (o GatewayIamMemberMapOutput) ToGatewayIamMemberMapOutput() GatewayIamMemberMapOutput

func (GatewayIamMemberMapOutput) ToGatewayIamMemberMapOutputWithContext 

func (o GatewayIamMemberMapOutput) ToGatewayIamMemberMapOutputWithContext(ctx context.Context) GatewayIamMemberMapOutput

type GatewayIamMemberOutput 

type GatewayIamMemberOutput struct{ *pulumi.OutputState }

func (GatewayIamMemberOutput) ElementType 

func (GatewayIamMemberOutput) ElementType() reflect.Type

func (GatewayIamMemberOutput) ToGatewayIamMemberOutput 

func (o GatewayIamMemberOutput) ToGatewayIamMemberOutput() GatewayIamMemberOutput

func (GatewayIamMemberOutput) ToGatewayIamMemberOutputWithContext 

func (o GatewayIamMemberOutput) ToGatewayIamMemberOutputWithContext(ctx context.Context) GatewayIamMemberOutput

func (GatewayIamMemberOutput) ToGatewayIamMemberPtrOutput 

func (o GatewayIamMemberOutput) ToGatewayIamMemberPtrOutput() GatewayIamMemberPtrOutput

func (GatewayIamMemberOutput) ToGatewayIamMemberPtrOutputWithContext 

func (o GatewayIamMemberOutput) ToGatewayIamMemberPtrOutputWithContext(ctx context.Context) GatewayIamMemberPtrOutput

type GatewayIamMemberPtrInput 

type GatewayIamMemberPtrInput interface {
	pulumi.Input

	ToGatewayIamMemberPtrOutput() GatewayIamMemberPtrOutput
	ToGatewayIamMemberPtrOutputWithContext(ctx context.Context) GatewayIamMemberPtrOutput
}

type GatewayIamMemberPtrOutput 

type GatewayIamMemberPtrOutput struct{ *pulumi.OutputState }

func (GatewayIamMemberPtrOutput) Elem added in v5.21.0 

func (o GatewayIamMemberPtrOutput) Elem() GatewayIamMemberOutput

func (GatewayIamMemberPtrOutput) ElementType 

func (GatewayIamMemberPtrOutput) ElementType() reflect.Type

func (GatewayIamMemberPtrOutput) ToGatewayIamMemberPtrOutput 

func (o GatewayIamMemberPtrOutput) ToGatewayIamMemberPtrOutput() GatewayIamMemberPtrOutput

func (GatewayIamMemberPtrOutput) ToGatewayIamMemberPtrOutputWithContext 

func (o GatewayIamMemberPtrOutput) ToGatewayIamMemberPtrOutputWithContext(ctx context.Context) GatewayIamMemberPtrOutput

type GatewayIamMemberState 

type GatewayIamMemberState struct {
	Condition GatewayIamMemberConditionPtrInput
	// (Computed) The etag of the IAM policy.
	Etag    pulumi.StringPtrInput
	Gateway pulumi.StringPtrInput
	Member  pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The region of the gateway for the API.
	// Used to find the parent resource to bind the IAM policy to. If not specified,
	// the value will be parsed from the identifier of the parent resource. If no region is provided in the parent identifier and no
	// region is specified, it is taken from the provider configuration.
	Region pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `apigateway.GatewayIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (GatewayIamMemberState) ElementType 

func (GatewayIamMemberState) ElementType() reflect.Type

type GatewayIamPolicy 

type GatewayIamPolicy struct {
	pulumi.CustomResourceState

	// (Computed) The etag of the IAM policy.
	Etag    pulumi.StringOutput `pulumi:"etag"`
	Gateway pulumi.StringOutput `pulumi:"gateway"`
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringOutput `pulumi:"policyData"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The region of the gateway for the API.
	// Used to find the parent resource to bind the IAM policy to. If not specified,
	// the value will be parsed from the identifier of the parent resource. If no region is provided in the parent identifier and no
	// region is specified, it is taken from the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
}

Three different resources help you manage your IAM policy for API Gateway Gateway. Each of these resources serves a different use case:

* `apigateway.GatewayIamPolicy`: Authoritative. Sets the IAM policy for the gateway and replaces any existing policy already attached. * `apigateway.GatewayIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the gateway are preserved. * `apigateway.GatewayIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the gateway are preserved.

> **Note:** `apigateway.GatewayIamPolicy` **cannot** be used in conjunction with `apigateway.GatewayIamBinding` and `apigateway.GatewayIamMember` or they will fight over what your policy should be.

> **Note:** `apigateway.GatewayIamBinding` resources **can be** used in conjunction with `apigateway.GatewayIamMember` resources **only if** they do not grant privilege to the same role.

## google\_api\_gateway\_gateway\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/apigateway"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				organizations.GetIAMPolicyBinding{
					Role: "roles/apigateway.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = apigateway.NewGatewayIamPolicy(ctx, "policy", &apigateway.GatewayIamPolicyArgs{
			Project:    pulumi.Any(google_api_gateway_gateway.Api_gw.Project),
			Region:     pulumi.Any(google_api_gateway_gateway.Api_gw.Region),
			Gateway:    pulumi.Any(google_api_gateway_gateway.Api_gw.Gateway_id),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_gateway\_iam\_binding

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewGatewayIamBinding(ctx, "binding", &apigateway.GatewayIamBindingArgs{
			Project: pulumi.Any(google_api_gateway_gateway.Api_gw.Project),
			Region:  pulumi.Any(google_api_gateway_gateway.Api_gw.Region),
			Gateway: pulumi.Any(google_api_gateway_gateway.Api_gw.Gateway_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_api\_gateway\_gateway\_iam\_member

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewGatewayIamMember(ctx, "member", &apigateway.GatewayIamMemberArgs{
			Project: pulumi.Any(google_api_gateway_gateway.Api_gw.Project),
			Region:  pulumi.Any(google_api_gateway_gateway.Api_gw.Region),
			Gateway: pulumi.Any(google_api_gateway_gateway.Api_gw.Gateway_id),
			Role:    pulumi.String("roles/apigateway.viewer"),
			Member:  pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms* projects/{{project}}/locations/{{region}}/gateways/{{gateway}} * {{project}}/{{region}}/{{gateway}} * {{region}}/{{gateway}} * {{gateway}} Any variables not passed in the import command will be taken from the provider configuration. API Gateway gateway IAM resources can be imported using the resource identifiers, role, and member. IAM member imports use space-delimited identifiersthe resource in question, the role, and the member identity, e.g.

```sh 

$ pulumi import gcp:apigateway/gatewayIamPolicy:GatewayIamPolicy editor "projects/{{project}}/locations/{{region}}/gateways/{{gateway}} roles/apigateway.viewer user:jane@example.com"

``` 

IAM binding imports use space-delimited identifiersthe resource in question and the role, e.g.

```sh 

$ pulumi import gcp:apigateway/gatewayIamPolicy:GatewayIamPolicy editor "projects/{{project}}/locations/{{region}}/gateways/{{gateway}} roles/apigateway.viewer"

``` 

IAM policy imports use the identifier of the resource in question, e.g.

```sh 

$ pulumi import gcp:apigateway/gatewayIamPolicy:GatewayIamPolicy editor projects/{{project}}/locations/{{region}}/gateways/{{gateway}}

``` 

-> **Custom Roles**If you're importing a IAM resource with a custom role, make sure to use the

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetGatewayIamPolicy 

func GetGatewayIamPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GatewayIamPolicyState, opts ...pulumi.ResourceOption) (*GatewayIamPolicy, error)

GetGatewayIamPolicy gets an existing GatewayIamPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGatewayIamPolicy 

func NewGatewayIamPolicy(ctx *pulumi.Context,
	name string, args *GatewayIamPolicyArgs, opts ...pulumi.ResourceOption) (*GatewayIamPolicy, error)

NewGatewayIamPolicy registers a new resource with the given unique name, arguments, and options.

func (*GatewayIamPolicy) ElementType 

func (*GatewayIamPolicy) ElementType() reflect.Type

func (*GatewayIamPolicy) ToGatewayIamPolicyOutput 

func (i *GatewayIamPolicy) ToGatewayIamPolicyOutput() GatewayIamPolicyOutput

func (*GatewayIamPolicy) ToGatewayIamPolicyOutputWithContext 

func (i *GatewayIamPolicy) ToGatewayIamPolicyOutputWithContext(ctx context.Context) GatewayIamPolicyOutput

func (*GatewayIamPolicy) ToGatewayIamPolicyPtrOutput 

func (i *GatewayIamPolicy) ToGatewayIamPolicyPtrOutput() GatewayIamPolicyPtrOutput

func (*GatewayIamPolicy) ToGatewayIamPolicyPtrOutputWithContext 

func (i *GatewayIamPolicy) ToGatewayIamPolicyPtrOutputWithContext(ctx context.Context) GatewayIamPolicyPtrOutput

type GatewayIamPolicyArgs 

type GatewayIamPolicyArgs struct {
	Gateway pulumi.StringInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The region of the gateway for the API.
	// Used to find the parent resource to bind the IAM policy to. If not specified,
	// the value will be parsed from the identifier of the parent resource. If no region is provided in the parent identifier and no
	// region is specified, it is taken from the provider configuration.
	Region pulumi.StringPtrInput
}

The set of arguments for constructing a GatewayIamPolicy resource.

func (GatewayIamPolicyArgs) ElementType 

func (GatewayIamPolicyArgs) ElementType() reflect.Type

type GatewayIamPolicyArray 

type GatewayIamPolicyArray []GatewayIamPolicyInput

func (GatewayIamPolicyArray) ElementType 

func (GatewayIamPolicyArray) ElementType() reflect.Type

func (GatewayIamPolicyArray) ToGatewayIamPolicyArrayOutput 

func (i GatewayIamPolicyArray) ToGatewayIamPolicyArrayOutput() GatewayIamPolicyArrayOutput

func (GatewayIamPolicyArray) ToGatewayIamPolicyArrayOutputWithContext 

func (i GatewayIamPolicyArray) ToGatewayIamPolicyArrayOutputWithContext(ctx context.Context) GatewayIamPolicyArrayOutput

type GatewayIamPolicyArrayInput 

type GatewayIamPolicyArrayInput interface {
	pulumi.Input

	ToGatewayIamPolicyArrayOutput() GatewayIamPolicyArrayOutput
	ToGatewayIamPolicyArrayOutputWithContext(context.Context) GatewayIamPolicyArrayOutput
}

GatewayIamPolicyArrayInput is an input type that accepts GatewayIamPolicyArray and GatewayIamPolicyArrayOutput values. You can construct a concrete instance of `GatewayIamPolicyArrayInput` via: 

GatewayIamPolicyArray{ GatewayIamPolicyArgs{...} }

type GatewayIamPolicyArrayOutput 

type GatewayIamPolicyArrayOutput struct{ *pulumi.OutputState }

func (GatewayIamPolicyArrayOutput) ElementType 

func (GatewayIamPolicyArrayOutput) ElementType() reflect.Type

func (GatewayIamPolicyArrayOutput) Index 

func (o GatewayIamPolicyArrayOutput) Index(i pulumi.IntInput) GatewayIamPolicyOutput

func (GatewayIamPolicyArrayOutput) ToGatewayIamPolicyArrayOutput 

func (o GatewayIamPolicyArrayOutput) ToGatewayIamPolicyArrayOutput() GatewayIamPolicyArrayOutput

func (GatewayIamPolicyArrayOutput) ToGatewayIamPolicyArrayOutputWithContext 

func (o GatewayIamPolicyArrayOutput) ToGatewayIamPolicyArrayOutputWithContext(ctx context.Context) GatewayIamPolicyArrayOutput

type GatewayIamPolicyInput 

type GatewayIamPolicyInput interface {
	pulumi.Input

	ToGatewayIamPolicyOutput() GatewayIamPolicyOutput
	ToGatewayIamPolicyOutputWithContext(ctx context.Context) GatewayIamPolicyOutput
}

type GatewayIamPolicyMap 

type GatewayIamPolicyMap map[string]GatewayIamPolicyInput

func (GatewayIamPolicyMap) ElementType 

func (GatewayIamPolicyMap) ElementType() reflect.Type

func (GatewayIamPolicyMap) ToGatewayIamPolicyMapOutput 

func (i GatewayIamPolicyMap) ToGatewayIamPolicyMapOutput() GatewayIamPolicyMapOutput

func (GatewayIamPolicyMap) ToGatewayIamPolicyMapOutputWithContext 

func (i GatewayIamPolicyMap) ToGatewayIamPolicyMapOutputWithContext(ctx context.Context) GatewayIamPolicyMapOutput

type GatewayIamPolicyMapInput 

type GatewayIamPolicyMapInput interface {
	pulumi.Input

	ToGatewayIamPolicyMapOutput() GatewayIamPolicyMapOutput
	ToGatewayIamPolicyMapOutputWithContext(context.Context) GatewayIamPolicyMapOutput
}

GatewayIamPolicyMapInput is an input type that accepts GatewayIamPolicyMap and GatewayIamPolicyMapOutput values. You can construct a concrete instance of `GatewayIamPolicyMapInput` via: 

GatewayIamPolicyMap{ "key": GatewayIamPolicyArgs{...} }

type GatewayIamPolicyMapOutput 

type GatewayIamPolicyMapOutput struct{ *pulumi.OutputState }

func (GatewayIamPolicyMapOutput) ElementType 

func (GatewayIamPolicyMapOutput) ElementType() reflect.Type

func (GatewayIamPolicyMapOutput) MapIndex 

func (o GatewayIamPolicyMapOutput) MapIndex(k pulumi.StringInput) GatewayIamPolicyOutput

func (GatewayIamPolicyMapOutput) ToGatewayIamPolicyMapOutput 

func (o GatewayIamPolicyMapOutput) ToGatewayIamPolicyMapOutput() GatewayIamPolicyMapOutput

func (GatewayIamPolicyMapOutput) ToGatewayIamPolicyMapOutputWithContext 

func (o GatewayIamPolicyMapOutput) ToGatewayIamPolicyMapOutputWithContext(ctx context.Context) GatewayIamPolicyMapOutput

type GatewayIamPolicyOutput 

type GatewayIamPolicyOutput struct{ *pulumi.OutputState }

func (GatewayIamPolicyOutput) ElementType 

func (GatewayIamPolicyOutput) ElementType() reflect.Type

func (GatewayIamPolicyOutput) ToGatewayIamPolicyOutput 

func (o GatewayIamPolicyOutput) ToGatewayIamPolicyOutput() GatewayIamPolicyOutput

func (GatewayIamPolicyOutput) ToGatewayIamPolicyOutputWithContext 

func (o GatewayIamPolicyOutput) ToGatewayIamPolicyOutputWithContext(ctx context.Context) GatewayIamPolicyOutput

func (GatewayIamPolicyOutput) ToGatewayIamPolicyPtrOutput 

func (o GatewayIamPolicyOutput) ToGatewayIamPolicyPtrOutput() GatewayIamPolicyPtrOutput

func (GatewayIamPolicyOutput) ToGatewayIamPolicyPtrOutputWithContext 

func (o GatewayIamPolicyOutput) ToGatewayIamPolicyPtrOutputWithContext(ctx context.Context) GatewayIamPolicyPtrOutput

type GatewayIamPolicyPtrInput 

type GatewayIamPolicyPtrInput interface {
	pulumi.Input

	ToGatewayIamPolicyPtrOutput() GatewayIamPolicyPtrOutput
	ToGatewayIamPolicyPtrOutputWithContext(ctx context.Context) GatewayIamPolicyPtrOutput
}

type GatewayIamPolicyPtrOutput 

type GatewayIamPolicyPtrOutput struct{ *pulumi.OutputState }

func (GatewayIamPolicyPtrOutput) Elem added in v5.21.0 

func (o GatewayIamPolicyPtrOutput) Elem() GatewayIamPolicyOutput

func (GatewayIamPolicyPtrOutput) ElementType 

func (GatewayIamPolicyPtrOutput) ElementType() reflect.Type

func (GatewayIamPolicyPtrOutput) ToGatewayIamPolicyPtrOutput 

func (o GatewayIamPolicyPtrOutput) ToGatewayIamPolicyPtrOutput() GatewayIamPolicyPtrOutput

func (GatewayIamPolicyPtrOutput) ToGatewayIamPolicyPtrOutputWithContext 

func (o GatewayIamPolicyPtrOutput) ToGatewayIamPolicyPtrOutputWithContext(ctx context.Context) GatewayIamPolicyPtrOutput

type GatewayIamPolicyState 

type GatewayIamPolicyState struct {
	// (Computed) The etag of the IAM policy.
	Etag    pulumi.StringPtrInput
	Gateway pulumi.StringPtrInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The region of the gateway for the API.
	// Used to find the parent resource to bind the IAM policy to. If not specified,
	// the value will be parsed from the identifier of the parent resource. If no region is provided in the parent identifier and no
	// region is specified, it is taken from the provider configuration.
	Region pulumi.StringPtrInput
}

func (GatewayIamPolicyState) ElementType 

func (GatewayIamPolicyState) ElementType() reflect.Type

type GatewayInput 

type GatewayInput interface {
	pulumi.Input

	ToGatewayOutput() GatewayOutput
	ToGatewayOutputWithContext(ctx context.Context) GatewayOutput
}

type GatewayMap 

type GatewayMap map[string]GatewayInput

func (GatewayMap) ElementType 

func (GatewayMap) ElementType() reflect.Type

func (GatewayMap) ToGatewayMapOutput 

func (i GatewayMap) ToGatewayMapOutput() GatewayMapOutput

func (GatewayMap) ToGatewayMapOutputWithContext 

func (i GatewayMap) ToGatewayMapOutputWithContext(ctx context.Context) GatewayMapOutput

type GatewayMapInput 

type GatewayMapInput interface {
	pulumi.Input

	ToGatewayMapOutput() GatewayMapOutput
	ToGatewayMapOutputWithContext(context.Context) GatewayMapOutput
}

GatewayMapInput is an input type that accepts GatewayMap and GatewayMapOutput values. You can construct a concrete instance of `GatewayMapInput` via: 

GatewayMap{ "key": GatewayArgs{...} }

type GatewayMapOutput 

type GatewayMapOutput struct{ *pulumi.OutputState }

func (GatewayMapOutput) ElementType 

func (GatewayMapOutput) ElementType() reflect.Type

func (GatewayMapOutput) MapIndex 

func (o GatewayMapOutput) MapIndex(k pulumi.StringInput) GatewayOutput

func (GatewayMapOutput) ToGatewayMapOutput 

func (o GatewayMapOutput) ToGatewayMapOutput() GatewayMapOutput

func (GatewayMapOutput) ToGatewayMapOutputWithContext 

func (o GatewayMapOutput) ToGatewayMapOutputWithContext(ctx context.Context) GatewayMapOutput

type GatewayOutput 

type GatewayOutput struct{ *pulumi.OutputState }

func (GatewayOutput) ElementType 

func (GatewayOutput) ElementType() reflect.Type

func (GatewayOutput) ToGatewayOutput 

func (o GatewayOutput) ToGatewayOutput() GatewayOutput

func (GatewayOutput) ToGatewayOutputWithContext 

func (o GatewayOutput) ToGatewayOutputWithContext(ctx context.Context) GatewayOutput

func (GatewayOutput) ToGatewayPtrOutput 

func (o GatewayOutput) ToGatewayPtrOutput() GatewayPtrOutput

func (GatewayOutput) ToGatewayPtrOutputWithContext 

func (o GatewayOutput) ToGatewayPtrOutputWithContext(ctx context.Context) GatewayPtrOutput

type GatewayPtrInput 

type GatewayPtrInput interface {
	pulumi.Input

	ToGatewayPtrOutput() GatewayPtrOutput
	ToGatewayPtrOutputWithContext(ctx context.Context) GatewayPtrOutput
}

type GatewayPtrOutput 

type GatewayPtrOutput struct{ *pulumi.OutputState }

func (GatewayPtrOutput) Elem added in v5.21.0 

func (o GatewayPtrOutput) Elem() GatewayOutput

func (GatewayPtrOutput) ElementType 

func (GatewayPtrOutput) ElementType() reflect.Type

func (GatewayPtrOutput) ToGatewayPtrOutput 

func (o GatewayPtrOutput) ToGatewayPtrOutput() GatewayPtrOutput

func (GatewayPtrOutput) ToGatewayPtrOutputWithContext 

func (o GatewayPtrOutput) ToGatewayPtrOutputWithContext(ctx context.Context) GatewayPtrOutput

type GatewayState 

type GatewayState struct {
	// Resource name of the API Config for this Gateway. Format: projects/{project}/locations/global/apis/{api}/configs/{apiConfig}.
	// When changing api configs please ensure the new config is a new resource and the lifecycle rule `createBeforeDestroy` is set.
	ApiConfig pulumi.StringPtrInput
	// The default API Gateway host name of the form {gatewayId}-{hash}.{region_code}.gateway.dev.
	DefaultHostname pulumi.StringPtrInput
	// A user-visible name for the API.
	DisplayName pulumi.StringPtrInput
	// Identifier to assign to the Gateway. Must be unique within scope of the parent resource(project).
	GatewayId pulumi.StringPtrInput
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapInput
	// Resource name of the Gateway. Format: projects/{project}/locations/{region}/gateways/{gateway}
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// The region of the gateway for the API.
	Region pulumi.StringPtrInput
}

func (GatewayState) ElementType 

func (GatewayState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.