Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://docs.microsoft.com/en-us/dotnet/aspire/fundamentals/integrations-overview below:

.NET Aspire integrations overview - .NET Aspire

.NET Aspire integrations are a curated suite of NuGet packages selected to facilitate the integration of cloud-native applications with prominent services and platforms, such as Redis and PostgreSQL. Each integration furnishes essential cloud-native functionalities through either automatic provisioning or standardized configuration patterns.

Tip

Always strive to use the latest version of .NET Aspire integrations to take advantage of the latest features, improvements, and security updates.

Most .NET Aspire integrations are made up of two separate libraries, each with a different responsibility. One type represents resources within the AppHost project—known as hosting integrations. The other type of integration represents client libraries that connect to the resources modeled by hosting integrations, and they're known as client integrations.

Hosting integrations configure applications by provisioning resources (like containers or cloud resources) or pointing to existing instances (such as a local SQL server). These packages model various services, platforms, or capabilities, including caches, databases, logging, storage, and messaging systems.

Hosting integrations extend the IDistributedApplicationBuilder interface, enabling the AppHost project to express resources within its app model. Hosting integrations work with any type of application, not just .NET applications. They provide infrastructure and inject configuration details (such as connection strings, endpoints, and credentials) as environment variables into any project, executable, or container that references them.

The official hosting integration NuGet packages are tagged with aspire, integration, and hosting. In addition to the official hosting integrations, the community has created hosting integrations for various services and platforms as part of the Community Toolkit.

For information on creating a custom hosting integration, see Create custom .NET Aspire hosting integration.

Client integrations wire up client libraries to dependency injection (DI), define configuration schema, and add health checks, resiliency, and telemetry where applicable. .NET Aspire client integration libraries are prefixed with Aspire. and then include the full package name that they integrate with, such as Aspire.StackExchange.Redis.

These packages configure existing client libraries to connect to hosting integrations. They extend the IHostApplicationBuilder interface allowing client-consuming projects, such as your web app or API, to use the connected resource. The official client integration NuGet packages are tagged with aspire, integration, and client. In addition to the official client integrations, the community has created client integrations for various services and platforms as part of the Community Toolkit.

For more information on creating a custom client integration, see Create custom .NET Aspire client integrations.

Hosting and client integrations are best when used together, but are not coupled and can be used separately. Some hosting integrations don't have a corresponding client integration. Configuration is what makes the hosting integration work with the client integration.

Client integrations are .NET-specific and provide convenient, opinionated ways to configure .NET applications. However, you can use hosting integrations without client integrations for non-.NET applications or when you prefer to configure connections manually. In these scenarios, the hosting integration still provides the infrastructure and exposes connection information through environment variables that any application technology can consume.

Consider the following diagram that depicts the relationship between hosting and client integrations:

The AppHost project is where hosting integrations are used. Configuration, specifically environment variables, is injected into projects, executables, and containers, allowing client integrations to connect to the hosting integrations.

When you add a client integration to a project within your .NET Aspire solution, service defaults are automatically applied to that project; meaning the Service Defaults project is referenced and the AddServiceDefaults extension method is called. These defaults are designed to work well in most scenarios and can be customized as needed. The following service defaults are applied:

• Observability and telemetry: Automatically sets up logging, tracing, and metrics configurations:

  • Logging: A technique where code is instrumented to produce logs of interesting events that occurred while the program was running.
  • Tracing: A specialized form of logging that helps you localize failures and performance issues within applications distributed across multiple machines or processes.
  • Metrics: Numerical measurements recorded over time to monitor application performance and health. Metrics are often used to generate alerts when potential problems are detected.

• Health checks: Exposes HTTP endpoints to provide basic availability and state information about an app. Health checks are used to influence decisions made by container orchestrators, load balancers, API gateways, and other management services.

• Resiliency: The ability of your system to react to failure and still remain functional. Resiliency extends beyond preventing failures to include recovering and reconstructing your cloud-native environment back to a healthy state.

Hosting and client integrations are updated each release to target the latest stable versions of dependent resources. When container images are updated with new image versions, the hosting integrations update to these new versions. Similarly, when a new NuGet version is available for a dependent client library, the corresponding client integration updates to the new version. This ensures the latest features and security updates are available to applications. The .NET Aspire update type (major, minor, patch) doesn't necessarily indicate the type of update in dependent resources. For example, a new major version of a dependent resource may be updated in a .NET Aspire patch release, if necessary.

When major breaking changes happen in dependent resources, integrations may temporarily split into version-dependent packages to ease updating across the breaking change. For more information, see the first example of such a breaking change.

.NET Aspire provides many integrations to help you build cloud-native applications. These integrations are designed to work seamlessly with the .NET Aspire AppHost and client libraries. The following sections detail cloud-agnostic, Azure-specific, Amazon Web Services (AWS), and Community Toolkit integrations.

The following section details cloud-agnostic .NET Aspire integrations with links to their respective docs and NuGet packages, and provides a brief description of each integration.

For more information on working with .NET Aspire integrations in Visual Studio, see Visual Studio tooling.

Azure integrations configure applications to use Azure resources. These hosting integrations are available in the Aspire.Hosting.Azure.* NuGet packages, while their client integrations are available in the Aspire.* NuGet packages:

For more information, see GitHub: Aspire.Hosting.AWS library.

Note

The Community Toolkit integrations are community-driven and maintained by the .NET Aspire community. These integrations are not officially supported by the .NET Aspire team.

For more information, see .NET Aspire Community Toolkit.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4