Samouczek — przygotowywanie aplikacji do Azure Kubernetes Service (AKS)

Wskazówka

Krótka odpowiedź: użyj Kompose do szybkiego wygenerowania szkieletu, Move2Kube do szerszej modernizacji, Docker Compose Bridge, jeśli używasz Docker Desktop, oraz Podman do eksportowania z uruchomionych kontenerów lub podów. Następnie spakuj wyniki za pomocą narzędzia Helm lub Kustomize i wykonaj iterację za pomocą narzędzia Skaffold lub Tilt.

Najważniejsze narzędzia: Kompose, Move2Kube, Docker Compose Bridge, Podman, Helm, Kustomize, Skaffold, Tilt i konwersja wspomagana przez sztuczną inteligencję.

W tym samouczku przygotujesz aplikację z wieloma kontenerami do użycia na platformie Kubernetes. Możesz użyć tego samouczka niezależnie od tego, czy zaczynasz od nowej przykładowej aplikacji, czy dostosowujesz koncepcje narzędzia Docker Compose dla aplikacji, którą planujesz przeprowadzić migrację do Azure Kubernetes Service (AKS). Istniejące narzędzia programistyczne, takie jak Docker Compose, są używane do lokalnego kompilowania i testowania aplikacji. Nauczysz się, jak:

• Sklonuj przykładowe źródło aplikacji z GitHub.
• Utwórz obraz kontenera na podstawie przykładowego źródła aplikacji.
• Przetestuj aplikację z wieloma kontenerami w lokalnym środowisku platformy Docker.

Ważna

Zaczynasz od nowa? Skorzystaj z tego samouczka, aby przygotować i przetestować przykładową aplikację dla usługi AKS. Już używasz narzędzia Docker Compose? Zapoznaj się z dokumentacją platformy Kubernetes dotyczącą migrowania narzędzia Docker Compose do platformy Kubernetes i przeglądu migracji usługi AKS, aby uzyskać szersze wskazówki dotyczące planowania.

Po zakończeniu następująca aplikacja będzie uruchomiona w lokalnym środowisku programistycznym:

W kolejnych samouczkach przekażesz obraz kontenera do Azure Container Registry (ACR), a następnie wdrożysz go w klastrze usługi AKS.

Zanim rozpoczniesz

Ten samouczek zakłada, że masz podstawową wiedzę na temat najważniejszych pojęć dotyczących platformy Docker, takich jak kontenery, obrazy kontenerów i polecenia docker. Aby uzyskać podstawowe informacje na temat kontenerów, zapoznaj się z tematem Get started with Docker (Rozpoczynanie pracy z platformą Docker).

Do ukończenia tego samouczka konieczne będzie lokalne środowisko programistyczne platformy Docker z działającymi kontenerami systemu Linux. Platforma Docker udostępnia pakiety, które konfigurują platformę Docker w Mac, Windows lub Linux system.

Uwaga

Azure Cloud Shell nie zawiera składników platformy Docker wymaganych do wykonania każdego kroku w tych samouczkach. Dlatego zalecamy używanie pełnego środowiska programistycznego usługi Docker.

---

Pobieranie kodu aplikacji

Przykładowa aplikacja sample używana w tym samouczku to podstawowa aplikacja frontendu sklepu, zawierająca następujące wdrożenia i usługi Kubernetes:

• Front sklepu: aplikacja internetowa dla klientów do wyświetlania produktów i składania zamówień.
• Usługa produktu: wyświetla informacje o produkcie.
• Usługa składania zamówień: składa zamówienia.
• RabbitMQ: kolejka komunikatów do obsługi kolejki zamówień.

Usługa Git

1. Utwórz katalog na komputerze i przejdź do niego w swojej sesji terminalu, na przykład w powłoce Bash. W tym przykładzie użyto katalogu o nazwie demorepo , ale możesz użyć dowolnej nazwy.

   mkdir demorepo
   cd demorepo
   

2. Użyj narzędzia git , aby sklonować przykładową aplikację do środowiska deweloperskiego.

   git clone https://github.com/Azure-Samples/aks-store-demo.git
   

3. Przejdź do sklonowanego katalogu.

   cd aks-store-demo
   

Azure Developer CLI

1. Jeśli używasz interfejsu wiersza polecenia dewelopera Azure lokalnie, utwórz pusty katalog o nazwie aks-store-demo , aby hostować pliki szablonu azd.

   mkdir aks-store-demo
   

2. Przejdź do nowego katalogu, aby załadować wszystkie pliki z szablonu azd.

   cd aks-store-demo
   

3. Sklonuj przykładową aplikację do katalogu aks-store-demo przy użyciu polecenia azd init z flagą --template ustawioną na aks-store-demo.

   azd init --template aks-store-demo
   

Przejrzyj plik Docker Compose

Przykładowa aplikacja, którą tworzysz w tym samouczku, korzysta z pliku YAML docker-compose-quickstart z repozytorium, które sklonowałeś.

W poniższej tabeli podsumowano wartości domyślne klucza z przykładowego pliku Compose, dzięki czemu można szybko zobaczyć, które usługi, porty i zależności są używane w samouczku:

Service	Źródło	Uwidoczniony port	Kluczowe ustawienia
RabbitMQ	rabbitmq:4.3.2-management-alpine obraz	15672, 5672	Domyślna nazwa użytkownika username, hasło password
Zamawianie usługi	src/order-service	3000	Nawiązuje połączenie z aplikacją RabbitMQ na porcie 5672 i używa kolejki orders
Usługa produktu	src/product-service	3002	Używa AI_SERVICE_URL=http://ai-service:5001/
Witryna sklepu	src/store-front	8080	Wywołuje usługę produktu na 3002 oraz usługę zamówień na 3000

services:
  rabbitmq:
    image: rabbitmq:4.3.2-management-alpine
    container_name: 'rabbitmq'
    restart: always
    environment:
      - "RABBITMQ_DEFAULT_USER=username"
      - "RABBITMQ_DEFAULT_PASS=password"
    ports:
      - 15672:15672
      - 5672:5672
    healthcheck:
      test: ["CMD", "rabbitmqctl", "status"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      - backend_services
  order-service:
    build: src/order-service
    container_name: 'order-service'
    restart: always
    ports:
      - 3000:3000
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://order-service:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - ORDER_QUEUE_HOSTNAME=rabbitmq
      - ORDER_QUEUE_PORT=5672
      - ORDER_QUEUE_USERNAME=username
      - ORDER_QUEUE_PASSWORD=password
      - ORDER_QUEUE_NAME=orders
    networks:
      - backend_services
    depends_on:
      rabbitmq:
        condition: service_healthy
  product-service:
    build: src/product-service
    container_name: 'product-service'
    restart: always
    ports:
      - 3002:3002
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://product-service:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - AI_SERVICE_URL=http://ai-service:5001/
    networks:
      - backend_services
  store-front:
    build: src/store-front
    container_name: 'store-front'
    restart: always
    ports:
      - 8080:8080
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://store-front:80/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - VUE_APP_PRODUCT_SERVICE_URL=http://product-service:3002/
      - VUE_APP_ORDER_SERVICE_URL=http://order-service:3000/
    networks:
      - backend_services
    depends_on:
      - product-service
      - order-service
networks:
  backend_services:
    driver: bridge

---

Tworzenie obrazów kontenerów i uruchamianie aplikacji

Za pomocą narzędzia Docker Compose można zautomatyzować tworzenie obrazów kontenerów i wdrażanie aplikacji wielokontenerowych.

Przed uruchomieniem następujących poleceń upewnij się, że platforma Docker jest uruchomiona w trybie kontenera systemu Linux.

1. W katalogu głównym sklonowanego repozytorium aks-store-demo utwórz obraz kontenera, pobierz obraz RabbitMQ i uruchom aplikację za pomocą polecenia docker compose:

   docker compose -f docker-compose-quickstart.yml up -d
   

2. Wyświetl utworzone obrazy przy użyciu docker images polecenia .

   docker images
   

   Następujące skrócone przykładowe dane wyjściowe pokazują utworzone obrazy:

   REPOSITORY                        TAG                          IMAGE ID
   aks-store-demo-product-service    latest                       72f5cd7e6b84
   aks-store-demo-order-service      latest                       54ad5de546f9
   aks-store-demo-store-front        latest                       1125f85632ae
   ...
   

3. Wyświetl uruchomione kontenery przy użyciu docker ps polecenia .

   docker ps
   

   Następujące skrócone przykładowe dane wyjściowe pokazują cztery uruchomione kontenery:

   CONTAINER ID        IMAGE
   f27fe74cfd0a        aks-store-demo-product-service
   df1eaa137885        aks-store-demo-order-service
   b3ce9e496e96        aks-store-demo-store-front
   31df28627ffa        rabbitmq:4.3.2-management-alpine
   

Testowanie aplikacji w środowisku lokalnym

Aby wyświetlić uruchomioną aplikację, przejdź do witryny http://localhost:8080 w lokalnej przeglądarce internetowej. Zostanie załadowana przykładowa aplikacja, jak pokazano w poniższym przykładzie:

Na tej stronie możesz wyświetlać produkty, dodawać je do koszyka, a następnie składać zamówienie.

Migruj własne pliki Compose

Jeśli masz już aplikację zdefiniowaną w pliku docker Compose, możesz użyć tego samouczka jako odwołania do lokalnej weryfikacji, a następnie przekonwertować istniejącą konfigurację narzędzia Compose na manifesty platformy Kubernetes. Użyj narzędzi, takich jak Kompose, Move2Kube, Docker Compose Bridge lub Podman , aby przekonwertować definicje narzędzia Docker Compose na zasoby kubernetes. Aby uzyskać pełną kompleksową ścieżkę konwersji, zobacz dokumentację platformy Kubernetes dotyczącą migrowania narzędzia Docker Compose do platformy Kubernetes i omówienie migracji usługi AKS, jeśli przenosisz się również z innego przepływu pracy orkiestratora lub modernizacji.

Wybieranie narzędzia konwersji

Użyj tej tabeli, gdy potrzebujesz szybkiego porównania najczęstszych opcji przejścia z Compose do Kubernetes.

Tool	Podsumowanie jednowierszowe
Kompose	Szybkie tworzenie szkieletu rozwiązania Kubernetes; run kompose convert; oczekiwano ręcznego czyszczenia magazynu i sond.
Move2Kube	Bardziej rozbudowany proces modernizacji; uruchamiany za pomocą move2kube plan -s ./path && move2kube transform; bardziej zasobożerny niż konwertery jednoplikowe.
Docker Compose Bridge	Ścieżka konwersji przeznaczona dla Docker Desktop; uruchom docker compose bridge convert -o ./k8s/; zobacz dokumentację Dockera, aby uzyskać szczegółowe informacje o aktualnym wsparciu.
Podman	Eksportuj YAML z uruchomionych kontenerów lub podów; uruchom podman kube generate mypod > k8s.yaml; najlepsze w przypadku przepływów pracy opartych na Podmanie.
Helm	Manifesty szablonów i pakietów dla powtarzalnych wdrożeń; uruchom helm create mychart; najlepiej po konwersji.
Kustomize	Nałóż zmiany specyficzne dla środowiska; uruchom kubectl apply -k .; najlepiej zrobić to po konwersji.
Skaffold	Zbuduj wewnętrzną pętlę programistyczną w Kubernetes; uruchom skaffold init; to nie jest bezpośredni konwerter.
Przechylenie	Aktualizuj na żywo lokalne środowisko programistyczne Kubernetes; uruchom tilt up; wymaga procesu pracy skoncentrowanego na Kubernetes.
Konwersja wspomagana przez sztuczną inteligencję	Przeprowadź wersję roboczą lub porównaj manifesty ze sztuczną inteligencją, a następnie zweryfikuj dane wyjściowe przed wdrożeniem.

Które narzędzie należy wybrać?

• Jeśli chcesz szybko przygotować dowód koncepcji lub początkowe manifesty, użyj Kompose.
• Jeśli używasz programu Docker Desktop i chcesz użyć ścieżki natywnej platformy Docker, użyj narzędzia Docker Compose Bridge.
• Jeśli realizujesz większe przedsięwzięcie związane z migracją lub modernizacją wielu usług, użyj Move2Kube.
• Jeśli chcesz eksportować dane z uruchomionych kontenerów lub podów, użyj Podman.
• Jeśli masz już manifesty i potrzebujesz opakowań lub nakładek, użyj narzędzia Helm lub Kustomize.
• Jeśli potrzebujesz lokalnej pętli deweloperskiej Kubernetes po konwersji, użyj narzędzia Skaffold lub Tilt.
• Jeśli potrzebujesz wersji roboczej manifestów lub wyjaśnień migracji, skorzystaj z pomocy dotyczącej sztucznej inteligencji i zweryfikuj wynik zgodnie z oficjalnymi wskazówkami dotyczącymi platformy Kubernetes i usługi AKS.

Inne narzędzia do rozważenia:

• 8gwifi.org Konwerter YAML dla Kubernetes: przydatny do szybkich eksperymentów online z małymi plikami Compose.
• Okteto: przydatne, gdy potrzebujesz pętli programowania w chmurze lub zdalnej platformy Kubernetes dla zespołów aplikacji.
• Devtron: Przydatne, gdy po konwersji potrzebujesz platformowego workflow do wdrażania w Kubernetesie.
• Portainer: przydatne, gdy potrzebujesz kontenera opartego na interfejsie użytkownika i środowiska zarządzania kubernetes.

Konwertuj pliki Compose

Użyj następujących poleceń z możliwością kopiowania jako punktu początkowego:

kompose convert
move2kube plan -s ./path && move2kube transform
docker compose bridge convert -o ./k8s/
podman kube generate mypod > k8s.yaml
skaffold init

Przykład konwersji Kompose

Narzędzie Kompose typu open source konwertuje typowe ustawienia narzędzia Docker Compose na obiekty Kubernetes, takie jak wdrożenia i usługi.

1. Na Windows zainstaluj aplikację Kompose przy użyciu następującego polecenia:

   curl -L https://github.com/kubernetes/kompose/releases/latest/download/kompose-windows-amd64.exe -o kompose.exe
   

   Aby uzyskać inne opcje instalacji, zobacz instrukcje instalacji Kompose.

2. Uruchom Kompose w katalogu, który zawiera plik docker-compose.yml.

   kompose convert
   

3. Przejrzyj wygenerowane pliki YAML Kubernetes przed wdrożeniem ich w usłudze AKS.

Konwersja wspomagana przez sztuczną inteligencję

Możesz użyć asystenta sztucznej inteligencji do utworzenia wersji roboczych manifestów platformy Kubernetes, porównać ustawienia redagowania z odpowiednikami platformy Kubernetes lub wyjaśnić, dlaczego konwersja wymaga ręcznych zmian.

Ogólny przykładowy monit:

Convert this docker-compose.yml into production-ready Kubernetes manifests. Use Apps/v1, move secrets to Kubernetes Secret objects, map local volumes to PersistentVolumeClaims, and add readiness and liveness probes for the web service.

Przykładowe polecenie ukierunkowane na AKS:

Convert this docker-compose.yml into AKS-ready Kubernetes manifests. Target an AKS cluster, push images to Azure Container Registry, use Apps/v1 objects, move secrets to Kubernetes Secret objects, map local volumes to Azure Files or Azure Disks-backed PersistentVolumeClaims, and add readiness and liveness probes for the web service.

Zawsze sprawdź wyniki działania SI przed ich zastosowaniem. Sprawdź wartości apiVersion, żądania i limity zasobów, klasy pamięci masowej, udostępnianie usługi oraz testy kondycji.

Obsługa typowych problemów z tłumaczeniem

Jak są obsługiwane woluminy?

Compose volumes często wymaga trwałych woluminów Kubernetes i klasy pamięci. W środowisku AKS zastąp instalacje dostępne tylko lokalnie usługami, takimi jak Azure Disks lub Azure Files.

Co zastępuje depends_on?

Funkcja Compose depends_on nie wymusza gotowości środowiska uruchomieniowego na platformie Kubernetes. W razie potrzeby zastąp to sondami gotowości, sondami startowymi lub logiką kontenera inicjalizacyjnego.

Jak obsługiwać sekrety i wartości zmiennych środowiskowych?

Wartości środowiskowe Compose często stają się zasobami Kubernetes ConfigMap lub Secret albo integracjami z usługą Azure Key Vault.

Co stanie się z portami i ingressem?

Utwórz mapowanie ports na obiekty Kubernetes Service , a czasami zasoby interfejsu API ruchu przychodzącego lub bramy, w zależności od sposobu publikowania aplikacji.

Jak są tłumaczone kontrole kondycji?

Ustawienia Compose healthcheck zwykle stają się sondami żywotności i gotowości w Kubernetes.

Co dzieje się z sieciami Compose?

Sieci Compose zwykle odpowiadają wykrywaniu usług w Kubernetes za pomocą usług i klastrowego DNS zamiast niestandardowych sieci mostkowych.

Jak testować lokalnie za pomocą platformy Kubernetes?

Po konwersji wdróż wygenerowane manifesty do lokalnego środowiska Kubernetes, takiego jak kind lub minikube, a następnie użyj Skaffold lub Tilt, jeśli chcesz przyspieszyć cykl edycji, kompilacji i wdrażania.

Stosowanie korekt specyficznych dla usługi AKS po konwersji

Kompose stanowi punkt wyjścia, ale zazwyczaj trzeba wprowadzić ręczne zmiany na potrzeby usługi AKS:

• Zaktualizuj odwołania do obrazów tak, aby wskazywały na rejestr Azure Container Registry (ACR).
• Zastąp magazyn tylko lokalny i wiązanie instalacji magazynem trwałym, takim jak dyski Azure lub Azure Files, w zależności od potrzeb związanych z obciążeniem.
• Zastąp wpisy tajne Compose lub wartości specyficzne dla środowiska mechanizmami Kubernetes Secrets, ConfigMaps lub integracjami z usługą Azure Key Vault.
• Przejrzyj ustawienia sieci i ekspozycji, takie jak LoadBalancer, ruch przychodzący lub konfiguracja bramy, na podstawie sposobu publikowania aplikacji w usłudze AKS.
• Sprawdź, czy komponenty stanowe powinny pozostać Deploymentami, czy należy przenieść je do rozwiązań takich jak StatefulSety, gdy potrzebujesz stabilnej identyfikacji lub określonego zachowania pamięci masowej.
• Zweryfikuj żądania zasobów, sondy oraz wszelkie założenia dotyczące kolejności uruchamiania, ponieważ mechanizmy Compose, takie jak depends_on, nie mają bezpośredniego odpowiednika w działaniu środowiska uruchomieniowego Kubernetes.

Przepływ pracy po konwersji

1. Przekonwertuj plik Compose za pomocą narzędzia takiego jak Kompose, Move2Kube, Docker Compose Bridge, Podman lub wersji roboczej przejrzanej przez SI.
2. Przejrzyj i utwardź manifesty, poprawiając pamięć trwałą, sekrety, udostępnianie usług, sondy i odwołania do obrazów.
3. Spakuj manifesty za pomocą Helm lub nakładaj zmiany specyficzne dla środowiska warstwowo przy użyciu Kustomize.
4. Prześlij obrazy do rejestru, na przykład do usługi ACR, a następnie wdróż je za pomocą GitOps, CI/CD lub bezpośrednio za pomocą przepływów pracy kubectl.

Przykładowa sekwencja: kompose convert —> przeglądanie manifestów —> wypychanie obrazów do usługi ACR —> aktualizowanie odwołań do obrazów —>kubectl apply lub helm install.

Czyszczenie zasobów

Jeśli wykonano kroki przepływu pracy narzędzia Docker Compose, możesz zatrzymać i usunąć uruchomione kontenery. Nie usuwaj obrazów kontenerów, ponieważ będziesz ich używać w następnym samouczku. Jeśli postępujesz zgodnie z przepływem pracy Azure Developer CLI, użyj azd down zamiast docker compose down.

Zatrzymaj i usuń wystąpienia kontenera oraz zasoby przy użyciu polecenia docker compose down.

docker compose down

polecenia Azure Developer CLI

Korzystając z azd, nie ma zależności od ręcznych obrazów kontenera. azd obsługuje aprowizowanie, wdrażanie oraz usuwanie aplikacji i klastrów za pomocą poleceń azd up i azd down, podobnie jak Docker.

Kroki przygotowywania można dostosować, aby użyć narzędzia Terraform lub Bicep przed wdrożeniem klastra w infra sekcji azure.yaml. Domyślnie ten projekt używa programu Terraform:

infra:
  provider: terraform
  path: infra/terraform

Jeśli chcesz zmienić dostawcę na Bicep, zaktualizuj plik azure.yaml w następujący sposób:

infra:
  provider: bicep
  path: infra/bicep

---

Następne kroki

Azure CLI

W tym samouczku utworzyłeś przykładową aplikację, stworzyłeś obrazy kontenerowe aplikacji i następnie przetestowałeś aplikację. Nauczyłeś się, jak:

• Sklonuj przykładowe źródło aplikacji z GitHub.
• Utwórz obraz kontenera na podstawie przykładowego źródła aplikacji.
• Przetestuj aplikację z wieloma kontenerami w lokalnym środowisku platformy Docker.

W następnym samouczku dowiesz się, jak przechowywać obrazy kontenerowe w usłudze ACR.

Prześlij obrazy do Azure Container Registry

Azure Developer CLI

W tym samouczku sklonowałeś przykładową aplikację używając azd. Nauczyłeś się, jak:

• Sklonuj przykładowy szablon azd z GitHub.
• Wyświetl miejsce, gdzie obrazy kontenerów są zamieszczone w źródłach przykładowej aplikacji.

W następnym samouczku dowiesz się, jak utworzyć klaster, używając sklonowanego szablonu azd.

Utwórz klaster AKS

---