Delen via

De Back-end van Microsoft Fabric implementeren

  • Artikel

Deze voorbeeldopslagplaats voor Microsoft Fabric-workloadontwikkeling is een uitgangspunt voor het bouwen van toepassingen waarvoor integratie met verschillende services en voor integratie met lakehouse-architectuur is vereist. Dit artikel helpt u bij het instellen van de omgeving en het configureren van de benodigde onderdelen om aan de slag te gaan. In het artikel worden de belangrijkste onderdelen en hun rollen in de architectuur beschreven.

Front-end

De front-end is de plek waar u de gebruikerservaring (UX) en het gedrag beheert. Het communiceert met de front-endportal fabric via een iFrame om naadloze interactie te vergemakkelijken.

Zie de front-end van de Microsoft Fabric Workload Development Kit voor meer informatie.

Back-end

De back-end slaat zowel gegevens als metagegevens op. Het maakt gebruik van CRUD-bewerkingen (Create, Read, Update en Delete) om workloaditems en metagegevens te maken en voert taken uit om gegevens in de opslag in te vullen. Communicatie tussen de front-end en back-end wordt tot stand gebracht via openbare API's.

Azure Relay en DevGateway

Azure Relay maakt communicatie mogelijk tussen de lokale ontwikkelomgeving en de infrastructuurback-end in de ontwikkelaarsmodus. In de ontwikkelaarsmodus werkt de workload op de computer van de ontwikkelaar.

Het hulpprogramma DevGateway heeft twee rollen:

  • Het behandelt het gedeelte van de workload van het Azure Relay-kanaal en beheert de registratie van de lokale instantie van de workload bij Fabric in de context van een specifieke werkruimte. Het hulpprogramma verwerkt de uitschrijving wanneer het kanaal wordt verbroken.
  • Het werkt met Azure Relay naar API-aanroepen van de workload van het kanaal van Fabric naar de workload.

Api-aanroepen voor workloadbeheer worden rechtstreeks vanuit de workload naar Fabric uitgevoerd. Het Azure Relay-kanaal is niet vereist voor de aanroepen.

Lakehouse-integratie

De architectuur van de workload development kit kan naadloos worden geïntegreerd met een lakehouse-architectuur voor bewerkingen zoals het opslaan, lezen en ophalen van gegevens. De interactie wordt mogelijk gemaakt via Azure Relay en de Fabric SDK om veilige en geverifieerde communicatie te garanderen. Zie voor meer informatie werken met klantgegevens.

Verificatie en beveiliging

Microsoft Entra-id wordt gebruikt voor beveiligde verificatie, zodat alle interacties in de architectuur zijn geautoriseerd en beveiligd.

Het overzicht van de development kit biedt een kijkje in onze architectuur. Zie de volgende artikelen voor meer informatie over hoe projecten worden geconfigureerd, voor verificatierichtlijnen en om aan de slag te gaan:

Diagram waarin wordt getoond hoe de Fabric SDK kan worden geïntegreerd met Fabric.

De front-end brengt communicatie tot stand met de front-endportal fabric via een iFrame. De portal communiceert op zijn beurt met de fabric-back-end door aanroepen te doen naar de beschikbare openbare API's.

Voor interacties tussen het ontwikkelvak van de back-end en de infrastructuurback-end fungeert Azure Relay als een conduit. Daarnaast kan het ontwikkelvak van de back-end naadloos worden geïntegreerd met Lakehouse. De communicatie wordt mogelijk gemaakt met behulp van Azure Relay en de Fabric Software Development Kit (SDK) die is geïnstalleerd in het ontwikkelvak van de back-end.

De verificatie voor alle communicatie binnen deze onderdelen wordt gegarandeerd via Microsoft Entra. Microsoft Entra biedt een beveiligde en geverifieerde omgeving voor de interacties tussen de front-end, back-end, Azure Relay, Fabric SDK en Lakehouse.

Vereisten

Zorg ervoor dat de NuGet-Pakketbeheer is geïntegreerd in uw Visual Studio-installatie. Dit hulpprogramma is vereist voor gestroomlijnd beheer van externe bibliotheken en pakketten die essentieel zijn voor ons project.

NuGet-pakketbeheer

  • <NuspecFile>Packages\manifest\ManifestPackageDebug.nuspec</NuspecFile> en <NuspecFile>Packages\manifest\ManifestPackageRelease.nuspec</NuspecFile>: Met deze eigenschappen geeft u het pad op naar de NuSpec-bestanden die worden gebruikt voor het maken van het NuGet-pakket voor foutopsporings- en releasemodi. Het NuSpec-bestand bevat metagegevens over het pakket, zoals de id, versie, afhankelijkheden en andere relevante informatie.

  • <GeneratePackageOnBuild>true</GeneratePackageOnBuild>: Wanneer deze eigenschap is ingesteld true, geeft deze eigenschap de opdracht om tijdens elke build automatisch een NuGet-pakket te genereren. Deze eigenschap is handig om ervoor te zorgen dat het pakket altijd up-to-date is met de meest recente wijzigingen in het project.

  • <IsPackable>true</IsPackable>: Wanneer deze eigenschap is ingesteld true, geeft deze eigenschap aan dat het project kan worden verpakt in een NuGet-pakket. Packable is een essentiële eigenschap voor projecten die zijn bedoeld om NuGet-pakketten te produceren tijdens het buildproces.

Het gegenereerde NuGet-pakket voor foutopsporingsmodus bevindt zich in de map src\bin\Debug na het buildproces.

Wanneer u in de cloudmodus werkt, kunt u de buildconfiguratie van Visual Studio wijzigen in Release en build uw pakket. Het gegenereerde pakket bevindt zich in de src\bin\Release map. Zie de handleiding Werken in de cloudmodus voor meer informatie.

Afhankelijkheden

  • Het standaardvoorbeeld van de back-end is afhankelijk van de volgende Azure SDK-pakketten:

    • Azure.Core
    • Azure.Identity
    • Azure.Storage.Files.DataLake
    • Het Microsoft Identity-pakket

Als u NuGet-Pakketbeheer wilt configureren, geeft u het pad op in de sectie Pakketbronnen voordat u begint met het buildproces.

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net7.0</TargetFramework>
    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
    <BuildDependsOn>PreBuild</BuildDependsOn>
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
    <IsPackable>true</IsPackable>
  </PropertyGroup>
  
  <PropertyGroup Condition="'$(Configuration)' == 'Release'">
    <NuspecFile>Packages\manifest\ManifestPackageRelease.nuspec</NuspecFile>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)' == 'Debug'">
    <NuspecFile>Packages\manifest\ManifestPackageDebug.nuspec</NuspecFile>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Azure.Core" Version="1.38.0" />
    <PackageReference Include="Azure.Identity" Version="1.11.0" />
    <PackageReference Include="Azure.Storage.Files.DataLake" Version="12.14.0" />
    <PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="5.2.9" />
    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="7.0.5" />
    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="7.0.0" />
    <PackageReference Include="Microsoft.Identity.Client" Version="4.60.3" />
    <PackageReference Include="Microsoft.IdentityModel.Protocols" Version="6.30.1" />
    <PackageReference Include="Microsoft.IdentityModel.Protocols.OpenIdConnect" Version="6.30.1" />
    <PackageReference Include="Microsoft.IdentityModel.Tokens" Version="6.30.1" />
    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
  </ItemGroup>

  <ItemGroup>
    <Folder Include="Properties\ServiceDependencies\" />
  </ItemGroup>

  <Target Name="PreBuild" BeforeTargets="PreBuildEvent">
    <Exec Command="powershell.exe -ExecutionPolicy Bypass -File ValidationScripts\RemoveErrorFile.ps1 -outputDirectory ValidationScripts\" />
    <Exec Command="powershell.exe -ExecutionPolicy Bypass -File ValidationScripts\ManifestValidator.ps1 -inputDirectory .\Packages\manifest\ -inputXml WorkloadManifest.xml -inputXsd WorkloadDefinition.xsd -outputDirectory ValidationScripts\" />
    <Exec Command="powershell.exe -ExecutionPolicy Bypass -File ValidationScripts\ItemManifestValidator.ps1 -inputDirectory .\Packages\manifest\ -inputXsd ItemDefinition.xsd -outputDirectory ValidationScripts\" />
    <Exec Command="powershell.exe -ExecutionPolicy Bypass -File ValidationScripts\ValidateNoDefaults.ps1 -outputDirectory ValidationScripts\" />
    <Error Condition="Exists('ValidationScripts\ValidationErrors.txt')" Text="Validation errors with either manifests or default values" File="ValidationScripts\ValidationErrors.txt" />
  </Target>

</Project>

Aan de slag

Het voorbeeldproject voor de werkbelasting instellen op uw lokale computer:

  1. Kloon de opslagplaats: Uitvoeren git clone https://github.com/microsoft/Microsoft-Fabric-workload-development-sample.git.

  2. Open de oplossing in Visual Studio 2022.

  3. Stel een app-registratie in door de instructies in de zelfstudie voor verificatie te volgen. Zorg ervoor dat zowel uw front-end- als back-endprojecten over de benodigde installatie beschikken die in het artikel wordt beschreven. Microsoft Entra wordt gebruikt voor beveiligde verificatie om ervoor te zorgen dat alle interacties in de architectuur zijn geautoriseerd en beveiligd.

  4. Werk de BASIS-URL van Microsoft OneLake DFS bij. Afhankelijk van uw Fabric-omgeving kunt u mogelijk de waarde voor OneLakeDFSBaseURL in de map src\Constants bijwerken. De standaardwaarde is onelake.dfs.fabric.microsoft.com, maar u kunt de URL bijwerken zodat deze overeenkomt met uw omgeving. Zie de OneLake-documentatie voor meer informatie over DFS-paden.

  5. Stel de workloadconfiguratie in.

    1. Kopieer workload-dev-mode.json van src/Config naar C:.
    2. Werk in het workload-dev-mode.json bestand de volgende velden bij zodat deze overeenkomen met uw configuratie:
      • WorkspaceGuid: uw werkruimte-id. U vindt deze waarde in de browser-URL wanneer u een werkruimte selecteert in Fabric. Bijvoorbeeld: https://app.powerbi.com/groups/<WorkspaceID>/.
      • ManifestPackageFilePath: de locatie van het manifestpakket. Wanneer u de oplossing bouwt, wordt het manifestpakket opgeslagen in src\bin\Debug. Verderop in het artikel vindt u meer informatie over het manifestpakket.
      • WorkloadEndpointURL: de URL van het workloadeindpunt.
    3. Werk in het bestand Pakketten/manifest/WorkloadManifest.xml de volgende velden bij zodat deze overeenkomen met uw configuratie:
      • <AppId>: De client-id (toepassings-id) van de workload Microsoft Entra-toepassing.
      • <RedirectUri>: de omleidings-URI's. U vindt deze waarde in de app-registratie die u hebt gemaakt, onder Verificatie.
      • <ResourceId>: De doelgroep voor de binnenkomende Microsoft Entra-tokens. U vindt deze informatie in de app-registratie die u hebt gemaakt, onder Een API beschikbaar maken.
    4. Werk in het bestand src/appsettings.json de volgende velden bij zodat deze overeenkomen met uw configuratie:
      • PublisherTenantId: de id van de tenant van de workloaduitgever.
      • ClientId: de client-id (toepassings-id) van de Microsoft Entra-workloadtoepassing.
      • ClientSecret: het geheim voor de Microsoft Entra-workloadtoepassing.
      • Doelgroep: De doelgroep voor de binnenkomende Microsoft Entra-tokens. U vindt deze informatie in de app-registratie die u hebt gemaakt, onder Een API beschikbaar maken. Deze instelling wordt ook wel de URI van de toepassings-id genoemd.

  6. Genereer een manifestpakket.

    Bouw Fabric_Extension_BE_Boilerplate om een manifestpakketbestand te genereren. De build is een proces met drie stappen waarmee het manifestpakketbestand wordt gegenereerd. De volgende stappen worden uitgevoerd:

    1. Triggers ManifestValidator.ps1 op WorkloadManifest.xml in Packages\manifest/ en trigger ItemManifestValidator.ps1 op alle items XMLs (bijvoorbeeld Item1.xml) in Packages\manifest/. Als de validatie mislukt, wordt er een foutbestand gegenereerd. U kunt de validatiescripts bekijken in ValidationScripts/.
    2. Als er een foutbestand bestaat, mislukt de build met de foutvalidatiefouten met manifesten of standaardwaarden. Als u het foutenbestand in Visual Studio wilt zien, dubbelklikt u op de fout in de validatieresultaten.
    3. Nadat de validatie is geslaagd, verpakt u de WorkloadManifest.xml - en Item1.xml-bestanden in ManifestPackage.1.0.0.nupkg. Het resulterende pakket bevindt zich in src\bin\Debug.

    Kopieer het bestand ManifestPackage.1.0.0.nupkg naar het pad dat is gedefinieerd in het workload-dev-mode.json configuratiebestand.

  7. Program.cs is het beginpunt en het opstartscript voor uw toepassing. In dit bestand kunt u verschillende services configureren, de toepassing initialiseren en de webhost starten.

  8. Bouw om ervoor te zorgen dat uw project toegang heeft tot de vereiste afhankelijkheden voor compilatie en uitvoering.

  9. De DevGateway downloaden vanuit het Downloadcentrum van Microsoft

  10. Voer de Microsoft.Fabric.Workload.DevGateway.exe-toepassing uit en meld u aan met een gebruiker met werkruimtebeheerdersbevoegdheden voor de werkruimte die is opgegeven in het WorkspaceGuid veld van workload-dev-mode.json.

    Schermopname van de aanmeldingspagina van Microsoft.

    Na verificatie zorgen externe workloads voor communicatie met de infrastructuurback-end via Azure Relay. Dit proces omvat relayregistratie en communicatiebeheer dat wordt gefaciliteerd door een aangewezen proxyknooppunt. Het pakket dat het workloadmanifest bevat, wordt geüpload en gepubliceerd.

    In deze fase detecteert Fabric de workload en neemt de toegewezen capaciteit op.

    U kunt controleren op mogelijke fouten in de console.

    Als er geen fouten worden weergegeven, wordt de verbinding tot stand gebracht, wordt de registratie uitgevoerd en wordt het workloadmanifest systematisch geüpload.

    Schermopname van het laden van de verbinding zonder fouten.

  11. Wijzig uw opstartproject in Visual Studio in het standaardproject en selecteer Uitvoeren.

    Schermopname van de gebruikersinterface voor het opstarten van een project in Visual Studio.

Werken met het standaardvoorbeeldproject

Codegeneratie

We gebruiken het standaard C#-voorbeeld van de workload ASP.NET Core om te laten zien hoe u een workload bouwt met behulp van REST API's. Het voorbeeld begint met het genereren van server-stubs en contractklassen op basis van de Swagger-specificatie van de Workload-API. U kunt de code genereren met behulp van een van de verschillende hulpprogramma's voor het genereren van Swagger-code. Het standaardvoorbeeld maakt gebruik van NSwag. Het voorbeeld bevat het GenerateServerStub.cmd opdrachtregelscript, waarmee de NSwag-codegenerator wordt verpakt. Het script heeft één parameter, een volledig pad naar de installatiemap van NSwag. Ook wordt gecontroleerd op het Swagger-definitiebestand (swagger.json) en het configuratiebestand (nswag.json) in de map.

Als u dit script uitvoert, wordt een C#-bestand met de naam WorkloadAPI_Generated.cs gemaakt. De inhoud van dit bestand kan logisch worden onderverdeeld in drie delen, zoals wordt uitgelegd in de volgende secties.

ASP.NET Core stub controllers

ItemLifecycleController en JobsController klassen zijn dunne implementaties van ASP.NET Core-controllers voor twee subsets van de Workload-API: levenscyclusbeheer van items en taken. Deze klassen worden aangesloten op de ASP.NET Core HTTP-pijplijn. Ze fungeren als de toegangspunten voor de API-methoden die zijn gedefinieerd in de Swagger-specificatie. De klassen sturen de aanroepen door naar de 'echte' implementatie die wordt geleverd door de workload.

Hier volgt een voorbeeld van de CreateItem methode:

/// <summary>
/// Called by Microsoft Fabric for creating a new item.
/// </summary>
/// <remarks>
/// Upon item creation Fabric performs some basic validations, creates the item with 'provisioning' state and calls this API to notify the workload. The workload is expected to perform required validations, store the item metadata, allocate required resources, and update the Fabric item metadata cache with item relations and ETag. To learn more see [Microsoft Fabric item update flow](https://updateflow).
/// <br/>
/// <br/>This API should accept [SubjectAndApp authentication](https://subjectandappauthentication).
/// <br/>
/// <br/>##Permissions
/// <br/>Permissions are checked by Microsoft Fabric.
/// </remarks>
/// <param name="workspaceId">The workspace ID.</param>
/// <param name="itemType">The item type.</param>
/// <param name="itemId">The item ID.</param>
/// <param name="createItemRequest">The item creation request.</param>
/// <returns>Successfully created.</returns>
[Microsoft.AspNetCore.Mvc.HttpPost, Microsoft.AspNetCore.Mvc.Route("workspaces/{workspaceId}/items/{itemType}/{itemId}")]
public System.Threading.Tasks.Task CreateItem(System.Guid workspaceId, string itemType, System.Guid itemId, [Microsoft.AspNetCore.Mvc.FromBody] CreateItemRequest createItemRequest)
{

 return _implementation.CreateItemAsync(workspaceId, itemType, itemId, createItemRequest);
}

Interfaces voor workload-implementatie

IItemLifecycleController en IJobsController zijn interfaces voor de eerder genoemde "echte" implementaties. Ze definiëren dezelfde methoden, die door de controllers worden geïmplementeerd.

Definitie van contractklassen

C#-contractklassen zijn klassen die door de API's worden gebruikt.

Implementatie

De volgende stap na het genereren van code is het implementeren van de IItemLifecycleController en IJobsController interfaces. Implementeer deze interfaces in het standaardvoorbeeld ItemLifecycleControllerImplJobsControllerImpl .

Deze code is bijvoorbeeld de implementatie van de CreateItem-API:

/// <inheritdoc/>
public async Task CreateItemAsync(Guid workspaceId, string itemType, Guid itemId, CreateItemRequest createItemRequest)
{
 var authorizationContext = await _authenticationService.AuthenticateControlPlaneCall(_httpContextAccessor.HttpContext);
 var item = _itemFactory.CreateItem(itemType, authorizationContext);
 await item.Create(workspaceId, itemId, createItemRequest);
}

Een nettolading van een item verwerken

Verschillende API-methoden accepteren verschillende typen 'payload' als onderdeel van de aanvraagbody, of ze retourneren nettoladingen als onderdeel van het antwoord. Heeft bijvoorbeeld CreateItemRequest de creationPayload eigenschap.

"CreateItemRequest": {
 "description": "Create item request content.",
 "type": "object",
 "additionalProperties": false,
 "required": [ "displayName" ],
 "properties": {
 "displayName": {
  "description": "The item display name.",
  "type": "string",
  "readOnly": false
 },
 "description": {
  "description": "The item description.",
  "type": "string",
  "readOnly": false
 },
 "creationPayload": {
  "description": "Creation payload specific to the workload and item type, passed by the item editor or as Fabric Automation API parameter.",
  "$ref": "#/definitions/CreateItemPayload",
  "readOnly": false
 }
 }
}

De typen voor deze nettoladingeigenschappen worden gedefinieerd in de Swagger-specificatie. Er is een speciaal type voor elk soort nettolading. Met deze typen worden geen specifieke eigenschappen gedefinieerd en kunnen alle eigenschappen worden opgenomen.

Hier volgt een voorbeeld van het CreateItemPayload type:

"CreateItemPayload": {
 "description": "Creation payload specific to the workload and item type.",
 "type": "object",
 "additionalProperties": true
}

De gegenereerde C#-contractklassen worden gedefinieerd als partial. Ze hebben een woordenlijst met gedefinieerde eigenschappen.

Hier volgt een voorbeeld:

/// <summary>
/// Creation payload specific to the workload and item type.
/// </summary>
[System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "13.20.0.0 (NJsonSchema v10.9.0.0 (Newtonsoft.Json v13.0.0.0))")]
public partial class CreateItemPayload
{
 private System.Collections.Generic.IDictionary<string, object> _additionalProperties;

 [Newtonsoft.Json.JsonExtensionData]
 public System.Collections.Generic.IDictionary<string, object> AdditionalProperties
 {
  get { return _additionalProperties ?? (_additionalProperties = new System.Collections.Generic.Dictionary<string, object>()); }
  set { _additionalProperties = value; }
 }
}

De code kan deze woordenlijst gebruiken om eigenschappen te lezen en te retourneren. Een betere benadering is echter om specifieke eigenschappen te definiëren met behulp van bijbehorende typen en namen. U kunt de partial declaratie voor de gegenereerde klassen gebruiken om eigenschappen efficiënt te definiëren.

Het bestand CreateItemPayload.cs bevat bijvoorbeeld een aanvullende definitie voor de CreateItemPayload klasse.

In dit voorbeeld voegt de definitie de Item1Metadata eigenschap toe:

namespace Fabric_Extension_BE_Boilerplate.Contracts.FabricAPI.Workload
{
    /// <summary>
    /// Extend the generated class by adding item-type-specific fields.
    /// In this sample every type will have a dedicated property. Alternatively, polymorphic serialization could be used.
    /// </summary>
    public partial class CreateItemPayload
    {
        [Newtonsoft.Json.JsonProperty("item1Metadata", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public Item1Metadata Item1Metadata { get; init; }
    }
}

Als de werkbelasting echter meerdere itemtypen ondersteunt, moet de CreateItemPayload klasse verschillende typen nettoladingen voor het maken kunnen verwerken op één per itemtype. U hebt twee opties. De eenvoudigere manier, die in het standaardvoorbeeld wordt gebruikt, is om meerdere optionele eigenschappen te definiëren, die elk de nettolading voor het maken vertegenwoordigen voor een ander itemtype. Elke aanvraag heeft vervolgens slechts een van deze sets eigenschappen, afhankelijk van het itemtype dat wordt gemaakt. U kunt ook polymorfe serialisatie implementeren, maar deze optie wordt niet gedemonstreerd in het voorbeeld omdat de optie geen aanzienlijke voordelen biedt.

Als u bijvoorbeeld twee itemtypen wilt ondersteunen, moet de klassedefinitie worden uitgebreid, zoals in het volgende voorbeeld:

namespace Fabric_Extension_BE_Boilerplate.Contracts.FabricAPI.Workload
{
    public partial class CreateItemPayload
    {
        [Newtonsoft.Json.JsonProperty("item1Metadata", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public Item1Metadata Item1Metadata { get; init; }

        [Newtonsoft.Json.JsonProperty("item2Metadata", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public Item2Metadata Item2Metadata { get; init; }
    } 
}

Notitie

De nettolading die naar de workload wordt verzonden, wordt gegenereerd door de client. Dit kan de itemeditor iFrame of de Fabric Automation REST API zijn. De client is verantwoordelijk voor het verzenden van de juiste nettolading en het overeenkomende itemtype. De workload is verantwoordelijk voor verificatie. Fabric behandelt deze nettolading als een ondoorzichtig object en draagt het alleen over van de client naar de workload. Op dezelfde manier is het voor een nettolading die door de workload naar de client wordt geretourneerd, de verantwoordelijkheid van de workload en de client om de nettolading correct te verwerken.

Deze code laat bijvoorbeeld zien hoe de implementatie van het standaardvoorbeelditem1 de nettolading verwerkt:

protected override void SetDefinition(CreateItemPayload payload)
{
 if (payload == null)
 {
  Logger.LogInformation("No payload is provided for {0}, objectId={1}", ItemType, ItemObjectId);
  _metadata = Item1Metadata.Default.Clone();
  return;
 }

 if (payload.Item1Metadata == null)
 {
  throw new InvalidItemPayloadException(ItemType, ItemObjectId);
 }

 if (payload.Item1Metadata.Lakehouse == null)
 {
  throw new InvalidItemPayloadException(ItemType, ItemObjectId)
   .WithDetail(ErrorCodes.ItemPayload.MissingLakehouseReference, "Missing Lakehouse reference");
 }

 _metadata = payload.Item1Metadata.Clone();
}

Problemen oplossen en fouten opsporen

In de volgende secties wordt beschreven hoe u problemen met uw implementatie kunt oplossen en fouten kunt opsporen.

Bekende problemen en oplossingen

Krijg informatie over bekende problemen en manieren om ze op te lossen.

Ontbrekend clientgeheim

Fout:

Microsoft.Identity.Client.MsalServiceException: Een configuratieprobleem voorkomt verificatie. Controleer het foutbericht van de server voor meer informatie. U kunt de configuratie wijzigen in de portal voor toepassingsregistratie. Zie https://aka.ms/msal-net-invalid-client voor meer informatie.

Oorspronkelijke uitzondering: AADSTS7000215: er is een ongeldig clientgeheim opgegeven. Zorg ervoor dat het geheim dat wordt verzonden in de aanvraag de waarde van het clientgeheim is en niet de clientgeheim-id voor een geheim dat is toegevoegd aan de app-instelling app_guid .

Oplossing: zorg ervoor dat u het juiste clientgeheim hebt gedefinieerd in appsettings.json.

Fout:

Microsoft.Identity.Client.MsalUiRequiredException: AADSTS65001: De gebruiker of beheerder heeft geen toestemming gegeven voor het gebruik van de toepassing met id <example ID>. Verzend een interactieve autorisatieaanvraag voor deze gebruiker en resource.

Oplossing:

  1. Ga in de itemeditor naar de onderkant van de pijn en selecteer Navigeer naar verificatiepagina.

  2. Voer onder Bereiken .default in en selecteer vervolgens Toegangstoken ophalen.

  3. In het dialoogvenster keurt u de revisie goed.

Item maken mislukt vanwege capaciteitsselectie

Fout:

PriorityPlacement: Er zijn geen kernservices beschikbaar voor prioriteitsplaatsing. Alleen name, guiden workload-name zijn beschikbaar.

Oplossing:

Als gebruiker hebt u mogelijk alleen toegang tot de capaciteit van de proefversie. Zorg ervoor dat u een capaciteit gebruikt waartoe u toegang hebt.

Fout bij maken van bestand met fout 404 (NotFound)

Fout:

Het maken van een nieuw bestand is mislukt voor filePath: 'workspace-id'/'lakehouse-id'/Files/data.json. De antwoordstatuscode geeft geen succes aan: 404 (NotFound).

Oplossing:

Zorg ervoor dat u werkt met de DFS-URL van OneLake die bij uw omgeving past. Als u bijvoorbeeld met een PBM-omgeving werkt, wijzigt EnvironmentConstants.OneLakeDFSBaseUrl u de Constants.cs in de juiste URL.

Fouten opsporen

Wanneer u verschillende bewerkingen oplost, kunt u onderbrekingspunten instellen in de code om het gedrag te analyseren en fouten op te sporen. Volg deze stappen voor effectieve foutopsporing:

  1. Open de code in uw ontwikkelomgeving.
  2. Ga naar de relevante bewerkingshandlerfunctie (bijvoorbeeld OnCreateFabricItemAsync voor CRUD-bewerkingen of een eindpunt in een controller voor execute bewerkingen).
  3. Plaats onderbrekingspunten op specifieke regels waar u de code wilt inspecteren.
  4. Voer de toepassing uit in de foutopsporingsmodus.
  5. Activeer de bewerking vanuit de front-end die u wilt opsporen.

Het foutopsporingsprogramma onderbreekt de uitvoering op de opgegeven onderbrekingspunten, zodat u variabelen kunt onderzoeken, de code kunt doorlopen en problemen kunt identificeren.

Schermopname van het voorbeeldprogramma met onderbrekingspunten voor foutopsporing.

Werkplek

Als u een back-end verbindt met het voorbeeldworkloadproject, moet uw item behoren tot een werkruimte die is gekoppeld aan een capaciteit. De werkruimte Mijn werkruimte is standaard niet gekoppeld aan een capaciteit. Anders krijgt u mogelijk de fout die wordt weergegeven in de volgende schermopname:

Schermopname van de gebruikersinterface voor het benoemen van een voorbeeld van een workloaditem.

  1. Schakel over naar een benoemde werkruimte. Laat de standaardwerkruimtenaam Mijn werkruimte staan.

    Schermopname van de gebruikersinterface voor het maken van een voorbeeldworkload.

  2. Laad vanuit de juiste werkruimte de voorbeeldworkload en ga verder met de tests:

    Schermopname van de gebruikersinterface voor het maken van een voorbeeld van een workloaditem.

Bijdragen

We verwelkomen bijdragen aan dit project. Als u problemen ondervindt of nieuwe functies wilt toevoegen, voert u de volgende stappen uit:

  1. Fork de opslagplaats.
  2. Maak een nieuwe vertakking voor uw functie of foutoplossing.
  3. Breng uw wijzigingen aan en voer ze vervolgens door.
  4. Push uw wijzigingen naar uw geforkte opslagplaats.
  5. Maak een pull-aanvraag met een duidelijke beschrijving van uw wijzigingen.

Gerelateerde inhoud