Aspire Integratie van Pomelo MySQLEntity Framework Core

Inclusief: —&— Client integratie

MySQL is een opensource Relational Database Management System (RDBMS) dat gebruikmaakt van Structured Query Language (SQL) voor het beheren en bewerken van gegevens. Het wordt gebruikt in een groot aantal verschillende omgevingen, van kleine projecten tot grootschalige bedrijfssystemen en het is een populaire keuze om gegevens te hosten die microservices in een cloudeigen toepassing ondersteunen. De Aspire Pomelo MySQLEntity Framework Core-integratie stelt u in staat verbinding te maken met bestaande MySQL databases of nieuwe exemplaren te creëren van .NET met de mysql containerafbeelding.

Hostingintegratie

De MySQL-hostingintegratie modelleert de server als het MySqlServerResource-type en de database als het MySqlDatabaseResource-type. Als u toegang wilt krijgen tot deze typen en API's, voegt u de 📦Aspire. Hosting.MySql NuGet-pakket in het AppHost-project .

dotnet add package Aspire.Hosting.MySql

<PackageReference Include="Aspire.Hosting.MySql"
                  Version="*" />

Zie dotnet pakket toevoegen of Pakketafhankelijkheden beheren in .NET toepassingenvoor meer informatie.

MySQL serverresource en databaseresource toevoegen

Roep in uw AppHost-project AddMySql aan om een MySQL resourcebouwer toe te voegen en te retourneren. Koppel een aanroep aan de geretourneerde resourcebouwer met AddDatabaseom een MySQL databaseresource toe te voegen.

var builder = DistributedApplication.CreateBuilder(args);

var mysql = builder.AddMySql("mysql")
                   .WithLifetime(ContainerLifetime.Persistent);

var mysqldb = mysql.AddDatabase("mysqldb");

var myService = builder.AddProject<Projects.ExampleProject>()
                       .WithReference(mysqldb)
                       .WaitFor(mysqldb);

// After adding all resources, run the app...

Wanneer Aspire een containerimage aan de AppHost toevoegt, zoals weergegeven in het vorige voorbeeld met de mysql containerimage, wordt er een nieuw MySQL exemplaar op uw lokale machine gemaakt. Een verwijzing naar de MySQL hulpbronnenbouwer (de mysql-variabele) wordt gebruikt om een database toe te voegen. De database heeft de naam mysqldb en wordt vervolgens toegevoegd aan de ExampleProject. De MySQL-resource bevat standaardreferenties met een username van root en een willekeurige password die met de CreateDefaultPasswordParameter-methode is gegenereerd.

Wanneer de AppHost wordt uitgevoerd, wordt het wachtwoord opgeslagen in het geheime archief van AppHost. Deze wordt toegevoegd aan de sectie Parameters, bijvoorbeeld:

{
  "Parameters:mysql-password": "<THE_GENERATED_PASSWORD>"
}

De naam van de parameter is mysql-password, maar eigenlijk is het alleen het opmaken van de resourcenaam met een -password achtervoegsel. Zie Veilige opslag van app-geheimen in ontwikkeling in ASP.NET Core en MySQL resource toevoegen met parametersvoor meer informatie.

De methode WithReference configureert een verbinding in de ExampleProject met de naam mysqldb.

Een MySQL-resource toevoegen met een gegevensvolume

Als u een gegevensvolume wilt toevoegen aan de SQL Server-resource, roept u de methode WithDataVolume aan voor de SQL Server resource:

var builder = DistributedApplication.CreateBuilder(args);

var mysql = builder.AddMySql("mysql")
                   .WithDataVolume();

var mysqldb = mysql.AddDatabase("mysqldb");

builder.AddProject<Projects.ExampleProject>()
       .WithReference(mysqldb)
       .WaitFor(mysqldb);

// After adding all resources, run the app...

Het gegevensvolume wordt gebruikt om de MySQL servergegevens buiten de levenscyclus van de container te behouden. Het gegevensvolume wordt gekoppeld aan het /var/lib/mysql pad in de SQL Server container en wanneer er geen name parameter wordt opgegeven, wordt de naam willekeurig gegenereerd. Voor meer informatie over gegevensvolumes en details over waarom ze de voorkeur hebben boven aankoppelpunten, zie Docker docs: Volumes.

Een MySQL-resource toevoegen met een databind-mount

Als u een koppeling voor gegevensbinding wilt toevoegen aan de MySQL-resource, roept u de WithDataBindMount methode aan:

var builder = DistributedApplication.CreateBuilder(args);

var mysql = builder.AddMySql("mysql")
                   .WithDataBindMount(source: @"C:\MySql\Data");

var db = sql.AddDatabase("mysqldb");

builder.AddProject<Projects.ExampleProject>()
       .WithReference(mysqldb)
       .WaitFor(mysqldb);

// After adding all resources, run the app...

Gegevensbindingen zijn afhankelijk van het bestandssysteem van de hostmachine om de MySQL-gegevens bij het herstarten van de container te behouden. De koppeling voor gegevensbinding wordt gekoppeld aan de C:\MySql\Data in Windows (of /MySql/Data op Unix) op de hostcomputer in de MySQL container. Zie Docker docs: Bindingskoppelingenvoor meer informatie over koppelingskoppelingen voor gegevens.

MySQL resource toevoegen met parameters

Wanneer u een hoofdwachtwoord MySQL expliciet wilt opgeven, kunt u dit doorgeven als parameter. Bekijk het volgende alternatieve voorbeeld:

var password = builder.AddParameter("password", secret: true);

var mysql = builder.AddMySql("mysql", password)
                   .WithLifetime(ContainerLifetime.Persistent);

var mysqldb = mysql.AddDatabase("mysqldb");

var myService = builder.AddProject<Projects.ExampleProject>()
                       .WithReference(mysqldb)
                       .WaitFor(mysqldb);

Zie Externe parametersvoor meer informatie.

Een PhpMyAdmin-resource toevoegen

phpMyAdmin is een populair webbeheerprogramma voor MySQL. U kunt deze gebruiken om door MySQL objecten zoals databases, tabellen, weergaven en indexen te bladeren en te wijzigen. Als u phpMyAdmin in uw Aspire oplossing wilt gebruiken, roept u de WithPhpMyAdmin methode aan. Met deze methode wordt een nieuwe containerresource toegevoegd aan de oplossing die phpMyAdmin host en deze verbindt met de MySQL-container:

var builder = DistributedApplication.CreateBuilder(args);

var mysql = builder.AddMySql("mysql")
                   .WithPhpMyAdmin();

var db = sql.AddDatabase("mysqldb");

builder.AddProject<Projects.ExampleProject>()
       .WithReference(mysqldb)
       .WaitFor(mysqldb);

// After adding all resources, run the app...

Wanneer u de oplossing uitvoert, worden in het Aspire dashboard de phpMyAdmin-resources met een eindpunt weergegeven. Selecteer de koppeling naar het eindpunt om phpMyAdmin weer te geven in een nieuw browsertabblad.

Gezondheidscontroles voor hostingintegratie

De MySQL hostingintegratie voegt automatisch een statuscontrole toe voor de MySQL resource. De gezondheidscontrole controleert of de MySQL-server draait en of er een verbinding mee kan worden gemaakt.

De hostingintegratie is afhankelijk van het 📦 AspNetCore.HealthChecks.MySql NuGet-pakket.

integratie van Client

Installeer het Aspire NuGet-pakket in het client-consumerende project, dat wil zeggen, het project voor de toepassing die gebruikmaakt van de MySQL📦-client, om aan de slag te gaan met de Aspire Pomelo Entity Framework integratie.

dotnet add package Aspire.Pomelo.EntityFrameworkCore.MySql

<PackageReference Include="Aspire.Pomelo.EntityFrameworkCore.MySql"
                  Version="*" />

Zie dotnet pakket toevoegen of Pakketafhankelijkheden beheren in .NET toepassingenvoor meer informatie.

Een MySQL-databasecontext toevoegen

Roep in het Program.cs bestand van het clientgebruikte project de AddMySqlDbContext-extensiemethode aan op elke IHostApplicationBuilder om een DbContext te registreren voor gebruik via de container voor afhankelijkheidsinjectie. De methode gebruikt een verbindingsnaamparameter.

builder.AddMySqlDbContext<ExampleDbContext>(connectionName: "mysqldb");

Ga als volgende te werk om ExampleDbContext object op te halen uit een service:

public class ExampleService(ExampleDbContext context)
{
    // Use context...
}

Voor meer informatie over afhankelijkheidsinjectie, zie .NET afhankelijkheidsinjectie.

Een MySQL-databasecontext verrijken

U kunt liever de standaard Entity Framework-methode gebruiken om een databasecontext te verkrijgen en deze toe te voegen aan de container voor afhankelijkheidsinjectie:

builder.Services.AddDbContext<ExampleDbContext>(options =>
    options.UseMySql(builder.Configuration.GetConnectionString("mysqldb")
        ?? throw new InvalidOperationException("Connection string 'mysqldb' not found.")));

U hebt meer flexibiliteit wanneer u de databasecontext op deze manier maakt, bijvoorbeeld:

• U kunt bestaande configuratiecode opnieuw gebruiken voor de databasecontext zonder deze opnieuw te schrijven voor Aspire.
• U kunt Entity Framework Core interceptors gebruiken om databasebewerkingen te wijzigen.
• U kunt ervoor kiezen om Entity Framework Core contextpooling niet te gebruiken, wat in sommige omstandigheden beter kan presteren.

Als u deze methode gebruikt, kunt u de databasecontext verbeteren met herhaalde pogingen in de stijl van Aspire, statuscontroles, logboekregistratie en telemetriefuncties door de EnrichMySqlDbContext methode aan te roepen.

builder.EnrichMySqlDbContext<ExampleDbContext>(
    configureSettings: settings =>
    {
        settings.DisableRetry = false;
        settings.CommandTimeout = 30 // seconds
    });

De parameter settings is een exemplaar van de klasse PomeloEntityFrameworkCoreMySqlSettings.

Configuratie

De Aspire Pomelo MySQLEntity Framework Core integratie biedt meerdere opties voor het configureren van de databaseverbinding op basis van de vereisten en conventies van uw project.

Een verbindingsreeks gebruiken

Wanneer u een verbindingsreeks uit de sectie ConnectionStrings configuratie gebruikt, kunt u de naam van de verbindingsreeks opgeven bij het aanroepen van builder.AddMySqlDatabaseDbContext<TContext>():

builder.AddMySqlDatabaseDbContext<MyDbContext>("mysql");

Vervolgens wordt de verbindingsreeks opgehaald uit de sectie ConnectionStrings configuratie:

{
  "ConnectionStrings": {
    "mysql": "Server=mysql;Database=mysqldb"
  }
}

De EnrichMySqlDbContext maakt geen gebruik van de ConnectionStrings configuratiesectie, omdat er een DbContext wordt verwacht die moet worden geregistreerd op het punt dat deze wordt aangeroepen.

Zie de MySqlConnector: ConnectionString-documentatievoor meer informatie.

Configuratieproviders gebruiken

De Aspire Pomelo MySQLEntity Framework Core integratie ondersteunt Microsoft.Extensions.Configuration. Het laadt de PomeloEntityFrameworkCoreMySqlSettings uit configuratiebestanden zoals appsettings.json met behulp van de Aspire:Pomelo:EntityFrameworkCore:MySql sleutel.

In het volgende voorbeeld ziet u een appsettings.json waarmee een aantal van de beschikbare opties wordt geconfigureerd:

{
  "Aspire": {
    "Pomelo": {
      "EntityFrameworkCore": {
        "MySql": {
          "ConnectionString": "YOUR_CONNECTIONSTRING",
          "DisableHealthChecks": true,
          "DisableTracing": true
        }
      }
    }
  }
}

Zie MySQLvoor het schema van de volledige integratie JSONAspire. Pomelo.EntityFrameworkCore.MySql/ConfigurationSchema.json.

Gebruik inline-delegaten

U kunt ook de Action<PomeloEntityFrameworkCoreMySqlSettings> delegate doorgeven om sommige of alle opties inline in te stellen, bijvoorbeeld om gezondheidscontroles vanuit code uit te schakelen.

builder.AddMySqlDbContext<MyDbContext>(
    "mysqldb",
    static settings => settings.DisableHealthChecks = true);

of

builder.EnrichMySqlDbContext<MyDbContext>(
    static settings => settings.DisableHealthChecks = true);

Gezondheidscontroles voor Client-integratie

Aspire hebben standaard gezondheidscontroles ingeschakeld voor alle diensten. Op dezelfde manier maken veel Aspirehostingintegraties ook statuscontrole-eindpunten mogelijk. Zie voor meer informatie:

• .NET app-gezondheidscontroles in C#
• Gezondheidscontroles in ASP.NET Core

De Aspire Pomelo MySQLEntity Framework Core integratie:

• Voegt de gezondheidscontrole toe wanneer PomeloEntityFrameworkCoreMySqlSettings.DisableHealthChecks gelijk is aan false, waarmee de EF Core-methode van CanConnectAsyncwordt aangeroepen.
• Integreert met het /health HTTP-eindpunt, dat specificeert dat alle geregistreerde gezondheidscontroles moeten slagen opdat de app klaar is om verkeer te accepteren.

Waarneembaarheid en telemetrie

Aspire Integraties stellen automatisch configuraties voor logboekregistratie, tracering en metrische gegevens in, die ook wel de pijlers van waarneembaarheid worden genoemd. Zie het overzicht van integratieobserveerbaarheid en telemetrie voor meer informatie over integratieobserveerbaarheid en telemetrieAspire. Afhankelijk van de back-upservice ondersteunen sommige integraties mogelijk slechts enkele van deze functies. Sommige integraties ondersteunen bijvoorbeeld logboekregistratie en tracering, maar geen metrische gegevens. Telemetriefuncties kunnen ook worden uitgeschakeld met behulp van de technieken die worden weergegeven in de sectie Configuratie.

Logboekregistratie

De integratie van Aspire Pomelo MySQLEntity Framework Core maakt gebruik van de volgende logboekcategorieën:

• Microsoft.EntityFrameworkCore.ChangeTracking
• Microsoft.EntityFrameworkCore.Database.Command
• Microsoft.EntityFrameworkCore.Database.Connection
• Microsoft.EntityFrameworkCore.Database.Transaction
• Microsoft.EntityFrameworkCore.Infrastructure
• Microsoft.EntityFrameworkCore.Migrations
• Microsoft.EntityFrameworkCore.Model
• Microsoft.EntityFrameworkCore.Model.Validation
• Microsoft.EntityFrameworkCore.Query
• Microsoft.EntityFrameworkCore.Update

Traceren

De integratie van Aspire Pomelo MySQLEntity Framework Core verzendt de volgende traceringsactiviteiten met behulp van OpenTelemetry:

• MySqlConnector

Statistieken

De integratie van Aspire Pomelo MySQLEntity Framework Core ondersteunt momenteel de volgende metrische gegevens:

• MySqlConnector:
  • db.client.connections.create_time
  • db.client.connections.use_time
  • db.client.connections.wait_time
  • db.client.connections.idle.max
  • db.client.connections.idle.min
  • db.client.connections.max
  • db.client.connections.pending_requests
  • db.client.connections.timeouts
  • db.client.connections.usage

Zie ook

• MySQL databank
• Entity Framework Core documenten
• Aspire Integraties
• Aspire GitHub Repo