### Include Example Usage in Documentation

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/README.md

Uncomment this block to include example resource/data source usage in your documentation. Ensure example files exist at the specified path.

```markdown
{{- /* Uncomment this block as you add "examples/{serviceName}/resources/example_1.tf"

## Example Usage

{{tffile "examples/{serviceName}/resources/example_1.tf" }}

*/ -}}
```

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

### Example Usage

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/storage_bucket_grant.md

Provides examples of how to configure the `yandex_storage_bucket_grant` resource for different scenarios, including managing grants for individual users and groups.

```APIDOC
## Example Usage

```terraform
provider "yandex" {
  cloud_id           = "<my_cloud_id>"
  folder_id          = "<my_folder_id>"
  storage_access_key = "<my_storage_access_key>"
  storage_secret_key = "<my_storage_secret_key>"
  token              = "<my_iam_token>"
}

resource "yandex_storage_bucket_grant" "my_grant_0" {
  bucket = "my_bucket_name_0"
  grant {
    id          = "<user_id>"
    permissions = ["READ", "WRITE", "FULL_CONTROL"]
    type        = "CanonicalUser"
  }
}

resource "yandex_storage_bucket_grant" "my_grant_1" {
  bucket = "my_bucket_name_1"
  grant {
    id          = "<user_id>"
    permissions = ["FULL_CONTROL"]
    type        = "CanonicalUser"
  }
  grant {
    uri         = "<group_uri>"
    permissions = ["READ"]
    type        = "Group"
  }
}
```

```terraform
//
// Create new grants on an existing Storage Bucket.
//
resource "yandex_storage_bucket_grant" "my_bucket_grant" {
  bucket = "my_bucket_name_0"
  grant {
    id          = "<user0_id>"
    permissions = ["READ", "WRITE"]
    type        = "CanonicalUser"
  }
  grant {
    id          = "<user1_id>"
    permissions = ["FULL_CONTROL"]
    type        = "CanonicalUser"
  }
  grant {
    uri         = "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
    permissions = ["READ"]
    type        = "Group"
  }
}
```
```

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

### Example Usage

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/backup_policy_bindings.md

Example of how to create a new Cloud Backup Policy Binding using Terraform.

```APIDOC
```terraform
#
# Create a new Cloud Backup Policy Binding
#
resource "yandex_iam_service_account" "test_sa" {
  name = "sa-backup-editor"
}

resource "yandex_resourcemanager_folder_iam_member" "test_binding" {
  folder_id = yandex_iam_service_account.test_sa.folder_id
  role      = "backup.editor"
  member    = "serviceAccount:${yandex_iam_service_account.test_sa.id}"
}

resource "yandex_vpc_network" "test_backup_network" {}

resource "yandex_vpc_subnet" "test_backup_subnet" {
  zone           = "ru-central1-a"
  network_id     = yandex_vpc_network.test_backup_network.id
  v4_cidr_blocks = ["192.168.0.0/24"]
}

# https://yandex.cloud/ru/docs/backup/concepts/vm-connection#vm-network-access
resource "yandex_vpc_security_group" "test_backup_security_group" {
  name       = "cloud-backup"
  network_id = yandex_vpc_network.test_backup_network.id
  egress {
    protocol       = "TCP"
    from_port      = 7770
    to_port        = 7800
    v4_cidr_blocks = ["84.47.172.0/24"]
  }
  egress {
    protocol       = "TCP"
    port           = 443
    v4_cidr_blocks = ["213.180.204.0/24", "213.180.193.0/24", "178.176.128.0/24", "84.201.181.0/24", "84.47.172.0/24"]
  }
  egress {
    protocol       = "TCP"
    port           = 80
    v4_cidr_blocks = ["213.180.204.0/24", "213.180.193.0/24"]
  }
  egress {
    protocol       = "TCP"
    port           = 8443
    v4_cidr_blocks = ["84.47.172.0/24"]
  }
  egress {
    protocol       = "TCP"
    port           = 44445
    v4_cidr_blocks = ["51.250.1.0/24"]
  }
}

data "yandex_compute_image" "ubuntu" {
  family = "ubuntu-2004-lts"
}

resource "yandex_compute_instance" "test_backup_compute" {
  name        = "test-backup-compute"
  platform_id = "standard-v1"
  zone        = "ru-central1-a"

  service_account_id = yandex_iam_service_account.test_sa.id

  network_interface {
    subnet_id          = yandex_vpc_subnet.test_backup_subnet.id
    security_group_ids = [yandex_vpc_security_group.test_backup_security_group.id]
    nat                = true
  }

  boot_disk {
    initialize_params {
      image_id = data.yandex_compute_image.ubuntu.id
    }
  }

  resources {
    cores  = 2
    memory = 4
  }

  metadata = {
    user-data = "#cloud-config\npackages:\n  - curl\n  - perl\n  - jq\nruncmd:\n  - curl https://storage.yandexcloud.net/backup-distributions/agent_installer.sh | sudo bash\n"
  }
}

data "yandex_backup_policy" "test_backup_policy" {
  name = "Default daily"
}

resource "yandex_backup_policy_bindings" "test_backup_binding" {
  instance_id = yandex_compute_instance.test_backup_compute.id
  policy_id   = data.yandex_backup_policy.test_backup_policy.id
}
```
```

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

### Shared Credentials File Example

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/index.md

Example structure for a shared credentials file, defining different profiles with storage access and secret keys.

```shell
[prod]
storage_access_key = prod_access_key_here
storage_secret_key = prod_secret_key_here

[testing]
storage_access_key = testing_access_key_here
storage_secret_key = testing_secret_key_here

[default]
storage_access_key = default_access_key_here
storage_secret_key = default_secret_key_here
```

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

### Example Usage

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/storage_bucket_policy.md

Demonstrates how to configure the `yandex_storage_bucket_policy` resource in Terraform.

```APIDOC
```terraform
provider "yandex" {
  cloud_id           = "<my_cloud_id>"
  folder_id          = "<my_folder_id>"
  storage_access_key = "<my_storage_access_key>"
  storage_secret_key = "<my_storage_secret_key>"
  token              = "<my_iam_token>"
}

resource "yandex_storage_bucket_policy" "my_policy_0" {
  bucket = "my_bucket_name_0"
  policy = <<POLICY
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:*",
      "Resource": [
        "arn:aws:s3:::my-policy-bucket/*",
        "arn:aws:s3:::my-policy-bucket"
      ]
    },
    {
      "Effect": "Deny",
      "Principal": "*",
      "Action": "s3:PutObject",
      "Resource": [
        "arn:aws:s3:::my-policy-bucket/*",
        "arn:aws:s3:::my-policy-bucket"
      ]
    }
  ]
}
POLICY
}
```
```

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

### yandex_sws_waf_rule_set_descriptor

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/sws_waf_rule_set_descriptor.md

Example of how to get information about an existing SWS WAF Rule Descriptor using its name and version.

```APIDOC
## Get SWS WAF Rule Set Descriptor

### Description
Use this data source to retrieve information about an existing SWS WAF Rule Set Descriptor.

### Method
`data "yandex_sws_waf_rule_set_descriptor"`

### Parameters
#### Arguments
- **name** (String) - Required - Name of the RuleSetDescriptor resource to return.
- **version** (String) - Required - Version of the RuleSetDescriptor resource to return.

#### Attributes Reference
- **id** (String) - ID of the rule set.
- **rule_set_descriptor_id** (String) - ID of the rule set.
- **rules** (List of Objects) - List of rules.
  - **anomaly_score** (Number) - Numeric anomaly value.
  - **id** (String) - ID of the rule.
  - **paranoia_level** (Number) - Paranoia level classifies rules according to their aggression.
  - **rule_set_descriptor_id** (String) - ID of the rule.
- **timeouts** (Block) - Configuration block for timeouts.
  - **create** (String) - Timeout for create operations.
  - **delete** (String) - Timeout for delete operations.
  - **read** (String) - Timeout for read operations.
  - **update** (String) - Timeout for update operations.

### Request Example
```terraform
data "yandex_sws_waf_rule_set_descriptor" "owasp4" {
  name    = "OWASP Core Ruleset"
  version = "4.0.0"
}
```

### Response Example
(Attributes are available as data.yandex_sws_waf_rule_set_descriptor.owasp4.id, data.yandex_sws_waf_rule_set_descriptor.owasp4.name, etc.)
```

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

### Create Compute Instance and IAM Binding

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/compute_instance_iam_binding.md

This example demonstrates how to create a new Compute Instance and then assign an IAM binding to it. Ensure the necessary resources like disks and networks are defined.

```terraform
resource "yandex_compute_instance" "vm1" {
  name        = "test"
  platform_id = "standard-v3"
  zone        = "ru-central1-a"

  resources {
    cores  = 2
    memory = 4
  }

  boot_disk {
    disk_id = yandex_compute_disk.boot-disk.id
  }

  network_interface {
    index     = 1
    subnet_id = yandex_vpc_subnet.foo.id
  }

  metadata = {
    foo      = "bar"
    ssh-keys = "ubuntu:${file("~/.ssh/id_ed25519.pub")}"
  }
}

resource "yandex_compute_instance_iam_binding" "editor" {
  image_id = data.yandex_compute_instance.vm1.id

  role = "editor"

  members = [
    "userAccount:some_user_id",
  ]
}
```

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

### Get Lockbox Secret Version Information with Resource Reference

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/lockbox_secret_version.md

This example demonstrates how to get information about an existing Lockbox Secret Version by referencing a `yandex_lockbox_secret` resource and its associated `yandex_lockbox_secret_version` resource. This ensures you are querying the correct, potentially newly created, secret version.

```terraform
resource "yandex_lockbox_secret" "my_secret" {
  # ...
}

resource "yandex_lockbox_secret_version" "my_version" {
  secret_id = yandex_lockbox_secret.my_secret.id
  # ...
}

data "yandex_lockbox_secret_version" "my_version" {
  secret_id  = yandex_lockbox_secret.my_secret.id
  version_id = yandex_lockbox_secret_version.my_version.id
}

output "my_secret_entries" {
  value = data.yandex_lockbox_secret_version.my_version.entries
}
```

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

### Get Cloud Information

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/resourcemanager_cloud.md

Use this data source to retrieve information about an existing Yandex Cloud. Either `cloud_id` or `name` must be specified. This example demonstrates fetching a cloud by its name and outputting its creation timestamp.

```terraform
data "yandex_resourcemanager_cloud" "my_cloud" {
  name = "foo-cloud"
}

output "cloud_create_timestamp" {
  value = data.yandex_resourcemanager_cloud.my_cloud.created_at
}
```

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

### Create YDB Topic

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/ydb_topic.md

Example of creating a YDB Topic with specified codecs, partition count, and retention period. It also configures a consumer with its own codec support and starting timestamp. Requires a `yandex_ydb_database_serverless` resource to be defined.

```terraform
resource "yandex_ydb_topic" "my_topic" {
  database_endpoint = yandex_ydb_database_serverless.database_name.ydb_full_endpoint
  name              = "topic-test"

  supported_codecs    = ["raw", "gzip"]
  partitions_count    = 1
  retention_period_ms = 2000000
  consumer {
    name                          = "consumer-name"
    supported_codecs              = ["raw", "gzip"]
    starting_message_timestamp_ms = 0
  }
}

resource "yandex_ydb_database_serverless" "database_name" {
  name        = "database-name"
  location_id = "ru-central1"
}
```

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

### Example Usage of yandex_cloud_desktops_desktop

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/cloud_desktops_desktop.md

Demonstrates the creation of a network, subnet, desktop group, and a desktop within that group. Ensure you replace placeholder IDs with your actual values.

```terraform
resource "yandex_vpc_network" "network" {}

resource "yandex_vpc_subnet" "subnet" {
	zone 			= "ru-central1-a"
	network_id 		= yandex_vpc_network.network.id
	v4_cidr_blocks 	= ["10.1.0.0/24"]
}

data "yandex_cloud_desktops_image" "desktop_image_by_folder_and_name" {
	name 	  = "Ubuntu 20.04 LTS (2024-12-03)"
}

// desktop group
resource "yandex_cloud_desktops_desktop_group" "desktop_group" {
	name 		= "desktop-group-name"
	folder_id 	= "<your folder id (optional)>"
	image_id 	= data.yandex_cloud_desktops_image.image.id
	description = "Sample description"
	
desktop_template = {
		resources = {
			cores 			= 4
			memory 			= 8
			core_fraction 	= 100
		}
		boot_disk = {
			initialize_params = {
				size = 24
				type = "SSD"
			}
		}
		data_disk = {
			initialize_params = {
				size = 16
				type = "HDD"
			}
		}
		network_interface = {
			network_id = yandex_vpc_network.network.id
			subnet_ids = ["${yandex_vpc_subnet.subnet.id}"]
		}
		group_config = {
			initialize_params = {
				min_ready_desktops 	= 1
				max_desktops_amount = 5
				desktop_type 		= "PERSISTENT"
				members				= [
					{
						id 		= "<your id>"
						type 	= "userAccount"
					}
				]
			}
		}
				
	  	labels = {
    		label1 = "label1-value"
    		label2 = "label2-value"
  		}
}

// desktop
resource "yandex_cloud_desktops_desktop" "desktop" {
	name 				= "desktop-name"
	desktop_group_id 	= yandex_cloud_desktops_desktop_group.desktop_group.desktop_group_id
	
	network_interface = {
		subnet_id = yandex_vpc_subnet.subnet.id
	}

	members = [
		{
			subject_id 		= "bfblmuiaug62t0cki3dq"
			subject_type 	= "userAccount"
		},
	]

	labels = {
		label1 = "label1-value"
		label2 = "label2-value"
	}
}

```

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

### Create Kubernetes Marketplace Helm Release

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/kubernetes_marketplace_helm_release.md

Example of creating a new Kubernetes Marketplace Helm Release. Ensure that the cluster, namespace, and product version IDs are correctly specified. Complex values for installation can be encoded using `yamlencode()`.

```terraform
resource "yandex_kubernetes_marketplace_helm_release" "gwin_helm_release" {
  cluster_id = yandex_kubernetes_cluster.cluster_resource_name.id

  product_version = "f2e04077v04sobds7gkt" # Gwin v1.1.0

  name      = "gwin"
  namespace = kubernetes_namespace.namespace_resource_name.metadata[0].name

  user_values = {
    "controller.folderId" = yandex_resourcemanager_folder.folder_resource_name.id
    "controller.ycServiceAccount.workloadIdentityFederation.serviceAccountID" = yandex_iam_service_account.service_account_resource_name.id
    "controller.defaultBalancerSubnets" = yamlencode([
      yandex_vpc_subnet.subnet_resource_name_1.id,
      yandex_vpc_subnet.subnet_resource_name_2.id
    ])
  }
}
```

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

### Get Entry from Pinned Secret Version

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/lockbox_secret_version_entry.md

This example shows how to retrieve a specific entry from a particular version of a Lockbox secret. It requires both the `secret_id` and `version_id` to pinpoint the exact secret version. The `output` block shows how to access the sensitive text value.

```terraform
resource "yandex_lockbox_secret" "my_secret" {
  # ...
}

resource "yandex_lockbox_secret_version" "my_version" {
  secret_id = yandex_lockbox_secret.my_secret.id
  entries {
    key        = "db_password"
    text_value = "s3cr3t"
  }
  entries {
    key        = "db_user"
    text_value = "admin"
  }
}

data "yandex_lockbox_secret_version_entry" "db_password" {
  secret_id  = yandex_lockbox_secret.my_secret.id
  version_id = yandex_lockbox_secret_version.my_version.id
  key        = "db_password"
}

output "db_password" {
  value     = data.yandex_lockbox_secret_version_entry.db_password.text_value
  sensitive = true
}
```

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

### Create Compute Disk and IAM Binding

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/compute_disk_iam_binding.md

This example demonstrates how to create a new Compute Disk and then establish an IAM binding for it, granting 'editor' role to a specific user account. Ensure the disk exists before applying the IAM binding.

```terraform
resource "yandex_compute_disk" "disk1" {
  name     = "disk-name"
  type     = "network-ssd"
  zone     = "ru-central1-a"
  image_id = "ubuntu-16.04-v20180727"

  labels = {
    environment = "test"
  }
}

resource "yandex_compute_disk_iam_binding" "editor" {
  disk_id = data.yandex_compute_disk.disk1.id

  role = "editor"

  members = [
    "userAccount:some_user_id",
  ]
}
```

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

### Create Compute Filesystem and IAM Binding

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/compute_filesystem_iam_binding.md

This example demonstrates how to create a new Compute Filesystem and then assign an IAM role to specific members for that filesystem. Ensure the filesystem is created before attempting to bind IAM roles.

```terraform
resource "yandex_compute_filesystem" "fs1" {
  name = "fs-name"
  type = "network-ssd"
  zone = "ru-central1-a"
  size = 10

  labels = {
    environment = "test"
  }
}

resource "yandex_compute_filesystem_iam_binding" "editor" {
  filesystem_id = data.yandex_compute_filesystem.fs1.id

  role = "editor"

  members = [
    "userAccount:some_user_id",
  ]
}
```

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

### Configure Kubernetes Provider with Yandex Client Config

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/client_config.md

This example demonstrates how to use the yandex_client_config data source to obtain an IAM token and other details for configuring the Kubernetes provider. Ensure the yandex_kubernetes_cluster data source is also configured to get cluster endpoint and certificate.

```terraform
//
// Example of using Yandex Cloud client configuration
//
data "yandex_client_config" "client" {}

data "yandex_kubernetes_cluster" "kubernetes" {
  name = "kubernetes"
}

provider "kubernetes" {
  load_config_file = false

  host                   = data.yandex_kubernetes_cluster.kubernetes.master.0.external_v4_endpoint
  cluster_ca_certificate = data.yandex_kubernetes_cluster.kubernetes.master.0.cluster_ca_certificate
  token                  = data.yandex_client_config.client.iam_token
}
```

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

### Simple SmartCaptcha Example

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/smartcaptcha_captcha.md

A basic configuration for a Smart Captcha resource. Use this for straightforward deployments.

```terraform
// 
// Simple SmartCaptcha example.
//
resource "yandex_smartcaptcha_captcha" "demo-captcha-simple" {
  deletion_protection = true
  name                = "demo-captcha-simple"
  complexity          = "HARD"
  pre_check_type      = "SLIDER"
  challenge_type      = "IMAGE_TEXT"

  allowed_sites = [
    "example.com",
    "example.ru"
  ]
}

```

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

### yandex_logging_group Resource Example

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/logging_group.md

Example of how to create a new Yandex Cloud Logging Group using Terraform.

```APIDOC
## POST /logging/v1/logGroups

### Description
Creates a new log group in Yandex Cloud Logging.

### Method
POST

### Endpoint
/logging/v1/logGroups

### Parameters
#### Request Body
- **name** (String) - Required - The name of the log group.
- **folder_id** (String) - Required - The ID of the folder to create the log group in.
- **description** (String) - Optional - A description for the log group.
- **labels** (Map Of String) - Optional - A set of key/value label pairs to assign to the resource.

### Request Example
```json
{
  "name": "my-log-group",
  "folder_id": "some-folder-id",
  "description": "My application logs",
  "labels": {
    "environment": "production"
  }
}
```

### Response
#### Success Response (200)
- **id** (String) - The unique identifier of the created log group.
- **name** (String) - The name of the log group.
- **folder_id** (String) - The ID of the folder the log group belongs to.
- **created_at** (String) - The timestamp when the log group was created.
- **status** (String) - The current status of the log group.
- **retention_period** (String) - The log retention period for the group.

#### Response Example
```json
{
  "id": "some-log-group-id",
  "name": "my-log-group",
  "folder_id": "some-folder-id",
  "created_at": "2023-10-27T10:00:00Z",
  "status": "ACTIVE",
  "retention_period": "30d"
}
```
```

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

### yandex_dns_firewall DataSource Example

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/dns_firewall.md

Example usage of the yandex_dns_firewall DataSource to retrieve details of an existing DNS firewall.

```APIDOC
## yandex_dns_firewall (DataSource)

A DNS firewall. For details about the concept, see [DNS firewalls](/docs/dns/concepts/dns-firewall).

## Example usage

```terraform
//
// Get information about existing DNS Firewall.
//
data "yandex_dns_firewall" "foo" {
  dns_firewall_id = yandex_dns_firewall.fw1.id
}

output "whitelist_fqdns" {
  value = data.yandex_dns_firewall.foo.whitelist_fqdns
}
```

## Arguments & Attributes Reference

- `blacklist_fqdns` (Set Of String). List of FQDNs that the DNS firewall blocks.
- `created_at` (*Read-Only*) (String). Creation timestamp.
- `deletion_protection` (Bool). Prevents accidental firewall removal.
- `description` (String). Description of the DNS firewall.
- `dns_firewall_id` (String). ID of the DNS firewall to return.

 To get a DNS firewall ID, make a [DnsFirewallService.List] request.
- `enabled` (Bool). Whether the DNS firewall is enabled.
- `folder_id` (String). ID of the folder that the DNS firewall belongs to.
- `id` (String). ID of the DNS firewall to return.

 To get a DNS firewall ID, make a [DnsFirewallService.List] request.
- `labels` (Map Of String). DNS firewall labels as `key:value` pairs.
- `name` (String). Name of the DNS firewall.
 The name is unique within the folder.
- `resource_config` [Block]. Resource settings.
 Specifies resources that the DNS firewall applies to.
  - `lock_resources` (Bool). Whether the locking policy is enabled.
  - `resource_ids` (Set Of String). Resource ids.
  - `type` (String). Type of the resource.
- `timeouts` [Block]. 
  - `create` (String). A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
  - `delete` (String). A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
  - `read` (String). A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
  - `update` (String). A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
- `whitelist_fqdns` (Set Of String). List of FQDNs that the DNS firewall allows to pass.
```

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

### Create OS Login Settings

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/organizationmanager_os_login_settings.md

Example of creating a new OS Login Settings resource for an organization. Ensure the organization ID is valid and configure SSH key and certificate settings as needed.

```terraform
//
// Create a new OrganizationManager OS Login Settings.
//
resource "yandex_organizationmanager_os_login_settings" "my_settings" {
  organization_id = "sdf4*********3fr"
  user_ssh_key_settings {
    enabled               = true
    allow_manage_own_keys = true
  }
  ssh_certificate_settings {
    enabled = true
  }
}

```

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

### Compute Instance Configuration

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/compute_instance.md

This section details the arguments that can be used to configure a compute instance, including its boot disk, network interfaces, and other hardware-specific settings.

```APIDOC
## Compute Instance Arguments

### `boot_disk` [Block]

The boot disk for the instance. Either `initialize_params` or `disk_id` must be specified.

- `auto_delete` (Bool) - Defines whether the disk will be auto-deleted when the instance is deleted. The default value is `True`.
- `device_name` (String) - Name that can be used to access an attached disk.
- `disk_id` (String) - The ID of the existing disk (such as those managed by `yandex_compute_disk`) to attach as a boot disk.
- `initialize_params` [Block] - Parameters for a new disk that will be created alongside the new instance. Either `initialize_params` or `disk_id` must be set. Either `image_id` or `snapshot_id` must be specified.
  - `block_size` (Number) - Block size of the disk, specified in bytes.
  - `description` (String) - Description of the boot disk.
  - `image_id` (String) - A disk image to initialize this disk from.
  - `kms_key_id` (String) - ID of KMS symmetric key used to encrypt disk.
  - `name` (String) - Name of the boot disk.
  - `size` (Number) - Size of the disk in GB.
  - `snapshot_id` (String) - A snapshot to initialize this disk from.
  - `type` (String) - Disk type.
- `mode` (String) - Type of access to the disk resource. By default, a disk is attached in `READ_WRITE` mode.

### `description` (String)

The resource description.

### `folder_id` (String)

The folder identifier that resource belongs to. If it is not provided, the default provider `folder-id` is used.

### `gpu_cluster_id` (String)

ID of the GPU cluster to attach this instance to.

### `instance_id` (String)

The ID of a specific instance.

### `labels` (Map Of String)

A set of key/value label pairs which assigned to resource.

### `maintenance_grace_period` (String)

Time between notification via metadata service and maintenance. E.g., `60s`.

### `maintenance_policy` (String)

Behavior on maintenance events. Can be: `unspecified`, `migrate`, `restart`. The default is `unspecified`.

### `metadata` (Map Of String)

Metadata key/value pairs to make available from within the instance.

### `name` (String)

The resource name.

### `network_acceleration_type` (String)

Type of network acceleration. Can be `standard` or `software_accelerated`. The default is `standard`.

### `network_interface` [Block]

Networks to attach to the instance. This can be specified multiple times.

- `dns_record` [Block] - List of configurations for creating ipv4 DNS records.
  - `dns_zone_id` (String) - DNS zone ID (if not set, private zone used).
  - `fqdn` (**Required**)(String) - DNS record FQDN (must have a dot at the end).
  - `ptr` (Bool) - When set to `true`, also create a PTR DNS record.
  - `ttl` (Number) - DNS record TTL in seconds.
- `index` (Number) - Index of network interface, will be calculated automatically for instance create or update operations if not specified. Required for attach/detach operations.
- `ip_address` (String) - The private IP address to assign to the instance. If empty, the address will be automatically assigned from the specified subnet.
- `ipv4` (Bool) - Allocate an IPv4 address for the interface. The default value is `true`.
- `ipv6` (Bool) - If `true`, allocate an IPv6 address for the interface. The address will be automatically assigned from the specified subnet.
- `ipv6_address` (String) - The private IPv6 address to assign to the instance.
- `ipv6_dns_record` [Block] - List of configurations for creating ipv6 DNS records.
  - `dns_zone_id` (String) - DNS zone ID (if not set, private zone used).
  - `fqdn` (**Required**)(String) - DNS record FQDN (must have a dot at the end).
  - `ptr` (Bool) - When set to `true`, also create a PTR DNS record.
  - `ttl` (Number) - DNS record TTL in seconds.
- `nat` (Bool) - Provide a public address, for instance, to access the internet over NAT.
- `nat_dns_record` [Block] - List of configurations for creating ipv4 NAT DNS records.
  - `dns_zone_id` (String) - DNS zone ID (if not set, private zone used).
  - `fqdn` (**Required**)(String) - DNS record FQDN (must have a dot at the end).
  - `ptr` (Bool) - When set to `true`, also create a PTR DNS record.
  - `ttl` (Number) - DNS record TTL in seconds.
- `nat_ip_address` (String) - Provide a public address, for instance, to access the internet over NAT. Address should be already reserved in web UI.
- `security_group_ids` (Set Of String) - Security Group (SG) IDs for network interface.
- `subnet_id` (**Required**)(String) - ID of the subnet to attach this interface to. The subnet must exist in the same zone where this instance will be created.

### `id` (String)


```

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

### Create Cloud Registry and IP Permissions

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/cloudregistry_registry_ip_permission.md

This example demonstrates how to create a new Docker registry and then configure IP permissions for it, specifying allowed CIDR blocks for push and pull operations.

```terraform
resource "yandex_cloudregistry_registry" "my_registry" {
  name      = "test-registry"
  folder_id = "test_folder_id"

  labels = {
    my-label = "my-label-value"
  }
  kind      = "DOCKER"
  type      = "LOCAL"

  description = "Some desctiption"
}

resource "yandex_cloudregistry_registry_ip_permission" "my_ip_permission" {
  registry_id = yandex_cloudregistry_registry.my_registry.id
  push        = ["10.1.0.0/16", "10.2.0.0/16", "10.3.0.0/16"]
  pull        = ["10.1.0.0/16", "10.5.0/16"]
}
```

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

### Example Usage of yandex_serverless_eventrouter_rule

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/serverless_eventrouter_rule.md

This is a placeholder for the actual Terraform configuration. It should be replaced with a complete example demonstrating the creation of an event router rule.

```terraform
//
// TBD
//
```

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

### Install YFM for Documentation Build

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/README.md

Installs the Yandex Framework Markdown (YFM) tool, which is required for building the documentation website locally.

```shell
make install-yfm
```

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

### Simple Private Bucket With Static Access Keys

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/storage_bucket.md

This example demonstrates creating a private storage bucket using static access keys and IAM service accounts for permissions. It includes creating a service account and granting it the storage editor role.

```terraform
//
// Simple Private Bucket With Static Access Keys. 
//
locals {
  folder_id = "<folder-id>"
}

provider "yandex" {
  zone = "ru-central1-a"
}

// Create SA
resource "yandex_iam_service_account" "sa" {
  folder_id = local.folder_id
  name      = "tf-test-sa"
}

// Grant permissions
resource "yandex_resourcemanager_folder_iam_member" "sa-editor" {
  folder_id = local.folder_id
  role      = "storage.editor"
  member    = "serviceAccount:${yandex_iam_service_account.sa.id}"
}

```

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

### yandex_alb_target_group Resource Example

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/alb_target_group.md

Example of how to create a new ALB Target Group using Terraform, specifying targets with subnet and IP addresses.

```APIDOC
## yandex_alb_target_group Resource

Creates a target group in the specified folder and adds the specified targets to it.

### Arguments

- `name` (String) - The resource name.
- `description` (String) - The resource description.
- `folder_id` (String) - The folder identifier. Defaults to the provider's `folder-id`.
- `labels` (Map Of String) - A set of key/value label pairs.
- `target` [Block] - A Target resource.
  - `subnet_id` (String) - ID of the subnet that targets are connected to. All targets in the target group must be connected to the same subnet within a single availability zone.
  - `ip_address` (**Required**)(String) - IP address of the target.
  - `external_address` (Bool) - External address of the target.
  - `private_ipv4_address` (Bool) - Private IPv4 address of the target.
- `timeouts` [Block] - Configuration for timeouts.
  - `create` (String) - Timeout for create operations.
  - `delete` (String) - Timeout for delete operations.
  - `update` (String) - Timeout for update operations.

### Attributes

- `created_at` (String) - Timestamp of the target group creation.
- `id` (String) - The unique identifier for the target group.

### Import

The resource can be imported by its resource ID.

```shell
terraform import yandex_alb_target_group.<resource Name> <resource Id>
```
```

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

### Create Disk Placement Group and IAM Binding

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/compute_disk_placement_group_iam_binding.md

This example demonstrates how to create a new disk placement group and then assign an IAM policy binding to it. Ensure the disk placement group is created before attempting to bind IAM policies.

```terraform
resource "yandex_compute_disk_placement_group" "group1" {
  name        = "test-pg"
  folder_id   = "abc*********123"
  description = "my description"
}

resource "yandex_compute_disk_placement_group_iam_binding" "editor" {
  disk_placement_group_id = data.yandex_compute_disk_placement_group.group1.id

  role = "editor"

  members = [
    "userAccount:some_user_id",
  ]
}
```

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

### All Bucket Settings Example

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/storage_bucket.md

This comprehensive example configures a Yandex Cloud Storage bucket with various settings including lifecycle rules, CORS, versioning, encryption, logging, size limits, folder ID, default storage class, anonymous access, HTTPS, and tags. It also includes provider configuration and a KMS key resource.

```terraform
//
// All Bucket settings example. 
//
provider "yandex" {
  token              = "<iam-token>"
  folder_id          = "<folder-id>"
  storage_access_key = "<storage-access-key>"
  storage_secret_key = "<storage-secret-key>"
}

resource "yandex_storage_bucket" "log_bucket" {
  bucket = "my-tf-log-bucket"

  lifecycle_rule {
    id      = "cleanupoldlogs"
    enabled = true
    expiration {
      days = 365
    }
  }
}

resource "yandex_kms_symmetric_key" "key-a" {
  name              = "example-symetric-key"
  description       = "description for key"
  default_algorithm = "AES_128"
  rotation_period   = "8760h" // equal to 1 year
}

resource "yandex_storage_bucket" "all_settings" {
  bucket = "example-tf-settings-bucket"
  website {
    index_document = "index.html"
    error_document = "error.html"
  }

  lifecycle_rule {
    id      = "test"
    enabled = true
    prefix  = "prefix/"
    expiration {
      days = 30
    }
  }
  lifecycle_rule {
    id      = "log"
    enabled = true

    prefix = "log/"

    transition {
      days          = 30
      storage_class = "COLD"
    }

    expiration {
      days = 90
    }
  }

  lifecycle_rule {
    id      = "everything180"
    prefix  = ""
    enabled = true

    expiration {
      days = 180
    }
  }
  lifecycle_rule {
    id      = "cleanupoldversions"
    prefix  = "config/"
    enabled = true

    noncurrent_version_transition {
      days          = 30
      storage_class = "COLD"
    }

    noncurrent_version_expiration {
      days = 90
    }
  }
  lifecycle_rule {
    id                                     = "abortmultiparts"
    prefix                                 = ""
    enabled                                = true
    abort_incomplete_multipart_upload_days = 7
  }

  cors_rule {
    allowed_headers = ["*"]
    allowed_methods = ["GET", "PUT"]
    allowed_origins = ["https://storage-cloud.example.com"]
    expose_headers  = ["ETag"]
    max_age_seconds = 3000
  }

  versioning {
    enabled = true
  }

  server_side_encryption_configuration {
    rule {
      apply_server_side_encryption_by_default {
        kms_master_key_id = yandex_kms_symmetric_key.key-a.id
        sse_algorithm     = "aws:kms"
      }
    }
  }

  logging {
    target_bucket = yandex_storage_bucket.log_bucket.id
    target_prefix = "tf-logs/"
  }

  max_size = 1024

  folder_id = "<folder_id>"

  default_storage_class = "COLD"

  anonymous_access_flags {
    read = true
    list = true
  }

  https = {
    certificate_id = "<certificate_id>"
  }

  tags = {
    some_key = "some_value"
  }
}

```

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

### Get OrganizationManager MFA Enforcement

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/organizationmanager_mfa_enforcement.md

Use this data source to get information about an MFA enforcement configuration. Required arguments include `acr_id`.

```terraform
//
// OrganizationManager MFA Enforcement.
//
data "yandex_organizationmanager_mfa_enforcement" "example_mfa_enforcement" {
  acr_id 	 	      = "any-mfa"
}

```

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

### Create a ClickHouse User with Permissions and Quotas

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/mdb_clickhouse_user.md

This example demonstrates how to provision a ClickHouse user with specific database permissions and resource quotas. Ensure the ClickHouse cluster and database are created prior to this resource.

```terraform
resource "yandex_vpc_network" "foo" {}

resource "yandex_vpc_subnet" "foo" {
  zone           = "ru-central1-a"
  network_id     = yandex_vpc_network.foo.id
  v4_cidr_blocks = ["10.5.0.0/24"]
}

resource "yandex_mdb_clickhouse_cluster" "foo" {
  name        = "test"
  environment = "PRESTABLE"
  network_id  = yandex_vpc_network.foo.id

  resources {
    resource_preset_id = "s2.micro"
    disk_type_id       = "network-ssd"
    disk_size          = 32
  }

  config {
  }

  host {
    type      = "CLICKHOUSE"
    zone      = "ru-central1-a"
    subnet_id = yandex_vpc_subnet.foo.id
  }

  service_account_id = "your_service_account_id"

  maintenance_window {
    type = "ANYTIME"
  }

  lifecycle {
    ignore_changes = [database, user, ]
  }
}

resource "yandex_mdb_clickhouse_database" "foo" {
  cluster_id = yandex_mdb_clickhouse_cluster.foo.id
  name       = "database1"
}

resource "yandex_mdb_clickhouse_user" "foo" {
  cluster_id = yandex_mdb_clickhouse_cluster.foo.id
  name       = "user"
  password   = "your_password"

  permission {
    database_name = yandex_mdb_clickhouse_database.foo.name
  }
  settings {
    max_memory_usage_for_user               = 1000000000
    read_overflow_mode                      = "throw"
    output_format_json_quote_64bit_integers = true
  }
  quota {
    interval_duration = 3600000
    queries           = 10000
    errors            = 1000
  }
  quota {
    interval_duration = 79800000
    queries           = 50000
    errors            = 5000
  }
}
```

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

### Get User SSH Key Information

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/organizationmanager_user_ssh_key.md

Use this data source to get information about an existing User SSH Key. You must specify the `user_ssh_key_id`.

```terraform
//
// Get information about existing OrganizationManager User SSH Key.
//
data "yandex_organizationmanager_user_ssh_key" "my_user_ssh_key" {
  user_ssh_key_id = "some_user_ssh_key_id"
}

output "my_user_ssh_key_name" {
  value = "data.yandex_organizationmanager_user_ssh_key.my_user_ssh_key.name"
}
```

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

### Import IAM Binding

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/container_registry_iam_binding.md

This example shows how to import an existing IAM binding for a Container Registry. Ensure you have the correct registry ID and role.

```shell
# terraform import yandex_container_registry_iam_binding.<binding Name> "<registry_id>,<resource Role>"
terraform import yandex_container_registry_iam_binding.puller "crps9**********k9psn,container-registry.images.puller"
```

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

### Create Certificates with Per-Domain DNS Challenges

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/cm_certificate.md

This example demonstrates creating multiple managed certificates for a set of domains, each requiring a unique DNS CNAME challenge. It also shows how to provision DNS records using the `yandex_dns_recordset` resource, with `challenge_count` set to match the number of domains.

```terraform
resource "yandex_cm_certificate" "example" {
  name    = "example"
  domains = ["one.example.com", "two.example.com"]

  managed {
    challenge_type = "DNS_CNAME"
    challenge_count = 2 # for each domain
  }
}

resource "yandex_dns_recordset" "example" {
  count   = yandex_cm_certificate.example.managed[0].challenge_count
  zone_id = "example-zone-id"
  name    = yandex_cm_certificate.example.challenges[count.index].dns_name
  type    = yandex_cm_certificate.example.challenges[count.index].dns_type
  data    = [yandex_cm_certificate.example.challenges[count.index].dns_value]
  ttl     = 60
}
```

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

### Get DNS Zone Information

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/dns_zone.md

Use this data source to get information about an existing DNS Zone. Ensure that either `dns_zone_id` or `name` is provided.

```terraform
data "yandex_dns_zone" "foo" {
  dns_zone_id = yandex_dns_zone.zone1.id
}

output "zone" {
  value = data.yandex_dns_zone.foo.zone
}
```

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

### Get Datasphere Community Information

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/datasphere_community.md

Use this data source to get information about an existing Datasphere Community by its ID. Ensure the `community_id` is correctly specified.

```terraform
//
// Get information about existing Datasphere Community.
//
data "yandex_datasphere_community" "my_datasphere_community" {
  community_id = "community-id"
}

```

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

### Create a Compute Disk in a Placement Group

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/resources/compute_disk.md

This example demonstrates creating a non-replicated SSD disk and associating it with a specific disk placement group. Ensure the placement group is defined.

```terraform
resource "yandex_compute_disk" "my_vm" {
  name = "non-replicated-disk-name"
  size = 93 // Non-replicated SSD disk size must be divisible by 93G
  type = "network-ssd-nonreplicated"
  zone = "ru-central1-b"

  disk_placement_policy {
    disk_placement_group_id = yandex_compute_disk_placement_group.my_pg.id
  }
}

resource "yandex_compute_disk_placement_group" "my_pg" {
  zone = "ru-central1-b"
}
```

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

### Get Cloud Registry Information

Source: https://github.com/yandex-cloud/terraform-provider-yandex/blob/master/docs/data-sources/cloudregistry_registry.md

Use this data source to get information about an existing Cloud Registry. You need to provide the `registry_id` to identify the registry.

```terraform
data "yandex_cloudregistry_registry" "source" {
  registry_id = "some_registry_id"
}
```