opencode-skills-collection 4.1.15 → 4.1.16

package/bundled-skills/azure-resource-manager-cosmosdb-dotnet/references/throughput.md

@@ -0,0 +1,308 @@
+# Throughput Configuration
+
+Patterns for configuring and managing throughput (RU/s) for Cosmos DB resources.
+
+## Throughput Concepts
+
+| Type | Description | Min RU/s | Use Case |
+|------|-------------|----------|----------|
+| **Manual** | Fixed provisioned throughput | 400 | Predictable workloads |
+| **Autoscale** | Scales between 10% and max | 1000 (max) | Variable workloads |
+| **Serverless** | Pay per request | N/A | Dev/test, sporadic traffic |
+
+## Database-Level Throughput (Shared)
+
+Throughput shared across all containers in the database.
+
+### Set Manual Throughput
+
+```csharp
+using Azure.ResourceManager.CosmosDB;
+using Azure.ResourceManager.CosmosDB.Models;
+
+// Create database with shared throughput
+var databaseData = new CosmosDBSqlDatabaseCreateOrUpdateContent(
+    new CosmosDBSqlDatabaseResourceInfo("my-database"))
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        Throughput = 400
+    }
+};
+
+await databaseCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "my-database",
+    databaseData);
+```
+
+### Set Autoscale Throughput
+
+```csharp
+var databaseData = new CosmosDBSqlDatabaseCreateOrUpdateContent(
+    new CosmosDBSqlDatabaseResourceInfo("my-database"))
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        AutoscaleSettings = new AutoscaleSettings
+        {
+            MaxThroughput = 4000  // Scales between 400-4000 RU/s
+        }
+    }
+};
+```
+
+### Update Database Throughput
+
+```csharp
+var database = await account.GetCosmosDBSqlDatabaseAsync("my-database");
+
+// Update to manual throughput
+var throughputData = new ThroughputSettingsUpdateData(
+    new ThroughputSettingsResourceInfo
+    {
+        Throughput = 800
+    });
+
+await database.Value.CreateOrUpdateCosmosDBSqlDatabaseThroughputAsync(
+    WaitUntil.Completed,
+    throughputData);
+```
+
+### Get Database Throughput
+
+```csharp
+var database = await account.GetCosmosDBSqlDatabaseAsync("my-database");
+var throughput = await database.Value.GetCosmosDBSqlDatabaseThroughputAsync();
+
+Console.WriteLine($"Throughput: {throughput.Value.Data.Resource.Throughput}");
+Console.WriteLine($"Min Throughput: {throughput.Value.Data.Resource.MinimumThroughput}");
+
+if (throughput.Value.Data.Resource.AutoscaleSettings != null)
+{
+    Console.WriteLine($"Autoscale Max: {throughput.Value.Data.Resource.AutoscaleSettings.MaxThroughput}");
+}
+```
+
+## Container-Level Throughput (Dedicated)
+
+Throughput dedicated to a single container.
+
+### Set Manual Throughput
+
+```csharp
+var containerData = new CosmosDBSqlContainerCreateOrUpdateContent(
+    new CosmosDBSqlContainerResourceInfo("my-container")
+    {
+        PartitionKey = new CosmosDBContainerPartitionKey
+        {
+            Paths = { "/partitionKey" },
+            Kind = CosmosDBPartitionKind.Hash
+        }
+    })
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        Throughput = 1000
+    }
+};
+
+await containerCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "my-container",
+    containerData);
+```
+
+### Set Autoscale Throughput
+
+```csharp
+var containerData = new CosmosDBSqlContainerCreateOrUpdateContent(
+    new CosmosDBSqlContainerResourceInfo("my-container")
+    {
+        PartitionKey = new CosmosDBContainerPartitionKey
+        {
+            Paths = { "/partitionKey" },
+            Kind = CosmosDBPartitionKind.Hash
+        }
+    })
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        AutoscaleSettings = new AutoscaleSettings
+        {
+            MaxThroughput = 10000  // Scales between 1000-10000 RU/s
+        }
+    }
+};
+```
+
+### Update Container Throughput
+
+```csharp
+var container = await database.GetCosmosDBSqlContainerAsync("my-container");
+
+// Update to new throughput
+var throughputData = new ThroughputSettingsUpdateData(
+    new ThroughputSettingsResourceInfo
+    {
+        Throughput = 2000
+    });
+
+await container.Value.CreateOrUpdateCosmosDBSqlContainerThroughputAsync(
+    WaitUntil.Completed,
+    throughputData);
+```
+
+### Get Container Throughput
+
+```csharp
+var container = await database.GetCosmosDBSqlContainerAsync("my-container");
+var throughput = await container.Value.GetCosmosDBSqlContainerThroughputAsync();
+
+Console.WriteLine($"Throughput: {throughput.Value.Data.Resource.Throughput}");
+```
+
+## Migrate Between Throughput Modes
+
+### Manual to Autoscale
+
+```csharp
+var container = await database.GetCosmosDBSqlContainerAsync("my-container");
+
+// Migrate to autoscale
+await container.Value.MigrateCosmosDBSqlContainerToAutoscaleAsync(WaitUntil.Completed);
+```
+
+### Autoscale to Manual
+
+```csharp
+var container = await database.GetCosmosDBSqlContainerAsync("my-container");
+
+// Migrate to manual (uses current autoscale throughput as manual value)
+await container.Value.MigrateCosmosDBSqlContainerToManualThroughputAsync(WaitUntil.Completed);
+```
+
+### Database-Level Migration
+
+```csharp
+var database = await account.GetCosmosDBSqlDatabaseAsync("my-database");
+
+// To autoscale
+await database.Value.MigrateCosmosDBSqlDatabaseToAutoscaleAsync(WaitUntil.Completed);
+
+// To manual
+await database.Value.MigrateCosmosDBSqlDatabaseToManualThroughputAsync(WaitUntil.Completed);
+```
+
+## Throughput Calculation Guidelines
+
+### Estimating RU/s
+
+| Operation | Approximate RU Cost |
+|-----------|---------------------|
+| Point read (1KB doc by ID + partition key) | 1 RU |
+| Write (1KB doc) | 5-10 RU |
+| Query (simple, single partition) | 2-5 RU |
+| Query (complex, cross-partition) | 10-100+ RU |
+
+### Sizing Formula
+
+```
+Required RU/s = (Reads/sec × RU per read) + (Writes/sec × RU per write) + (Queries/sec × RU per query)
+```
+
+### Autoscale Tiers
+
+| Max Throughput | Min Throughput (10%) | Monthly Cost Estimate |
+|----------------|----------------------|----------------------|
+| 1,000 RU/s | 100 RU/s | ~$58 |
+| 4,000 RU/s | 400 RU/s | ~$233 |
+| 10,000 RU/s | 1,000 RU/s | ~$584 |
+| 100,000 RU/s | 10,000 RU/s | ~$5,840 |
+
+## Best Practices
+
+1. **Start with autoscale** for new workloads until you understand traffic patterns
+2. **Use database-level throughput** when containers have similar access patterns
+3. **Use container-level throughput** for containers with distinct performance needs
+4. **Monitor RU consumption** via Azure Monitor to right-size throughput
+5. **Set alerts** for 429 (rate limiting) errors
+6. **Consider serverless** for dev/test or sporadic workloads
+
+## Error Handling
+
+```csharp
+try
+{
+    await container.Value.CreateOrUpdateCosmosDBSqlContainerThroughputAsync(
+        WaitUntil.Completed,
+        throughputData);
+}
+catch (RequestFailedException ex) when (ex.Status == 400)
+{
+    // Common: throughput below minimum or invalid autoscale settings
+    Console.WriteLine($"Invalid throughput configuration: {ex.Message}");
+}
+catch (RequestFailedException ex) when (ex.Status == 409)
+{
+    // Conflict: migration already in progress
+    Console.WriteLine($"Throughput migration in progress: {ex.Message}");
+}
+```
+
+## Throughput for Other APIs
+
+### Cassandra Keyspace
+
+```csharp
+var keyspaceData = new CassandraKeyspaceCreateOrUpdateContent(
+    new CassandraKeyspaceResourceInfo("my-keyspace"))
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        Throughput = 400
+    }
+};
+```
+
+### MongoDB Database
+
+```csharp
+var mongoDbData = new MongoDBDatabaseCreateOrUpdateContent(
+    new MongoDBDatabaseResourceInfo("my-mongodb"))
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        AutoscaleSettings = new AutoscaleSettings
+        {
+            MaxThroughput = 4000
+        }
+    }
+};
+```
+
+### Gremlin Database
+
+```csharp
+var gremlinData = new GremlinDatabaseCreateOrUpdateContent(
+    new GremlinDatabaseResourceInfo("my-gremlin"))
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        Throughput = 400
+    }
+};
+```
+
+### Table API
+
+```csharp
+var tableData = new CosmosDBTableCreateOrUpdateContent(
+    new CosmosDBTableResourceInfo("my-table"))
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        Throughput = 400
+    }
+};
+```

package/bundled-skills/azure-resource-manager-sql-dotnet/SKILL.md

@@ -5,6 +5,9 @@ risk: critical
 source: community
 date_added: '2026-02-27'
 ---
+## Bundled upstream support
+
+Supporting files are included at skill-relative paths. See [UPSTREAM-NOTICE.md](UPSTREAM-NOTICE.md) for their pinned sources, licenses, hashes, and import changes.
 
 # Azure.ResourceManager.Sql (.NET)
 

package/bundled-skills/azure-resource-manager-sql-dotnet/UPSTREAM-LICENSE.txt

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/bundled-skills/azure-resource-manager-sql-dotnet/UPSTREAM-NOTICE.md

@@ -0,0 +1,15 @@
+# Upstream helpers for azure-resource-manager-sql-dotnet
+
+The files listed below were recovered from [microsoft/skills](https://github.com/microsoft/skills) at commit `fc164ba1d7a0c10377dbcc1c9ac07253b9329fdb`. The repository ID is `1135891523`.
+
+They retain the upstream **MIT** license reproduced in [UPSTREAM-LICENSE.txt](UPSTREAM-LICENSE.txt). This notice applies to the listed support files; it does not replace the license metadata of other catalog files. Preserve the upstream license and this attribution when redistributing them.
+
+License wording is unchanged; text-only trailing whitespace and EOF blank lines are normalized. Original license: https://github.com/microsoft/skills/blob/fc164ba1d7a0c10377dbcc1c9ac07253b9329fdb/LICENSE
+
+| Local file | Original upstream path | Original Git blob SHA | Import changes |
+| --- | --- | --- | --- |
+| `references/server-management.md` | `.github/plugins/azure-sdk-dotnet/skills/azure-resource-manager-sql-dotnet/references/server-management.md` | `adf798802cd54d0fd8b5e8ab6edcc58222918e62` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/database-operations.md` | `.github/plugins/azure-sdk-dotnet/skills/azure-resource-manager-sql-dotnet/references/database-operations.md` | `542dcfa8d966768fa701157e7f93bff750ff0145` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/elastic-pools.md` | `.github/plugins/azure-sdk-dotnet/skills/azure-resource-manager-sql-dotnet/references/elastic-pools.md` | `48b3f486310d6b68a3a74db2ac4168c6fca9661e` | text-only trailing whitespace and EOF blank lines normalized |
+
+Cloud examples and setup/evaluation scripts use the configured Azure identity and resources. Installing these files does not authenticate, provision, receive messages, or run an evaluation. Runtime verification against a live account is outside this restoration.

package/bundled-skills/azure-resource-manager-sql-dotnet/references/database-operations.md

@@ -0,0 +1,268 @@
+# Database Operations
+
+Advanced database operations for Azure SQL.
+
+## Create Database with vCore SKU
+
+```csharp
+using Azure.ResourceManager.Sql;
+using Azure.ResourceManager.Sql.Models;
+
+var databaseData = new SqlDatabaseData(AzureLocation.EastUS)
+{
+    Sku = new SqlSku("GP_Gen5_2")
+    {
+        Tier = "GeneralPurpose",
+        Family = "Gen5",
+        Capacity = 2 // vCores
+    },
+    MaxSizeBytes = 32L * 1024 * 1024 * 1024, // 32 GB
+    ZoneRedundant = false,
+    ReadScale = SqlDatabaseReadScale.Disabled,
+    RequestedBackupStorageRedundancy = SqlBackupStorageRedundancy.Geo
+};
+
+var operation = await databaseCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "my-vcore-database",
+    databaseData);
+```
+
+## Create Serverless Database
+
+```csharp
+var databaseData = new SqlDatabaseData(AzureLocation.EastUS)
+{
+    Sku = new SqlSku("GP_S_Gen5_2")
+    {
+        Tier = "GeneralPurpose",
+        Family = "Gen5",
+        Capacity = 2 // Max vCores
+    },
+    AutoPauseDelay = 60, // Minutes of inactivity before auto-pause
+    MinCapacity = 0.5,   // Minimum vCores (can be fractional)
+    MaxSizeBytes = 32L * 1024 * 1024 * 1024
+};
+
+await databaseCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "my-serverless-db",
+    databaseData);
+```
+
+## Scale Database
+
+```csharp
+// Get existing database
+var database = await databaseCollection.GetAsync("my-database");
+
+// Update SKU
+var updateData = new SqlDatabaseData(database.Value.Data.Location)
+{
+    Sku = new SqlSku("S3") { Tier = "Standard" }
+};
+
+await databaseCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "my-database",
+    updateData);
+```
+
+## Copy Database
+
+```csharp
+var copyData = new SqlDatabaseData(AzureLocation.EastUS)
+{
+    CreateMode = SqlDatabaseCreateMode.Copy,
+    SourceDatabaseId = sourceDatabase.Id,
+    Sku = new SqlSku("S0") { Tier = "Standard" }
+};
+
+await targetDatabaseCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "database-copy",
+    copyData);
+```
+
+## Restore Database from Point-in-Time
+
+```csharp
+var restoreData = new SqlDatabaseData(AzureLocation.EastUS)
+{
+    CreateMode = SqlDatabaseCreateMode.PointInTimeRestore,
+    SourceDatabaseId = sourceDatabase.Id,
+    RestorePointInTime = DateTimeOffset.UtcNow.AddHours(-2), // 2 hours ago
+    Sku = new SqlSku("S0") { Tier = "Standard" }
+};
+
+await databaseCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "restored-database",
+    restoreData);
+```
+
+## Restore Deleted Database
+
+```csharp
+// List deleted databases
+var deletedDatabases = server.GetRestorableDroppedDatabases();
+
+await foreach (var deleted in deletedDatabases)
+{
+    Console.WriteLine($"Deleted: {deleted.Data.DatabaseName} at {deleted.Data.DeletionOn}");
+
+    // Restore the deleted database
+    var restoreData = new SqlDatabaseData(AzureLocation.EastUS)
+    {
+        CreateMode = SqlDatabaseCreateMode.Restore,
+        RestorableDroppedDatabaseId = deleted.Id,
+        Sku = new SqlSku("S0") { Tier = "Standard" }
+    };
+
+    await databaseCollection.CreateOrUpdateAsync(
+        WaitUntil.Completed,
+        "restored-deleted-db",
+        restoreData);
+
+    break; // Restore first one
+}
+```
+
+## Geo-Restore Database
+
+```csharp
+// List recoverable databases (geo-replicated backups)
+var recoverableDatabases = server.GetRecoverableDatabases();
+
+await foreach (var recoverable in recoverableDatabases)
+{
+    var restoreData = new SqlDatabaseData(AzureLocation.WestUS) // Different region
+    {
+        CreateMode = SqlDatabaseCreateMode.Recovery,
+        RecoverableDatabaseId = recoverable.Id,
+        Sku = new SqlSku("S0") { Tier = "Standard" }
+    };
+
+    await targetDatabaseCollection.CreateOrUpdateAsync(
+        WaitUntil.Completed,
+        "geo-restored-db",
+        restoreData);
+
+    break;
+}
+```
+
+## Configure Long-Term Retention
+
+```csharp
+var ltrPolicy = new LongTermRetentionPolicyData
+{
+    WeeklyRetention = "P4W",  // 4 weeks
+    MonthlyRetention = "P12M", // 12 months
+    YearlyRetention = "P5Y",   // 5 years
+    WeekOfYear = 1 // First week for yearly backup
+};
+
+var ltrPolicyResource = database.GetLongTermRetentionPolicy();
+await ltrPolicyResource.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    ltrPolicy);
+```
+
+## Configure Short-Term Retention
+
+```csharp
+var strPolicy = new ShortTermRetentionPolicyData
+{
+    RetentionDays = 14, // 7-35 days
+    DiffBackupIntervalInHours = 12 // 12 or 24 hours
+};
+
+var strPolicyResource = database.GetShortTermRetentionPolicy();
+await strPolicyResource.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    strPolicy);
+```
+
+## Export Database to Bacpac
+
+```csharp
+var exportRequest = new DatabaseExportDefinition
+{
+    StorageKeyType = StorageKeyType.StorageAccessKey,
+    StorageKey = "<storage-account-key>",
+    StorageUri = new Uri("https://mystorageaccount.blob.core.windows.net/backups/mydb.bacpac"),
+    AdministratorLogin = "sqladmin",
+    AdministratorLoginPassword = "YourPassword123!"
+};
+
+var exportOperation = await database.ExportAsync(WaitUntil.Completed, exportRequest);
+```
+
+## Import Database from Bacpac
+
+```csharp
+var importRequest = new ImportExistingDatabaseDefinition
+{
+    StorageKeyType = StorageKeyType.StorageAccessKey,
+    StorageKey = "<storage-account-key>",
+    StorageUri = new Uri("https://mystorageaccount.blob.core.windows.net/backups/mydb.bacpac"),
+    AdministratorLogin = "sqladmin",
+    AdministratorLoginPassword = "YourPassword123!"
+};
+
+// Import into existing database
+var importOperation = await database.ImportAsync(WaitUntil.Completed, importRequest);
+```
+
+## Rename Database
+
+```csharp
+var renameRequest = new ResourceMoveDefinition(
+    new ResourceIdentifier($"{server.Id}/databases/new-database-name"));
+
+await database.RenameAsync(renameRequest);
+```
+
+## Delete Database
+
+```csharp
+var database = await databaseCollection.GetAsync("my-database");
+await database.Value.DeleteAsync(WaitUntil.Completed);
+```
+
+## Transparent Data Encryption
+
+```csharp
+// TDE is enabled by default for new databases
+// To check or modify:
+var tdeResource = database.GetSqlDatabaseTransparentDataEncryption();
+var tde = await tdeResource.GetAsync();
+
+Console.WriteLine($"TDE State: {tde.Value.Data.State}");
+
+// Disable TDE (not recommended)
+var tdeData = new SqlDatabaseTransparentDataEncryptionData
+{
+    State = TransparentDataEncryptionState.Disabled
+};
+await tdeResource.CreateOrUpdateAsync(WaitUntil.Completed, tdeData);
+```
+
+## Database Threat Detection
+
+```csharp
+var threatDetectionData = new SqlDatabaseSecurityAlertPolicyData
+{
+    State = SecurityAlertsPolicyState.Enabled,
+    DisabledAlerts = { }, // Empty = all alerts enabled
+    EmailAddresses = { "security@contoso.com" },
+    EmailAccountAdmins = true,
+    RetentionDays = 30,
+    StorageEndpoint = "https://mystorageaccount.blob.core.windows.net",
+    StorageAccountAccessKey = "<storage-key>"
+};
+
+var securityPolicy = database.GetSqlDatabaseSecurityAlertPolicy();
+await securityPolicy.CreateOrUpdateAsync(WaitUntil.Completed, threatDetectionData);
+```