(PRZESTARZAŁE) Tworzenie i wdrażanie aplikacji na platformie Kubernetes za pomocą narzędzia Draft z usługą Azure Container Service i Azure Container Registry

  • Artykuł

Porada

Aby uzyskać zaktualizowaną wersję tego artykułu korzystającą z Azure Kubernetes Service, zobacz Używanie wersji roboczej z Azure Kubernetes Service (AKS).

Ostrzeżenie

Usługa Azure Container Service (ACS) stała się przestarzała. Do usługi ACS nie są już dodawane żadne nowe funkcje. Wszystkie interfejsy API, środowisko portalu, polecenia interfejsu wiersza polecenia i dokumentacja są oznaczone jako przestarzałe.

W 2017 r. wprowadziliśmy usługę Azure Kubernetes Service (AKS), aby uprościć wdrażanie i operacje platformy Kubernetes oraz zarządzanie nią. Jeśli używasz orkiestratora platformy Kubernetes, przeprowadź migrację do usługi AKS do 31 stycznia 2020 r. Aby rozpocząć pracę, zapoznaj się z artykułem dotyczącym migracji do usługi Azure Kubernetes Service.

Aby uzyskać więcej informacji, zobacz ogłoszenie o zakończeniu obsługi usługi Azure Container Service w witrynie Azure.com.

Draft to nowe narzędzie open-source, które ułatwia programowanie aplikacji bazujących na kontenerach i wdrażanie ich w klastrach Kubernetes bez bliższej znajomości rozwiązań Docker i Kubernetes (a nawet bez ich instalacji). Narzędzia takie jak Draft pozwalają Tobie i Twoim zespołom skupiać się na tworzeniu aplikacji z użyciem rozwiązania Kubernetes bez poświęcania większej uwagi infrastrukturze.

Narzędzia Draft można użyć z dowolnym rejestrem obrazów Docker i dowolnym klastrem Kubernetes, w tym lokalnym. W tym samouczku pokazano, jak używać usług ACS z platformą Kubernetes i usługą ACR w celu utworzenia dynamicznego, ale bezpiecznego potoku dewelopera na platformie Kubernetes przy użyciu usługi Draft oraz jak za pomocą usługi Azure DNS uwidocznić ten potok dewelopera dla innych osób w celu wyświetlenia w domenie.

Tworzenie rejestru Azure Container Registry

Możesz z łatwością utworzyć nowy rejestr Azure Container Registry, przy czym kroki są następujące:

  1. Utwórz grupę zasobów platformy Azure, aby zarządzać rejestrem usługi ACR i klastrem Kubernetes w usłudze ACS.

    az group create --name draft --location eastus

  2. Utwórz rejestr obrazów usługi ACR przy użyciu polecenia az acr create i upewnij się, że opcja jest ustawiona --admin-enabled na truewartość .

    az acr create --resource-group draft --name draftacs --sku Basic

Tworzenie usługi Azure Container Service za pomocą rozwiązania Kubernetes

Teraz można już użyć polecenia az acs create do utworzenia klastra ACS za pomocą rozwiązania Kubernetes jako wartości --orchestrator-type.

az acs create --resource-group draft --name draft-kube-acs --dns-prefix draft-cluster --orchestrator-type kubernetes --generate-ssh-keys

Uwaga

Ponieważ rozwiązanie Kubernetes nie jest domyślnym typem koordynatora, pamiętaj o użyciu przełącznika --orchestrator-type kubernetes.

Dane wyjściowe po pomyślnym wykonaniu polecenia wyglądają podobnie do następujących.

waiting for AAD role to propagate.done
{
  "id": "/subscriptions/<guid>/resourceGroups/draft/providers/Microsoft.Resources/deployments/azurecli14904.93snip09",
  "name": "azurecli1496227204.9323909",
  "properties": {
    "correlationId": "<guid>",
    "debugSetting": null,
    "dependencies": [],
    "mode": "Incremental",
    "outputs": null,
    "parameters": {
      "clientSecret": {
        "type": "SecureString"
      }
    },
    "parametersLink": null,
    "providers": [
      {
        "id": null,
        "namespace": "Microsoft.ContainerService",
        "registrationState": null,
        "resourceTypes": [
          {
            "aliases": null,
            "apiVersions": null,
            "locations": [
              "westus"
            ],
            "properties": null,
            "resourceType": "containerServices"
          }
        ]
      }
    ],
    "provisioningState": "Succeeded",
    "template": null,
    "templateLink": null,
    "timestamp": "2017-05-31T10:46:29.434095+00:00"
  },
  "resourceGroup": "draft"
}

Po utworzeniu klastra można zaimportować poświadczenia za pomocą polecenia az acs kubernetes get-credentials. Zostanie utworzony lokalny plik konfiguracji klastra, którego narzędzia Helm i Draft wymagają do wykonania pracy.

Instalowanie i konfigurowanie narzędzia Draft

  1. Pobierz wersję roboczą środowiska na https://github.com/Azure/draft/releases stronie i zainstaluj je w ścieżce PATH, aby można było użyć polecenia .

  2. Pobierz narzędzie helm dla środowiska pod adresem https://github.com/kubernetes/helm/releases i zainstaluj je w ścieżce PATH, aby można było użyć polecenia .

  3. Skonfiguruj narzędzie Draft do korzystania z Twojego rejestru i tworzenia poddomen dla każdego planu Helm, które to narzędzie utworzy. Aby skonfigurować narzędzie Draft, potrzebne są:

    • nazwa rejestru Azure Container Registry (w tym przykładzie: draftacsdemo);
    • klucz rejestru lub hasło z polecenia az acr credential show -n <registry name> --output tsv --query "passwords[0].value";

    Wywołanie draft init metody i proces konfiguracji wyświetla monit o podanie powyższych wartości. Zwróć uwagę, że format adresu URL dla adresu URL rejestru to nazwa rejestru (w tym przykładzie draftacsdemo) i .azurecr.io. Nazwa użytkownika jest nazwą rejestru samodzielnie. Gdy proces uruchomisz po raz pierwszy, będzie on wyglądać podobnie do następującego.

     $ draft init
 Creating /home/ralph/.draft 
 Creating /home/ralph/.draft/plugins 
 Creating /home/ralph/.draft/packs 
 Creating pack go...
 Creating pack python...
 Creating pack ruby...
 Creating pack javascript...
 Creating pack gradle...
 Creating pack java...
 Creating pack php...
 Creating pack csharp...
 $DRAFT_HOME has been configured at /home/ralph/.draft.

 In order to configure Draft, we need a bit more information...

 1. Enter your Docker registry URL (e.g. docker.io/myuser, quay.io/myuser, myregistry.azurecr.io): draftacsdemo.azurecr.io
 2. Enter your username: draftacsdemo
 3. Enter your password: 
 Draft has been installed into your Kubernetes Cluster.
 Happy Sailing!

Teraz możesz wdrożyć aplikację.

Kompilowanie i wdrażanie aplikacji

W repozytorium narzędzia Draft znajduje się sześć prostych, przykładowych aplikacji. Sklonuj repozytorium i użyjmy przykładu języka Java. Przejdź do katalogu examples/java i wpisz draft create , aby skompilować aplikację. Powinno to wyglądać podobnie jak na poniższym przykładzie.

$ draft create
--> Draft detected the primary language as Java with 91.228814% certainty.
--> Ready to sail

Dane wyjściowe obejmują plik Docker i plan Helm. W celu skompilowania i wdrożenia wystarczy wpisać polecenie draft up. Dane wyjściowe są obszerne, ale powinny być podobne do poniższego przykładu.

$ draft up
Draft Up Started: 'handy-labradoodle'
handy-labradoodle: Building Docker Image: SUCCESS ⚓  (35.0232s)
handy-labradoodle: Pushing Docker Image: SUCCESS ⚓  (17.0062s)
handy-labradoodle: Releasing Application: SUCCESS ⚓  (3.8903s)
handy-labradoodle: Build ID: 01BT0ZJ87NWCD7BBPK4Y3BTTPB

Bezpieczne wyświetlanie aplikacji

Kontener jest teraz uruchomiony w usłudze ACS. Aby go wyświetlić, użyj draft connect polecenia , które tworzy zabezpieczone połączenie z adresem IP klastra z określonym portem dla aplikacji, aby można było wyświetlić je lokalnie. W przypadku powodzenia poszukaj adresu URL, aby nawiązać połączenie z aplikacją w pierwszym wierszu po wskaźniku SUCCESS .

Uwaga

Jeśli zostanie wyświetlony komunikat z informacją, że żadne zasobniki nie były gotowe, poczekaj chwilę i ponów próbę lub możesz obejrzeć, jak zasobniki staną się gotowe kubectl get pods -w , a następnie ponów próbę, gdy to zrobią.

draft connect
Connecting to your app...SUCCESS...Connect to your app on localhost:46143
Starting log streaming...
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See https://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
== Spark has ignited ...
>> Listening on 0.0.0.0:4567

W poprzednim przykładzie można wpisać curl -s https://localhost:46143 , aby otrzymać odpowiedź, Hello World, I'm Java!. Po naciśnięciu klawiszy CTRL+ lub CMD+C (w zależności od środowiska systemu operacyjnego) bezpieczny tunel zostanie usunięty i będzie można kontynuować iteracji.

Udostępnianie aplikacji przez skonfigurowanie domeny wdrożenia za pomocą usługi Azure DNS

Wykonano już pętlę iteracji dla deweloperów, którą program Draft tworzy w poprzednich krokach. Możesz jednak udostępnić aplikację w Internecie, wykonując następujące czynności:

  1. Instalowanie ruchu przychodzącego w klastrze ACS (w celu udostępnienia publicznego adresu IP, pod którym ma być wyświetlana aplikacja)
  2. Delegowanie domeny niestandardowej do usługi Azure DNS i mapowanie domeny na adres IP USŁUGI ACS przypisuje do kontrolera ruchu przychodzącego

Użyj narzędzia Helm, aby zainstalować kontroler ruchu przychodzącego.

Użyj narzędzia Helm , aby wyszukać i zainstalować stable/traefikkontroler ruchu przychodzącego, aby włączyć żądania przychodzące dla kompilacji.

$ helm search traefik
NAME          	VERSION	DESCRIPTION
stable/traefik	1.3.0  	A Traefik based Kubernetes ingress controller w...

$ helm install stable/traefik --name ingress

Teraz ustaw wyrażenie kontrolne na kontrolerze ingress, aby przechwycić wartość zewnętrznego adresu IP po jego wdrożeniu. Ten adres IP zostanie zamapowany na domenę wdrażania w następnej sekcji.

$ kubectl get svc -w
NAME                          CLUSTER-IP     EXTERNAL-IP     PORT(S)                      AGE
ingress-traefik               10.0.248.104   13.64.108.240   80:31046/TCP,443:32556/TCP   1h
kubernetes                    10.0.0.1       <none>          443/TCP                      7h

W tym przypadku zewnętrzny adres IP dla domeny wdrażania to 13.64.108.240. Teraz możesz zamapować swoją domenę na ten adres IP.

Mapuj adres IP ruchu przychodzącego na niestandardową poddomenę

Narzędzie Draft tworzy wydanie dla każdego tworzonego planu Helm, czyli każdej aplikacji, nad którą pracujesz. Każda z nich pobiera wygenerowaną nazwę, która jest używana przez wersję roboczą jako poddomenę u góry domeny wdrożenia głównego, którą kontrolujesz. (W tym przykładzie używamy squillace.io jako domeny wdrożenia). Aby włączyć to zachowanie poddomeny, należy utworzyć rekord A dla '*.draft' wpisów DNS dla domeny wdrożenia, aby każda wygenerowana poddomena została skierowana do kontrolera ruchu przychodzącego klastra Kubernetes.

Twój dostawca domeny ma swój własny sposób przypisywania serwerów DNS. Aby wydelegować serwery nazw Twojej domeny do usługi Azure DNS, musisz wykonać następujące kroki:

  1. Utwórz grupę zasobów dla swojej strefy.

    az group create --name squillace.io --location eastus
{
  "id": "/subscriptions/<guid>/resourceGroups/squillace.io",
  "location": "eastus",
  "managedBy": null,
  "name": "zones",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

  2. Utwórz strefę DNS dla swojej domeny. Użyj polecenia az network dns zone create, aby uzyskać serwery nazw w celu delegowania kontroli DNS do usługi Azure DNS dla Twojej domeny.

    az network dns zone create --resource-group squillace.io --name squillace.io
{
  "etag": "<guid>",
  "id": "/subscriptions/<guid>/resourceGroups/zones/providers/Microsoft.Network/dnszones/squillace.io",
  "location": "global",
  "maxNumberOfRecordSets": 5000,
  "name": "squillace.io",
  "nameServers": [
    "ns1-09.azure-dns.com.",
    "ns2-09.azure-dns.net.",
    "ns3-09.azure-dns.org.",
    "ns4-09.azure-dns.info."
  ],
  "numberOfRecordSets": 2,
  "resourceGroup": "squillace.io",
  "tags": {},
  "type": "Microsoft.Network/dnszones"
}

  3. Dodaj uzyskane serwery DNS do dostawcy domeny dla Twojej domeny wdrażania, co pozwoli używać usługi Azure DNS do dowolnego zmieniania sposobu wskazywania Twojej domeny. Sposób, w jaki to robisz, różni się w zależności od udostępniania domeny; Delegowanie serwerów nazw domeny do usługi Azure DNS zawiera niektóre szczegóły, które należy znać.

  4. Po delegowaniu domeny do usługi Azure DNS utwórz wpis zestawu rekordów dla mapowania domeny wdrożenia na ingress adres IP z kroku 2 poprzedniej sekcji.

    az network dns record-set a add-record --ipv4-address 13.64.108.240 --record-set-name '*.draft' -g squillace.io -z squillace.io

    Dane wyjściowe wyglądają podobnie do tych:

    {
 "arecords": [
   {
     "ipv4Address": "13.64.108.240"
   }
 ],
 "etag": "<guid>",
 "id": "/subscriptions/<guid>/resourceGroups/squillace.io/providers/Microsoft.Network/dnszones/squillace.io/A/*",
 "metadata": null,
 "name": "*.draft",
 "resourceGroup": "squillace.io",
 "ttl": 3600,
 "type": "Microsoft.Network/dnszones/A"
}

  5. Zainstaluj ponownie wersję roboczą

    1. Usuń wersję roboczą z klastra, wpisując helm delete --purge draft.
    2. Zainstaluj ponownie wersję roboczą przy użyciu tego samego draft-init polecenia, ale z opcją --ingress-enabled :
      draft init --ingress-enabled
      Odpowiedz na monity, tak jak po raz pierwszy, powyżej. Masz jednak jeszcze jedno pytanie, na które należy odpowiedzieć, korzystając z pełnej ścieżki domeny skonfigurowanej w usłudze Azure DNS.

  6. Wprowadź domenę najwyższego poziomu dla ruchu przychodzącego (np. draft.example.com): draft.squillace.io

  7. Po wywołaniu draft up tego wywołania aplikacja (lub curl jej) będzie widoczna pod adresem URL formularza <appname>.draft.<domain>.<top-level-domain>. W przypadku tego przykładu wartość http://handy-labradoodle.draft.squillace.io.

    curl -s http://handy-labradoodle.draft.squillace.io
Hello World, I'm Java!

Następne kroki

Teraz, gdy już masz klaster ACS Kubernetes, możesz przyjrzeć się sposobie korzystania z usługi Azure Container Registry, aby utworzyć więcej innych wdrożeń tego scenariusza. Na przykład możesz utworzyć zestaw rekordów usługi DNS dla domeny draft.basedomain.toplevel, który steruje działaniem na poziomie głębszej poddomeny dla specyficznych wdrożeń usługi ACS.