### Complete Example: Active-Active Subscription Multi-Region Setup

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

This example demonstrates provisioning an Active-Active Redis Cloud subscription across two GCP regions with per-region PSC endpoints. It includes shared VPC configuration.

```hcl
provider "google" {
  project = var.gcp_project_id
  region  = "us-central1"
}

# Shared VPC across all regions
resource "google_compute_network" "network" {
  project                 = var.gcp_project_id
  name                    = var.prefix
  auto_create_subnetworks = false
}
```

--------------------------------

### Complete Example: Pro Subscription End-to-End Setup

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

This comprehensive example provisions GCP networking infrastructure, a Redis Cloud Pro subscription, and wires them together using the PSC module. It includes VPC, subnet, and DNS response policy configurations.

```hcl
provider "google" {
  project = var.gcp_project_id
  region  = var.gcp_region   # default: "us-central1"
}

# Look up payment method for Redis Cloud subscription
data "rediscloud_payment_method" "card" {
  card_type = "Visa"
}

# GCP VPC and subnet
resource "google_compute_network" "network" {
  project                 = var.gcp_project_id
  name                    = var.prefix
  auto_create_subnetworks = false
}

resource "google_compute_subnetwork" "subnet" {
  project       = var.gcp_project_id
  name          = var.prefix
  ip_cidr_range = cidrsubnet(var.subnet_cidr_range, 8, 0)  # e.g. 10.0.0.0/24
  region        = var.gcp_region
  network       = google_compute_network.network.id
}

# DNS response policy — must be attached to the VPC before PSC
resource "google_dns_response_policy" "response_policy" {
  response_policy_name = "redis-${google_compute_network.network.name}"
  project              = var.gcp_project_id
  networks {
    network_url = google_compute_network.network.id
  }
}

# Redis Cloud Pro subscription on GCP
resource "rediscloud_subscription" "subscription" {
  name              = "${var.prefix}-psc"
  payment_method_id = data.rediscloud_payment_method.card.id

  cloud_provider {
    provider = "GCP"
    region {
      region                     = var.gcp_region
      networking_deployment_cidr = var.redis_cidr_range  # e.g. "10.0.0.0/24"
    }
  }

  creation_plan {
    dataset_size_in_gb           = 15
    quantity                     = 1
    replication                  = true
    throughput_measurement_by    = "operations-per-second"
    throughput_measurement_value = 20000
  }
}

# PSC module wires everything together
module "psc" {
  source = "RedisLabs/private-service-connect/rediscloud"

  rediscloud_subscription_type = "pro"
  rediscloud_subscription_id   = rediscloud_subscription.subscription.id

  gcp_region = var.gcp_region
  endpoints = [
    {
      gcp_project_id           = var.gcp_project_id
      gcp_vpc_name             = google_compute_network.network.name
      gcp_vpc_subnetwork_name  = google_compute_subnetwork.subnet.name
      gcp_response_policy_name = google_dns_response_policy.response_policy.response_policy_name
    }
  ]

  depends_on = [
    google_compute_network.network,
    google_compute_subnetwork.subnet
  ]
}

output "redis_connection_host" {
  value = module.psc.redis_dns_records[0][0]
}
```

--------------------------------

### Instantiate PSC Module for Pro Subscription

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

This example demonstrates how to instantiate the PSC module for a Redis Cloud Pro subscription, specifying subscription details and GCP network configurations.

```hcl
module "psc" {
  source                       = "RedisLabs/private-service-connect/rediscloud"
  version                      = "1.0.1"
  rediscloud_subscription_type = "pro"
  rediscloud_subscription_id   = "12345"
  gcp_region                   = "us-central1"
  endpoints = [{
    gcp_project_id           = "my-project"
    gcp_vpc_name             = "my-vpc"
    gcp_vpc_subnetwork_name  = "my-subnet"
    gcp_response_policy_name = "redis-my-vpc"
  }]
}
```

--------------------------------

### Handle Invalid Subscription Type Input

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Example demonstrating how an invalid `rediscloud_subscription_type` will cause a plan-time error, enforcing correct usage.

```hcl
# Example — will fail at plan time:
module "bad" {
  source                       = "RedisLabs/private-service-connect/rediscloud"
  rediscloud_subscription_type = "flex"   # ERROR: invalid value
  rediscloud_subscription_id   = "99999"
  gcp_region                   = "us-central1"
  endpoints                    = []
}
# │ Error: Invalid value for variable
# │   rediscloud_subscription_type must be either active-active or pro
```

--------------------------------

### Run Module Tests

Source: https://github.com/redislabs/terraform-rediscloud-private-service-connect/blob/main/README.md

Execute the module tests using the Go test command. Ensure all required environment variables for Redis Cloud and GCP are set.

```shell
go test ./test
```

--------------------------------

### Run All Integration Tests with Terratest

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Executes all integration tests defined in the './test' directory using Go and Terratest. The '-v' flag provides verbose output, and '-timeout' sets a maximum execution time.

```bash
# Run all integration tests
go test ./test -v -timeout 60m
```

--------------------------------

### Direct Submodule Usage for Pro Subscriptions

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Use this module for direct management of the full PSC lifecycle for a Pro subscription. It handles service creation, endpoint registration, and connection acceptance.

```hcl
module "psc_direct" {
  source = "github.com/RedisLabs/terraform-rediscloud-private-service-connect//modules/private_service_connect"

  rediscloud_subscription_id = "12345"
  gcp_region                 = "us-central1"

  endpoints = [
    {
      gcp_project_id           = "my-gcp-project"
      gcp_vpc_name             = "my-vpc"
      gcp_vpc_subnetwork_name  = "my-subnet"
      gcp_response_policy_name = "redis-my-vpc"
    }
  ]

  dns_record_ttl = 120
}

output "service_id"    { value = module.psc_direct.private_service_connect_service_id }
output "endpoint_ids"  { value = module.psc_direct.private_service_connect_endpoint_ids }
output "dns_records"   { value = module.psc_direct.redis_dns_records }
```

--------------------------------

### Expected Output of Integration Tests

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Illustrates the expected output when integration tests are run successfully, indicating that DNS records contain the correct region keys and each endpoint has one service attachment.

```bash
# Expected output (parallel execution):
# --- RUN   TestTerraformPrivateServiceConnect
# --- RUN   TestTerraformPrivateServiceConnect/../examples/active_active
# --- RUN   TestTerraformPrivateServiceConnect/../examples/pro
# PASS: validate stage confirms dns_records contain expected region keys and
#       each endpoint has exactly 1 service attachment
```

--------------------------------

### Deploy PSC for a Pro Redis Cloud Subscription

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Configure the root module for a Pro subscription, specifying the subscription ID, region, and GCP endpoint details. This sets up a single private connection.

```hcl
# Pro subscription — single region, single endpoint
module "psc_pro" {
  source  = "RedisLabs/private-service-connect/rediscloud"
  version = "1.0.1"

  rediscloud_subscription_type = "pro"
  rediscloud_subscription_id   = "12345"

  gcp_region = "us-central1"

  endpoints = [
    {
      gcp_project_id           = "my-gcp-project"
      gcp_vpc_name             = "my-vpc"
      gcp_vpc_subnetwork_name  = "my-subnet"
      gcp_response_policy_name = "redis-my-vpc"
    }
  ]

  dns_record_ttl = 300  # optional, default 300
}

# Outputs:
# module.psc_pro.private_service_connect_service_id   => "psc-svc-abc123"
# module.psc_pro.private_service_connect_endpoint_ids => ["ep-001"]
# module.psc_pro.redis_dns_records                    => [["redis-12345-0.private.redis.io."]]
```

--------------------------------

### Terraform Development Formatting Commands

Source: https://github.com/redislabs/terraform-rediscloud-private-service-connect/blob/main/README.md

Run these commands to format your Terraform code, generate documentation, and lint your configuration.

```shell
terraform fmt  --recursive
terraform-docs markdown --recursive . --output-file README.md
tflint --recursive
```

--------------------------------

### Active-Active Subscriptions with PSC

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Instantiate this module once per GCP region for Active-Active subscriptions. It requires a `rediscloud_region_id` to target specific replica regions.

```hcl
locals {
  regions = {
    "us-central1"  = 101
    "europe-west1" = 202
  }
}

module "psc_aa" {
  source   = "RedisLabs/private-service-connect/rediscloud"
  version  = "1.0.1"
  for_each = local.regions

  rediscloud_subscription_type = "active-active"
  rediscloud_subscription_id   = rediscloud_active_active_subscription.sub.id
  rediscloud_region_id         = each.value   # region-specific numeric ID

  gcp_region = each.key

  endpoints = [
    {
      gcp_project_id           = "my-gcp-project"
      gcp_vpc_name             = "shared-vpc"
      gcp_vpc_subnetwork_name  = "subnet-${each.key}"
      gcp_response_policy_name = "redis-shared-vpc"
    }
  ]
}

# Access per-region outputs:
output "us_central1_dns" {
  value = module.psc_aa["us-central1"].redis_dns_records
}
output "europe_west1_dns" {
  value = module.psc_aa["europe-west1"].redis_dns_records
}
```

--------------------------------

### Configure Active-Active Private Service Connect

Source: https://github.com/redislabs/terraform-rediscloud-private-service-connect/blob/main/README.md

Use this configuration to set up Private Service Connect for an active-active Redis Cloud subscription. Ensure the GCP provider and necessary variables are defined.

```hcl
provider "gcp" {
  region = var.region
}

module "psc" {
  source  = "RedisLabs/private-service-connect/rediscloud"

  rediscloud_subscription_type = "active-active"
  rediscloud_subscription_id   = var.subscription_id
  rediscloud_region_id         = var.region_id
  
  gcp_region = var.gcp_region
  
  endpoints = [
    {
        gcp_project_id          = var.gcp_project_id
        gcp_vpc_name            = var.gcp_vpc_name
        gcp_vpc_subnetwork_name = var.gcp_vpc_subnetwork_name
    }
  ]
}
```

--------------------------------

### Configure Active-Active Redis Cloud Subscription

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Sets up an Active-Active subscription for Redis Cloud, specifying memory limits, quantity, and regional configurations. Requires a valid payment method ID.

```terraform
resource "rediscloud_active_active_subscription" "subscription" {
  name              = "${var.prefix}-psc-aa"
  payment_method_id = data.rediscloud_payment_method.card.id
  cloud_provider    = "GCP"

  creation_plan {
    memory_limit_in_gb = 1
    quantity           = 1
    dynamic "region" {
      for_each = { for idx, key in var.gcp_regions : key => idx }
      content {
        region                      = region.key
        networking_deployment_cidr  = cidrsubnet(var.cidr_range, 8, region.value)
        write_operations_per_second = 1000
        read_operations_per_second  = 1000
      }
    }
  }
}
```

--------------------------------

### Run Specific Integration Test with Terratest

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Executes a specific integration test, identified by its name, using Go and Terratest. This is useful for targeted testing and debugging.

```bash
# Run a specific test
go test ./test -v -run TestTerraformPrivateServiceConnect -timeout 60m
```

--------------------------------

### Configure Kubernetes ConfigMap with Redis Hostname

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

This snippet shows how to use the DNS record output from the PSC module to configure a Kubernetes ConfigMap for application access to Redis.

```hcl
resource "kubernetes_config_map" "redis_config" {
  metadata { name = "redis" }
  data = {
    REDIS_HOST = module.psc.redis_dns_records[0][0]
    REDIS_PORT = "6379"
  }
}
```

--------------------------------

### Deploy Redis Cloud Private Service Connect Module

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Instantiates the Redis Cloud Private Service Connect module for each specified GCP region. This requires the subscription ID and region-specific details.

```terraform
module "psc" {
  source   = "RedisLabs/private-service-connect/rediscloud"
  for_each = toset(var.gcp_regions)

  rediscloud_subscription_type = "active-active"
  rediscloud_subscription_id   = rediscloud_active_active_subscription.subscription.id
  rediscloud_region_id = {
    for r in rediscloud_active_active_subscription_regions.regions.region :
    r.region => r.region_id
  }[each.key]

  gcp_region = each.key
  endpoints = [
    {
      gcp_project_id           = var.gcp_project_id
      gcp_vpc_name             = google_compute_network.network.name
      gcp_vpc_subnetwork_name  = google_compute_subnetwork.subnets[each.key].name
      gcp_response_policy_name = google_dns_response_policy.response_policy.response_policy_name
    }
  ]

  depends_on = [google_compute_network.network, google_compute_subnetwork.subnets]
}
```

--------------------------------

### Output Redis DNS Records

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

This snippet shows how to output the DNS records for Redis instances managed by the PSC module, which can be used for application configuration.

```hcl
output "redis_hostnames" {
  value = module.psc.redis_dns_records
  # => [["redis-12345-0.c.redis-prod.internal."]]
}
```

--------------------------------

### Configure Terraform Providers for Redis Cloud PSC

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Declare required Terraform providers and their versions for Redis Cloud and Google Cloud. Ensure compatibility with the module.

```hcl
terraform {
  required_version = "~> 1.2"

  required_providers {
    rediscloud = {
      source  = "RedisLabs/rediscloud"
      version = "~> 2.1"
    }
    google = {
      source  = "hashicorp/google"
      version = "~> 6.5"
    }
  }
}
```

--------------------------------

### Configure Multiple Endpoints for a Pro Subscription

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Connect a single Pro Redis Cloud subscription to multiple GCP subnetworks by providing a list of endpoint configurations. This allows access from different VPCs.

```hcl
# Connect a single Pro subscription to two different GCP subnetworks
module "psc_multi_endpoint" {
  source  = "RedisLabs/private-service-connect/rediscloud"
  version = "1.0.1"

  rediscloud_subscription_type = "pro"
  rediscloud_subscription_id   = "12345"
  gcp_region                   = "us-central1"

  endpoints = [
    {
      gcp_project_id           = "project-a"
      gcp_vpc_name             = "vpc-prod"
      gcp_vpc_subnetwork_name  = "subnet-prod"
      gcp_response_policy_name = "redis-vpc-prod"
    },
    {
      gcp_project_id           = "project-b"
      gcp_vpc_name             = "vpc-staging"
      gcp_vpc_subnetwork_name  = "subnet-staging"
      gcp_response_policy_name = "redis-vpc-staging"
    }
  ]
}

# Results in:
# - 2x rediscloud_private_service_connect_endpoint resources
# - 2x google_compute_address (internal IPs, one per endpoint)
# - 2x google_compute_forwarding_rule
# - 2x google_dns_response_policy_rule
```

--------------------------------

### Set up GCP DNS Response Policy

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Creates a DNS response policy in GCP for the Redis Cloud network. This is essential for managing DNS resolution within the private network.

```terraform
resource "google_dns_response_policy" "response_policy" {
  response_policy_name = "redis-${google_compute_network.network.name}"
  project              = var.gcp_project_id
  networks {
    network_url = google_compute_network.network.id
  }
}
```

--------------------------------

### Set Environment Variables for Integration Tests

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Configures the necessary environment variables for running integration tests with Terratest. This includes Redis Cloud credentials and GCP project details.

```bash
# Set required environment variables
export REDISCLOUD_ACCESS_KEY="your-access-key"
export REDISCLOUD_SECRET_KEY="your-secret-key"
export GCP_PROJECT_ID="your-gcp-project"
export GOOGLE_CREDENTIALS="$(cat /path/to/service-account.json)"
```

--------------------------------

### Configure Active-Active Subscription Regions

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Defines the regional settings for an Active-Active Redis Cloud subscription, including networking CIDR and database configurations. This resource must be used in conjunction with `rediscloud_active_active_subscription`.

```terraform
resource "rediscloud_active_active_subscription_regions" "regions" {
  subscription_id = rediscloud_active_active_subscription.subscription.id
  dynamic "region" {
    for_each = { for idx, key in var.gcp_regions : key => idx }
    content {
      region                     = region.key
      networking_deployment_cidr = cidrsubnet(var.cidr_range, 8, region.value)
      database {
        database_id                       = rediscloud_active_active_subscription_database.database.db_id
        database_name                     = rediscloud_active_active_subscription_database.database.name
        local_write_operations_per_second = 1000
        local_read_operations_per_second  = 1000
      }
    }
  }
}
```

--------------------------------

### Configure GCP Subnets for Redis Cloud

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Defines GCP subnets for each specified region using Terraform's for_each meta-argument. Ensure the CIDR range is correctly defined.

```terraform
resource "google_compute_subnetwork" "subnets" {
  for_each      = { for idx, key in var.gcp_regions : key => idx }
  project       = var.gcp_project_id
  name          = "${var.prefix}-${each.key}"
  ip_cidr_range = cidrsubnet(var.cidr_range, 8, each.value)
  region        = each.key
  network       = google_compute_network.network.id
}
```

--------------------------------

### Internal GCP Service Attachment Provisioning

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

This submodule is called internally by PSC submodules to provision necessary GCP resources for each service attachment. It is not typically used directly.

```hcl
module "gcp_service_attachments" {
  source = "../gcp_service_attachments"

  count = length(var.endpoints)

  rediscloud_service_attachments = rediscloud_private_service_connect_endpoint.endpoint[count.index].service_attachments
  # service_attachments schema:
  # [{
  #   name                 = "projects/redis-prod/regions/us-central1/serviceAttachments/sa-abc"
  #   forwarding_rule_name = "redis-12345-0-fwd"
  #   ip_address_name      = "redis-12345-0-ip"
  #   dns_record           = "redis-12345-0.c.redis-prod.internal."
  # }]

  gcp_project_id           = var.endpoints[count.index].gcp_project_id
  gcp_region               = var.gcp_region
  gcp_vpc_name             = var.endpoints[count.index].gcp_vpc_name
  gcp_vpc_subnetwork_name  = var.endpoints[count.index].gcp_vpc_subnetwork_name
  gcp_response_policy_name = var.endpoints[count.index].gcp_response_policy_name

  dns_record_ttl = var.dns_record_ttl
}
```

--------------------------------

### Output PSC Service ID

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

This snippet shows how to output the Private Service Connect service ID, which can be used for referencing the PSC service in other configurations.

```hcl
output "psc_service" {
  value = module.psc.private_service_connect_service_id
  # => "psc-svc-abc123def456"
}
```

--------------------------------

### Output PSC Endpoint IDs

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

This snippet shows how to output the Private Service Connect endpoint IDs, which can be used for managing or referencing individual PSC endpoints.

```hcl
output "psc_endpoints" {
  value = module.psc.private_service_connect_endpoint_ids
  # => ["ep-001abc", "ep-002def"]
}
```

--------------------------------

### Output Redis DNS Records

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Outputs all DNS records for the deployed Redis Cloud instances across different regions. This helps in verifying connectivity and accessing the databases.

```terraform
output "all_dns_records" {
  value = { for region, mod in module.psc : region => mod.redis_dns_records }
  # => {
  #   "us-central1"  = [["redis-sub-0.c.redis-prod.internal."]]
  #   "europe-west1" = [["redis-sub-0.c.redis-prod-eu.internal."]]
  # }
}
```

--------------------------------

### Validate Redis Cloud Subscription Type Input

Source: https://context7.com/redislabs/terraform-rediscloud-private-service-connect/llms.txt

Define a variable with validation to ensure only 'active-active' or 'pro' subscription types are accepted, preventing configuration errors.

```hcl
variable "rediscloud_subscription_type" {
  type        = string
  description = "The subscription type - `active-active` or `pro`"
  validation {
    condition     = can(regex("^(active-active|pro)$", var.rediscloud_subscription_type))
    error_message = "rediscloud_subscription_type must be either active-active or pro"
  }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.