コード例 #1
0
 private void VerifyCosmosDBAccount(DatabaseAccount databaseAccount, PatchableDatabaseAccountData parameters)
 {
     Assert.True(databaseAccount.Data.Tags.SequenceEqual(parameters.Tags));
     Assert.AreEqual(databaseAccount.Data.IsVirtualNetworkFilterEnabled, parameters.IsVirtualNetworkFilterEnabled);
     Assert.AreEqual(databaseAccount.Data.EnableAutomaticFailover, parameters.EnableAutomaticFailover);
     Assert.AreEqual(databaseAccount.Data.DisableKeyBasedMetadataWriteAccess, parameters.DisableKeyBasedMetadataWriteAccess);
 }
コード例 #2
0
        private void VerifyCosmosDBAccount(DatabaseAccount expectedValue, DatabaseAccount actualValue)
        {
            var expectedData = expectedValue.Data;
            var actualData   = actualValue.Data;

            Assert.AreEqual(expectedData.Name, actualData.Name);
            Assert.AreEqual(expectedData.Location, actualData.Location);
            Assert.True(expectedData.Tags.SequenceEqual(actualData.Tags));
            Assert.AreEqual(expectedData.Kind, actualData.Kind);
            Assert.AreEqual(expectedData.ProvisioningState, actualData.ProvisioningState);
            Assert.AreEqual(expectedData.DocumentEndpoint, actualData.DocumentEndpoint);
            Assert.AreEqual(expectedData.DatabaseAccountOfferType, actualData.DatabaseAccountOfferType);
            Assert.AreEqual(expectedData.IpRules.Count, actualData.IpRules.Count);
            Assert.AreEqual(expectedData.IpRules[0].IpAddressOrRangeValue, actualData.IpRules[0].IpAddressOrRangeValue);
            Assert.AreEqual(expectedData.IsVirtualNetworkFilterEnabled, actualData.IsVirtualNetworkFilterEnabled);
            Assert.AreEqual(expectedData.EnableAutomaticFailover, actualData.EnableAutomaticFailover);
            VerifyConsistencyPolicy(expectedData.ConsistencyPolicy, actualData.ConsistencyPolicy);
            Assert.AreEqual(expectedData.Capabilities.Count, actualData.Capabilities.Count);
            VerifyLocations(expectedData.WriteLocations, actualData.WriteLocations);
            VerifyLocations(expectedData.ReadLocations, actualData.ReadLocations);
            VerifyLocations(expectedData.Locations, actualData.Locations);
            VerifyFailoverPolicies(expectedData.FailoverPolicies, actualData.FailoverPolicies);
            Assert.AreEqual(expectedData.VirtualNetworkRules.Count, actualData.VirtualNetworkRules.Count);
            Assert.AreEqual(expectedData.PrivateEndpointConnections.Count, actualData.PrivateEndpointConnections.Count);
            Assert.AreEqual(expectedData.EnableMultipleWriteLocations, actualData.EnableMultipleWriteLocations);
            Assert.AreEqual(expectedData.EnableCassandraConnector, actualData.EnableCassandraConnector);
            Assert.AreEqual(expectedData.ConnectorOffer, actualData.ConnectorOffer);
            Assert.AreEqual(expectedData.DisableKeyBasedMetadataWriteAccess, actualData.DisableKeyBasedMetadataWriteAccess);
            Assert.AreEqual(expectedData.KeyVaultKeyUri, actualData.KeyVaultKeyUri);
            Assert.AreEqual(expectedData.PublicNetworkAccess, actualData.PublicNetworkAccess);
            Assert.AreEqual(expectedData.EnableFreeTier, actualData.EnableFreeTier);
            Assert.AreEqual(expectedData.ApiProperties.ServerVersion.ToString(), actualData.ApiProperties.ServerVersion.ToString());
            Assert.AreEqual(expectedData.EnableAnalyticalStorage, actualData.EnableAnalyticalStorage);
            Assert.AreEqual(expectedData.Cors.Count, actualData.Cors.Count);
        }
コード例 #3
0
        private async Task PrepareDatabaseAccount()
        {
            var locations = new List <Location>()
            {
                {
                    new Location(
                        id: default(string),
                        locationName: location,
                        documentEndpoint: default(string),
                        provisioningState: default(string),
                        failoverPriority: default(int?),
                        isZoneRedundant: default(bool?))
                }
            };
            DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations)
            {
                Location = location,
                Kind     = DatabaseAccountKind.GlobalDocumentDB,
            };
            DatabaseAccount databaseAccount = await WaitForCompletionAsync(
                await CosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters));

            Assert.AreEqual(databaseAccount.Name, databaseAccountName);
            var isDatabaseNameExists = await CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName);

            Assert.AreEqual(true, isDatabaseNameExists.Value);
            Assert.AreEqual(200, isDatabaseNameExists.GetRawResponse().Status);
        }
コード例 #4
0
        public async Task SetUp()
        {
            // need to overwrite with the resource group fetched by ArmClient, otherwise it won't be recorded
            _resourceGroup = await ArmClient.GetResourceGroup(_resourceGroupIdentifier).GetAsync();

            _databaseAccount = await ArmClient.GetDatabaseAccount(_databaseAccountIdentifier).GetAsync();
        }
コード例 #5
0
        public async Task <StatusResultServiceModel> StatusAsync()
        {
            var result = new StatusResultServiceModel(false, "Storage check failed");

            try
            {
                DatabaseAccount response = null;
                if (this.client != null)
                {
                    // make generic call to see if storage client can be reached
                    response = await this.client.GetDatabaseAccountAsync();
                }

                if (response != null)
                {
                    result.IsHealthy = true;
                    result.Message   = "Alive and Well!";
                }
            }
            catch (Exception e)
            {
                this.logger.LogInformation(e, result.Message);
            }

            return(result);
        }
コード例 #6
0
        public async Task RestorableDatabaseAccountListByLocation()
        {
            _restorableDatabaseAccount = await CreateRestorableDatabaseAccount(Recording.GenerateAssetName("r-database-account-"));

            var restorableAccounts = await(await ArmClient.GetDefaultSubscriptionAsync()).GetRestorableDatabaseAccounts(AzureLocation.WestUS).GetAllAsync().ToEnumerableAsync();

            Assert.That(restorableAccounts.Any(account => account.Data.AccountName == _restorableDatabaseAccount.Data.Name));
        }
コード例 #7
0
        public async Task DatabaseAccountCreateAndUpdateTest()
        {
            var locations = new List <Location>();

            locations.Add(new Location(id: null, locationName: location, documentEndpoint: null, provisioningState: null, failoverPriority: null, isZoneRedundant: false));
            var databaseAccountCreateOrUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations);

            databaseAccountCreateOrUpdateParameters.Location = location;
            databaseAccountCreateOrUpdateParameters.Tags.Add("key1", "value1");
            databaseAccountCreateOrUpdateParameters.Tags.Add("key2", "value2");
            databaseAccountCreateOrUpdateParameters.Kind = DatabaseAccountKind.MongoDB;
            databaseAccountCreateOrUpdateParameters.ConsistencyPolicy =
                new ConsistencyPolicy(DefaultConsistencyLevel.BoundedStaleness, maxStalenessPrefix, maxIntervalInSeconds);
            databaseAccountCreateOrUpdateParameters.IpRules.Add(new IpAddressOrRange("23.43.230.120"));
            databaseAccountCreateOrUpdateParameters.IsVirtualNetworkFilterEnabled = true;
            databaseAccountCreateOrUpdateParameters.EnableAutomaticFailover       = false;
            databaseAccountCreateOrUpdateParameters.ConnectorOffer = "Small";
            databaseAccountCreateOrUpdateParameters.DisableKeyBasedMetadataWriteAccess = false;
            DatabaseAccount databaseAccount1 =
                await WaitForCompletionAsync(
                    await CosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountCreateOrUpdateParameters));

            var response = await CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName);

            Assert.AreEqual(true, response.Value);
            Assert.AreEqual(200, response.GetRawResponse().Status);
            DatabaseAccount databaseAccount2 = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);

            VerifyCosmosDBAccount(databaseAccount1, databaseAccount2);

            var databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters();

            databaseAccountUpdateParameters.Tags.Add("key3", "value3");
            databaseAccountUpdateParameters.Tags.Add("key4", "value4");
            databaseAccountUpdateParameters.IsVirtualNetworkFilterEnabled      = false;
            databaseAccountUpdateParameters.EnableAutomaticFailover            = true;
            databaseAccountUpdateParameters.DisableKeyBasedMetadataWriteAccess = true;
            await WaitForCompletionAsync(
                await CosmosDBManagementClient.DatabaseAccounts.StartUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountUpdateParameters));

            var failoverPolicyList = new List <FailoverPolicy>();

            failoverPolicyList.Add(new FailoverPolicy()
            {
                LocationName     = location,
                FailoverPriority = 0
            });
            FailoverPolicies failoverPolicies = new FailoverPolicies(failoverPolicyList);

            await WaitForCompletionAsync(
                await CosmosDBManagementClient.DatabaseAccounts.StartFailoverPriorityChangeAsync(resourceGroupName, databaseAccountName, failoverPolicies));

            DatabaseAccount databaseAccount3 = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);

            VerifyCosmosDBAccount(databaseAccount3, databaseAccountUpdateParameters);
            VerifyFailoverPolicies(failoverPolicyList, databaseAccount3.FailoverPolicies);
        }
コード例 #8
0
    private void CreateCosmosDB(string location, string cosmosDBAccountName, ResourceGroup resourceGroup)
    {
        var dbAccount = new DatabaseAccount(cosmosDBAccountName, new DatabaseAccountArgs
        {
            AccountName       = cosmosDBAccountName,
            ResourceGroupName = resourceGroup.Name,
            Location          = resourceGroup.Location,
            Locations         =
            {
                new LocationArgs
                {
                    LocationName     = location,
                    FailoverPriority = 0
                }
            },
            DatabaseAccountOfferType = DatabaseAccountOfferType.Standard,
            Capabilities             = new[] {
                new Pulumi.AzureNextGen.DocumentDB.Latest.Inputs.CapabilityArgs
                {
                    Name = "EnableServerless"
                }
            }
        });

        // Export the primary key of the Storage Account
        this.CosmosConnectionString = Output.Tuple(resourceGroup.Name, dbAccount.Name).Apply(names =>
                                                                                             Output.CreateSecret(GetCosmosConnectionString(names.Item1, names.Item2)));

        var dbName      = "todos-db";
        var cosmosSqlDB = new SqlResourceSqlDatabase(dbName, new SqlResourceSqlDatabaseArgs
        {
            AccountName  = dbAccount.Name,
            DatabaseName = dbName,
            Options      = new CreateUpdateOptionsArgs(),
            Resource     = new SqlDatabaseResourceArgs
            {
                Id = dbName
            },
            ResourceGroupName = resourceGroup.Name,
            Location          = resourceGroup.Location
        });

        var containerName = "todos-sql-Container";
        var dbContainer   = new SqlResourceSqlContainer(containerName, new SqlResourceSqlContainerArgs
        {
            AccountName       = dbAccount.Name,
            ContainerName     = containerName,
            DatabaseName      = cosmosSqlDB.Name,
            ResourceGroupName = resourceGroup.Name,
            Location          = resourceGroup.Location,
            Options           = new CreateUpdateOptionsArgs(),
            Resource          = new SqlContainerResourceArgs
            {
                Id = containerName
            }
        });
    }
コード例 #9
0
        public async Task TestTearDown()
        {
            DatabaseAccount account = await DatabaseAccountCollection.GetIfExistsAsync(_databaseAccountName);

            if (account != null)
            {
                await account.DeleteAsync(WaitUntil.Completed);
            }
        }
コード例 #10
0
 public static DatabaseAccount GetDatabaseAccount(this ArmClient client, ResourceIdentifier id)
 {
     return(client.GetClient(() =>
     {
         DatabaseAccount.ValidateResourceId(id);
         return new DatabaseAccount(client, id);
     }
                             ));
 }
コード例 #11
0
        public async Task TestTearDown()
        {
            DatabaseAccount account = await DatabaseAccountCollection.GetIfExistsAsync(_databaseAccountName);

            if (account != null)
            {
                await account.Delete().WaitForCompletionResponseAsync();
            }
        }
コード例 #12
0
        public async Task GlobalSetup()
        {
            _resourceGroup = await GlobalClient.GetResourceGroup(_resourceGroupIdentifier).GetAsync();

            _databaseAccount = await CreateDatabaseAccount(SessionRecording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.MongoDB);

            _mongoDBDatabaseId = (await MongoDBDatabaseTests.CreateMongoDBDatabase(SessionRecording.GenerateAssetName("mongodb-"), null, _databaseAccount.GetMongoDBDatabases())).Id;

            await StopSessionRecordingAsync();
        }
コード例 #13
0
        public async Task DatabaseAccountListByResourceGroupTest()
        {
            List <DatabaseAccount> databaseAccounts = await CosmosDBManagementClient.DatabaseAccounts.ListByResourceGroupAsync(resourceGroupName).ToEnumerableAsync();

            Assert.IsNotNull(databaseAccounts);
            Assert.AreEqual(1, databaseAccounts.Count);
            DatabaseAccount expectedDatabaseAccount = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);

            VerifyCosmosDBAccount(expectedDatabaseAccount, databaseAccounts[0]);
        }
コード例 #14
0
        public async Task GlobalSetup()
        {
            _resourceGroup = await GlobalClient.GetResourceGroup(_resourceGroupIdentifier).GetAsync();

            _databaseAccount = await CreateDatabaseAccount(SessionRecording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.GlobalDocumentDB, new DatabaseAccountCapability("EnableCassandra"));

            _cassandraKeyspaceId = (await CassandraKeyspaceTests.CreateCassandraKeyspace(SessionRecording.GenerateAssetName("cassandra-keyspace-"), null, _databaseAccount.GetCassandraKeyspaces())).Id;

            await StopSessionRecordingAsync();
        }
コード例 #15
0
        protected override void ProcessRecord()
        {
            var uri    = base.Context.Properties["Uri"].Value.ToString();
            var key    = base.Context.Properties["Key"].Value.ToString();
            var client = new DocumentClient(new Uri(uri), key);
            var task   = client.GetDatabaseAccountAsync();

            task.Wait();
            DatabaseAccount db = task.Result;

            WriteObject(db.ConsistencyPolicy.DefaultConsistencyLevel);
        }
コード例 #16
0
        public async Task GlobalSetup()
        {
            _resourceGroup = await GlobalClient.GetResourceGroup(_resourceGroupIdentifier).GetAsync();

            _databaseAccount = await CreateDatabaseAccount(SessionRecording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.GlobalDocumentDB);

            _sqlDatabase = await SqlDatabaseTests.CreateSqlDatabase(SessionRecording.GenerateAssetName("sql-db-"), null, _databaseAccount.GetSqlDatabases());

            _sqlContainerId = (await SqlContainerTests.CreateSqlContainer(SessionRecording.GenerateAssetName("sql-container-"), null, _sqlDatabase.GetSqlContainers())).Id;

            await StopSessionRecordingAsync();
        }
コード例 #17
0
        public static async Task Main(string[] args)
        {
            Console.WriteLine("Started");
            using (DocumentClient client = new DocumentClient(endPointUri, primaryKey))
            {
                DatabaseAccount account = await client.GetDatabaseAccountAsync();

                await client.OpenAsync();
                await CreateDatabase(client);
                await CreateDefaultCollection(client);

                bool isSQL = IsSQLAPI(account);
                await CreateCustomCollectionsAndIndexingPolicies(client);

                await Populator.PopulateUnlimitedCollectionWithData(client);
            }
        }
コード例 #18
0
    public CosmosDBMongoDB(string name, CosmosDBMongoDBArgs args)
        : base("example:component:CosmosDBMongoDB", name)
    {
        var config   = new Config("azure-native");
        var location = config.Require("location");

        var databaseAccount = new DatabaseAccount("cosmos-mongodb", new DatabaseAccountArgs
        {
            ResourceGroupName        = args.ResourceGroupName,
            DatabaseAccountOfferType = DatabaseAccountOfferType.Standard,
            Kind = DatabaseAccountKind.MongoDB,
            ConsistencyPolicy = new ConsistencyPolicyArgs
            {
                DefaultConsistencyLevel = DefaultConsistencyLevel.BoundedStaleness,
                MaxIntervalInSeconds    = 10,
                MaxStalenessPrefix      = 200,
            },
            Locations =
            {
                new LocationArgs
                {
                    FailoverPriority = 0,
                    LocationName     = location
                }
            }
        }, new CustomResourceOptions {
            Parent = this
        });

        this.AccountName = databaseAccount.Name;

        var database = new MongoDBResourceMongoDBDatabase(args.DatabaseName, new MongoDBResourceMongoDBDatabaseArgs
        {
            ResourceGroupName = args.ResourceGroupName,
            AccountName       = databaseAccount.Name,
            Resource          = new MongoDBDatabaseResourceArgs {
                Id = args.DatabaseName
            }
        }, new CustomResourceOptions {
            Parent = this
        });

        this.DatabaseName = database.Name;
    }
コード例 #19
0
        // 利用可能リージョンを追加
        private static async Task <ConnectionPolicy> AddPreferredLocations(ConnectionPolicy cp)
        {
            var preClient = new DocumentClient(
                new Uri(ConfigurationManager.AppSettings["endpoint"]),
                ConfigurationManager.AppSettings["authKey"]
                );
            DatabaseAccount db = await preClient.GetDatabaseAccountAsync();

            var locations = db.ReadableLocations;

            foreach (var l in locations)
            {
                if (l.Name != ConfigurationManager.AppSettings["appRegion"])
                {
                    cp.PreferredLocations.Add(l.Name);
                }
            }
            preClient.Dispose();
            return(cp);
        }
コード例 #20
0
        public async Task DatabaseAccountListBySubscriptionTest()
        {
            List <DatabaseAccount> databaseAccounts = await CosmosDBManagementClient.DatabaseAccounts.ListAsync().ToEnumerableAsync();

            Assert.IsNotNull(databaseAccounts);
            bool            databaseAccountFound  = false;
            DatabaseAccount actualDatabaseAccount = null;

            foreach (DatabaseAccount databaseAccount in databaseAccounts)
            {
                if (databaseAccount.Name == databaseAccountName)
                {
                    databaseAccountFound  = true;
                    actualDatabaseAccount = databaseAccount;
                }
            }
            Assert.AreEqual(true, databaseAccountFound);
            DatabaseAccount expectedDatabaseAccount = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);

            VerifyCosmosDBAccount(expectedDatabaseAccount, actualDatabaseAccount);
        }
コード例 #21
0
        public async Task DatabaseAccountCreateAndUpdateTest()
        {
            var account = await CreateDatabaseAccount(Recording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.MongoDB);

            bool ifExists = await DatabaseAccountCollection.ExistsAsync(_databaseAccountName);

            Assert.AreEqual(true, ifExists);

            DatabaseAccount account2 = await DatabaseAccountCollection.GetAsync(_databaseAccountName);

            VerifyCosmosDBAccount(account, account2);

            var updateOptions = new PatchableDatabaseAccountData()
            {
                IsVirtualNetworkFilterEnabled      = false,
                EnableAutomaticFailover            = true,
                DisableKeyBasedMetadataWriteAccess = true,
            };

            updateOptions.Tags.Add("key3", "value3");
            updateOptions.Tags.Add("key4", "value4");
            await account2.UpdateAsync(WaitUntil.Completed, updateOptions);

            var failoverPolicyList = new List <FailoverPolicy>
            {
                new FailoverPolicy()
                {
                    LocationName     = AzureLocation.WestUS,
                    FailoverPriority = 0
                }
            };
            FailoverPolicies failoverPolicies = new FailoverPolicies(failoverPolicyList);
            await account2.FailoverPriorityChangeAsync(WaitUntil.Completed, new FailoverPolicies(failoverPolicyList));

            DatabaseAccount account3 = await DatabaseAccountCollection.GetAsync(_databaseAccountName);

            VerifyCosmosDBAccount(account3, updateOptions);
            VerifyFailoverPolicies(failoverPolicyList, account3.Data.FailoverPolicies);
        }
コード例 #22
0
    public MyStack()
    {
        Config config = new Config();

        // Create an Azure Resource Group
        var resourceGroup = new ResourceGroup("resourceGroup", new ResourceGroupArgs
        {
            ResourceGroupName = "pulumidemo",
            Location          = "AustraliaSouthEast"
        });

        // Create a Cosmos DB Database
        string cosmosAccountName = "mypulumidemo-dev";
        var    cosmosAccount     = new DatabaseAccount(cosmosAccountName, new DatabaseAccountArgs()
        {
            AccountName       = cosmosAccountName,
            ResourceGroupName = resourceGroup.Name,
            Location          = resourceGroup.Location,
            ConsistencyPolicy = new ConsistencyPolicyArgs()
            {
                DefaultConsistencyLevel = "Session"
            },
            DatabaseAccountOfferType      = "Standard",
            EnableFreeTier                = false,
            EnableMultipleWriteLocations  = false,
            IsVirtualNetworkFilterEnabled = false,
            Locations =
            {
                new LocationArgs
                {
                    FailoverPriority = 0,
                    IsZoneRedundant  = false,
                    LocationName     = resourceGroup.Location,
                }
            }
        });

        // Export the CosmosDb Connection String
        this.CosmosDatabaseConnectionString = Output
                                              .Tuple(resourceGroup.Name, cosmosAccount.Name)
                                              .Apply(names => Output.CreateSecret(GetCosmosDatabaseConnectionString(names.Item1, names.Item2)));

        // set with > pulumi config set myCosmosDb.autoScaleThroughput 4000
        int autoScaleThroughput = config.RequireInt32("myCosmosDb.autoScaleThroughput");

        string cosmosDatabaseName = "myCosmosDatabase";
        var    cosmosSqlDatabase  = new SqlResourceSqlDatabase(cosmosDatabaseName, new SqlResourceSqlDatabaseArgs()
        {
            DatabaseName      = cosmosDatabaseName,
            AccountName       = cosmosAccount.Name,
            ResourceGroupName = resourceGroup.Name,
            Location          = resourceGroup.Location,
            Resource          = new SqlDatabaseResourceArgs()
            {
                Id = cosmosDatabaseName
            },
            Options = new CreateUpdateOptionsArgs()
            {
                AutoscaleSettings = new AutoscaleSettingsArgs()
                {
                    MaxThroughput = autoScaleThroughput
                }
            }
        });

        string rulesContainerName = "rules";
        var    rulesContainer     = new SqlResourceSqlContainer(rulesContainerName, new SqlResourceSqlContainerArgs
        {
            AccountName       = cosmosAccount.Name,
            ContainerName     = rulesContainerName,
            DatabaseName      = cosmosSqlDatabase.Name,
            ResourceGroupName = resourceGroup.Name,
            Location          = resourceGroup.Location,
            Options           = new CreateUpdateOptionsArgs()
            {
            },
            Resource = new SqlContainerResourceArgs
            {
                Id             = rulesContainerName,
                IndexingPolicy = new IndexingPolicyArgs
                {
                    Automatic    = true,
                    IndexingMode = "Consistent",
                },
                PartitionKey = new ContainerPartitionKeyArgs
                {
                    Kind  = "Hash",
                    Paths =
                    {
                        "/id",
                    },
                }
            }
        });

        // Create an AppService Plan (Web Server)
        string appServicePlanName = "myRulesServer";
        var    appServicePlan     = new AppServicePlan(appServicePlanName, new AppServicePlanArgs
        {
            Name              = appServicePlanName,
            Location          = resourceGroup.Location,
            ResourceGroupName = resourceGroup.Name,
            Kind              = "app",
            Sku = new SkuDescriptionArgs
            {
                Capacity = 1,
                Family   = "P",
                Name     = "P1",
                Size     = "P1",
                Tier     = "Premium",
            }
        });

        // Create a WebApp
        string appServiceName = "myRulesApp";
        var    appService     = new WebApp(appServiceName, new WebAppArgs
        {
            Name              = appServiceName,
            Location          = resourceGroup.Location,
            ResourceGroupName = resourceGroup.Name,
            ServerFarmId      = appServicePlan.Id,
            SiteConfig        = new SiteConfigArgs()
            {
                AlwaysOn    = true,
                AppSettings = new InputList <NameValuePairArgs>()
                {
                },
                ConnectionStrings = new InputList <ConnStringInfoArgs>()
                {
                    new ConnStringInfoArgs()
                    {
                        Name             = "RulesDatabase",
                        Type             = "Custom",
                        ConnectionString = Output
                                           .Tuple(resourceGroup.Name, cosmosAccount.Name)
                                           .Apply(names => Output.Create(GetCosmosDatabaseConnectionString(names.Item1, names.Item2)))
                    }
                }
            }
        });
    }
コード例 #23
0
 private static bool IsSQLAPI(DatabaseAccount account)
 {
     //TODO - Check for a simple write and read. The exception will occur if CosmosDB Account is not SQL API. Differentiate the exception and determine the API model.
     return(true);
 }
コード例 #24
0
 public async Task SetUp()
 {
     _databaseAccount = await ArmClient.GetDatabaseAccount(_databaseAccountIdentifier).GetAsync();
 }
コード例 #25
0
 public static DatabaseAccount GetDatabaseAccount(this ArmClient armClient, ResourceIdentifier id)
 {
     DatabaseAccount.ValidateResourceId(id);
     return(new DatabaseAccount(armClient, id));
 }