Share via

DevOps-metoder för LUIS

  • Artikel

Viktigt

LUIS dras tillbaka den 1 oktober 2025 och från och med den 1 april 2023 kommer du inte att kunna skapa nya LUIS-resurser. Vi rekommenderar att du migrerar dina LUIS-program till konversationsspråkförståning för att dra nytta av fortsatt produktsupport och flerspråkiga funktioner.

Programvarutekniker som utvecklar en Language Understanding-app (LUIS) kan tillämpa DevOps-metoder kring källkontroll, automatiserade versioner, testning och versionshantering genom att följa dessa riktlinjer.

Källkontroll och förgreningsstrategier för LUIS

En av de viktigaste faktorerna som DevOps framgång är beroende av är källkontroll. Med ett källkontrollsystem kan utvecklare samarbeta om kod och spåra ändringar. Med hjälp av grenar kan utvecklare växla mellan olika versioner av kodbasen och arbeta oberoende av andra medlemmar i teamet. När utvecklare skickar en pull-begäran (PR) för att föreslå uppdateringar från en gren till en annan, eller när ändringar slås samman, kan dessa vara utlösaren för automatiserade versioner för att skapa och kontinuerligt testa kod.

Med hjälp av de begrepp och riktlinjer som beskrivs i det här dokumentet kan du utveckla en LUIS-app samtidigt som du spårar ändringar i ett källkontrollsystem och följa dessa metodtips för programvaruutveckling:

  • Källkontroll

    • Källkoden för LUIS-appen är i ett läsbart format för människor.
    • Modellen kan byggas från källan på ett repeterbart sätt.
    • Källkoden kan hanteras av en källkodslagringsplats.
    • Autentiseringsuppgifter och hemligheter som nycklar lagras aldrig i källkoden.

  • Förgrening och sammanslagning

    • Utvecklare kan arbeta från oberoende grenar.
    • Utvecklare kan arbeta i flera grenar samtidigt.
    • Det går att integrera ändringar i en LUIS-app från en gren till en annan via ombasering eller sammanslagning.
    • Utvecklare kan slå samman en PR till den överordnade grenen.

  • Versionshantering

    • Varje komponent i ett stort program bör versionshanteras oberoende av varandra, så att utvecklare kan identifiera icke-bakåtkompatibla ändringar eller uppdateringar bara genom att titta på versionsnumret.

  • Kodgranskningar

    • Ändringarna i PR visas som en läsbar källkod för människor som kan granskas innan pr accepteras.

Källkontroll

Om du vill behålla appschemadefinitionen för en LUIS-app i ett källkodshanteringssystem använder du LUDown-formatrepresentationen (.lu) för appen. .lu format är att föredra att .json formatera eftersom det är läsbart för människor, vilket gör det enklare att göra och granska ändringar i PR.

Spara en LUIS-app med LUDown-formatet

Så här sparar du en LUIS-app i .lu format och placerar den under källkontroll:

  • ANTINGEN: Exportera appversionen från .luLUIS-portalen och lägg till den i källkontrolllagringsplatsen

  • ELLER: Använd en textredigerare för att skapa en .lu fil för en LUIS-app och lägga till den i källkontrolllagringsplatsen

Tips

Om du arbetar med JSON-exporten av en LUIS-app kan du konvertera den till LUDown. Använd alternativet --sort för att se till att avsikter och yttranden sorteras alfabetiskt.
Observera att . LU-exportfunktionen som är inbyggd i LUIS-portalen sorterar redan utdata.

Skapa LUIS-appen från källan

För en LUIS-app kan du skapa från källa för att skapa en ny LUIS-appversion genom att .lu importera källan , träna versionen och publicera den. Du kan göra detta i LUIS-portalen eller på kommandoraden:

Filer som ska underhållas under källkontroll

Följande typer av filer för DITT LUIS-program bör underhållas under källkontroll:

Autentiseringsuppgifter och nycklar är inte incheckade

Inkludera inte nycklar eller liknande konfidentiella värden i filer som du checkar in på din lagringsplats där de kan vara synliga för obehörig personal. Nycklarna och andra värden som du bör förhindra från att checka in är:

  • LUIS-redigerings- och förutsägelsenycklar
  • LUIS-slutpunkter för redigering och förutsägelse
  • Azure-resursnycklar
  • Åtkomsttoken, till exempel token för ett Azure-tjänsthuvudnamn som används för automatiseringsautentisering

Strategier för säker hantering av hemligheter

Strategier för säker hantering av hemligheter är:

  • Om du använder Git-versionskontroll kan du lagra körningshemligheter i en lokal fil och förhindra incheckning av filen genom att lägga till ett mönster som matchar filnamnet i en .gitignore-fil
  • I ett automationsarbetsflöde kan du lagra hemligheter på ett säkert sätt i konfigurationen av parametrarna som erbjuds av automatiseringstekniken. Om du till exempel använder GitHub Actions kan du lagra hemligheter på ett säkert sätt i GitHub-hemligheter.

Förgrening och sammanslagning

Distribuerade versionskontrollsystem som Git ger flexibilitet i hur teammedlemmar publicerar, delar, granskar och itererar kodändringar via utvecklingsgrenar som delas med andra. Anta en Git-förgreningsstrategi som passar ditt team.

Oavsett vilken förgreningsstrategi du använder är en viktig princip för alla att teammedlemmar kan arbeta med lösningen i en funktionsgren oberoende av det arbete som pågår i andra grenar.

Så här stöder du oberoende arbete i grenar med ett LUIS-projekt:

  • Huvudgrenen har en egen LUIS-app. Den här appen representerar det aktuella tillståndet för din lösning för projektet och dess aktuella aktiva version bör alltid mappas till källan .lu som finns i huvudgrenen. Alla uppdateringar av källan för den .lu här appen bör granskas och testas så att den här appen kan distribueras till att skapa miljöer som Produktion när som helst. När uppdateringar av .lu slås samman till main från en funktionsgren bör du skapa en ny version i LUIS-appen och öka versionsnumret.

  • Varje funktionsgren måste använda sin egen instans av en LUIS-app. Utvecklare arbetar med den här appen i en funktionsgren utan att riskera att påverka utvecklare som arbetar i andra grenar. Den här dev-grenappen är en fungerande kopia som ska tas bort när funktionsgrenen tas bort.

Git-funktionsgren

Utvecklare kan arbeta från oberoende grenar

Utvecklare kan arbeta med uppdateringar i en LUIS-app oberoende av andra grenar genom att:

  1. Skapa en funktionsgren från huvudgrenen (beroende på din grenstrategi, vanligtvis main eller develop).

  2. Skapa en ny LUIS-app i LUIS-portalen ("dev branch-appen") enbart för att stödja arbetet i funktionsgrenen.

    • .lu Om källan för din lösning redan finns i din gren, eftersom den sparades efter arbete som utförts i en annan gren tidigare i projektet, skapar du din DEV Branch LUIS-app genom att .lu importera filen.

    • Om du börjar arbeta med ett nytt projekt har .lu du ännu inte källan för din huvudsakliga LUIS-app på lagringsplatsen. Du skapar .lu filen genom att exportera utvecklingsgrenappen från portalen när du har slutfört funktionsgrenens arbete och skicka den som en del av din PR.

  3. Arbeta med den aktiva versionen av utvecklingsgrenappen för att implementera nödvändiga ändringar. Vi rekommenderar att du bara arbetar i en enda version av utvecklingsgrenappen för allt funktionsgrenarbete. Om du skapar mer än en version i utvecklingsgrenappen bör du se till att spåra vilken version som innehåller de ändringar som du vill checka in när du höjer din pull-begäran.

  4. Testa uppdateringarna – se Testa för LUIS DevOps för mer information om hur du testar din dev-grenapp.

  5. Exportera den aktiva versionen av utvecklingsgrenappen .lu från versionslistan.

  6. Kontrollera dina uppdateringar och bjud in peer-granskning av dina uppdateringar. Om du använder GitHub skapar du en pull-begäran.

  7. När ändringarna godkänns sammanfogar du uppdateringarna till huvudgrenen. Nu ska du skapa en ny version av luis-huvudappen med hjälp av den uppdaterade .lu huvudappen. Mer information om hur du anger versionsnamnet finns i Versionshantering .

  8. När funktionsgrenen tas bort är det en bra idé att ta bort LUIS-appen för utvecklingsgrenen som du skapade för funktionsgrenens arbete.

Utvecklare kan arbeta i flera grenar samtidigt

Om du följer mönstret som beskrivs ovan i Utvecklare kan arbeta från oberoende grenar använder du ett unikt LUIS-program i varje funktionsgren. En enskild utvecklare kan arbeta med flera grenar samtidigt, så länge de växlar till rätt LUIS-app för utvecklingsgrenen för den gren som de för närvarande arbetar med.

Vi rekommenderar att du använder samma namn för både funktionsgrenen och för LUIS-appen för utvecklingsgrenen som du skapar för funktionsgrenen, för att göra det mindre troligt att du av misstag arbetar med fel app.

Som nämnts ovan rekommenderar vi att du för enkelhetens skull arbetar i en enda version i varje dev branch-app. Om du använder flera versioner måste du aktivera rätt version när du växlar mellan dev branch-appar.

Flera utvecklare kan arbeta på samma gren samtidigt

Du kan stödja flera utvecklare som arbetar med samma funktionsgren samtidigt:

  • Utvecklare checkar ut samma funktionsgren och push- och pull-ändringar som skickas in av sig själva och andra utvecklare medan arbetet fortsätter som vanligt.

  • Om du följer mönstret som beskrivs ovan i Utvecklare kan arbeta från oberoende grenar använder den här grenen ett unikt LUIS-program som stöd för utveckling. Luis-appen dev branch skapas av den första medlemmen i utvecklingsteamet som börjar arbeta i funktionsgrenen.

  • Lägg till gruppmedlemmar som deltagare i LUIS-appen för utvecklingsgrenen.

  • När funktionsgrenens arbete har slutförts exporterar du den aktiva versionen av LUIS-appen .lu för dev-grenen från versionslistan, sparar den uppdaterade .lu filen på lagringsplatsen och checkar in och pr-överför ändringarna.

Införliva ändringar från en gren till en annan med ombasering eller sammanslagning

Vissa andra utvecklare i ditt team som arbetar i en annan gren kan ha gjort uppdateringar av .lu källan och sammanfogat dem till huvudgrenen efter att du har skapat din funktionsgren. Du kanske vill införliva ändringarna i din arbetsversion innan du fortsätter att göra egna ändringar i funktionsgrenen. Du kan göra detta genom att ombaseras eller slås samman till main på samma sätt som andra kodtillgångar. Eftersom LUIS-appen i LUDown-format är läsbar för människor stöder den sammanslagning med hjälp av standardverktyg för sammanslagning.

Följ de här tipsen om du ombaserar LUIS-appen i en funktionsgren:

  • Innan du ombaseras eller sammanfogas kontrollerar du att din lokala kopia av .lu källan för din app har alla de senaste ändringarna som du har tillämpat med hjälp av LUIS-portalen, genom att exportera appen från portalen igen först. På så sätt kan du se till att alla ändringar som du har gjort i portalen och som inte har exporterats ännu inte går förlorade.

  • Under sammanslagningen använder du standardverktyg för att lösa eventuella sammanslagningskonflikter.

  • Glöm inte när ombasering eller sammanslagning har slutförts för att importera appen tillbaka till portalen, så att du arbetar med den uppdaterade appen när du fortsätter att tillämpa dina egna ändringar.

Sammanfoga PULL-flöden

När din pull-begäran har godkänts kan du sammanfoga ändringarna till huvudgrenen. Inga särskilda överväganden gäller LUDown-källan för en LUIS-app: den är läsbar för människor och har därför stöd för sammanslagning med hjälp av standardverktyg för sammanslagning. Eventuella sammanslagningskonflikter kan lösas på samma sätt som med andra källfiler.

När din pull-begäran har slagits samman rekommenderar vi att du rensar:

  • Ta bort grenen på lagringsplatsen

  • Ta bort LUIS-appen dev branch som du skapade för funktionsgrenen.

På samma sätt som med programkodtillgångar bör du skriva enhetstester som medföljer LUIS-appuppdateringar. Du bör använda arbetsflöden för kontinuerlig integrering för att testa:

  • Uppdateringar i en pull-begäran innan pull-begäran slås samman
  • Luis-huvudgrenappen efter att en pull-begäran har godkänts och ändringarna har slagits samman till huvudappen.

Mer information om testning för LUIS DevOps finns i Testa för DevOps för LUIS. Mer information om hur du implementerar arbetsflöden finns i Automation-arbetsflöden för LUIS DevOps.

Kodgranskningar

En LUIS-app i LUDown-format är läsbar för människor, vilket stöder kommunikation av ändringar i en pull-begäran som är lämplig för granskning. Enhetstestfiler skrivs också i LUDown-format och kan också enkelt granskas i en pull-begäran.

Versionshantering

Ett program består av flera komponenter som kan innehålla saker som en robot som körs i Azure AI Bot Service, QnA Maker, Azure AI Speech Service med mera. För att uppnå målet med löst kopplade program använder du versionskontroll så att varje komponent i ett program versionshanteras oberoende av varandra, så att utvecklare kan identifiera icke-bakåtkompatibla ändringar eller uppdateringar bara genom att titta på versionsnumret. Det är enklare att versionshantera LUIS-appen oberoende av andra komponenter om du underhåller den på en egen lagringsplats.

LUIS-appen för huvudgrenen bör ha ett versionsschema tillämpat. När du sammanfogar uppdateringar av .lu för en LUIS-app till main importerar du sedan den uppdaterade källan till en ny version i LUIS-appen för huvudgrenen.

Vi rekommenderar att du använder ett numeriskt versionsschema för huvudversionen av LUIS-appen, till exempel:

major.minor[.build[.revision]]

Varje uppdatering av versionsnumret ökas vid den sista siffran.

Huvudversionen/delversionen kan användas för att ange omfånget för ändringarna i LUIS-appens funktioner:

  • Huvudversion: En betydande ändring, till exempel stöd för en ny avsikt eller entitet
  • Delversion: En bakåtkompatibel mindre ändring, till exempel efter betydande ny utbildning
  • Build: Inga funktioner ändras, bara en annan version.

När du har fastställt versionsnumret för den senaste versionen av luis-huvudappen måste du skapa och testa den nya appversionen och publicera den till en slutpunkt där den kan användas i olika byggmiljöer, till exempel Kvalitetssäkring eller Produktion. Vi rekommenderar starkt att du automatiserar alla dessa steg i ett arbetsflöde för kontinuerlig integrering (CI).

Se:

Versionshantering av LUIS-appen "funktionsgren"

När du arbetar med en LUIS-app för utvecklingsgrenar som du har skapat för att stödja arbete i en funktionsgren, exporterar du din app när ditt arbete är klart och du kommer att inkludera den uppdaterade 'lu i din pull-begäran. Grenen på din lagringsplats och LUIS-appen dev branch bör tas bort när pr-begäran har sammanfogats med huvudnamnet. Eftersom den här appen endast finns för att stödja arbetet i funktionsgrenen finns det inget särskilt versionsschema som du behöver använda i den här appen.

När dina ändringar i din pull-begäran slås samman till huvudversionen är det då versionshantering ska tillämpas, så att alla uppdateringar av huvudversionen versionshanteras oberoende av varandra.

Nästa steg