Konfigurera scheman för pipelines

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019

Azure Pipelines innehåller flera typer av utlösare för att konfigurera hur din pipeline startar.

• Schemalagda triggers startar din pipeline baserat på ett schema, till exempel en nattlig kompilering. Den här artikeln innehåller vägledning om hur du använder schemalagda utlösare för att köra dina pipelines baserat på ett schema.
• Händelsebaserade utlösare startar din pipeline som svar på händelser, till exempel att skapa en pull request eller pusha till en gren. Information om hur du använder händelsebaserade utlösare finns i Utlösare i Azure Pipelines.

Du kan kombinera schemalagda och händelsebaserade utlösare i dina pipelines, till exempel för att verifiera versionen varje gång en push görs (CI-utlösare), när en pull-begäran görs (PR-utlösare) och en nattlig version (schemalagd utlösare). Om du bara vill skapa din pipeline enligt ett schema och inte svara på händelsebaserade utlösare kontrollerar du att pipelinen inte har några andra utlösare aktiverade. YAML-pipelines på en GitHub-lagringsplats har till exempel CI-utlösare och PR-utlösare aktiverade som standard. Information om hur du inaktiverar standardutlösare finns i Utlösare i Azure Pipelines och gå till avsnittet som omfattar din lagringsplatstyp.

Schemalagda utlösare

YAML

Viktig

Schemalagda utlösare som definierats med hjälp av användargränssnittet för pipelineinställningar har företräde framför YAML-schemalagda utlösare.

Om YAML-pipelinen har både YAML-schemalagda utlösare och gränssnittsdefinierade schemalagda utlösare körs endast de gränssnittsdefinierade schemalagda utlösarna. Om du vill köra de YAML-definierade schemalagda utlösarna i YAML-pipelinen måste du ta bort de schemalagda utlösare som definierats i användargränssnittet för pipelineinställningar. När alla schemalagda utlösare för användargränssnittet har tagits bort måste en push göras för att de SCHEMALAGDa YAML-utlösarna ska börja utvärderas.

För att ta bort UI-schemalagda utlösare från en YAML-pipeline, se UI-inställningar åsidosätter schemalagda YAML-utlösare.

Schemalagda utlösare konfigurerar en pipeline så att den körs enligt ett schema som definierats med hjälp av cron-syntax.

schedules:
- cron: string # cron syntax defining a schedule
  displayName: string # friendly name given to a specific schedule
  branches:
    include: [ string ] # which branches the schedule applies to
    exclude: [ string ] # which branches to exclude from the schedule
  always: boolean # whether to always run the pipeline or only if there have been source code changes since the last successful scheduled run. The default is false.
  batch: boolean # Whether to run the pipeline if the previously scheduled run is in-progress; the default is false.
  # batch is available in Azure DevOps Server 2022.1 and higher

Schemalagda pipelines i YAML har följande begränsningar.

• Tidszonen för cron-scheman är UTC. Du kan få AI-hjälp från GitHub Copilot för att skapa dina cron-uttryck.
• Om du anger en exclude-sats utan en include-sats för branchesmotsvarar det att ange * i include-satsen.
• Du kan inte använda pipelinevariabler när du anger scheman.
• Om du använder mallar i YAML-filenmåste schemana anges i YAML-huvudfilen och inte i mallfilerna.

Branchöverväganden för schemalagda utlösare

Schemalagda utlösare utvärderas för en gren när följande händelser inträffar.

• En rörledning skapas.
• En pipelines YAML-fil uppdateras, antingen från en push-överföring eller genom att redigera den i pipelineredigeraren.
• En pipelines YAML-filsökväg uppdateras för att referera till en annan YAML-fil. Den här ändringen uppdaterar bara standardgrenen och hämtar därför bara scheman i den uppdaterade YAML-filen för standardgrenen. Om andra grenar därefter sammanfogar standardgrenen, till exempel git pull origin main, utvärderas de schemalagda utlösarna från den nyligen refererade YAML-filen för den grenen.
• En ny gren skapas.

När en av dessa händelser inträffar i en gren läggs alla schemalagda körningar för den grenen till, om grenen matchar grenfiltren för de schemalagda utlösarna i YAML-filen i den grenen.

Viktig

Schemalagda körningar för en gren läggs bara till om grenen matchar grenfiltren för de schemalagda utlösarna i YAML-filen i den specifika grenen.

Till exempel skapas en pipeline med följande schema och den här versionen av YAML-filen checkas in i main-grenen. Det här schemat bygger main-grenen dagligen.

# YAML file in the main branch
schedules:
- cron: '0 0 * * *'
  displayName: Daily midnight build
  branches:
    include:
    - main

Sedan skapas en ny gren baserat på mainmed namnet new-feature. De schemalagda utlösarna från YAML-filen i den nya grenen läses och eftersom det inte finns någon matchning för new-feature grenen görs inga ändringar i de schemalagda versionerna och new-feature-grenen skapas inte med en schemalagd utlösare.

Om new-feature läggs till i branches-listan och den här ändringen skickas till new-feature-grenen läss YAML-filen och eftersom new-feature nu finns i listan med grenar läggs en schemalagd version till för new-feature-grenen.

# YAML file in the new-feature-branch
schedules:
- cron: '0 0 * * *'
  displayName: Daily midnight build
  branches:
    include:
    - main
    - new-feature

Tänk nu på att en gren med namnet release skapas baserat på mainoch sedan läggs release till i grenfiltren i YAML-filen i main-grenen, men inte i den nyligen skapade release-grenen.

# YAML file in the release branch
schedules:
- cron: '0 0 * * *'
  displayName: Daily midnight build
  branches:
    include:
    - main

# YAML file in the main branch with release added to the branches list
schedules:
- cron: '0 0 * * *'
  displayName: Daily midnight build
  branches:
    include:
    - main
    - release

Eftersom release lades till i grenfiltren i main-grenen, men inte till grenfiltren i release-grenen, kommer release-grenen inte att byggas enligt det schemat. Endast när release-grenen läggs till i grenfiltren i YAML-filen i versionsgrenen läggs den schemalagda versionen till i schemaläggaren.

Batchöverväganden för schemalagda utlösare

Egenskapen batch konfigurerar om pipelinen ska köras när en tidigare schemalagd körning fortfarande pågår. När batch är truestartar inte en ny pipelinekörning på grund av schemat om en tidigare pipelinekörning fortfarande pågår. Standardvärdet är false.

Egenskapen batch påverkas av inställningen för egenskapen always. När always är truekörs pipelinen enligt cron-schemat, även när batch är true och en pågående körning pågår.

Alltid	Omgång	Uppförande
false	false	Pipeline körs endast om det sker en ändring i förhållande till den senaste lyckade schemalagda pipelinekörningen, även om det pågår en pågående körning från den senaste schemalagda utlösaren.
false	true	Pipeline körs endast om det sker en ändring i förhållande till den senaste lyckade schemalagda pipelinekörningen och det inte finns någon pågående schemalagd pipelinekörning.
true	false	Pipeline körs enligt cron-schemat.
true	true	Pipeline körs enligt cron-schemat även om det pågår en pågående körning.

Variabeln Build.CronSchedule.DisplayName

När en pipeline körs på grund av en schemalagd cron-utlösare innehåller den fördefinierade Build.CronSchedule.DisplayName variabeln displayName för cron-schemat som utlöste pipelinekörningen.

YAML-pipelinen kan innehålla flera cron-scheman och du kanske vill att din pipeline ska köra olika steg eller jobb baserat på vilket cron-schema som körs. Du har till exempel ett nattligt bygge och en veckoversion, och du vill bara köra en viss fas under det nattliga bygget. Du kan använda variabeln Build.CronSchedule.DisplayName i ett jobb- eller fasvillkor för att avgöra om jobbet eller fasen ska köras.

- stage: stage1
  # Run this stage only when the pipeline is triggered by the 
  # "Daily midnight build" cron schedule
  condition: eq(variables['Build.CronSchedule.DisplayName'], 'Daily midnight build')

Fler exempel finns i schedules.cron-exempel.

Klassisk

Välj de dagar och tider då du vill köra bygget med den klassiska redigeraren.

Om lagringsplatsen är Azure Repos Git, GitHub eller Annan Git kan du även ange grenar som ska inkluderas och exkluderas. Om du vill använda jokertecken skriver du grenspecifikationen (till exempel features/modules/*) och trycker sedan på Enter.

Exempel

YAML

I följande exempel definieras två scheman:

schedules:
- cron: '0 0 * * *'
  displayName: Daily midnight build
  branches:
    include:
    - main
    - releases/*
    exclude:
    - releases/ancient/*
- cron: '0 12 * * 0'
  displayName: Weekly Sunday build
  branches:
    include:
    - releases/*
  always: true

Det första schemat, Daily midnight build, kör en pipeline vid midnatt varje dag, men bara om koden har ändrats sedan den senaste lyckade schemalagda körningen, för main och alla releases/* grenar, förutom grenarna under releases/ancient/*.

Det andra schemat, weekly sunday build, kör en pipeline kl. 12.00 på söndagar, oavsett om koden har ändrats eller inte sedan den senaste körningen, för alla releases/* grenar.

Anteckning

Tidszonen för cron-scheman är UTC, så i dessa exempel är midnattsversionen och 12:00-versionen vid midnatt och 12:00 i UTC.

Fler exempel finns i Migrera från den klassiska redigeraren.

klassisk

Exempel: Nattligt bygge av Git-lagringsplats i flera tidszoner

I det här exemplet har den klassiska schemalagda triggern två inlägg som skapar följande byggen.

• Varje måndag – fredag kl. 03:00 UTC + 5:30 skapas grenar som uppfyller kriterierna för features/india/*-grenfilter.

  

• Varje måndag – fredag kl. 03:00 (UTC–5:00 tidszon) skapar du grenar som uppfyller kriterierna för features/nc/*-grenfilter

  

Exempel: Nightly build med olika frekvenser

Azure Pipelines och Azure DevOps 2019 Server

I det här exemplet har den klassiska utlösaren för schemalagda jobb i redigeraren två poster, vilket resulterar i följande byggen.

• Varje måndag – fredag kl. 03:00 UTC skapar du grenar som uppfyller main och releases/* villkor för grenfilter

  

• Varje söndag kl. 03:00 UTC skapar du releases/lastversion-grenen, även om källan eller pipelinen inte har ändrats

  

Cron-syntax

YAML-

Varje schemalagt cron-uttryck för Azure Pipelines-utlösare är ett utrymmesavgränsat uttryck som består av fem poster i följande ordning. Uttrycket omges av enkla citattecken '.

mm HH DD MM DW
 \  \  \  \  \__ Days of week
  \  \  \  \____ Months
   \  \  \______ Days
    \  \________ Hours
     \__________ Minutes

Fält	Godkända värden
Protokoll	0 till 59
Timmar	0 till 23
Dagar	1 till 31
Månader	1 till 12, fullständiga engelska namn, första tre bokstäverna i engelska namn
Veckodagar	0 till 6 (börjar med söndag), fullständiga engelska namn, de tre första bokstäverna i engelska namn

Värden kan ha följande format.

Format	Exempel	Beskrivning
Wildcard	*	Matchar alla värden för det här fältet
Enskilt värde	5	Anger ett enda värde för det här fältet
Kommaavgränsad	3,5,6	Anger flera värden för det här fältet. Flera format kan kombineras, till exempel 1,3-6
Intervall	1-3	Det inkluderande värdeintervallet för det här fältet
Intervall	*/4 eller 1-5/2	Intervall som ska matchas för det här fältet, till exempel vart fjärde värde eller intervallet 1–5 med ett stegintervall på 2

Exempel	Cron-uttryck
Bygg varje måndag, onsdag och fredag kl. 18:00	0 18 * * Mon,Wed,Fri, 0 18 * * 1,3,5eller 0 18 * * 1-5/2
Skapa var 6:e timme	0 0,6,12,18 * * *, 0 */6 * * * eller 0 0-18/6 * * *
Skapa var 6:e timme med start kl. 09:00	0 9,15,21 * * * eller 0 9-21/6 * * *

Mer information om format som stöds finns i Crontab Expression.

Använda GitHub Copilot för att skapa ett cron-uttryck

Du kan få AI-hjälp från GitHub Copilot för att skapa cron-uttryck eller konvertera befintliga cron-uttryck från din lokala tidszon till UTC.

Cron-scheman för Azure Pipelines definieras i UTC, så scheman som Build varje måndag, onsdag och fredag kl. 18:00 måste skapas med cron-syntax och konverteras från din lokala tidszon till UTC.

Anpassa följande uppmaningar för att skapa cron-uttryck eller konvertera cron-uttryck till UTC från tidszonen som du använde för att skapa uttrycken.

I följande exempel uppmanas Copilot att skapa ett cron-schema i UTC för att bygga varje måndag, onsdag och fredag kl. 18:00 Eastern Standard Time.

Build a UTC cron expression for Monday, Wednesday, and Friday at 6:00 PM Eastern Standard Time

Om du redan har ett cron-uttryck i din lokala tidszon kan du be Copilot att konvertera det till UTC. I det här exemplet konverteras ett cron-schema för att bygga varje måndag, onsdag och fredag kl. 18:00 (0 18 * * Mon,Wed,Fri) Eastern Standard Time till UTC.

Convert the following cron expression from Eastern Standard Time to UTC: 0 18 * * Mon,Wed,Fri

Konvertering av ett cron-uttryck till UTC kan kräva att veckodagarna i uttrycket ändras. I följande exempel uppmanas Copilot att skapa ett UTC cron-schema för att bygga måndag till fredag kl. 12:30 centraleuropeisk standardtid. Centraleuropeisk standardtid ligger före UTC, så det resulterande uttrycket börjar sent söndag kväll istället för tidigt på måndagsmorgonen och slutar på torsdag.

Build a UTC cron expression for Monday through Friday at 12:30 AM Central European Standard Time

Om du vill få ytterligare information om cron-uttrycket som genereras av Copilot kan du be Copilot att ge en förklaring av det genererade cron-uttrycket i din prompt.

Build a UTC cron expression for Monday through Friday at 12:30 AM Central European Standard Time and explain the different parts of the cron expression

Copilot drivs av AI, så överraskningar och misstag är möjliga. Mer information finns i vanliga frågor och svar om användning av Copilot.

Klassiska

Klassiska scheman definieras med hjälp av en grafisk redigerare i stället för cron-syntax. Information om hur du definierar klassiska scheman finns i Exempel.

Vy över schemalagda körningar

YAML-

Du kan visa en förhandsversion av kommande schemalagda versioner genom att välja Schemalagda körningar från snabbmenyn på sidan pipelineinformation för din pipeline.

Viktig

Vyn schemalagda körningar visar endast pipelines som är schemalagda att köras inom sju dagar från det aktuella datumet. Om ditt cron-schema har ett intervall som är längre än 7 dagar och nästa körning är schemalagd att starta efter sju dagar från det aktuella datumet visas det inte i vyn Schemalagda körningar.

När du har skapat eller uppdaterat dina schemalagda utlösare kan du verifiera dem med hjälp av Översikt över schemalagda körningar.

I det här exemplet visas schemalagda körningar för följande schema.

schedules:
- cron: '0 0 * * *'
  displayName: Daily midnight build
  branches:
    include:
    - main

I Schemalagda körningar visas tiderna konverterade till lokal tidszon enligt inställningen på datorn som används för att surfa till Azure DevOps-portalen. I det här exemplet visas en skärmbild som tagits i EST-tidszonen.

Not

Om du uppdaterar schemat för en pågående pipeline uppdateras inte vyn för schemalagda körningar med det nya schemat förrän den nuvarande pipelinen har slutförts.

Klassiska

Du kan visa en förhandsversion av kommande schemalagda versioner genom att välja Schemalagda körningar från snabbmenyn på sidan pipelineinformation för din pipeline.

När du har skapat eller uppdaterat dina schemalagda utlösare kan du verifiera dem med hjälp av den här vyn.

Körs även om det inte finns några kodändringar

Din pipeline körs inte automatiskt som standard, om det inte har gjorts några kodändringar sedan den senaste lyckade schemalagda körningen. Anta till exempel att du har schemalagt att en pipeline ska köras varje kväll klockan 21:00. Under vardagar skickar du olika ändringar i koden. Rörledningen körs enligt schemat. Under helgerna gör du inga ändringar i koden. Om det inte har gjorts några kodändringar sedan den schemalagda körningen i fredags körs inte pipelinen som planerat under helgen.

YAML

Om du vill tvinga en pipeline att köras även om det inte finns några kodändringar kan du använda nyckelordet always.

schedules:
- cron: ...
  ...
  always: true

klassiska

Om du bara vill konfigurera den schemalagda pipelinen så att den skapas om det har skett en ändring sedan den senaste versionen kontrollerar du Endast schemaversioner om källan eller pipelinen har ändrats.

Begränsningar för antalet schemalagda körningar i YAML-pipelines

Det finns vissa gränser för hur ofta du kan schemalägga en pipeline som ska köras. Dessa gränser har införts för att förhindra missbruk av Azure Pipelines-resurser, särskilt de Microsoft-värdbaserade agenterna. Gränserna är:

• cirka 1 000 körningar per pipeline per vecka
• 10 körningar per pipeline per 15 minuter

Migrera från den klassiska redigeraren

I följande exempel visas hur du migrerar dina scheman från den klassiska redigeraren till YAML.

• Exempel: Nattligt bygge av Git-lagringsplats i flera tidszoner
• Exempel: Natlig build med olika frekvenser

Exempel: Nattligt bygge av Git-lagringsplats i flera tidszoner

I det här exemplet har den schemalagda utlösaren i den klassiska redigeraren två poster som skapar följande versioner.

• Varje måndag – fredag kl. 03:00 (UTC + 5:30 tidszon), skapar grenar som uppfyller kriterierna för features/india/*-grenfilter

  

• Varje måndag – fredag kl. 03:00 (UTC–5:00 tidszon) skapar du grenar som uppfyller kriterierna för features/nc/*-grenfilter

  

Motsvarande schemalagda YAML-utlösare är:

schedules:
- cron: '30 21 * * Sun-Thu'
  displayName: M-F 3:00 AM (UTC + 5:30) India daily build
  branches:
    include:
    - /features/india/*
- cron: '0 8 * * Mon-Fri'
  displayName: M-F 3:00 AM (UTC - 5) NC daily build
  branches:
    include:
    - /features/nc/*

I det första schemat M-F 03:00 (UTC + 5:30) Indien daglig versionär cron-syntaxen (mm HH DD MM DW) 30 21 * * Sun-Thu.

• Minuter och timmar – 30 21 – Detta mappar till 21:30 UTC (9:30 PM UTC). Eftersom den angivna tidszonen i den klassiska redigeraren är UTC + 5:30måste vi subtrahera 5 timmar och 30 minuter från önskad byggtid på 03:00 för att komma fram till önskad UTC-tid för att ange yaml-utlösaren. Du kan få AI-hjälp från GitHub Copilot för att skapa ditt cron-uttryck.
• Dagar och månader anges som jokertecken eftersom det här schemat inte anger att endast ska köras vissa dagar i månaden eller en viss månad.
• Dagar i veckan – Sun-Thu – på grund av tidszonskonverteringen, för att våra versioner ska kunna köras kl. 03:00 i tidszonen UTC + 5:30 Indien måste vi ange att de ska startas föregående dag i UTC-tid. Vi kan också ange veckodagarna som 0-4 eller 0,1,2,3,4.

I det andra schemat M-F 03:00 (UTC – 5) NC daglig versionär cron-syntaxen 0 8 * * Mon-Fri.

• Minuter och timmar - 0 8 - Detta motsvarar 8:00 AM UTC. Eftersom den angivna tidszonen i den klassiska redigeraren är UTC – 5:00måste vi lägga till 5 timmar från den önskade byggtiden 03:00 för att komma fram till önskad UTC-tid för att ange för YAML-utlösaren. Du kan få AI-hjälp från GitHub Copilot för att skapa ditt cron-uttryck.
• Dagar och månader anges som jokertecken eftersom det här schemat inte anger att endast ska köras vissa dagar i månaden eller en viss månad.
• Veckodagar – Mon-Fri – Eftersom våra tidszonskonverteringar inte sträcker sig över flera dagar i veckan för önskat schema behöver vi inte göra någon konvertering här. Vi kan också ange veckodagarna som 1-5 eller 1,2,3,4,5.

Viktig

UTC-tidszonerna i YAML-schemalagda utlösare tar inte hänsyn till sommartid.

Tips

När du använder tre bokstavs förkortningar av veckodagarna och vill ha ett intervall på flera dagar till och med söndag, bör söndag betraktas som den första dagen i veckan, t.ex. För ett schema vid midnatt EST, torsdag till söndag, är cron-syntaxen 0 5 * * Sun,Thu-Sat.

Exempel: Nightly build med olika variationer

I det här exemplet har den klassiska, schemalagda utlösaren i redigeraren två inlägg, vilket skapar följande byggen.

• Varje måndag – fredag kl. 03:00 UTC skapar du grenar som uppfyller main och releases/* villkor för grenfilter

  

• Varje söndag kl. 03:00 UTC skapar du releases/lastversion-grenen, även om källan eller pipelinen inte har ändrats

  

Motsvarande schemalagda YAML-utlösare är:

schedules:
- cron: '0 3 * * Mon-Fri'
  displayName: M-F 3:00 AM (UTC) daily build
  branches:
    include:
    - main
    - /releases/*
- cron: '0 3 * * Sun'
  displayName: Sunday 3:00 AM (UTC) weekly latest version build
  branches:
    include:
    - /releases/lastversion
  always: true

I det första schemat daglig version av M-F 03:00 (UTC)är cron-syntaxen 0 3 * * Mon-Fri.

• Minuter och timmar – 0 3 – Detta motsvarar 3:00 AM UTC. Eftersom den angivna tidszonen i den klassiska redigeraren är UTC-behöver vi inte göra några tidszonskonverteringar.
• Dagar och månader anges som jokertecken eftersom det här schemat inte anger att endast ska köras vissa dagar i månaden eller en viss månad.
• Veckodagar – Mon-Fri – eftersom det inte finns någon tidszonskonvertering, följer veckodagarna direkt det klassiska redigeringsschemat. Vi kan också ange veckodagarna som 1,2,3,4,5.

I det andra schemat är cron-syntaxen 0 3 * * Sunför den veckovisa, senaste versionsbyggnaden, söndag 03:00 (UTC).

• Minuter och timmar – 0 3 – Detta motsvarar 3:00 AM UTC. Eftersom den angivna tidszonen i den klassiska redigeraren är UTC-behöver vi inte göra några tidszonskonverteringar.
• Dagar och månader anges som jokertecken eftersom det här schemat inte anger att endast ska köras vissa dagar i månaden eller en viss månad.
• Veckodagar – Sun – Eftersom våra tidszonskonverteringar inte sträcker sig över flera dagar i veckan för önskat schema behöver vi inte göra någon konvertering här. Vi kan också ange veckodagarna som 0.
• Vi anger också always: true eftersom den här versionen är schemalagd att köras oavsett om källkoden har uppdaterats eller inte.

FAQ

• jag vill att min pipeline bara ska köras enligt schemat och inte när någon skickar en ändring till en gren
• Jag definierade ett schema i YAML-filen. Men den fungerade inte. Vad hände?
• Mina YAML-scheman fungerade bra. Men de slutade fungera nu. Hur felsöker jag detta?
• Min kod har inte ändrats, men en schemalagd version utlöses. Varför?
• Jag ser den planerade körningen i panelen Schemalagda körningar. Den körs dock inte vid den tidpunkten. Varför?
• Scheman som definierats i YAML-pipelinen fungerar för en gren men inte den andra. Hur åtgärdar jag detta?

Jag vill att min pipeline endast ska köras enligt schemat och inte när någon pushar en ändring till en gren.

Om du vill att pipelinen endast ska köras enligt schemat och inte när någon skickar en ändring till en gren eller sammanfogar en ändring till huvudgrenen, måste du uttryckligen inaktivera standardutlösarna för CI och PR på pipelinen.

Om du vill inaktivera standardutlösare för CI och PR lägger du till följande instruktioner i YAML-pipelinen och säkerställ att du inte har åsidosatt YAML-pipelineutlösarna med UI-utlösare.

trigger: none
pr: none

För mer information, se pr-definition och utlösardefinition.

Jag definierade ett schema i YAML-filen. Men den fungerade inte. Vad hände?

• Kontrollera de kommande körningarna som Azure Pipelines har schemalagt för din pipeline. Du hittar dessa körningar genom att välja åtgärden Schemalagda körningar i din pipeline. Listan filtreras ned för att bara visa de kommande körningarna under de närmaste dagarna. Om detta inte uppfyller dina förväntningar är det förmodligen så att du har feltypat cron-schemat, eller så har du inte det schema som definierats i rätt gren. Läs avsnittet ovan för att förstå hur du konfigurerar scheman. Omvärdera cron-syntaxen. Alla tider för cron-scheman finns i UTC.

• Gör en liten trivial ändring av YAML-filen och skicka uppdateringen till lagringsplatsen. Om det uppstod problem med att läsa scheman från YAML-filen tidigare bör det åtgärdas nu.

• Om du har några scheman som definierats i användargränssnittet respekteras inte dina YAML-scheman. Kontrollera att du inte har några användargränssnittsscheman genom att gå till redigeraren för din pipeline och sedan välja Utlösare.

• Det finns en gräns för antalet körningar som du kan schemalägga för en pipeline. Läs mer om -begränsningarna.

• Om det inte finns några ändringar i din kod kanske Azure Pipelines inte startar nya körningar. Lär dig hur man åsidosätter det här beteendet.

Mina YAML-scheman fungerade bra. Men de slutade fungera nu. Hur felsöker jag detta?

• Om du inte har angett always:trueschemaläggs inte pipelinen om det inte finns några uppdateringar av koden. Kontrollera om det har gjorts några kodändringar och hur du konfigurerat scheman.

• Det finns en gräns för antalet gånger du kan schemalägga din pipeline. Kontrollera om du har överskridit dessa gränser.

• Kontrollera om någon har aktiverat fler scheman i användargränssnittet. Öppna redigeraren för din pipeline och välj Utlösare. Om de har definierat scheman i användargränssnittet kommer dina YAML-scheman inte att uppfyllas.

• Kontrollera om pipelinen är pausad eller inaktiverad. Välj Inställningar för din pipeline.

• Kontrollera de kommande körningarna som Azure Pipelines har schemalagt för din pipeline. Du hittar dessa körningar genom att välja åtgärden Schemalagda körningar i pipelinen. Om du inte ser de scheman som du förväntade dig gör du en liten trivial ändring av YAML-filen och push-överför uppdateringen till lagringsplatsen. Detta bör synkronisera om schemana.

• Om du använder GitHub för att lagra din kod är det möjligt att GitHub har begränsat Azure Pipelines när den försökte starta en ny process. Kontrollera om du kan starta en ny körning manuellt.

Min kod har inte ändrats, men en schemalagd version utlöses. Varför?

• Du kan ha aktiverat ett alternativ för att alltid köra en schemalagd version även om det inte finns några kodändringar. Om du använder en YAML-fil kontrollerar du syntaxen för schemat i YAML-filen. Om du använder klassiska pipelines kontrollerar du om du har markerat det här alternativet i de schemalagda utlösarna.

• Du kan ha uppdaterat bygg-pipelinen eller någon egenskap i pipelinen. Detta gör att en ny körning schemaläggs även om du inte har uppdaterat källkoden. Kontrollera historiken över ändringarna i bearbetningskedjan med hjälp av den klassiska redigeraren.

• Du kan ha uppdaterat tjänstanslutningen som används för att ansluta till lagringsplatsen. Detta gör att en ny körning schemaläggs även om du inte har uppdaterat källkoden.

• Azure Pipelines kontrollerar först om det finns några uppdateringar av koden. Om Azure Pipelines inte kan nå din lagringsplats eller hämta den här informationen skapar den en informationskörning. Det är en dummy-version som låter dig veta att Azure Pipelines inte kan nå din lagringsplats.

• Din pipeline kanske inte har en helt lyckad version. För att avgöra om en ny version ska schemaläggas eller inte letar Azure DevOps upp den senaste helt lyckade schemalagda versionen. Om den inte hittar någon utlöser den en ny schemalagd version. Delvis lyckade schemalagda versioner anses inte vara lyckade, så om din pipeline bara har delvis lyckade versioner utlöser Azure DevOps schemalagda versioner, även om koden inte har ändrats.

Jag ser den planerade körningen i panelen Schemalagda körningar. Den kör dock inte vid den tidpunkten. Varför?

• Panelen Schemalagda körningar visar alla möjliga scheman. Men den kanske inte körs om du inte har gjort verkliga uppdateringar av koden. Om du vill tvinga ett schema att alltid köras kontrollerar du att du har angett alltid-egenskapen i YAML-pipelinen eller kontrollerat alternativet att alltid köra i en klassisk pipeline.

Scheman som definierats i YAML-pipelinen fungerar för en gren men inte den andra. Hur åtgärdar jag detta?

Scheman definieras i YAML-filer och dessa filer är associerade med grenar. Om du vill att en pipeline ska schemaläggas för en viss gren, till exempel features/X, kontrollerar du att YAML-filen i den grenen har cron-schemat definierat i den och att den har rätt greninkluderingar för schemat. YAML-filen i features/X-grenen bör ha följande schedule i det här exemplet:

schedules: 
- cron: '0 12 * * 0'   # replace with your schedule
  branches: 
    include: 
    - features/X  

Mer information finns i Branch-överväganden för schemalagda utlösare.