Samouczek: Wdrażanie środowisk w CI/CD za pomocą GitHub i Azure Deployment Environments

W tym samouczku nauczysz się, jak zintegrować Azure Deployment Environments z potokiem CI/CD. Możesz użyć dowolnego dostawcy GitOps, który obsługuje CI/CD, na przykład GitHub Actions, Azure Arc, GitLab lub Jenkins.

Ciągła integracja i ciągłe dostarczanie (CI/CD) to podejście programistyczne, które pomaga zespołom zautomatyzować proces tworzenia, testowania i wdrażania zmian oprogramowania. CI/CD umożliwia częstsze wydawanie zmian w oprogramowaniu z większą pewnością siebie.

Używasz przepływu pracy, który zawiera trzy gałęzie: główne, deweloperskie i testowe.

• Gałąź główna jest zawsze uważana za produkcyjną.
• Gałęzie funkcji są tworzone z gałęzi głównej .
• Tworzysz żądania pull, aby scalić gałęzie funkcjonalne z main.

W tym samouczku przepływ pracy jest uproszczonym przykładem. Rzeczywiste przepływy pracy mogą być bardziej złożone.

Przed rozpoczęciem tego samouczka zapoznaj się ze składnikami i pojęciami dotyczącymi środowisk wdrażania, zapoznając się z tematem Kluczowe pojęcia dotyczące środowisk wdrażania platformy Azure.

Z tego samouczka dowiesz się, jak wykonywać następujące działania:

• Tworzenie i konfigurowanie centrum deweloperskiego
• Utwórz magazyn kluczy
• Tworzenie i konfigurowanie repozytorium GitHub
• Łączenie katalogu z centrum deweloperów
• Konfigurowanie tożsamości wdrożenia
• Konfigurowanie środowisk usługi GitHub
• Przetestuj potok CI/CD

Wymagania wstępne

Produkt	Wymagania
Azure	- Subskrypcja platformy Azure . — Uprawnienia właściciela w subskrypcji platformy Azure. - Zainstalowany interfejs wiersza polecenia platformy Azure.
Git	— Konto usługi GitHub. - Zainstalowano narzędzie Git.

1. Tworzenie i konfigurowanie centrum deweloperskiego

W tej sekcji utworzysz centrum deweloperskie środowiska wdrażania platformy Azure i projekt z trzema typami środowisk: Tworzenie, testowanie i prod.

• Typ środowiska Prod zawiera jedno środowisko produkcyjne.
• Nowe środowisko jest tworzone w środowisku deweloperskim dla każdej gałęzi funkcji.
• Nowe środowisko jest tworzone w Test dla każdego pull requestu.

1.1 Konfigurowanie interfejsu wiersza polecenia platformy Azure

Aby rozpocząć, zaloguj się do platformy Azure. Uruchom następujące polecenie i postępuj zgodnie z monitami, aby ukończyć proces uwierzytelniania:

az login

Następnie zainstaluj rozszerzenie azure devcenter dla interfejsu wiersza polecenia platformy Azure:

az extension add --name devcenter --upgrade

Po zainstalowaniu bieżącego Microsoft.DevCenter rozszerzenia zarejestruj przestrzeń nazw:

az provider register --namespace Microsoft.DevCenter

Wskazówka

W trakcie tego samouczka zapiszesz kilka wartości jako zmienne środowiskowe do późniejszego użycia. Możesz również zarejestrować te wartości w innym miejscu, aby upewnić się, że są one dostępne, gdy są potrzebne.

Pobierz identyfikator użytkownika i ustaw go na zmienną środowiskową na później:

MY_AZURE_ID=$(az ad signed-in-user show --query id -o tsv)

Pobierz identyfikator subskrypcji dla bieżącej subskrypcji:

AZURE_SUBSCRIPTION_ID=$(az account show --query id --output tsv)

Pobierz identyfikator dzierżawy dla twojego obecnego najemcy.

AZURE_TENANT_ID=$(az account show --query tenantId --output tsv)

Ustaw następujące zmienne środowiskowe:

LOCATION="eastus"
AZURE_RESOURCE_GROUP=<resourceGroupName>
AZURE_DEVCENTER=<devcenterName>
AZURE_PROJECT=<projectName>
AZURE_KEYVAULT=<keyVaultName>

Uwaga

Musisz użyć nazwy skrytki kluczy unikalnej na skalę globalną. W przeciwnym razie może zostać wyświetlony następujący błąd:

Code: VaultAlreadyExists Message: The vault name 'mykeyvaultname' is already in use. Vault names are globally unique so it is possible that the name is already taken.

1.2. Tworzenie centrum deweloperskiego

Centrum deweloperów to kolekcja projektów i środowisk, które mają podobne ustawienia. Centra deweloperów zapewniają dostęp do katalogu szablonów i artefaktów, których można użyć do tworzenia środowisk. Centra deweloperów zapewniają również sposób zarządzania dostępem do środowisk i projektów.

Tworzenie grupy zasobów:

az group create \
  --name $AZURE_RESOURCE_GROUP \
  --location $LOCATION

Tworzenie centrum deweloperskiego:

az devcenter admin devcenter create \
  --name $AZURE_DEVCENTER \
  --identity-type SystemAssigned \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION

Poprzednie polecenie zwraca dane JSON. Zapisz wartości zmiennych id środowiskowych i identity.principalId jako zmienne środowiskowe do późniejszego użycia:

AZURE_DEVCENTER_ID=<id>
AZURE_DEVCENTER_PRINCIPAL_ID=<identity.principalId>

1.3 Przypisz rolę właściciela tożsamości centrum programistów w subskrypcji

Centrum programistyczne musi mieć uprawnienia do przypisywania ról w subskrypcjach skojarzonych z rodzajami środowisk.

Aby zmniejszyć niepotrzebną złożoność, w tym samouczku użyjesz jednej subskrypcji dla centrum programistycznego i wszystkich typów środowisk. W praktyce subskrypcje centrów deweloperskich i docelowych wdrożeń prawdopodobnie byłyby oddzielnymi subskrypcjami z zastosowaniem różnych zasad.

az role assignment create \
  --scope /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --role Owner \
  --assignee-object-id $AZURE_DEVCENTER_PRINCIPAL_ID \
  --assignee-principal-type ServicePrincipal

1.4. Tworzenie typów środowisk

Na poziomie centrum programistycznego, typy środowisk definiują te, które zespoły programistyczne mogą tworzyć, takie jak deweloperskie, testowe, piaskownica, przedprodukcyjne i produkcyjne.

Utwórz trzy nowe typy środowisk: Tworzenie, testowanie i Prod:

az devcenter admin environment-type create \
  --name Dev \
  --resource-group $AZURE_RESOURCE_GROUP \
  --dev-center $AZURE_DEVCENTER

az devcenter admin environment-type create \
  --name Test \
  --resource-group $AZURE_RESOURCE_GROUP \
  --dev-center $AZURE_DEVCENTER

az devcenter admin environment-type create \
  --name Prod \
  --resource-group $AZURE_RESOURCE_GROUP \
  --dev-center $AZURE_DEVCENTER

1.5 Tworzenie projektu

Projekt jest punktem dostępu dla zespołu deweloperów. Każdy projekt jest skojarzony z centrum rozwoju.

Utwórz projekt:

az devcenter admin project create \
  --name $AZURE_PROJECT \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --dev-center-id $AZURE_DEVCENTER_ID

Poprzednie polecenie zwraca dane JSON. id Zapisz wartość jako zmienną środowiskową do późniejszego użycia:

AZURE_PROJECT_ID=<id>

Przypisz sobie rolę administratora projektu DevCenter w projekcie:

az role assignment create \
  --scope "$AZURE_PROJECT_ID" \
  --role "DevCenter Project Admin" \
  --assignee-object-id $MY_AZURE_ID \
  --assignee-principal-type User

1.6. Tworzenie typów środowisk projektu

Na poziomie projektu inżynierowie platformy określają, które typy środowisk są odpowiednie dla zespołu deweloperskiego.

Utwórz nowy typ środowiska projektu dla każdego typu środowiska utworzonego w centrum deweloperów:

az devcenter admin project-environment-type create \
  --name Dev \
  --roles "{\"b24988ac-6180-42a0-ab88-20f7382dd24c\":{}}" \
  --deployment-target-id /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --project $AZURE_PROJECT \
  --identity-type SystemAssigned \
  --status Enabled

az devcenter admin project-environment-type create \
  --name Test \
  --roles "{\"b24988ac-6180-42a0-ab88-20f7382dd24c\":{}}" \
  --deployment-target-id /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --project $AZURE_PROJECT \
  --identity-type SystemAssigned \
  --status Enabled

az devcenter admin project-environment-type create \
  --name Prod \
  --roles "{\"b24988ac-6180-42a0-ab88-20f7382dd24c\":{}}" \
  --deployment-target-id /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --project $AZURE_PROJECT \
  --identity-type SystemAssigned \
  --status Enabled

2. Tworzenie magazynu kluczy

W tej sekcji utworzysz nową składnicę kluczy. Użyjesz tego skarbca kluczy w dalszej części samouczka, aby zapisać osobisty token dostępu z usługi GitHub.

az keyvault create \
  --name $AZURE_KEYVAULT \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --enable-rbac-authorization true

Ponownie zapisz dane id wyjściowe JSON poprzedniego polecenia jako zmienną środowiskową:

AZURE_KEYVAULT_ID=<id>

Nadaj sobie rolę administratora Key Vault w nowym zasobie kluczy:

az role assignment create \
  --scope $AZURE_KEYVAULT_ID \
  --role "Key Vault Administrator" \
  --assignee-object-id $MY_AZURE_ID \
  --assignee-principal-type User

Przypisz tożsamości centrum deweloperskiego rolę użytkownika sekretów Key Vault.

az role assignment create \
  --scope $AZURE_KEYVAULT_ID \
  --role "Key Vault Secrets User" \
  --assignee-object-id $AZURE_DEVCENTER_PRINCIPAL_ID \
  --assignee-principal-type ServicePrincipal

3. Tworzenie i konfigurowanie repozytorium GitHub

W tej sekcji utworzysz nowe repozytorium GitHub do przechowywania katalogu. Środowiska wdrażania platformy Azure obsługują repozytoria GitHub i Azure DevOps. W tym samouczku użyjesz GitHuba.

3.1 Tworzenie repozytorium GitHub

W tym kroku utworzysz nowe repozytorium na koncie usługi GitHub, które ma wstępnie zdefiniowaną strukturę katalogów, gałęzie i pliki. Te elementy są generowane z przykładowego repozytorium szablonów.

1. Wygeneruj nowe repozytorium GitHub na podstawie przykładowego szablonu:

   

2. Jeśli nie masz płatnego konta usługi GitHub, ustaw repozytorium na Wartość Publiczna.

3. Kliknij przycisk Create repository (Utwórz repozytorium).

3.2 Ochrona głównej gałęzi repozytorium

Ważne gałęzie można chronić, ustawiając reguły ochrony gałęzi. Reguły ochrony określają, czy współpracownicy mogą usunąć gałąź lub wymusić przepchnięcie do gałęzi. Ustawiają również wymagania dotyczące wprowadzania zmian do gałęzi, takich jak zaliczanie kontroli stanu lub wymuszanie liniowej historii zatwierdzeń.

Uwaga

Chronione gałęzie są dostępne w repozytoriach publicznych za pomocą usługi GitHub Free i GitHub Free dla organizacji oraz w repozytoriach publicznych i prywatnych za pomocą usług GitHub Pro, GitHub Team, GitHub Enterprise Cloud i GitHub Enterprise Server. Aby uzyskać więcej informacji, zobacz Plany usługi GitHub.

1. Jeśli jeszcze nie jest otwarty, przejdź do strony głównej repozytorium.

2. Wybierz pozycję Ustawienia w menu w górnej części okna:

   

3. W sekcji Kod i automatyzacja na lewym pasku bocznym wybierz pozycję Gałęzie:

   

4. W obszarze Reguły ochrony gałęzi wybierz pozycję Dodaj zestaw reguł gałęzi:

   

5. Na stronie Nowy zestaw reguł gałęzi w polu Nazwa zestawu reguł wprowadź CI-CD-tutorial-ruleset:

   

6. W obszarze Gałęzie docelowe wybierz pozycję Dodaj element docelowy, a następnie wybierz pozycję Uwzględnij gałąź domyślną lub Uwzględnij wszystkie gałęzie:

   

7. W obszarze Reguły gałęzi wybierz pozycję Wymagaj żądania zatwierdzenia przed scaleniem:

   

8. Opcjonalnie możesz włączyć więcej reguł ochrony.

9. Wybierz Utwórz.

3.3. Konfigurowanie zmiennych repozytorium

1. W sekcji Zabezpieczenia paska bocznego wybierz pozycję Wpisy tajne i zmienne, a następnie wybierz pozycję Akcje:

   

2. Wybierz kartę Zmienne .

3. Dla każdego elementu w poniższej tabeli:

   1. Wybierz pozycję Nowa zmienna repozytorium.
   2. W polu Nazwa wprowadź nazwę zmiennej.
   3. W polu Wartość wprowadź wartość opisaną w tabeli.
   4. Wybierz pozycję Dodaj zmienną.

   Nazwa zmiennej	Wartość zmiennej
   AZURE_DEVCENTER	Nazwa centrum deweloperskiego
   AZURE_PROJECT	Nazwa projektu
   Katalog Azure	Ustaw na Środowiska
   AZURE_CATALOG_ITEM	Ustaw wartość FunctionApp
   AZURE_SUBSCRIPTION_ID	Identyfikator subskrypcji platformy Azure
   AZURE_TENANT_ID	Twój identyfikator dzierżawy platformy Azure

   

3.4 Tworzenie osobistego tokenu dostępu usługi GitHub

Następnie utwórz szczegółowy osobisty token dostępu, aby umożliwić centrum deweloperów środowisk wdrożeniowych Azure połączyć się z Twoim repozytorium i korzystać z katalogu środowiska.

Uwaga

Możesz zostawić opinię na temat szczegółowych osobistych tokenów dostępu w dyskusji zwrotnej.

1. W prawym górnym rogu dowolnej strony na GitHub.com wybierz swoje zdjęcie profilowe, a następnie wybierz pozycję Ustawienia.

2. Na lewym pasku bocznym wybierz pozycję Ustawienia dewelopera.

3. Na pasku bocznym po lewej stronie w obszarze Osobiste tokeny dostępu wybierz pozycję Szczegółowe tokeny, a następnie wybierz pozycję Generuj nowy token:

   

4. Na stronie Nowy szczegółowy osobisty token dostępu w polu nazwa tokenu wprowadź nazwę tokenu.

5. W obszarze Wygaśnięcie wybierz wygaśnięcie tokenu.

6. W obszarze Właściciel zasobu wybierz nazwę użytkownika usługi GitHub.

7. W obszarze Dostęp do repozytorium wybierz pozycję Tylko wybierz repozytoria. W obszarze Wybrane repozytoria wyszukaj i wybierz utworzone repozytorium:

   

8. W obszarze Uprawnienia wybierz Uprawnienia repozytorium, a następnie zmień Zawartość na Tylko do odczytu:

   

9. Wybierz pozycję Generuj token.

10. Skopiuj i zapisz osobisty token dostępu. Nie będzie można go ponownie wyświetlić.

3.5 Zapisz twój osobisty token dostępu w magazynie kluczy

Następnie zapisz osobisty token dostępu jako tajny klucz w magazynie o nazwie pat:

az keyvault secret set \
    --name pat \
    --vault-name $AZURE_KEYVAULT \
    --value <personalAccessToken>

4. Łączenie katalogu z centrum deweloperów

W środowiskach wdrażania platformy Azure wykaz to repozytorium zawierające zestaw definicji środowiska. Elementy wykazu składają się z szablonu infrastruktury jako kodu (IaC) i pliku środowiska, który działa jako manifest. Szablon definiuje środowisko, a plik środowiska zawiera metadane dotyczące szablonu. Zespoły deweloperów używają definicji środowiska z katalogu do tworzenia środowisk.

Szablon użyty do utworzenia repozytorium GitHub zawiera katalog w folderze Środowiska .

Dodaj katalog do swojego centrum developerskiego

W poniższym poleceniu zastąp < Organization/Repository > nazwą swojej organizacji i repozytorium na GitHubie:

az devcenter admin catalog create \
    --name Environments \
    --resource-group $AZURE_RESOURCE_GROUP \
    --dev-center $AZURE_DEVCENTER \
    --git-hub path="/Environments" branch="main" secret-identifier="https://$AZURE_KEYVAULT.vault.azure.net/secrets/pat" uri="https://github.com/< Organization/Repository >.git"

5. Konfigurowanie tożsamości związanych z wdrożeniem

OpenID Connect z GitHub Actions to metoda uwierzytelniania, która używa krótkotrwałych tokenów, aby zapewnić lepsze bezpieczeństwo. Jest to zalecany sposób uwierzytelniania funkcji GitHub Actions na platformie Azure.

Możesz również uwierzytelnić jednostkę usługi bezpośrednio przy użyciu wpisu tajnego, ale to wykracza poza zakres tego samouczka.

5.1 Generowanie identyfikatorów wdrożenia

1. Zarejestruj aplikacje i jednostki główne usługi Microsoft Entra dla każdego z trzech typów środowisk.

   Utwórz aplikację Microsoft Entra dla deweloperów:

   az ad app create --display-name "$AZURE_PROJECT-Dev"
   

   To polecenie zwraca kod JSON z id, którego używasz podczas tworzenia poświadczeń federacyjnych za pomocą interfejsu API programu Graph, oraz z appId (nazywanym również identyfikatorem klienta).

   Ustaw następujące zmienne środowiskowe:

   DEV_AZURE_CLIENT_ID=<appId>
   DEV_APPLICATION_ID=<id>
   

   Powtórz następujące kroki dla testu:

   az ad app create --display-name "$AZURE_PROJECT-Test"
   

   TEST_AZURE_CLIENT_ID=<appId>
   TEST_APPLICATION_ID=<id>
   

   Powtórz ponownie kroki dla Prod:

   az ad app create --display-name "$AZURE_PROJECT-Prod"
   

   PROD_AZURE_CLIENT_ID=<appId>
   PROD_APPLICATION_ID=<id>
   

2. Utwórz główny obiekt usługi dla każdej aplikacji.

   Uruchom następujące polecenie, aby utworzyć nową tożsamość usługi Dev:

    az ad sp create --id $DEV_AZURE_CLIENT_ID
   

   To polecenie generuje dane wyjściowe JSON z inną id wartością, która będzie używana w następnym kroku.

   Ustaw następującą zmienną środowiskową:

   DEV_SERVICE_PRINCIPAL_ID=<id>
   

   Powtórz następujące kroki dla testu:

    az ad sp create --id $TEST_AZURE_CLIENT_ID
   

   TEST_SERVICE_PRINCIPAL_ID=<id>
   

   Powtórz ponownie kroki dla Prod:

    az ad sp create --id $PROD_AZURE_CLIENT_ID
   

   PROD_SERVICE_PRINCIPAL_ID=<id>
   

3. Uruchom następujące polecenia, aby utworzyć nowe poświadczenia tożsamości federacyjnej dla każdej aplikacji Firmy Microsoft Entra.

   W każdym z trzech następujących poleceń zastąp ciąg < Organization/Repository > nazwą organizacji i repozytorium GitHub.

   Utwórz poświadczenie tożsamości federacyjnej dla Dev:

   az rest --method POST \
       --uri "https://graph.microsoft.com/beta/applications/$DEV_APPLICATION_ID/federatedIdentityCredentials" \
       --body '{"name":"ADEDev","issuer":"https://token.actions.githubusercontent.com","subject":"repo:< Organization/Repository >:environment:Dev","description":"Dev","audiences":["api://AzureADTokenExchange"]}'
   

   Utwórz poświadczenie dla testu:

   az rest --method POST \
       --uri "https://graph.microsoft.com/beta/applications/$TEST_APPLICATION_ID/federatedIdentityCredentials" \
       --body '{"name":"ADETest","issuer":"https://token.actions.githubusercontent.com","subject":"repo:< Organization/Repository >:environment:Test","description":"Test","audiences":["api://AzureADTokenExchange"]}'
   

   Utwórz poświadczenie dla usługi Prod:

   az rest --method POST \
       --uri "https://graph.microsoft.com/beta/applications/$PROD_APPLICATION_ID/federatedIdentityCredentials" \
       --body '{"name":"ADEProd","issuer":"https://token.actions.githubusercontent.com","subject":"repo:< Organization/Repository >:environment:Prod","description":"Prod","audiences":["api://AzureADTokenExchange"]}'
   

5.2 Przypisywanie ról do tożsamości wdrożeniowej

1. Przypisz każdej tożsamości wdrożenia rolę Czytelnik w projekcie.

   az role assignment create \
       --scope "$AZURE_PROJECT_ID" \
       --role Reader \
       --assignee-object-id $DEV_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

   az role assignment create \
       --scope "$AZURE_PROJECT_ID" \
       --role Reader \
       --assignee-object-id $TEST_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

   az role assignment create \
       --scope "$AZURE_PROJECT_ID" \
       --role Reader \
       --assignee-object-id $PROD_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

2. Przypisz rolę użytkownika środowisk wdrożeniowych do odpowiedniego typu środowiska dla każdej tożsamości wdrożeniowej:

   az role assignment create \
       --scope "$AZURE_PROJECT_ID/environmentTypes/Dev" \
       --role "Deployment Environments User" \
       --assignee-object-id $DEV_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

   az role assignment create \
       --scope "$AZURE_PROJECT_ID/environmentTypes/Test" \
       --role "Deployment Environments User" \
       --assignee-object-id $TEST_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

   az role assignment create \
       --scope "$AZURE_PROJECT_ID/environmentTypes/Prod" \
       --role "Deployment Environments User" \
       --assignee-object-id $PROD_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

6. Konfigurowanie środowisk usługi GitHub

Za pomocą środowisk GitHub można konfigurować je z regułami ochrony i tajnymi danymi. Zadanie przepływu pracy, które odwołuje się do środowiska, musi przestrzegać wszelkich reguł ochrony środowiska roboczego przed uruchomieniem lub uzyskaniem dostępu do tajnych danych środowiska.

Utwórz środowiska deweloperskie, testowe i produkcyjne odpowiadające typom środowisk w projekcie Środowiska wdrażania platformy Azure.

Uwaga

Środowiska, tajne składniki środowiska i reguły ochrony środowiska są dostępne w repozytoriach publicznych dla wszystkich produktów. Aby uzyskać dostęp do środowisk, tajnych danych środowiska i gałęzi wdrażania w repozytoriach prywatnych lub wewnętrznych, należy użyć GitHub Pro, GitHub Team lub GitHub Enterprise. Aby uzyskać dostęp do innych reguł ochrony środowiska w repozytoriach prywatnych lub wewnętrznych, należy użyć usługi GitHub Enterprise. Aby uzyskać więcej informacji, zobacz Plany usługi GitHub.

6.1 Tworzenie środowiska deweloperskiego

1. W usłudze GitHub przejdź do strony głównej repozytorium.

2. W obszarze nazwy repozytorium wybierz pozycję Ustawienia. Jeśli nie widzisz karty Ustawienia , wybierz menu rozwijane ... , a następnie wybierz pozycję Ustawienia.

3. Na lewym pasku bocznym wybierz pozycję Środowiska.

4. Wybierz pozycję Nowe środowisko i wprowadź wartość Dev jako nazwę środowiska, a następnie wybierz pozycję Konfiguruj środowisko:

   

5. W sekcji Tajne dane środowiska wybierz Dodaj tajne dane środowiska, a następnie wprowadź AZURE_CLIENT_ID w polu Nazwa.

   

6. W polu Wartość wprowadź identyfikator klienta (appId) utworzonej wcześniej aplikacji Dev Microsoft Entra (zapisaną jako zmienną $DEV_AZURE_CLIENT_ID środowiskową):

   

7. Wybierz Dodaj sekret.

6.2. Tworzenie środowiska testowego

Wróć do strony środowiska głównego, wybierając pozycję Środowiska na lewym pasku bocznym.

1. Wybierz pozycję Nowe środowisko, wprowadź frazę Test dla nazwy środowiska, a następnie wybierz pozycję Konfiguruj środowisko.

2. W sekcji Tajne dane środowiska wybierz Dodaj tajne dane środowiska, a następnie wprowadź AZURE_CLIENT_ID w polu Nazwa.

3. W polu Wartość wprowadź identyfikator klienta (appId) dla utworzonej wcześniej aplikacji Test Microsoft Entra (zapisanej jako zmienna $TEST_AZURE_CLIENT_ID środowiskowa).

4. Wybierz Dodaj sekret.

6.3 Tworzenie środowiska Prod

Po raz kolejny wróć do strony głównych środowisk, wybierając pozycję Środowiska na pasku bocznym po lewej stronie.

1. Wybierz pozycję Nowe środowisko, wprowadź ciąg Prod jako nazwę środowiska, a następnie wybierz pozycję Konfiguruj środowisko.

2. W sekcji Tajne dane środowiska wybierz Dodaj tajne dane środowiska, a następnie wprowadź AZURE_CLIENT_ID w polu Nazwa.

3. W polu Wartość wprowadź identyfikator klienta (appId) utworzonej wcześniej aplikacji Prod Microsoft Entra (zapisanej jako zmienna $PROD_AZURE_CLIENT_ID środowiskowa).

4. Wybierz Dodaj sekret.

Następnie ustaw się jako wymagany recenzent dla tego środowiska. Po podjęciu próby wdrożenia w usłudze Prod funkcja GitHub Actions czeka na zatwierdzenie przed rozpoczęciem. Gdy zadanie oczekuje na zatwierdzenie, ma stan Oczekiwanie. Jeśli zadanie nie zostanie zatwierdzone w ciągu 30 dni, automatycznie zakończy się niepowodzeniem.

Aby uzyskać więcej informacji na temat środowisk i wymaganych zatwierdzeń, zobacz Używanie środowisk do wdrożenia.

1. Wybierz pozycję Wymagani recenzenci.

2. Wyszukaj i wybierz nazwę użytkownika usługi GitHub. Możesz wprowadzić maksymalnie sześć osób lub zespołów. Aby kontynuować, tylko jeden z wymaganych recenzentów musi zatwierdzić zadanie.

3. Wybierz pozycję Zapisz reguły ochrony.

Na koniec skonfiguruj main jako gałąź wdrożenia:

1. Na liście Gałęzie wdrożenia i tagi wybierz pozycję Wybrane gałęzie i tagi.

2. Wybierz Dodaj gałąź wdrożenia lub regułę tagu, upewnij się, że wybrano Ref type: Branch, a następnie wprowadź main w polu wzorzec nazwy.

3. Wybierz Dodaj regułę.

7. Przetestuj przepływ CI/CD

W tej części dokonasz pewnych zmian w repozytorium i przetestujesz pipeline CI/CD.

7.1 Klonowanie repozytorium

1. W Git Bash użyj cd, aby przejść do folderu, w którym chcesz sklonować repozytorium lokalnie.

2. Sklonuj repozytorium. Pamiętaj, aby zastąpić < Organization/Repository > w poniższym poleceniu nazwą organizacji i repozytorium GitHub.

   git clone https://github.com/< Organization/Repository >.git
   

3. Przejdź do sklonowanego katalogu:

   cd <repository>
   

4. Utwórz nową gałąź i opublikuj ją zdalnie:

   git checkout -b feature1
   

   git push -u origin feature1
   

   Na platformie Azure jest tworzone nowe środowisko specyficzne dla tej gałęzi.

5. W usłudze GitHub przejdź do strony głównej nowo utworzonego repozytorium.

6. W obszarze nazwy repozytorium wybierz pozycję Akcje:

   Powinien być uruchomiony nowy przepływ pracy o nazwie "Tworzenie Środowiska".

7.2 Wprowadź zmianę w kodzie

1. Otwórz sklonowane lokalnie repozytorium w programie Visual Studio Code.

2. W folderze ADE.Tutorial wprowadź zmianę w pliku.

3. Zapisz zmiany.

7.3 Wypychanie zmian w celu zaktualizowania środowiska

1. Przygotuj zmiany i wypchnij do feature1 gałęzi:

   git add .
   git commit -m '<commit message>'
   git push
   

2. Na stronie Akcje repozytorium zostanie wyświetlony nowy przepływ pracy środowiska aktualizacji.

7.4 Utwórz pull request

1. Utwórz żądanie pull na GitHubie main <- feature1.

2. Na stronie Akcje repozytorium zobaczysz, że nowy przepływ pracy jest uruchamiany w celu utworzenia środowiska specyficznego dla żądania ściągnięcia. Używany jest typ środowiska testowego.

7.5 Scal żądanie ściągnięcia

1. W usłudze GitHub przejdź do pull requestu, który utworzyłeś.

2. Połącz żądanie ściągnięcia.

   Zmiany są publikowane w środowisku produkcyjnym, a środowiska gałęzi i pull requestów są usuwane.

Czyszczenie zasobów

Jeśli nie planujesz korzystać z żadnych utworzonych zasobów, usuń je, aby nie ponosić żadnych dodatkowych opłat. Jeśli przykładowa aplikacja została wdrożona w innej grupie zasobów, warto powtórzyć poniższe kroki.

Aby usunąć zasoby przy użyciu witryny Azure Portal:

1. Wybierz przycisk menu w lewym górnym rogu, a następnie wybierz pozycję Grupy zasobów.

2. Z listy wybierz utworzoną grupę zasobów.

3. Wybierz pozycję Usuń grupę zasobów.

4. Wpisz nazwę grupy zasobów. Następnie wybierz Usuń.

Aby usunąć zasoby przy użyciu interfejsu wiersza polecenia platformy Azure, wprowadź następujące polecenie:

az group delete --name <my-dev-center-rg>

Należy pamiętać, że usunięcie grupy zasobów spowoduje usunięcie wszystkich zawartych w niej zasobów.

Powiązana zawartość

• Tworzenie środowiska i uzyskiwanie do tego dostępu przy użyciu interfejsu wiersza polecenia platformy Azure
• Aby uzyskać pełne listy poleceń, zobacz dokumentację interfejsu wiersza polecenia platformy Azure dla usług Microsoft Dev Box i Azure Deployment Environments