ASP.NET Core uygulamasını Google Kubernetes Engine'de Kubernetes'e dağıtma

1. Genel Bakış

ASP.NET Core, C# programlama dilini kullanarak modern bulut tabanlı ve internete bağlı uygulamalar oluşturmak için yeni bir açık kaynaklı ve platformlar arası çerçevedir.

Kubernetes; dizüstü bilgisayarlardan yüksek kullanılabilirlik sağlayan çok düğümlü kümelere, herkese açık bulutlardan şirket içi dağıtımlara, sanal makinelerden çıplak metal sunuculara kadar birçok farklı ortamda çalışabilen açık kaynaklı bir projedir.

Bu laboratuvarda, Kubernetes Engine üzerinde çalışan Kubernetes'e basit bir ASP.NET Core uygulaması dağıtıyorsunuz. Bu codelab, Google Cloud Shell'de ASP.NET Core uygulaması derleme ve kullanıma sunma codelab'ine dayanmaktadır. Bu laboratuvara başlamadan önce söz konusu laboratuvarı tamamlamanız önerilir.

Bu codelab'in amacı, kodunuzu (burada basit bir Hello World ASP.NET Core uygulaması) Kubernetes'te çalışan bir kopyalanmış uygulamaya dönüştürmenizi sağlamaktır. Makinenizde geliştirdiğiniz kodu alıp Docker container görüntüsüne dönüştürür ve bu görüntüyü Google Kubernetes Engine'de çalıştırırsınız.

Bu codelab'de kullanılan çeşitli parçaların nasıl bir araya geldiğini anlamanıza yardımcı olacak bir diyagram aşağıda verilmiştir. Bu bilgiyi, codelab'de ilerlerken referans olarak kullanın. Sonuna geldiğinizde her şey anlaşılır olacaktır (ancak şimdilik bu bilgiyi göz ardı edebilirsiniz).

Bu codelab'in amacı doğrultusunda, Kubernetes Engine (Compute Engine'de çalışan, Google tarafından barındırılan bir Kubernetes sürümü) gibi yönetilen bir ortam kullanmak, temel altyapıyı ayarlamak yerine Kubernetes'i deneyimlemeye daha fazla odaklanmanızı sağlar.

Kubernetes'i yerel makinenizde (ör. geliştirme dizüstü bilgisayarı) çalıştırmak istiyorsanız Minikube'u incelemeniz önerilir. Bu, geliştirme ve test amaçları için tek düğümlü bir Kubernetes kümesinin basit bir şekilde kurulmasını sağlar. İsterseniz bu codelab'i incelemek için Minikube'u kullanabilirsiniz.

Neler öğreneceksiniz?

Basit bir ASP.NET Core uygulamasını Docker container'ı olarak paketleme
Google Kubernetes Engine'de (GKE) Kubernetes kümenizi nasıl oluşturacağınızı öğrenin.
ASP.NET Core uygulamanızı bir poda nasıl dağıtacağınız.
Harici trafiğin pod'unuza ulaşmasına nasıl izin verebilirsiniz?
Hizmetinizi nasıl ölçeklendireceğinizi ve yükseltme dağıtacağınızı öğrenin.
Kubernetes grafik kontrol panelini çalıştırma

İhtiyacınız olanlar

Chrome veya Firefox gibi bir tarayıcı

Bu eğitimi nasıl kullanacaksınız?

Yalnızca okuyun

Okuyun ve alıştırmaları tamamlayın

Google Cloud Platform deneyiminizi nasıl değerlendirirsiniz?

Başlangıç

Orta

İleri

2. Kurulum ve Gereksinimler

Yönlendirmesiz ortam kurulumu

Google Cloud Console'da oturum açın ve yeni bir proje oluşturun veya mevcut bir projeyi yeniden kullanın. Gmail veya Google Workspace hesabınız yoksa hesap oluşturmanız gerekir.

Proje adı, bu projenin katılımcıları için görünen addır. Google API'leri tarafından kullanılmayan bir karakter dizesidir. Dilediğiniz zaman bunu güncelleyebilirsiniz.
Proje kimliği, tüm Google Cloud projelerinde benzersiz olmalı ve sabittir (ayarlandıktan sonra değiştirilemez). Cloud Console, benzersiz bir dizeyi otomatik olarak oluşturur. Genellikle bu dizenin ne olduğuyla ilgilenmezsiniz. Çoğu codelab'de proje kimliğine (genellikle PROJECT_ID olarak tanımlanır) başvurmanız gerekir. Oluşturulan kimliği beğenmezseniz başka bir rastgele kimlik oluşturabilirsiniz. Dilerseniz kendi adınızı deneyerek kullanılabilir olup olmadığını kontrol edebilirsiniz. Bu adımdan sonra değiştirilemez ve proje süresince geçerli kalır.
Bazı API'lerin kullandığı üçüncü bir değer olan Proje Numarası da vardır. Bu üç değer hakkında daha fazla bilgiyi belgelerde bulabilirsiniz.

Ardından, Cloud kaynaklarını/API'lerini kullanmak için Cloud Console'da faturalandırmayı etkinleştirmeniz gerekir. Bu codelab'i tamamlamak neredeyse hiç maliyetli değildir. Bu eğitimin ötesinde faturalandırma ücreti alınmaması için kaynakları kapatmak üzere oluşturduğunuz kaynakları veya projenin tamamını silebilirsiniz. Google Cloud'un yeni kullanıcıları 300 ABD doları değerinde ücretsiz deneme programından yararlanabilir.

Cloud Shell'i başlatma

Google Cloud, dizüstü bilgisayarınızdan uzaktan çalıştırılabilir. Ancak bu codelab'de, Cloud'da çalışan bir komut satırı ortamı olan Google Cloud Shell'i kullanacaksınız.

Cloud Shell'i etkinleştirme

Cloud Console'da Cloud Shell'i etkinleştir 'i tıklayın.

Cloud Shell'i daha önce hiç başlatmadıysanız ne olduğunu açıklayan bir ara ekran (ekranın alt kısmı) gösterilir. Bu durumda Devam'ı tıkladığınızda bu ekranı bir daha görmezsiniz. Bu tek seferlik ekran aşağıdaki gibi görünür:

Cloud Shell'in temel hazırlığı ve bağlanması yalnızca birkaç dakikanızı alır.

Bu sanal makine, ihtiyaç duyduğunuz tüm geliştirme araçlarını içerir. 5 GB boyutunda kalıcı bir ana dizin bulunur ve Google Cloud'da çalışır. Bu sayede ağ performansı ve kimlik doğrulama önemli ölçüde güçlenir. Bu codelab'deki çalışmalarınızın neredeyse tamamını yalnızca bir tarayıcı veya Chromebook'unuzla yapabilirsiniz.

Cloud Shell'e bağlandıktan sonra kimliğinizin doğrulandığını ve projenin, proje kimliğinize ayarlandığını görürsünüz.

Kimliğinizin doğrulandığını onaylamak için Cloud Shell'de şu komutu çalıştırın:

gcloud auth list

Komut çıkışı

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

gcloud komutunun projeniz hakkında bilgi sahibi olduğunu onaylamak için Cloud Shell'de aşağıdaki komutu çalıştırın:

gcloud config list project

Komut çıkışı

[core]
project = <PROJECT_ID>

Değilse şu komutla ayarlayabilirsiniz:

gcloud config set project <PROJECT_ID>

Komut çıkışı

Updated property [core/project].

3. Cloud Shell'de ASP.NET Core uygulaması oluşturma

Cloud Shell isteminde, sürümünü kontrol ederek dotnet komut satırı aracının zaten yüklü olduğunu doğrulayabilirsiniz. Bu komut, yüklü dotnet komut satırı aracının sürümünü yazdırmalıdır:

dotnet --version

Ardından yeni bir iskelet ASP.NET Core web uygulaması oluşturun.

dotnet new mvc -o HelloWorldAspNetCore

Bu komut bir proje oluşturur ve projenin bağımlılarını yeniler. Aşağıdakine benzer bir mesaj görürsünüz.

Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.

Restore succeeded.

4. ASP.NET Core uygulamasını çalıştırma

Uygulamamızı çalıştırmaya neredeyse hazırız. Uygulama klasörüne gidin.

cd HelloWorldAspNetCore

Son olarak uygulamayı çalıştırın.

dotnet run --urls=http://localhost:8080

Uygulama, 8080 numaralı bağlantı noktasında dinlemeye başlar.

Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.

Uygulamanın çalıştığını doğrulamak için sağ üstteki web önizleme düğmesini tıklayın ve "8080 numaralı bağlantı noktasında önizle"yi seçin.

Varsayılan ASP.NET Core web sayfasını görürsünüz:

Uygulamanın çalıştığını doğruladıktan sonra Ctrl+C tuşlarına basarak uygulamayı kapatın.

5. ASP.NET Core uygulamasını Docker container'ı olarak paketleme

Ardından, uygulamanızı container olarak çalışmaya hazırlayın. İlk adım, kapsayıcıyı ve içeriğini tanımlamaktır.

Uygulamanın temel dizininde, Docker görüntüsünü tanımlamak için bir Dockerfile oluşturun.

touch Dockerfile

Sık kullandığınız düzenleyiciyi (vim, nano,emacs veya Cloud Shell'in kod düzenleyicisi) kullanarak Dockerfile dosyasına aşağıdakileri ekleyin.

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out

# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine-amd64 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Make sure the app binds to port 8080
ENV ASPNETCORE_URLS http://*:8080

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "HelloWorldAspNetCore.dll"]

Dockerfile'ınızda yer alan önemli bir yapılandırma, uygulamanın gelen trafiği dinlediği bağlantı noktasıdır (8080). Bu, ASP.NET Core uygulamalarının hangi bağlantı noktasının dinleneceğini belirlemek için kullandığı ASPNETCORE_URLS ortam değişkeni ayarlanarak gerçekleştirilir.

Bu Dockerfile kaydedin. Şimdi görüntüyü oluşturalım:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .

Bu işlem tamamlandıktan sonra (her şeyin indirilmesi ve ayıklanması biraz zaman alır) görüntünün oluşturulduğunu ve yerel olarak kaydedildiğini görebilirsiniz:

docker images

REPOSITORY                             TAG   
gcr.io/yourproject-XXXX/hello-dotnet   v1

Aşağıdaki komutla görüntüyü yerel olarak test edin. Bu komut, yeni oluşturduğunuz container görüntüsünden 8080 numaralı bağlantı noktasında yerel olarak bir Docker container'ı çalıştırır:

docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

Cloud Shell'in web önizleme özelliğinden tekrar yararlanın :

Screenshot from 2015-11-03 17:20:22.png

Varsayılan ASP.NET Core web sayfasını yeni bir sekmede görmelisiniz.

Uygulamanın yerel olarak bir Docker kapsayıcısında sorunsuz çalıştığını doğruladıktan sonra Ctrl-> C ile çalışan kapsayıcıyı durdurabilirsiniz.

Görüntü artık beklendiği gibi çalıştığına göre, her Google Cloud projesinden (ancak Google Cloud Platform'un dışından da) erişilebilen Docker görüntüleriniz için özel bir depo olan Google Container Registry'ye aktarabilirsiniz:

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

Her şey yolunda giderse kısa bir süre sonra kapsayıcı resminin Container Registry bölümünde listelendiğini görürsünüz. Bu noktada, Kubernetes'in erişebileceği ve birkaç dakika içinde göreceğiniz gibi düzenleyebileceği proje genelinde bir Docker görüntüsüne sahip olursunuz.

Merak ediyorsanız Google Cloud Storage'da depolanan kapsayıcı resimlerine şu bağlantıyı kullanarak göz atabilirsiniz: https://console.cloud.google.com/storage/browser/ (Sonuç olarak elde edilen bağlantı şu biçimde olmalıdır: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).

6. Kubernetes kümesi oluşturma

Tamam, artık GKE kümenizi oluşturmaya hazırsınız. Ancak bundan önce web konsolunun Google Kubernetes Engine bölümüne gidin ve sistemin başlatılmasını bekleyin (yalnızca birkaç saniye sürer).

Küme, Google tarafından yönetilen bir Kubernetes ana API sunucusundan ve bir dizi çalışma düğümünden oluşur. Çalışan düğümleri, Compute Engine sanal makineleridir.

Küme oluşturmak için Cloud Shell oturumunuzdaki gcloud KSA'yı kullanalım. Bölgenizi size yakın bir yere ayarlayın ( bölge listesi). Bu işlemin tamamlanması birkaç dakika sürer:

gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b

Sonunda, kümenin oluşturulduğunu görürsünüz.

Creating cluster hello-dotnet-cluster...done.
Created [https://container.googleapis.com/v1/projects/dotnet-atamel/zones/europe-west1-b/clusters/hello-dotnet-cluster].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-dotnet-cluster  europe-west1-b  1.10.7-gke.6

Artık Google Kubernetes Engine tarafından desteklenen, tam işlevli bir Kubernetes kümeniz olmalıdır:

Şimdi kendi container mimarisine alınmış uygulamanızı Kubernetes kümesine dağıtma zamanı. Bundan sonra kubectl komut satırını (Cloud Shell ortamınızda zaten ayarlanmış) kullanacaksınız. Bu codelab'in geri kalanında hem Kubernetes istemci hem de sunucu sürümünün 1.2 veya üzeri olması gerekir. kubectl version, komutun mevcut sürümünü gösterir.

7. Dağıtım oluşturun

Kubernetes kapsülü, yönetim ve ağ oluşturma amacıyla birbirine bağlı bir grup kapsayıcıdır. Tek bir kapsayıcı veya birden fazla kapsayıcı içerebilir. Burada, özel kapsayıcı kayıt defterinizde depolanan ASP.NET Core görüntünüzle oluşturulmuş tek bir kapsayıcı kullanmanız yeterlidir. 8080 numaralı bağlantı noktasında içerik sunar.

En sevdiğiniz düzenleyiciyi (vim, nano,emacs veya Cloud Shell'in kod düzenleyicisi) kullanarak bir hello-dotnet.yaml dosyası oluşturun ve pod için Kubernetes dağıtımını tanımlayın:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: hello-dotnet
  template:
    metadata:
      labels:
        run: hello-dotnet
    spec:
      containers:
      - name: hello-dotnet
        image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

kubectl ile varsayılan ad alanına dağıtın:

kubectl apply -f hello-dotnet.yaml

deployment.apps/hello-dotnet created

Gördüğünüz gibi bir deployment (dağıtım) nesnesi oluşturdunuz. Dağıtımlar, pod oluşturmak ve ölçeklendirmek için önerilen yöntemdir. Burada, hello-dotnet:v1 görüntüsünü çalıştıran tek bir kapsül replikası yeni bir Dağıtım tarafından yönetilir.

Yeni oluşturduğunuz dağıtımı görüntülemek için şu komutu çalıştırın:

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   1         1         1            1           37s

Dağıtım tarafından oluşturulan pod'u görüntülemek için şu komutu çalıştırın:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-ztzrb   1/1       Running   0          57s

Şimdi bazı ilginç kubectl komutlarını incelemek için iyi bir zaman (bunların hiçbiri kümenin durumunu değiştirmez, tam belgeler burada mevcuttur):

kubectl get pods
kubectl cluster-info
kubectl config view
kubectl get events
kubectl logs <pod-name>

Bu noktada, kapsayıcınız Kubernetes'in kontrolü altında çalışıyor olmalıdır ancak yine de dış dünyaya erişilebilir hale getirmeniz gerekir.

8. Harici trafiğe izin ver

Pod'a varsayılan olarak yalnızca küme içindeki dahili IP'si üzerinden erişilebilir. hello-dotnet kapsayıcısının Kubernetes sanal ağı dışından erişilebilir olması için pod'u Kubernetes hizmeti olarak kullanıma açmanız gerekir.

Cloud Shell'den, kubectl expose komutunu --type="LoadBalancer" işaretiyle birlikte kullanarak pod'u herkese açık internete sunabilirsiniz. Bu işaret, harici olarak erişilebilen bir IP oluşturmak için gereklidir :

kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080

Bu komutta kullanılan işaret, temel altyapı tarafından sağlanan yük dengeleyiciyi (bu örnekte Compute Engine yük dengeleyici) kullanacağınızı belirtir. Doğrudan pod'u değil, dağıtımı kullanıma sunduğunuzu unutmayın. Bu işlem, sonuçtaki hizmetin trafiği dağıtım tarafından yönetilen tüm pod'lar arasında yük dengelemesine neden olur (bu durumda yalnızca 1 pod vardır ancak daha sonra daha fazla kopya ekleyeceksiniz).

Kubernetes ana makinesi, hizmetin Google Cloud Platform dışından tam olarak erişilebilir olması için yük dengeleyiciyi ve ilgili Compute Engine yönlendirme kurallarını, hedef havuzlarını ve güvenlik duvarı kurallarını oluşturur.

Hizmetin herkese açık IP adresini bulmak için kubectl ile tüm küme hizmetlerinin listelenmesini isteyin:

kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-dotnet 10.3.253.62   104.155.20.69   8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Hizmetiniz için 2 IP adresinin listelendiğini ve her ikisinin de 8080 bağlantı noktasına hizmet verdiğini unutmayın. Biri yalnızca bulut sanal ağınızda görünen dahili IP, diğeri ise harici yük dengeli IP'dir. Bu örnekte, harici IP adresi 104.155.20.69'dır.

Artık tarayıcınızı şu adrese yönlendirerek hizmete ulaşabilirsiniz: http://<EXTERNAL_IP>:8080

Bu noktada, container'lara ve Kubernetes'e geçerek en azından birkaç özellik kazanmış olursunuz. İş yükünüzü hangi ana makinede çalıştıracağınızı belirtmeniz gerekmez. Ayrıca hizmet izleme ve yeniden başlatma özelliklerinden de yararlanabilirsiniz. Yeni Kubernetes altyapınızdan başka hangi avantajları elde edebileceğinize bakalım.

9. Hizmetinizi ölçeklendirme

Kubernetes'in sunduğu güçlü özelliklerden biri, uygulamanızı ölçeklendirmenin ne kadar kolay olduğudur. Uygulamanız için aniden daha fazla kapasiteye ihtiyacınız olduğunu varsayalım. Bu durumda, replikasyon denetleyicisine, pod'unuz için yeni bir replika sayısı yönetmesini söylemeniz yeterlidir:

kubectl scale deployment hello-dotnet --replicas=4

kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         4         4            3           16m

kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m
hello-dotnet-714049816-sh812   1/1       Running   0          1m
hello-dotnet-714049816-ztzrb   1/1       Running   0          16m

Burada bildirime dayalı yaklaşım kullanıldığını unutmayın. Yeni örnekleri başlatmak veya durdurmak yerine, her zaman kaç örneğin çalışması gerektiğini bildirirsiniz. Kubernetes uzlaştırma döngüleri, gerçekliğin istediğinizle eşleştiğinden emin olur ve gerekirse işlem yapar.

Kubernetes kümenizin durumunu özetleyen bir şema aşağıda verilmiştir:

Ayrıca hizmetinizin ölçeğini çok kolay bir şekilde azaltabilirsiniz. 4 poddan 2 poda nasıl ölçeği azaltacağınız aşağıda açıklanmıştır.

kubectl scale deployment hello-dotnet --replicas=2

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

10. Dayanıklılığı Test Etme

Kubernetes (daha doğrusu ReplicaSet) kapsüllerinizi izler ve kapsülde bir sorun varsa ve kapsül çökerse hemen yeni bir kapsül oluşturur. Bunu test edip nasıl çalıştığını görelim.

Öncelikle pod'ların listesini alın:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

Kapsül adını ileterek kapsüllerden birini silin:

kubectl delete pod hello-dotnet-714049816-g4azy

Kapsül listesine tekrar baktığınızda yeni bir kapsülün oluşturulduğunu ve hemen tekrar çalıştığını görürsünüz:

kubectl get pods

NAME                         READY     STATUS           RESTARTS   AGE
hello-dotnet-714049816-abczy   1/1    ContainerCreating  0          1m
hello-dotnet-714049816-rk0u6   1/1    Running            0          1m

11. Hizmetinizde yükseltme yayınlama

Üretime dağıttığınız uygulama, bir noktada hata düzeltmeleri veya ek özellikler gerektirecektir. Bu sürecin nasıl göründüğüne bakalım.

Öncelikle uygulamayı değiştirelim. Cloud Shell'den kod düzenleyiciyi açın.

HelloWorldAspNetCore > Views > Home bölümündeki Index.cshtml seçeneğine gidin ve bant mesajlarından birini güncelleyin.

Aşağıdaki satırı bulun:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core

Şu şekilde değiştirin:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud

Değişiklikleri kaydedip Cloud Shell'e geri dönün. HelloWorldAspNetCore,Docker görüntüsünü oluşturun:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .

Ve Container Registry'ye aktarın:

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2

Artık Kubernetes'in, Replication Controller'ınızı uygulamanın yeni sürümüne sorunsuz bir şekilde güncellemesine hazırsınız. Çalışan kapsayıcınızın resim etiketini değiştirmek için mevcut hello-dotnet deployment öğesini düzenlemeniz ve resmi gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 öğesinden gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 öğesine değiştirmeniz gerekir.

Bunun için kubectl edit komutunu kullanırsınız. Bu işlem, tam dağıtım yaml yapılandırmasını gösteren bir metin düzenleyici açar. Şu anda tam yaml yapılandırmasını anlamanız gerekmez. Bunun yerine, yapılandırmadaki spec.template.spec.containers.image alanını güncelleyerek dağıtıma, pod'ları yeni görüntüyü kullanacak şekilde güncellemesini söylediğinizi anlamanız yeterlidir.

kubectl edit deployment hello-dotnet

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  creationTimestamp: 2017-01-06T10:05:28Z
  generation: 3
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
  resourceVersion: "151017"
  selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-dotnet
  uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
  replicas: 4
  selector:
    matchLabels:
      run: hello-dotnet
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: hello-dotnet
    spec:
      containers:
      - image: gcr.io/PROJECT_ID/hello-dotnet:v1 # Update this line
        imagePullPolicy: IfNotPresent
        name: hello-dotnet
        ports:
        - containerPort: 8080
          protocol: TCP
        resources: {}
        terminationMessagePath: /dev/termination-log
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      securityContext: {}
      terminationGracePeriodSeconds: 30

Değişikliği yaptıktan sonra dosyayı kaydedip kapatın (vi kullanıldığından "Esc" tuşuna basın, ardından :wq yazıp "Enter" tuşuna basın).

deployment "hello-dotnet" edited

Bu işlem, dağıtımı yeni görüntüyle güncelleyerek yeni kapsüllerin yeni görüntüyle oluşturulmasına ve eski kapsüllerin silinmesine neden olur.

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         5         4            3           1h

Bu işlem sırasında hizmet kullanıcıları herhangi bir kesinti görmemelidir. Bir süre sonra uygulamanızın yeni sürümüne erişmeye başlarlar.

Periyodik güncellemeler hakkında daha fazla bilgiyi Kubernetes belgelerinde bulabilirsiniz.

Umarız bu dağıtım, ölçeklendirme ve güncelleme özellikleriyle, ortamınızı (burada GKE/Kubernetes kümeniz) kurduktan sonra Kubernetes'in altyapıyı yönetmek yerine uygulamanıza odaklanmanıza yardımcı olacağı konusunda hemfikir olursunuz.

12. Cloud Build

Şimdiye kadar, normal Docker komutlarıyla (docker build ...) container'lar oluşturup görüntüyü manuel olarak Google Cloud Platform'un Container Registry'sine aktarıyorduk. Ayrıca, her iki adımı da Docker'ın yerel olarak yüklenmesine gerek kalmadan kapsayıcı görüntüsünü oluşturup aktarabilen sunucu tarafı Cloud Build'e ertelemek de mümkündür.

Öncelikle API Yöneticisi > Kitaplık'ta Cloud Build API'yi etkinleştirin. Cloud Build'u arayın ve Cloud Build API'yi tıklayın:

Henüz etkinleştirilmemişse API'yi etkinleştir'i tıklayın. Sonunda, API'nin aşağıdaki gibi etkinleştirildiğini görmeniz gerekir:

Cloud Build API etkinleştirildikten sonra, görüntünüzü Container Builder hizmetinden derleyip göndermek için aşağıdaki komutu çalıştırabilirsiniz:

$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3

Görüntü, Container Registry'de otomatik olarak depolanır.

13. Kubernetes grafik kontrol panelini çalıştırma

Kubernetes'in son sürümlerinde grafik web kullanıcı arayüzü (kontrol paneli) kullanıma sunuldu. Bu kullanıcı arayüzü, hızlı bir şekilde başlamanıza olanak tanır ve CLI'da bulunan bazı işlevleri, sistemle etkileşim kurmanın daha kolay ve keşfedilebilir bir yolu olarak etkinleştirir.

Kubernetes kümesi kontrol paneline erişimi yapılandırmak için Cloud Shell penceresinde şu komutları yazın :

gcloud container clusters get-credentials hello-dotnet-cluster \
    --zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}

kubectl proxy --port 8081

Ardından, 8081 bağlantı noktasına gitmek için Cloud Shell önizleme özelliğini tekrar kullanın:

Bu işlem sizi API uç noktasına yönlendirmelidir. "Yetkisiz" sayfası görebilirsiniz ancak bu konuda endişelenmenize gerek yoktur. Kontrol paneline gitmek için "?authuser=3" ifadesini kaldırıp "/ui" ile değiştirin.

Kubernetes grafik kontrol panelinin keyfini çıkarın ve bu paneli, container mimarisine alınmış uygulamaları dağıtmanın yanı sıra kümelerinizi izlemek ve yönetmek için kullanın.

Alternatif olarak, web konsolunda izlemek istediğiniz küme için "Bağlan" düğmesine bastığınızda verilen benzer talimatları kullanarak kontrol paneline bir geliştirme veya yerel makineden de erişebilirsiniz.

Kontrol panelini kullanmayı bitirdiğinizde proxy'yi durdurmak için Control + C tuşlarına basabilirsiniz. Kontrol paneli turuna katılarak Kubernetes kontrol paneli hakkında daha fazla bilgi edinin.

14. Günlük Kaydı

Kubernetes'te çalışan bir kapsayıcının günlüklerini almak için kubectl logs komutunu kullanabilirsiniz. Yönetilen Kubernetes kümelerini çalıştırmak için Google Kubernetes Engine'i kullandığınızda tüm günlükler otomatik olarak Google Cloud Logging'e yönlendirilir ve burada depolanır. Google Cloud Console'da Stackdriver → Logging → Logs'a giderek pod'lardan gelen tüm günlük çıkışlarını görebilirsiniz:

Günlük konsoluna girdikten sonra, STDOUT'tan toplanan tüm günlükleri görmek için GKE Container'a gidebilirsiniz:

Buradan, günlükleri daha ayrıntılı analiz için Google BigQuery'ye aktarabilir veya günlüğe dayalı uyarılar ayarlayabilirsiniz. Bu işlemi laboratuvar sırasında yapmayacağız.

15. Tebrikler!

ASP.NET Core ve Kubernetes ile ilgili bu basit başlangıç codelab'ini tamamladınız. Bu teknolojinin yalnızca yüzeyini inceledik. Kendi kapsülleriniz, replikasyon denetleyicileriniz ve hizmetlerinizle daha fazla keşif yapmanızı, ayrıca yayın durumu kontrollerini (durum denetimleri) incelemenizi ve doğrudan Kubernetes API'sini kullanmayı düşünmenizi öneririz.

Temizleme

İşte bu kadar. Kullanılan kaynakları temizleme zamanı (maliyetten tasarruf etmek ve iyi bir bulut kullanıcısı olmak için).

Dağıtımı (çalışan pod'ları da siler) ve hizmeti (harici yük dengeleyicinizi de siler) silin:

Öncelikle hizmeti ve dağıtımı silin. Bu işlem, harici yük dengeleyicinizi de siler:

kubectl delete service,deployment hello-dotnet

service "hello-dotnet" deleted
deployment "hello-dotnet" deleted

Ardından, kümenizi silin:

gcloud container clusters delete hello-dotnet-cluster --zone=europe-west1-b

The following clusters will be deleted.
 - [hello-dotnet-cluster] in [europe-west1-b]
Do you want to continue (Y/n)?  Y
Deleting cluster hello-dotnet-cluster...done.                                                                                                                                                                                            
Deleted [https://container.googleapis.com/v1/projects/<PROJECT_ID>/zones/europe-west1-b/clusters/hello-dotnet-cluster].

Bu işlem, kümeyi çalıştıran tüm Google Compute Engine örneklerini siler.

Son olarak, resimlerinizi barındıran Docker kayıt defteri depolama paketini silin:

gsutil ls

gs://artifacts.<PROJECT_ID>.appspot.com/

gsutil rm -r gs://artifacts.${GOOGLE_CLOUD_PROJECT}.appspot.com/
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Elbette projenin tamamını da silebilirsiniz ancak yaptığınız tüm faturalandırma ayarlarını kaybedersiniz (önce proje faturalandırmasını devre dışı bırakmanız gerekir). Ayrıca, bir projenin silinmesi, faturalandırmayı yalnızca mevcut faturalandırma dönemi sona erdikten sonra durdurur.

İşlediğimiz konular

Basit bir ASP.NET Core uygulamasını Docker container'ı olarak paketleme
Google Kubernetes Engine'de Kubernetes kümenizi oluşturma
ASP.NET Core uygulamanızı bir poda nasıl dağıtacağınız.
Harici trafiğin pod'unuza ulaşmasına nasıl izin verebilirsiniz?
Hizmetinizi nasıl ölçeklendireceğinizi ve yükseltme dağıtacağınızı öğrenin.
Kubernetes grafik kontrol panelini çalıştırma

Sonraki Adımlar

Kubernetes hakkında daha fazla bilgi edinin ( http://kubernetes.io/).
Google Cloud Platform'da Windows hakkında daha fazla bilgi edinin.
Google Cloud Platform'da.NET hakkında daha fazla bilgi edinin.
Google Cloud Platform'da SQL Server hakkında daha fazla bilgi edinin.
Cloud Tools for Visual Studio hakkında daha fazla bilgi edinin.
Cloud Tools for PowerShell hakkında daha fazla bilgi edinin.

Lisans

Bu çalışma, Creative Commons Attribution 2.0 Genel Amaçlı Lisans ile lisans altına alınmıştır.