Usar bancos de dados NoSQL como infraestrutura de persistênciaUse NoSQL databases as a persistence infrastructure

Ao usar bancos de dados NoSQL para a camada de dados da infraestrutura, normalmente, não se usa um ORM (mapeamento objeto-relacional) como o Entity Framework Core.When you use NoSQL databases for your infrastructure data tier, you typically do not use an ORM like Entity Framework Core. Nesse caso, é possível usar a API fornecida pelo mecanismo NoSQL, como o Azure Cosmos DB, o MongoDB, o Cassandra, o RavenDB, o CouchDB ou as tabelas de Armazenamento do Azure.Instead you use the API provided by the NoSQL engine, such as Azure Cosmos DB, MongoDB, Cassandra, RavenDB, CouchDB, or Azure Storage Tables.

No entanto, ao usar um banco de dados NoSQL, principalmente um banco de dados orientado a documentos como o Azure Cosmos DB, o CouchDB ou o RavenDB, a maneira de criar o modelo com agregações de DDD é parcialmente semelhante à maneira de fazer isso no EF Core, em relação à identificação de raízes agregadas, classes de entidade filha e classes de objeto de valor.However, when you use a NoSQL database, especially a document-oriented database like Azure Cosmos DB, CouchDB, or RavenDB, the way you design your model with DDD aggregates is partially similar to how you can do it in EF Core, in regards to the identification of aggregate roots, child entity classes, and value object classes. Mas, por fim, a seleção do banco de dados realmente afetará o design.But, ultimately, the database selection will impact in your design.

Ao usar um banco de dados orientado a documentos, você implementa uma agregação como um único documento serializado em JSON ou em outro formato.When you use a document-oriented database, you implement an aggregate as a single document, serialized in JSON or another format. No entanto, o uso do banco de dados é transparente do ponto de vista do código do modelo de domínio.However, the use of the database is transparent from a domain model code point of view. Ao usar um banco de dados NoSQL, você ainda está usando classes de entidade e classes de raiz de agregação, mas com maior flexibilidade do que ao usar o EF Core porque a persistência não é relacional.When using a NoSQL database, you still are using entity classes and aggregate root classes, but with more flexibility than when using EF Core because the persistence is not relational.

A diferença está em como persistir esse modelo.The difference is in how you persist that model. Se você implementar o modelo de domínio com base em classes de entidade POCO (objeto CRL básico), independentemente da persistência da infraestrutura, poderá parecer que é possível passar para uma infraestrutura de persistência diferente, até mesmo de relacional para NoSQL.If you implemented your domain model based on POCO entity classes, agnostic to the infrastructure persistence, it might look like you could move to a different persistence infrastructure, even from relational to NoSQL. No entanto, essa não deve ser a sua meta.However, that should not be your goal. Sempre há restrições e compensações nas diferentes tecnologias de bancos de dados, portanto, não é possível usar o mesmo modelo para bancos de dados relacionais ou NoSQL.There are always constraints and trade-offs in the different database technologies, so you will not be able to have the same model for relational or NoSQL databases. Alterar os modelos de persistência não é tão fácil, pois as transações e as operações de persistência são muito diferentes.Changing persistence models is not a trivial task, because transactions and persistence operations will be very different.

Por exemplo, em um banco de dados orientado a documentos, é possível que uma raiz de agregação tenha diversas propriedades de coleção filhas.For example, in a document-oriented database, it is okay for an aggregate root to have multiple child collection properties. Em um banco de dados relacional, consultar várias propriedades de coleção filhas é algo de difícil otimização, pois o EF retorna a você uma instrução UNION ALL SQL.In a relational database, querying multiple child collection properties is not easily optimized, because you get a UNION ALL SQL statement back from EF. Ter o mesmo modelo de domínio para bancos de dados relacionais ou bancos de dados NoSQL não é simples e não é recomendado.Having the same domain model for relational databases or NoSQL databases is not simple, and you should not try to do it. Você realmente precisa criar seu modelo com uma compreensão de como os dados serão usados em cada banco de dados específico.You really have to design your model with an understanding of how the data is going to be used in each particular database.

Um benefício de usar bancos de dados NoSQL é que as entidades são mais desnormalizadas, portanto, você não precisa definir um mapeamento de tabela.A benefit when using NoSQL databases is that the entities are more denormalized, so you do not set a table mapping. O modelo de domínio pode ser mais flexível do que ao usar um banco de dados relacional.Your domain model can be more flexible than when using a relational database.

Ao criar o modelo de domínio baseado em agregações, passar para bancos de dados NoSQL e orientados a documentos pode ser ainda mais fácil do que usar um banco de dados relacional, porque as agregações criadas são semelhantes aos documentos serializados em um banco de dados orientado a documentos.When you design your domain model based on aggregates, moving to NoSQL and document-oriented databases might be even easier than using a relational database, because the aggregates you design are similar to serialized documents in a document-oriented database. Em seguida, é possível incluir nesses “pacotes” todas as informações que possam ser necessárias para essa agregação.Then you can include in those “bags” all the information you might need for that aggregate.

Por exemplo, o código JSON a seguir é um exemplo da implementação de uma agregação de pedido ao usar um banco de dados orientado a documentos.For instance, the following JSON code is a sample implementation of an order aggregate when using a document-oriented database. Ele é semelhante à agregação de pedido que foi implementada no exemplo eShopOnContainers, mas sem usar o Core EF.It is similar to the order aggregate we implemented in the eShopOnContainers sample, but without using EF Core underneath.

{
    "id": "2017001",
    "orderDate": "2/25/2017",
    "buyerId": "1234567",
    "address": [
        {
        "street": "100 One Microsoft Way",
        "city": "Redmond",
        "state": "WA",
        "zip": "98052",
        "country": "U.S."
        }
    ],
    "orderItems": [
        {"id": 20170011, "productId": "123456", "productName": ".NET T-Shirt",
        "unitPrice": 25, "units": 2, "discount": 0},
        {"id": 20170012, "productId": "123457", "productName": ".NET Mug",
        "unitPrice": 15, "units": 1, "discount": 0}
    ]
}

Introdução ao Azure Cosmos DB e à API nativa do Cosmos DBIntroduction to Azure Cosmos DB and the native Cosmos DB API

O Azure Cosmos DB é o serviço de banco de dados distribuído globalmente da Microsoft para aplicativos críticos.Azure Cosmos DB is Microsoft's globally distributed database service for mission-critical applications. O Azure Cosmos DB fornece distribuição global imediata, dimensionamento elástico da taxa de transferência e do armazenamento mundialmente, latências de milissegundos de um dígito no 99º percentil, cinco níveis de consistência bem-definidos e garantia de alta disponibilidade, tudo isso com suporte de SLAs líderes do setor.Azure Cosmos DB provides turn-key global distribution, elastic scaling of throughput and storage worldwide, single-digit millisecond latencies at the 99th percentile, five well-defined consistency levels, and guaranteed high availability, all backed by industry-leading SLAs. O Azure Cosmos DB indexa dados automaticamente sem a necessidade de lidar com o gerenciamento do esquema e do índice.Azure Cosmos DB automatically indexes data without requiring you to deal with schema and index management. Ele tem vários modelos e dá suporte a modelos de dados de colunas, grafos, valores-chave e documentos.It is multi-model and supports document, key-value, graph, and columnar data models.

Diagrama mostrando a distribuição global Azure Cosmos DB.

Figura 7-19.Figure 7-19. Distribuição global do Azure Cosmos DBAzure Cosmos DB global distribution

Ao usar um modelo C# para implementar a agregação a ser usada pela API do Azure Cosmos DB, a agregação pode ser semelhante à das classes POCO do C# usadas com o EF Core.When you use a C# model to implement the aggregate to be used by the Azure Cosmos DB API, the aggregate can be similar to the C# POCO classes used with EF Core. A diferença está na maneira de usá-las nas camadas de aplicativo e de infraestrutura, como no código a seguir:The difference is in the way to use them from the application and infrastructure layers, as in the following code:

// C# EXAMPLE OF AN ORDER AGGREGATE BEING PERSISTED WITH AZURE COSMOS DB API
// *** Domain Model Code ***
// Aggregate: Create an Order object with its child entities and/or value objects.
// Then, use AggregateRoot’s methods to add the nested objects so invariants and
// logic is consistent across the nested properties (value objects and entities).

Order orderAggregate = new Order
{
    Id = "2017001",
    OrderDate = new DateTime(2005, 7, 1),
    BuyerId = "1234567",
    PurchaseOrderNumber = "PO18009186470"
}

Address address = new Address
{
    Street = "100 One Microsoft Way",
    City = "Redmond",
    State = "WA",
    Zip = "98052",
    Country = "U.S."
}

orderAggregate.UpdateAddress(address);

OrderItem orderItem1 = new OrderItem
{
    Id = 20170011,
    ProductId = "123456",
    ProductName = ".NET T-Shirt",
    UnitPrice = 25,
    Units = 2,
    Discount = 0;
};

//Using methods with domain logic within the entity. No anemic-domain model
orderAggregate.AddOrderItem(orderItem1);
// *** End of Domain Model Code ***

// *** Infrastructure Code using Cosmos DB Client API ***
Uri collectionUri = UriFactory.CreateDocumentCollectionUri(databaseName,
    collectionName);

await client.CreateDocumentAsync(collectionUri, orderAggregate);

// As your app evolves, let's say your object has a new schema. You can insert
// OrderV2 objects without any changes to the database tier.
Order2 newOrder = GetOrderV2Sample("IdForSalesOrder2");
await client.CreateDocumentAsync(collectionUri, newOrder);

Você pode ver que a maneira de trabalhar com o modelo de domínio pode ser semelhante à maneira de usá-lo na camada do modelo de domínio quando a infraestrutura é o EF.You can see that the way you work with your domain model can be similar to the way you use it in your domain model layer when the infrastructure is EF. Você ainda pode usar os mesmos métodos de raiz de agregação para garantir a consistência, as invariáveis e as validações na agregação.You still use the same aggregate root methods to ensure consistency, invariants, and validations within the aggregate.

No entanto, ao persistir o modelo para o banco de dados NoSQL, o código e a API serão radicalmente alterados em comparação com o código do EF Core ou com qualquer outro código relacionado a bancos de dados relacionais.However, when you persist your model into the NoSQL database, the code and API change dramatically compared to EF Core code or any other code related to relational databases.

Implementar o código do .NET direcionado ao MongoDB e ao Azure Cosmos DBImplement .NET code targeting MongoDB and Azure Cosmos DB

Usar o Azure Cosmos DB de contêineres do .NETUse Azure Cosmos DB from .NET containers

Você pode acessar os bancos de dados Azure Cosmos DB do código do .NET em execução em contêineres, como de qualquer outro aplicativo .NET.You can access Azure Cosmos DB databases from .NET code running in containers, like from any other .NET application. Por exemplo, os microsserviços Locations.API e Marketing.API no eShopOnContainers são implementados para que possam consumir bancos de dados Azure Cosmos DB.For instance, the Locations.API and Marketing.API microservices in eShopOnContainers are implemented so they can consume Azure Cosmos DB databases.

No entanto, há uma limitação no Azure Cosmos DB do ponto de vista do ambiente de desenvolvimento do Docker.However, there’s a limitation in Azure Cosmos DB from a Docker development environment point of view. Embora haja um emulador de Azure Cosmos DB local que pode ser executado em um computador de desenvolvimento, ele dá suporte apenas ao Windows.Even though there’s an on-premises Azure Cosmos DB Emulator that can run in a local development machine, it only supports Windows. Não há suporte para Linux e macOS.Linux and macOS aren't supported.

Também há a possibilidade de executar esse emulador no Docker, mas apenas em contêineres do Windows, não com contêineres do Linux.There's also the possibility to run this emulator on Docker, but just on Windows Containers, not with Linux Containers. Essa é uma handicap inicial para o ambiente de desenvolvimento se seu aplicativo for implantado como contêineres do Linux, já que, no momento, você não pode implantar contêineres do Linux e do Windows em Docker for Windows ao mesmo tempo.That's an initial handicap for the development environment if your application is deployed as Linux containers, since, currently, you can't deploy Linux and Windows Containers on Docker for Windows at the same time. Todos os contêineres que estão sendo implantados precisam ser do Linux ou do Windows.Either all containers being deployed have to be for Linux or for Windows.

O modo de implantação mais simples e ideal para uma solução de Desenvolvimento/Teste é poder implantar os sistemas de banco de dados como contêineres juntamente com contêineres personalizados para que os ambientes de Desenvolvimento/Teste estejam sempre consistentes.The ideal and more straightforward deployment for a dev/test solution is to be able to deploy your database systems as containers along with your custom containers so your dev/test environments are always consistent.

Usar a API do MongoDB para contêineres locais do Linux/Windows de Desenvolvimento/Teste além do Azure Cosmos DBUse MongoDB API for local dev/test Linux/Windows containers plus Azure Cosmos DB

Os bancos de dados Cosmos DB são compatíveis com a API do MongoDB para .NET, e com o protocolo de transmissão nativo do MongoDB.Cosmos DB databases support MongoDB API for .NET as well as the native MongoDB wire protocol. Isso significa que, usando os drivers existentes, o aplicativo escrito para o MongoDB agora pode se comunicar com o Cosmos DB e usar os bancos de dados do Cosmos DB em vez dos bancos de dados do MongoDB, conforme é mostrado na Figura 7-20.This means that by using existing drivers, your application written for MongoDB can now communicate with Cosmos DB and use Cosmos DB databases instead of MongoDB databases, as shown in Figure 7-20.

Diagrama mostrando que Cosmos DB dá suporte ao protocolo de transmissão .NET e MongoDB.

Figura 7-20.Figure 7-20. Usando a API e o protocolo do MongoDB para acessar o Azure Cosmos DBUsing MongoDB API and protocol to access Azure Cosmos DB

Essa é uma abordagem muito conveniente para prova de conceitos em ambientes do Docker com contêineres do Linux, porque a imagem do Docker do MongoDB é uma imagem para várias arquiteturas, compatível com contêineres do Linux do Docker e do Windows do Docker.This is a very convenient approach for proof of concepts in Docker environments with Linux containers because the MongoDB Docker image is a multi-arch image that supports Docker Linux containers and Docker Windows containers.

Conforme é mostrado na imagem a seguir, usando a API do MongoDB, o eShopOnContainers permite contêineres do Windows e do Linux do MongoDB para o ambiente de desenvolvimento local, mas também é possível passar para uma solução de nuvem de PaaS escalonável, como o Azure Cosmos DB, simplesmente alterando a cadeia de conexão do MongoDB para apontar para o Azure Cosmos DB.As shown in the following image, by using the MongoDB API, eShopOnContainers supports MongoDB Linux and Windows containers for the local development environment but then, you can move to a scalable, PaaS cloud solution as Azure Cosmos DB by simply changing the MongoDB connection string to point to Azure Cosmos DB.

Diagrama mostrando que o microserviço de localização no eShopOnContainers pode usar o Cosmos DB ou o Mongo DB.

Figura 7-21.Figure 7-21. eShopOnContainers usando contêineres do MongoDB para o ambiente de desenvolvimento ou para o Azure Cosmos DB para produçãoeShopOnContainers using MongoDB containers for dev-env or Azure Cosmos DB for production

O Azure Cosmos DB de produção estaria em execução na nuvem do Azure como um serviço escalonável e de PaaS.The production Azure Cosmos DB would be running in Azure’s cloud as a PaaS and scalable service.

Os contêineres do .NET Core personalizados podem ser executados em um host do Docker de desenvolvimento local (que esteja usando o Docker para Windows em um computador Windows 10) ou ser implantados em um ambiente de produção, como o Kubernetes no AKS do Azure ou no Azure Service Fabric.Your custom .NET Core containers can run on a local development Docker host (that is using Docker for Windows in a Windows 10 machine) or be deployed into a production environment, like Kubernetes in Azure AKS or Azure Service Fabric. Nesse segundo ambiente, você implantaria somente os contêineres personalizados do .NET Core, mas não o contêiner do MongoDB, pois você estaria usando o Azure Cosmos DB na nuvem para lidar com os dados de produção.In this second environment, you would deploy only the .NET Core custom containers but not the MongoDB container since you’d be using Azure Cosmos DB in the cloud for handling the data in production.

Um benefício claro de usar a API do MongoDB é que a solução pode ser executada em ambos os mecanismos de banco de dados, MongoDB ou Azure Cosmos DB, facilitando as migrações para diferentes ambientes.A clear benefit of using the MongoDB API is that your solution could run in both database engines, MongoDB or Azure Cosmos DB, so migrations to different environments should be easy. No entanto, às vezes, vale a pena usar uma API nativa (ou seja, a API nativa do Cosmos DB) para aproveitar ao máximo os recursos de um mecanismo de banco de dados específico.However, sometimes it is worthwhile to use a native API (that is the native Cosmos DB API) in order to take full advantage of the capabilities of a specific database engine.

Para obter mais comparações entre o simples uso do MongoDB ou do Cosmos DB na nuvem, consulte Benefícios de usar o Azure Cosmos DB, nesta página.For further comparison between simply using MongoDB versus Cosmos DB in the cloud, see the Benefits of using Azure Cosmos DB in this page.

Analise sua abordagem para aplicativos de produção: API do MongoDB versus API de Cosmos DBAnalyze your approach for production applications: MongoDB API vs. Cosmos DB API

No eShopOnContainers, estamos usando a API do MongoDB porque nossa prioridade era basicamente ter um ambiente de Desenvolvimento/Teste consistente usando um banco de dados NoSQL que também pudesse funcionar com o Azure Cosmos DB.In eShopOnContainers, we’re using MongoDB API because our priority was fundamentally to have a consistent dev/test environment using a NoSQL database that could also work with Azure Cosmos DB.

No entanto, se você planeja usar a API do MongoDB para acessar o Azure Cosmos DB no Azure para aplicativos de produção, analise as diferenças de recursos e de desempenho ao usar a API do MongoDB para acessar bancos de dados Azure Cosmos DB em comparação com o uso da API nativa do Azure Cosmos DB.However, if you planning to use MongoDB API to access Azure Cosmos DB in Azure for production applications, you should analyze the differences in capabilities and performance when using MongoDB API to access Azure Cosmos DB databases compared to using the native Azure Cosmos DB API. Se for semelhante, você poderá usar a API do MongoDB e obter o benefício de permitir dois mecanismos de banco de dados NoSQL simultaneamente.If it is similar you can use MongoDB API and you get the benefit of supporting two NoSQL database engines at the same time.

Você também pode usar clusters do MongoDB como o banco de dados de produção na nuvem do Azure, com o Serviço do Azure para MongoDB.You could also use MongoDB clusters as the production database in Azure’s cloud, too, with MongoDB Azure Service. Mas esse não é um serviço de PaaS fornecido pela Microsoft.But that is not a PaaS service provided by Microsoft. Nesse caso, o Azure está apenas hospedando essa solução proveniente do MongoDB.In this case, Azure is just hosting that solution coming from MongoDB.

Basicamente, isso é apenas um aviso de isenção de responsabilidade informando que você não deve usar sempre a API do MongoDB no Azure Cosmos DB, como fizemos no eShopOnContainers, porque essa foi uma opção conveniente para contêineres do Linux.Basically, this is just a disclaimer stating that you shouldn’t always use MongoDB API against Azure Cosmos DB, as we did in eShopOnContainers because it was a convenient choice for Linux containers. A decisão deve ser baseada as necessidades específicas e nos testes que você precisa fazer para o aplicativo de produção.The decision should be based on the specific needs and tests you need to do for your production application.

O código: usar a API MongoDB em aplicativos .NET CoreThe code: Use MongoDB API in .NET Core applications

A API do MongoDB para .NET baseia-se em pacotes NuGet que você precisa adicionar nos projetos, como no projeto Locations.API mostrado na figura a seguir.MongoDB API for .NET is based on NuGet packages that you need to add to your projects, like in the Locations.API project shown in the following figure.

Captura de tela das dependências nos pacotes NuGet do MongoDB.

Figura 7-22.Figure 7-22. Referências de pacotes NuGet da API do MongoDB em um projeto do .NET CoreMongoDB API NuGet packages references in a .NET Core project

Vamos examinar o código nas seções a seguir.Let's investigate the code in the following sections.

Um modelo usado pela API do MongoDBA Model used by MongoDB API

Primeiro, você precisa definir um modelo que armazenará os dados provenientes do banco de dados no espaço de memória do aplicativo.First, you need to define a model that will hold the data coming from the database in your application’s memory space. Aqui está um exemplo do modelo usado para Locais no eShopOnContainers.Here’s an example of the model used for Locations at eShopOnContainers.

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Driver.GeoJsonObjectModel;
using System.Collections.Generic;

public class Locations
{
    [BsonId]
    [BsonRepresentation(BsonType.ObjectId)]
    public string Id { get; set; }
    public int LocationId { get; set; }
    public string Code { get; set; }
    [BsonRepresentation(BsonType.ObjectId)]
    public string Parent_Id { get; set; }
    public string Description { get; set; }
    public double Latitude { get; set; }
    public double Longitude { get; set; }
    public GeoJsonPoint<GeoJson2DGeographicCoordinates> Location
                                                             { get; private set; }
    public GeoJsonPolygon<GeoJson2DGeographicCoordinates> Polygon
                                                             { get; private set; }
    public void SetLocation(double lon, double lat) => SetPosition(lon, lat);
    public void SetArea(List<GeoJson2DGeographicCoordinates> coordinatesList)
                                                    => SetPolygon(coordinatesList);

    private void SetPosition(double lon, double lat)
    {
        Latitude = lat;
        Longitude = lon;
        Location = new GeoJsonPoint<GeoJson2DGeographicCoordinates>(
            new GeoJson2DGeographicCoordinates(lon, lat));
    }

    private void SetPolygon(List<GeoJson2DGeographicCoordinates> coordinatesList)
    {
        Polygon = new GeoJsonPolygon<GeoJson2DGeographicCoordinates>(
                  new GeoJsonPolygonCoordinates<GeoJson2DGeographicCoordinates>(
                  new GeoJsonLinearRingCoordinates<GeoJson2DGeographicCoordinates>(
                                                                 coordinatesList)));
    }
}

Você pode ver que há alguns atributos e tipos provenientes dos pacotes NuGet do MongoDB.You can see there are a few attributes and types coming from the MongoDB NuGet packages.

Os bancos de dados NoSQL normalmente são muito bem adequados para trabalhar com os dados hierárquicos não relacionais.NoSQL databases are usually very well suited for working with non-relational hierarchical data. Neste exemplo, estamos usando tipos do MongoDB criados especialmente para localizações geográficas, como GeoJson2DGeographicCoordinates.In this example, we are using MongoDB types especially made for geo-locations, like GeoJson2DGeographicCoordinates.

Recuperar o banco de dados e a coleçãoRetrieve the database and the collection

No eShopOnContainers, criamos um contexto de banco de dados personalizado no qual podemos implementar o código para recuperar o banco de dados e as MongoCollections, como no código a seguir.In eShopOnContainers, we have created a custom database context where we implement the code to retrieve the database and the MongoCollections, as in the following code.

public class LocationsContext
{
    private readonly IMongoDatabase _database = null;

    public LocationsContext(IOptions<LocationSettings> settings)
    {
        var client = new MongoClient(settings.Value.ConnectionString);
        if (client != null)
            _database = client.GetDatabase(settings.Value.Database);
    }

    public IMongoCollection<Locations> Locations
    {
        get
        {
            return _database.GetCollection<Locations>("Locations");
        }
    }
}

Recuperar os dadosRetrieve the data

No código C#, como nos controladores de API Web ou na implementação personalizada de repositórios, você pode escrever um código semelhante ao seguinte ao consultar por meio da API do MongoDB.In C# code, like Web API controllers or custom Repositories implementation, you can write similar code to the following when querying through the MongoDB API. Observe que o objeto _context é uma instância da classe LocationsContext anterior.Note that the _context object is an instance of the previous LocationsContext class.

public async Task<Locations> GetAsync(int locationId)
{
    var filter = Builders<Locations>.Filter.Eq("LocationId", locationId);
    return await _context.Locations
                            .Find(filter)
                            .FirstOrDefaultAsync();
}

Use uma variável de ambiente no arquivo docker-compose.override.yml para a cadeia de conexão do MongoDBUse an env-var in the docker-compose.override.yml file for the MongoDB connection string

Ao criar um objeto do MongoClient, ele precisa de um parâmetro fundamental, que é exatamente o parâmetro ConnectionString, apontando para o banco de dados certo.When creating a MongoClient object, it needs a fundamental parameter which is precisely the ConnectionString parameter pointing to the right database. No caso do eShopOnContainers, a cadeia de conexão pode apontar para um contêiner do Docker do MongoDB local ou para um banco de dados Azure Cosmos DB de "produção".In the case of eShopOnContainers, the connection string can point to a local MongoDB Docker container or to a “production” Azure Cosmos DB database. Essa cadeia de conexão vem de variáveis de ambiente definidas em arquivos docker-compose.override.yml usados ao implantar com o docker-compose ou o Visual Studio, como no código yml a seguir.That connection string comes from the environment variables defined in the docker-compose.override.yml files used when deploying with docker-compose or Visual Studio, as in the following yml code.

# docker-compose.override.yml
version: '3.4'
services:
  # Other services
  locations-api:
    environment:
      # Other settings
      - ConnectionString=${ESHOP_AZURE_COSMOSDB:-mongodb://nosqldata}

A variável de ambiente ConnectionString é resolvida desta forma: se a variável global ESHOP_AZURE_COSMOSDB estiver definida no arquivo .env com a cadeia de conexão do Azure Cosmos DB, ela o usará para acessar o banco de dados Azure Cosmos DB na nuvem.The ConnectionString environment variable is resolved this way: If the ESHOP_AZURE_COSMOSDB global variable is defined in the .env file with the Azure Cosmos DB connection string, it will use it to access the Azure Cosmos DB database in the cloud. Se não estiver definido, ele utilizará o valor mongodb://nosqldata e usará o contêiner de desenvolvimento do MongoDB.If it’s not defined, it will take the mongodb://nosqldata value and use the development MongoDB container.

O código a seguir mostra o arquivo .env com a variável de ambiente global da cadeia de conexão do Azure Cosmos DB, conforme implementado no eShopOnContainers:The following code shows the .env file with the Azure Cosmos DB connection string global environment variable, as implemented in eShopOnContainers:

# .env file, in eShopOnContainers root folder
# Other Docker environment variables

ESHOP_EXTERNAL_DNS_NAME_OR_IP=localhost
ESHOP_PROD_EXTERNAL_DNS_NAME_OR_IP=<YourDockerHostIP>

#ESHOP_AZURE_COSMOSDB=<YourAzureCosmosDBConnData>

#Other environment variables for additional Azure infrastructure assets
#ESHOP_AZURE_REDIS_BASKET_DB=<YourAzureRedisBasketInfo>
#ESHOP_AZURE_STORAGE_CATALOG_URL=<YourAzureStorage_Catalog_BLOB_URL>
#ESHOP_AZURE_SERVICE_BUS=<YourAzureServiceBusInfo>

Remova a marca de comentário da linha de ESHOP_AZURE_COSMOSDB e atualize-a com a cadeia de conexão Azure Cosmos DB obtida do portal do Azure, conforme explicado em conectar um aplicativo MongoDB a Azure Cosmos DB.Uncomment the ESHOP_AZURE_COSMOSDB line and update it with your Azure Cosmos DB connection string obtained from the Azure portal as explained in Connect a MongoDB application to Azure Cosmos DB.

Se a variável global ESHOP_AZURE_COSMOSDB estiver vazia, o que significa que ela está comentada no arquivo .env, o contêiner usará uma cadeia de conexão padrão do MongoDB.If the ESHOP_AZURE_COSMOSDB global variable is empty, meaning it's commented out in the .env file, then the container uses a default MongoDB connection string. Essa cadeia de conexão aponta para o contêiner local do MongoDB implantado em eShopOnContainers chamado nosqldata e foi definido no arquivo Docker-Compose, conforme mostrado no seguinte código. yml:This connection string points to the local MongoDB container deployed in eShopOnContainers that is named nosqldata and was defined at the docker-compose file, as shown in the following .yml code:

# docker-compose.yml
version: '3.4'
services:
  # ...Other services...
  nosqldata:
    image: mongo

Recursos adicionaisAdditional resources