Övning – Skydda huvudgrenen

5 minuter

Ditt team arbetar med en Bicep-mall som redan innehåller en webbplats och en databas. Du har distribuerat komponenterna till din produktionsmiljö. Nu måste du uppdatera Bicep-mallen för att lägga till din orderbearbetningskö.

I den här övningen skapar du en funktionsgren för ändringen. Du skyddar även huvudgrenen och tillåter endast att ändringar sammanfogas till huvudgrenen när de har granskats. Innan det måste du dock se till att din miljö har konfigurerats för att slutföra resten av den här modulen.

Under processen gör du följande:

Konfigurera en GitHub-lagringsplats för den här modulen.
Klona lagringsplatsen till datorn.
Lägg till grenskydd i lagringsplatsens huvudgren.
Skapa en lokal funktionsgren för ändringen.
Försök att sammanfoga funktionsgrenen till main.

Konfigurera ett Azure DevOps-projekt för den här modulen.
Klona projektets lagringsplats till datorn.
Lägg till grenprinciper i lagringsplatsens huvudgren.
Skapa en lokal funktionsgren för ändringen.
Försök att sammanfoga funktionsgrenen till main.

Hämta GitHub-lagringsplatsen

Här ser du till att din GitHub-lagringsplats är konfigurerad för att slutföra resten av den här modulen. Du konfigurerar den genom att skapa en ny lagringsplats baserat på en malllagringsplats. Malllagringsplatsen innehåller de filer som du behöver för att komma igång för den här modulen.

Börja från malllagringsplatsen

Kör en mall som konfigurerar din GitHub-lagringsplats.

Kör mallen

På GitHub-webbplatsen följer du dessa steg för att skapa en lagringsplats från mallen:

Välj Använd den här mallen>Skapa en ny lagringsplats.
Ange ett namn för ditt nya projekt, till exempel leksakswebbplatsgranskning.
Välj alternativet Offentlig .

När du skapar egna lagringsplatser kanske du vill göra dem privata. I den här modulen arbetar du med funktioner i GitHub som endast fungerar med offentliga lagringsplatser och med GitHub Enterprise-konton.
Välj Create repository from template (Skapa lagringsplats från mall).

Hämta Azure DevOps-projektet

Här ser du till att din Azure DevOps-organisation har konfigurerats för att slutföra resten av den här modulen. Du konfigurerar det genom att köra en mall som skapar ett projekt i Azure DevOps.

Kör mallen

Följ dessa steg på azure DevOps Demo Generator-webbplatsen:

Välj Logga in och godkänn användningsvillkoren.
På sidan Skapa nytt projekt väljer du din Azure DevOps-organisation. Ange sedan ett projektnamn, till exempel leksakswebbplatsgranskning.
Välj Skapa projekt.

Det tar en stund att köra mallen. Den skapar automatiskt en pipeline och en Bicep-fil som du ska använda i senare övningar.
Välj Navigera till projekt för att gå till projektet i Azure DevOps.

Klona lagringsplatsen

Nu har du en kopia av malllagringsplatsen i ditt eget konto. Klona den här lagringsplatsen lokalt så att du kan börja arbeta i den.

Välj Kod och välj sedan ikonen Kopiera .
Öppna Visual Studio Code.
Öppna ett Terminalfönster i Visual Studio Code genom att välja Terminal>Ny terminal. Fönstret öppnas vanligtvis längst ned på skärmen.
I terminalen går du till den katalog där du vill klona GitHub-lagringsplatsen på den lokala datorn. Om du till exempel vill klona lagringsplatsen till mappen toy-website-review kör du följande kommando:
```
cd toy-website-review
```
Skriv git clone och klistra in url:en som du kopierade tidigare och kör sedan kommandot. Kommandot ser ut så här:
```
git clone https://github.com/mygithubuser/toy-website-review.git
```
Öppna Visual Studio Code igen i lagringsplatsens mapp genom att köra följande kommando i Visual Studio Code-terminalen:
```
code -r toy-website-review
```

Nu har du ett projekt i ditt eget konto. Klona den här lagringsplatsen lokalt så att du kan börja arbeta i den.

Välj Lagringsfiler>.
Välj Klona.
Om du använder macOS behöver du ett särskilt lösenord för att klona Git-lagringsplatsen. Välj Generera Git-autentiseringsuppgifter och kopiera det användarnamn och lösenord som visas till en säker plats.
Välj Klona i VS Code. Om du uppmanas att tillåta att Visual Studio Code öppnas väljer du Öppna.
Skapa en mapp som ska användas för lagringsplatsen och välj sedan Välj lagringsplats.
Du använder den här lagringsplatsen för första gången, så du uppmanas att logga in.
- Om du använder Windows anger du samma autentiseringsuppgifter som du använde för att logga in på Azure DevOps tidigare i den här övningen.
- Om du använder macOS anger du det Git-användarnamn och lösenord som du genererade för en stund sedan.
Visual Studio Code uppmanar dig att öppna lagringsplatsen. Välj Öppna.

Lägga till grenskydd

Konfigurera Din Git-lagringsplats för att förhindra direkta push-överföringar till huvudgrenen.

Välj Inställningar i webbläsaren.
Välj Grenar.
Välj Lägg till grenskyddsregel.
I textrutan Förgreningsnamnsmönster anger du main.
Välj Kräv en pull-begäran innan du sammanfogar.

Rensa Kräv godkännanden. Normalt väljer du det här alternativet. Men i det här exemplet sammanfogar du en egen pull-begäran och alternativet Kräv godkännanden hindrar dig från att göra det.
Välj Tillåt inte att ovanstående inställningar kringgås.

Du väljer den här inställningen som ett exempel för att main visa hur git push du misslyckas senare i den här övningen. I en produktionsmiljö kanske du inte vill begränsa direkta sammanslagningar till main för administratörer eller lagringsplatsägare.
Välj Skapa längst ned på sidan.

GitHub kan be dig att logga in igen för att bekräfta din identitet.

Lägga till grenprinciper

Konfigurera Din Git-lagringsplats för att förhindra direkta push-överföringar till huvudgrenen.

I webbläsaren går du till Repos Branches (Lagringsgrenar>).
Hovra över huvudgrenen och välj de tre punkterna.
Välj Grenprinciper.
I fönstret Grenprinciper ändrar du inställningen Kräv ett minsta antal granskare till På.
Ändra det minsta antalet granskare till 1 och välj alternativet Tillåt begäranden att godkänna sina egna ändringar.

Kommentar

Här gör du det möjligt för begärande att godkänna sina egna ändringar . I de här övningarna arbetar du på egen hand, så du måste både skapa och godkänna ändringarna. Men i en verklig gruppmiljö kanske du inte vill aktivera det här alternativet.

Skapa en lokal funktionsgren

Kör följande instruktion i Visual Studio Code-terminalen:
```
git checkout -b add-orders-queue
```
Det här kommandot skapar en ny funktionsgren som du kan arbeta från.
Öppna filen main.bicep i distributionsmappen.

Under parametrarna lägger du till en ny variabel för namnet på kön:

var storageAccountSkuName = (environmentType == 'prod') ? 'Standard_GRS' : 'Standard_LRS'
var processOrderQueueName = 'processorder'

Lägg till kön som en kapslad underordnad resurs i lagringskontoresursen:

resource storageAccount 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: storageAccountSkuName
  }
  kind: 'StorageV2'
  properties: {
    accessTier: 'Hot'
  }

  resource queueServices 'queueServices' existing = {
    name: 'default'

    resource processOrderQueue 'queues' = {
      name: processOrderQueueName
    }
  }
}

I moduldefinitionen appService lägger du till lagringskontot och könamnen som parametrar:

module appService 'modules/appService.bicep' = {
  name: 'appService'
  params: {
    location: location
    appServiceAppName: appServiceAppName
    storageAccountName: storageAccount.name
    processOrderQueueName: storageAccount::queueServices::processOrderQueue.name
    environmentType: environmentType
  }
}

Med den här koden kan programmet hitta kön där det skickar meddelanden.

Spara filen main.bicep.
Öppna filen appService.bicep i mappen deploy/modules.

Längst upp i filen appService.bicep lägger du till nya parametrar för lagringskontot och könamnen:

@description('The Azure region into which the resources should be deployed.')
param location string

@description('The name of the App Service app to deploy. This name must be globally unique.')
param appServiceAppName string

@description('The name of the storage account to deploy. This name must be globally unique.')
param storageAccountName string

@description('The name of the queue to deploy for processing orders.')
param processOrderQueueName string

@description('The type of the environment. This must be nonprod or prod.')
@allowed([
  'nonprod'
  'prod'
])
param environmentType string

Uppdatera resursen appServiceApp för att sprida lagringskontot och könamnen till programmets miljövariabler:

resource appServiceApp 'Microsoft.Web/sites@2022-03-01' = {
  name: appServiceAppName
  location: location
  properties: {
    serverFarmId: appServicePlan.id
    httpsOnly: true
    siteConfig: {
      appSettings: [
        {
          name: 'StorageAccountName'
          value: storageAccountName
        }
        {
          name: 'ProcessOrderQueueName'
          value: processOrderQueueName
        }
      ]
    }
  }
}

Checka in och push-överföra din funktionsgren

Checka in ändringarna och skicka dem till din GitHub-lagringsplats genom att köra följande kommandon i Visual Studio Code-terminalen:

Checka in ändringarna och skicka dem till azure-lagringsplatsen genom att köra följande kommandon i Visual Studio Code-terminalen:

git add .
git commit -m "Add orders queue and associated configuration"
git push --set-upstream origin add-orders-queue

Funktionsgrenen skickas till en ny gren, även kallad add-orders-queue, på fjärrlagringsplatsen.

Försök att sammanfoga funktionsgrenen till main

Du har lärt dig varför det inte är lämpligt att push-överföra direkt till huvudgrenen. Här försöker du bryta den riktlinjen så att du kan se hur huvudgrenens skydd förhindrar att du oavsiktligt skickar ändringarna till en skyddad gren.

I Visual Studio Code-terminalen kör du följande instruktioner för att växla till huvudgrenen och sammanfoga grenen add-orders-queue till den:
```
git checkout main
git merge add-orders-queue
```
Kommandot fungerade, men du sammanfogade grenen add-orders-queue till din huvudgren på endast din lokala Git-lagringsplats.

Kör följande instruktion för att försöka skicka ändringarna till GitHub:

git push

Observera att push-överföringen misslyckas med ett felmeddelande som ser ut så här:

Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
remote: error: GH006: Protected branch update failed for refs/heads/main.
remote: error: Changes must be made through a pull request.
To https://github.com/mygithubuser/toy-website-review.git
 ! [remote rejected] main -> main (protected branch hook declined)
error: failed to push some refs to 'https://github.com/mygithubuser/toy-website-review.git'

Felmeddelandet anger att push-överföring till huvudgrenen inte är tillåten och att du måste använda en pull-begäran för att uppdatera grenen.

Ångra sammanfogningen genom att köra följande instruktion:
```
git reset --hard HEAD~1
```
Med det här kommandot uppmanas din lokala Git-lagringsplats att återställa tillståndet för huvudgrenen till vad den var innan den senaste incheckningen sammanfogades och inte spara ändringarna. Grenen add-orders-queue påverkas inte.

Du har lärt dig varför det inte är lämpligt att push-överföra direkt till huvudgrenen. Här försöker du bryta den riktlinjen så att du kan se hur grenprinciperna hindrar dig från att oavsiktligt skicka ändringarna till en skyddad gren.

I Visual Studio Code-terminalen kör du följande instruktioner för att växla till huvudgrenen och sammanfoga grenen add-orders-queue till den:
```
git checkout main
git merge add-orders-queue
```
Kommandot fungerade, men du sammanfogade grenen add-orders-queue till din huvudgren på endast din lokala Git-lagringsplats.

Kör följande instruktion för att försöka skicka ändringarna till Azure Repos:

git push