Share via

Implementatiehandleiding voor back-end (preview)

  • Artikel

Deze voorbeeldopslagplaats voor microsoft Fabric-workloadontwikkeling fungeert als uitgangspunt voor het bouwen van toepassingen waarvoor integratie met verschillende services is vereist, evenals integratie met het Lakehouse-platform. Deze handleiding helpt u bij het instellen van de omgeving en het configureren van de benodigde onderdelen om aan de slag te gaan. In dit 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, waardoor naadloze interactie met de gebruiker wordt vergemakkelijkt. Zie de front-endhandleiding voor fabric-workloadontwikkelingskits voor meer informatie.

Back-end

De back-end slaat zowel gegevens als metagegevens op. Er worden CRUD-bewerkingen gebruikt om workloaditems (WL) samen met metagegevens te maken en taken uit te voeren om gegevens in de opslag te vullen. De 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 tijdens het werken in de ontwikkelmodus. In de ontwikkelaarsmodus werkt de workload op de computer van de ontwikkelaar. Het DevGateway.exe hulpprogramma heeft twee rollen:

  • Verwerkt de workloadzijde van het Azure Relay-kanaal en beheert de registratie van het lokale exemplaar van de workload met Fabric in de context van een specifieke capaciteit, waardoor de workload toegankelijk is in alle werkruimten die aan die capaciteit zijn toegewezen. Het hulpprogramma verwerkt de registratie wanneer deze is gestopt.
  • Kanalen (samen met Azure Relay) workload-API-aanroepen van Fabric naar de workload.

Api-aanroepen voor workloadbeheer worden rechtstreeks vanuit de workload naar Fabric uitgevoerd en vereisen niet het Azure Relay-kanaal.

Lakehouse-integratie

De architectuur van de workload development kit kan naadloos worden geïntegreerd met Lakehouse, waardoor bewerkingen zoals het opslaan, lezen en ophalen van gegevens mogelijk zijn. De interactie wordt gefaciliteerd via Azure Relay en de Fabric SDK, waardoor beveiligde en geverifieerde communicatie wordt gegarandeerd.

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 respectieve secties in het overzicht van verificatie voor meer informatie over projectconfiguratie, verificatierichtlijnen en aan de slag.

Diagram waarin wordt getoond hoe Fabric SDK is geïntegreerd in 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 uit te voeren naar de weergegeven 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. 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>: Als deze eigenschap is ingesteld op 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>: Als deze eigenschap is ingesteld op true, geeft deze eigenschap aan dat het project kan worden verpakt in een NuGet-pakket. Het 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 src\bin\Debug map na het buildproces. Wanneer u in de cloudmodus werkt, kunt u de buildconfiguratie van Visual Studio omzetten in release en build van uw pakket. Het gegenereerde pakket bevindt zich in de src\bin\Release map. Zie de handleiding Werken in de cloudmodus voor meer informatie

Afhankelijkheden

  • De standaard voor het back-endvoorbeeld is afhankelijk van de volgende Azure SDK-pakketten:

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

Als u de NuGet-Pakketbeheer wilt configureren, geeft u het pad op in de sectie Pakketbronnen vóór 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

Voer de volgende stappen uit om het voorbeeldproject voor de werkbelasting op uw lokale computer in te stellen:

  1. Kloon de opslagplaats: 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 verificatiehandleiding te volgen. Zorg ervoor dat zowel uw front-end- als back-endprojecten de benodigde installatie hebben die in de handleiding wordt beschreven. Microsoft Entra wordt gebruikt voor beveiligde verificatie, zodat alle interacties in de architectuur zijn geautoriseerd en beveiligd.

  4. Werk de ONELake DFS-basis-URL bij: afhankelijk van uw Infrastructuuromgeving kunt u de OneLakeDFSBaseURL map src\Constants bijwerken. De standaardwaarde is, onelake.dfs.fabric.microsoft.com maar dit kan worden bijgewerkt met de omgeving waarin u zich bevindt. Meer informatie over de DFS-paden vindt u in de Documentatie van One Lake.

  5. Workloadconfiguratie instellen

    • Kopieer workload-dev-mode.json van src/Config naar C:\
    • Werk in het bestand workload-dev-mode.json de volgende velden bij zodat deze overeenkomen met uw configuratie:
      • CapacityGuid: uw capaciteits-id. Dit is te vinden in de Infrastructuurportal onder de capaciteitsinstellingen van de beheerportal.
      • ManifestPackageFilePath: de locatie van het manifestpakket. Wanneer u de oplossing bouwt, wordt het manifestpakket opgeslagen in src\bin\Debug. Meer informatie over het manifestpakket vindt u in latere stappen.
      • WorkloadEndpointURL: URL van het workloadeindpunt.
    • Werk in het bestand Packages/manifest/WorkloadManifest.xml de volgende velden bij zodat deze overeenkomen met uw configuratie:
      • <AppId>: client-id (toepassings-id) van de entra-workloadtoepassing.
      • <RedirectUri: Omleidings-URI's>. Deze vindt u in de app-registratie die u hebt gemaakt onder de sectie Verificatie.
      • <ResourceId>: Doelgroep voor de binnenkomende Entra-tokens. Deze informatie vindt u in de app-registratie die u hebt gemaakt onder de sectie 'Een API beschikbaar maken'.
    • 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: Client-id (toepassings-id) van de entra-workloadtoepassing.
      • ClientSecret: het geheim voor de Entra-workloadtoepassing.
      • Doelgroep: Doelgroep voor de binnenkomende Entra-tokens. Deze informatie vindt u in de app-registratie die u hebt gemaakt onder de sectie 'Een API beschikbaar maken'. Dit wordt ook wel de URI van de toepassings-id genoemd.

  6. Genereer een manifestpakket. Als u een manifestpakketbestand wilt genereren, bouwt u Fabric_Extension_BE_Boilerplate. Hiermee wordt een proces met drie stappen uitgevoerd om het manifestpakketbestand te genereren:

    1. WorkloadManifest.xml Activeren ManifestValidator.ps1 in *Packages\manifest* en trigger ItemManifestValidator.ps1 voor 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 Validation errors with either manifests or default values. Dubbelklik op de fout in Visual Studio om het foutenbestand weer te geven.
    3. Na een geslaagde validatie 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 manifestpackage.1.0.0.nupkg-bestand 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 die zich in de map DevGateway bevindt . Meld u aan met een gebruiker met capaciteitsbeheerdersbevoegdheden voor de capaciteit die u hebt gedefinieerd in workload-dev-mode.json (CapacityGuid). Na de initialisatie van de workload wordt een verificatieprompt weergegeven.

    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, mogelijk gemaakt door een aangewezen proxyknooppunt. Bovendien wordt het pakket met het workloadmanifest geüpload en gepubliceerd.

    In deze fase heeft Fabric kennis van de workload, die de toegewezen capaciteit omvat.

    Controle op mogelijke fouten kan worden weergegeven in de console.

    Als u geen fouten krijgt, wordt de verbinding tot stand gebracht, wordt de registratie uitgevoerd en is 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 de standaardplaat

Codegeneratie

We gebruiken het standaard C#-voorbeeld van de workload ASP.NET Core om uit te leggen hoe u een workload bouwt met REST API's. Begint met het genereren van server-stubs en contractklassen op basis van de Swagger-specificatie van de Workload-API. U kunt ze genereren met behulp van een van de verschillende hulpprogramma's voor het genereren van Swagger-code. Ons standaardvoorbeeld maakt gebruik van NSwag. Het voorbeeld bevat GenerateServerStub.cmd opdrachtregelscript, waarmee de NSwag-codegenerator wordt verpakt. Het script heeft één parameter, een volledig pad naar de installatiemap van NSwag. Er wordt ook verwacht dat het Swagger-definitiebestand (swagger.json) en het configuratiebestand (nswag.json) ernaast worden gevonden.

Als u dit script uitvoert, wordt een C#-bestand WorkloadAPI_Generated.cs. De inhoud van dit bestand kan als volgt logisch worden onderverdeeld in drie delen.

ASP.NET Core stub controllers

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

Dit is een voorbeeld van de methode CreateItem :

/// <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 die worden gebruikt door de API's.

Implementatie

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

Deze code is bijvoorbeeld de implementatie van 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);
}

Nettolading van item verwerken

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

"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 'payload'-eigenschappen 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. Dit is bijvoorbeeld het type CreateItemPayload :

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

De gegenereerde C#-contractklassen worden gedefinieerd als gedeeltelijk en hebben een woordenlijst met eigenschappen.

/// <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 voor het lezen en retourneren van eigenschappen. Een betere benadering is het definiëren van specifieke eigenschappen met bijbehorende typen en namen. Dit kan eenvoudig worden bereikt vanwege de 'gedeeltelijke' declaratie van de gegenereerde klassen.

CreateItemPayload.cs bestand bevat bijvoorbeeld een aanvullende definitie voor de klasse CreateItemPayload, waarmee de eigenschap Item1Metadata wordt toegevoegd.

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 workload echter meerdere itemtypen ondersteunt, moet de klasse CreateItemPayload verschillende typen nettoladingen kunnen verwerken, één per itemtype. Er zijn twee manieren om dit te doen. De eenvoudigere manier, die wordt gebruikt door het standaardvoorbeeld, is het definiëren van meerdere optionele eigenschappen, die elk de nettolading voor het maken van een ander itemtype vertegenwoordigen. Elke aanvraag heeft vervolgens slechts één van deze eigenschappensets, afhankelijk van het itemtype dat wordt gemaakt. U kunt ook polymorfe serialisatie implementeren, maar het wordt niet gedemonstreerd in het voorbeeld omdat het geen aanzienlijke voordelen biedt.

Voor het ondersteunen van twee itemtypen moet deze klassedefinitie bijvoorbeeld als volgt worden uitgebreid:

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 'payload' die naar de workload wordt verzonden, wordt gegenereerd door de client. Dit kan de itemeditor iFrame of 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 standaardvoorbeelditem1-implementatie verwerkt die:

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();
}

Probleemoplossing en foutopsporing

Bekende problemen en oplossingen

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: Ongeldig clientgeheim opgegeven. Zorg ervoor dat het geheim dat in de aanvraag wordt verzonden, de waarde van het clientgeheim is, niet de clientgeheim-id, voor een geheim dat is toegevoegd aan de app 'app_guid'.

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

Fout:

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

Oplossing: Navigeer in de itemeditor naar de onderkant en selecteer Naar verificatiepagina navigeren. Onder Scopes write .default en selecteer Get Access token. Toestemming goedkeuren in het pop-updialoogvenster.

Item maken mislukt vanwege capaciteitsselectie

Fout: PriorityPlacement: Er zijn geen beschikbare kernservices voor prioriteitsplaatsing alleen 'name','guid','workload-name'.

Oplossing: U gebruikt mogelijk een gebruiker die alleen toegang heeft tot 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. Fout: De antwoordstatuscode geeft niet aan dat het is gelukt: 404 (NotFound).

Oplossing: zorg ervoor dat u werkt met de ONELake DFS-URL die past bij uw omgeving. Als u bijvoorbeeld met de PBM-omgeving werkt, wijzigt u EnvironmentConstants.OneLakeDFSBaseUrl in Constants.cs naar de juiste URL.

Foutopsporing

Bij het oplossen van verschillende bewerkingen 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. Navigeer 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 vanaf de front-end (FE) die u wilt opsporen.

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

Schermopname van het voorbeeldprogramma met onderbrekingspunten voor foutopsporing.

Werkplek

Als u een back-end verbindt met de voorbeeldworkload, 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 deze fout:

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

  1. Schakel over naar een benoemde werkruimte en laat de standaard 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 door.
  4. Push uw wijzigingen naar uw geforkte opslagplaats.
  5. Maak een pull-aanvraag met een duidelijke beschrijving van uw wijzigingen.

Gerelateerde inhoud