Bu sayfa, Cloud Translation API ile çevrilmiştir.

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şturmaya yönelik yeni bir açık kaynak ve platformlar arası çerçevedir.

Kubernetes, dizüstü bilgisayarlardan yüksek kullanılabilirliğe sahip çok düğümlü kümelere, herkese açık bulutlardan şirket içi dağıtımlara ve sanal makinelerden bare metal'e kadar birçok farklı ortamda çalışabilen açık kaynaklı bir projedir.

Bu laboratuvarda, Kubernetes Engine'de çalışan Kubernetes'e basit bir ASP.NET Core uygulaması dağıtacaksınız. Bu codelab'de, Google Cloud Shell'de ASP.NET Core uygulamasını derleme ve başlatma codelab'i temel alınmıştır. Bu laboratuvara başlamadan önce ilgili laboratuvarı gerçekleştirmeniz önerilir.

Bu codelab'in amacı, kodunuzu (buradaki basit Hello World ASP.NET Core uygulaması) Kubernetes'te çalışan çoğaltılmış bir 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, ardından görüntüyü Google Kubernetes Engine'de çalıştırırsınız.

Parçaların nasıl bir araya geldiğini anlamanıza yardımcı olmak için bu codelab'deki çeşitli bölümlerin şemasını aşağıda bulabilirsiniz. Codelab'de ilerlerken bu belgeyi referans olarak kullanın. sonuna kadar tüm bunların anlamlı olması gerekir (ancak şu an için bunu göz ardı edebilirsiniz).

Bu codelab'de, Kubernetes Engine (Compute Engine'de çalışan Kubernetes'in Google tarafından barındırılan bir sürümü) gibi yönetilen bir ortam kullanarak temel altyapıyı kurmak yerine Kubernetes'i deneyimlemeye daha fazla odaklanabilirsiniz.

Kubernetes'i geliştirme dizüstü bilgisayarı gibi yerel makinenizde çalıştırmak istiyorsanız Minikube'yi incelemenizi öneririz. Bu özellik, geliştirme ve test amacıyla tek düğümlü Kubernetes kümesinin basit şekilde kurulumunu sunar. İsterseniz bu codelab'i tamamlamak için Minikube'yi kullanabilirsiniz.

Neler öğreneceksiniz?

Basit bir ASP.NET Core uygulamasını Docker container'ı olarak paketleme.
Google Kubernetes Engine'de (GKE) Kubernetes kümenizi oluşturma.
ASP.NET Core uygulamanızı kapsüle dağıtma.
Kapsülünüze harici trafiğe izin verme.
Hizmetinizin ölçeğini artırma ve yükseltmeyi kullanıma sunma
Kubernetes Grafik kontrol panelini çalıştırma

Gerekenler

Chrome veya Firefox gibi bir tarayıcı

Bu eğiticiden nasıl yararlanacaksınız?

Yalnızca okuma

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

Google Cloud Platform deneyiminizi nasıl değerlendirirsiniz?

Acemi

Orta

Yeterli

2. Kurulum ve Gereksinimler

Kendi hızınızda ortam kurulumu

Google Cloud Console'da oturum açıp 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. İstediğiniz zaman güncelleyebilirsiniz.
Proje Kimliği, tüm Google Cloud projelerinde benzersiz olmalıdır ve değiştirilemez (belirlendikten sonra değiştirilemez). Cloud Console, otomatik olarak benzersiz bir dize oluşturur. bunun ne olduğunu umursamıyorsunuz. Çoğu codelab'de proje kimliğini (genellikle PROJECT_ID olarak tanımlanır) referans almanız gerekir. Oluşturulan kimliği beğenmezseniz rastgele bir kimlik daha oluşturabilirsiniz. Alternatif olarak, kendi ölçümünüzü deneyip mevcut olup olmadığına bakabilirsiniz. Bu adımdan sonra değiştirilemez ve proje süresince kalır.
Bilginiz için bazı API'lerin kullandığı üçüncü bir değer, yani Proje Numarası daha vardır. Bu değerlerin üçü hakkında daha fazla bilgiyi belgelerde bulabilirsiniz.

Sonraki adımda, Cloud kaynaklarını/API'lerini kullanmak için Cloud Console'da faturalandırmayı etkinleştirmeniz gerekir. Bu codelab'i çalıştırmanın maliyeti, yüksek değildir. Bu eğitim dışında faturalandırma yapılmaması için kaynakları kapatmak isterseniz oluşturduğunuz kaynakları silebilir veya projenin tamamını silebilirsiniz. Yeni Google Cloud kullanıcıları, 300 ABD doları değerindeki ücretsiz denemeden yararlanabilir.

Cloud Shell'i başlatma

Google Cloud dizüstü bilgisayarınızdan uzaktan çalıştırılabilse de 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 simgesini 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ında) gösterilir. Bu durumda Devam'ı tıklayın (bunu bir daha görmezsiniz). Tek seferlik ekran şöyle görünür:

Temel hazırlık ve Cloud Shell'e bağlanmak yalnızca birkaç dakika sürer.

İhtiyaç duyduğunuz tüm geliştirme araçları bu sanal makinede yüklüdür. 5 GB boyutunda kalıcı bir ana dizin sunar ve Google Cloud'da çalışarak ağ performansını ve kimlik doğrulamasını büyük ölçüde iyileştirir. Bu codelab'deki çalışmalarınızın tamamı olmasa bile büyük bir kısmı yalnızca bir tarayıcı veya Chromebook'unuzla yapılabilir.

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

Kimlik doğrulamanızın tamamlandığını onaylamak için Cloud Shell'de aşağıdaki 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 projenizi bildiğini onaylamak için Cloud Shell'de aşağıdaki komutu çalıştırın:

gcloud config list project

Komut çıkışı

[core]
project = <PROJECT_ID>

Doğru değilse aşağıdaki 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, Dotnet komut satırı aracının sürümünü kontrol ederek zaten yüklü olduğunu doğrulayabilirsiniz. Bu komut, yüklü Pointnet 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şturmalı ve projenin bağımlılarını geri yüklemelidir. 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ından 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 önizlemesi düğmesini tıklayıp "8080 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, uygulamayı kapatmak için Ctrl+C tuşlarına basın.

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

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

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

touch Dockerfile

Favori düzenleyicinizi (vim, nano,emacs veya Cloud Shell'in kod düzenleyicisini) kullanarak aşağıdakileri Dockerfile öğesine 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ıza dahil olan önemli yapılandırmalardan biri, uygulamanın gelen trafiği (8080) dinlediği bağlantı noktasıdır. Bu işlem, ASP.NET Core uygulamalarının hangi bağlantı noktasını dinleyeceğini belirlemek için kullandığı ASPNETCORE_URLS ortam değişkeni ayarlanarak gerçekleştirilir.

Bu Dockerfile öğesini kaydedin. Şimdi de 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 şeyi indirip ayıklaması biraz zaman alabilir), görüntünün yerel olarak oluşturulduğunu ve kaydedildiğini görebilirsiniz:

docker images

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

Yeni oluşturulan container görüntünüzden 8080 bağlantı noktası üzerinde yerel olarak bir Docker container'ı çalıştıran aşağıdaki komutla görüntüyü yerel olarak test edin:

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

Tekrar CloudShell'in Web önizlemesi özelliğinden yararlanın :

Ekran görüntüsü: 2015-11-03 17:20:22.png

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

Uygulamanın bir Docker container'ında yerel olarak düzgün çalıştığını doğruladıktan sonra, çalışan kapsayıcıyı Ctrl-> C tarihine kadar durdurabilirsiniz.

Görüntünün beklendiği gibi çalıştığına göre artık görüntüyü Google Container Registry'ye aktarabilirsiniz. Google Container Registry, tüm Google Cloud projelerinden (ancak Google Cloud Platform dışından) erişilebilen Docker görüntüleriniz için özel bir depodur.

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

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

Merak ederseniz, Google Cloud Storage'da depolanan container görüntülerinin arasında şu bağlantıyı izleyerek gezinebilirsiniz: https://console.cloud.google.com/storage/browser/ (Tam 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

Artık GKE kümenizi oluşturmaya hazırsınız. Ancak öncesinde web konsolunun Google Kubernetes Engine bölümüne gidin ve sistemin ilk kullanıma hazırlanmasını bekleyin (Bu işlem yalnızca birkaç saniye sürer).

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

Küme oluşturmak için CloudShell oturumunuzdaki gcloud KSA'yı kullanalım. Alt bölgenizi size yakın bir yere ayarlayın ( alt bölgelerin 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

Son adımda, kümenin oluşturulduğunu göreceksiniz.

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ümenizin olması gerekir:

Kendi container mimarisine alınmış uygulamanızı Kubernetes kümesine dağıtmanın zamanı geldi. Artık kubectl komut satırını (zaten Cloud Shell ortamınızda oluşturulmuş) kullanacaksınız. Bu codelab'in geri kalanı için hem Kubernetes istemcisi 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 pod, yönetim ve ağ iletişimi amaçlarıyla birbirine bağlı bir container grubudur. Bir veya birden fazla kapsayıcı içerebilir. Burada, özel container kayıt defterinizde depolanan ASP.NET Core görüntünüzle derlenen bir container'ı kullanmanız yeterlidir. 8080 numaralı bağlantı noktasında içerik sunar.

Favori düzenleyicinizi (vim, nano,emacs veya Cloud Shell'in kod düzenleyicisi) kullanarak bir hello-dotnet.yaml dosyası oluşturun ve kapsül 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 nesnesi oluşturdunuz. Kapsül oluşturmak ve ölçeklendirmek için önerilen yöntem dağıtımdır. Burada yeni bir dağıtım, hello-dotnet:v1 görüntüsünü çalıştıran tek bir kapsül replikasını yönetir.

Oluşturduğunuz dağıtımı görüntülemek için şu komutu çalıştırmanız yeterlidir:

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 kapsülü 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ı çalıştırmanın tam zamanı (bunların hiçbiri kümenin durumunu değiştirmez. Dokümanların tamamına buradan ulaşabilirsiniz):

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

Bu noktada, container'ınızı Kubernetes kontrolü altında çalıştırmakla birlikte dış dünyanın erişimine de açmanız gerekir.

8. Harici trafiğe izin ver

Varsayılan olarak kapsüle yalnızca küme içindeki dahili IP'si ile erişilebilir. hello-dotnet container'ına Kubernetes sanal ağının dışından erişilebilmesini sağlamak için kapsülü bir Kubernetes hizmeti olarak kullanıma sunmanız gerekir.

Cloud Shell'den kubectl expose komutunu --type="LoadBalancer" işaretiyle birlikte kullanarak kapsülü herkese açık internette kullanıma sunabilirsiniz. Bu işaret, harici olarak erişilebilir bir IP oluşturmak için gereklidir :

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

Bu komutta kullanılan işaret, temel altyapı (bu örnekte Compute Engine yük dengeleyici) tarafından sağlanan yük dengeleyiciyi kullanacağınızı belirtir. Kapsülü doğrudan değil, dağıtımı kullanıma sunduğunuzu unutmayın. Bu durum, sonuçta elde edilen hizmetin, dağıtım tarafından yönetilen tüm kapsüllerde trafik yükünü dengelemesine neden olur (Bu durumda yalnızca 1 kapsül olur ancak daha sonra daha fazla replika eklemeniz gerekir).

Ana Kubernetes, hizmeti Google Cloud Platform dışından tamamen erişilebilir hale getirmek için yük dengeleyiciyi ve ilgili Compute Engine iletim kurallarını, hedef havuzları ve güvenlik duvarı kurallarını oluşturur.

Hizmetin herkesin erişebileceği IP adresini bulmak için kubectl sağlayıcısından 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 listelenen ve her ikisi de 8080 bağlantı noktası olmak üzere 2 IP adresi bulunduğunu unutmayın. Bunlardan biri, yalnızca bulut sanal ağınızda görünen dahili IP'dir. diğeri ise harici yük dengeli IP'dir. Bu örnekte, harici IP adresi 104.155.20.69 şeklindedir.

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

Bu noktada, container'lara ve Kubernetes'e geçerek en azından bir dizi özellik kazandınız. İş yükünüzü hangi ana makinede çalıştıracağınızı belirtmeniz gerekmez, ayrıca hizmet izleme ve yeniden başlatma avantajlarından yararlanabilirsiniz. Yeni Kubernetes altyapınızdan başka neler yapabileceğinizi görelim.

9. Hizmetinizi ölçeklendirme

Kubernetes'in sunduğu güçlü özelliklerden biri de uygulamanızı ölçeklendirmenin kolay olmasıdır. Uygulamanız için aniden daha fazla kapasiteye ihtiyaç duyduğunuzu varsayalım. replika denetleyicisine kapsülünüz için yeni sayıda replika yönetmesini söyleyebilirsiniz:

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

Buradaki bildirim temelli yaklaşımı göz önünde bulundurun. Yeni örnekleri başlatmak veya durdurmak yerine, her zaman kaç örneğin çalışması gerektiğini siz bildirirsiniz. Kubernetes mutabakat döngüleri, yalnızca gerçeğin istediğinizle eşleştiğinden emin olur ve gerekirse işlem yapar.

Aşağıda, Kubernetes kümenizin durumunu özetleyen bir şema görebilirsiniz:

Ayrıca hizmetinizi oldukça kolay bir şekilde ölçeklendirebilirsiniz. Ölçeği 4 kapsülden 2 kapsüle nasıl indireceğiniz 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. Test Esnekliği

Kubernetes (veya daha spesifik olarak ReplicaSet), kapsüllerinizi izler. Kapsülde bir sorun olup çöktüğünde hemen yeni bir kapsül oluşturur. Şimdi bunu test edip işleyiş şekline bakalım.

Öncelikle kapsüllerin 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 bakarsanız 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ükseltmeyi kullanıma sunma

Bir noktada, üretime dağıttığınız uygulama için hata düzeltmeleri veya ek özellikler gerekecek. Şimdi bu sürecin nasıl olduğuna bakalım.

İlk olarak uygulamayı değiştirelim. Cloud Shell'den kod düzenleyiciyi açın.

HelloWorldAspNetCore > Views > Home altında Index.cshtml bölümüne 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

Ardından ş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 kaydedin ve Cloud Shell'e geri dönün. Docker HelloWorldAspNetCore, görüntüsünün içinde:

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

Ardından Container Registry'ye aktarın:

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

Artık Kubernetes'i kullanarak çoğaltma denetleyicinizi uygulamanın yeni sürümüne sorunsuzca güncelleyebilirsiniz. Çalışan kapsayıcınızın görüntü etiketini değiştirmek için mevcut hello-dotnet deployment öğesini düzenlemeniz ve gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 olan görüntüyü gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 olarak değiştirmeniz gerekir.

Bunun için kubectl edit komutunu kullanmanız gerekir. Bu işlemle, tam dağıtım yaml yapılandırmasını gösteren bir metin düzenleyici açılır. Şu anda yaml yapılandırmasını tam olarak anlamanız gerekmez. Bunun yerine, yapılandırmadaki spec.template.spec.containers.image alanını güncelleyerek dağıtıma yeni görüntüyü kullanacak şekilde kapsülleri güncellemesini istediğinizi belirtmiş olursunuz.

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ı kaydedin ve kapatın (bu işlemde vi kullanılır, dolayısıyla "Esc" tuşuna basıp :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 durum yaşanırken hizmet kullanıcılarına herhangi bir kesinti yaşanmayacaktır. 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.

Bu dağıtım, ölçeklendirme ve güncelleme özellikleriyle ortamınızı (buradaki GKE/Kubernetes kümeniz) ayarladıktan sonra Kubernetes'in altyapıyı yönetmek yerine uygulamanıza odaklanmanıza yardımcı olabileceğini umuyoruz.

12. Cloud Build

Şu ana kadar normal Docker komutlarıyla (docker derlemesi ...) container'lar oluşturduk ve görüntüyü Google Cloud Platform'un Container Registry'sine manuel olarak aktardık. Ayrıca her iki adımı da sunucu tarafı Cloud Build'e erteleyebilirsiniz. Cloud Build, yerel Docker yüklemesi gerekmeden container görüntüsünü oluşturup aktarabilir.

İlk olarak API Yöneticisi > Kitaplık. Cloud Build'i arayın ve Cloud Build API'yi tıklayın:

Etkinleştirilmemişse API'yi etkinleştir'i tıklayın. En sonunda, API'nin aşağıdaki şekilde etkinleştirildiğini görürsünüz:

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

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

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

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

Kubernetes'in son sürümlerinde grafiksel web kullanıcı arayüzü (kontrol paneli) kullanıma sunulmuştur. Bu kullanıcı arayüzü, hızlı bir başlangıç yapmanıza olanak tanır ve KSA'da bulunan bazı işlevlerin, sistemle etkileşimde bulunmanın daha ulaşılabilir ve keşfedilebilir bir yolu olarak kullanılabilmesini sağlar.

Kubernetes kümesi kontrol paneline erişimi yapılandırmak için Cloud Shell penceresinden ş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 geçmek için Cloud Shell önizleme özelliğini tekrar kullanın:

Bunu yaptığınızda API uç noktasına yönlendirilirsiniz. "Yetkilendirilmemiş" dikkat edin. Kontrol paneline erişmek için şunu kaldırın: "?authuser=3" ve "/ui" ile değiştirin.

Kubernetes grafik kontrol panelini kullanarak container mimarisine alınmış uygulamaları dağıtmanın yanı sıra kümelerinizi izlemek ve yönetmek için de kullanabilirsiniz.

Alternatif olarak, Web konsolunda "Bağlan"a bastığınızda, sağlanan benzer talimatları kullanarak bir geliştirme veya yerel makineden kontrol paneline erişebilirsiniz düğmesini tıklayın.

Kontrol paneliyle işiniz bittiğinde, proxy'yi durdurmak için Control + C tuşlarına basın. Kontrol paneli turuna katılarak Kubernetes kontrol paneli hakkında daha fazla bilgi edinin.

14. Günlük Kaydı

Kubernetes içinde çalışan bir container'ı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 yönlendirilir ve Google Cloud Logging'de depolanır. Google Cloud konsolunda Stackdriver → Günlük Kaydı → Günlükler bölümüne giderek kapsüllerden alınan tüm günlük çıkışlarını görebilirsiniz:

Günlük kaydı konsoluna geldikten sonra GKE Container'ına giderek STDOUT'tan toplanan tüm günlükleri görebilirsiniz:

Buradan daha ayrıntılı günlük analizi için günlükleri Google BigQuery'ye aktarabilir veya günlük tabanlı uyarı ayarlayabilirsiniz. Bu işlemi bugünkü laboratuvarda yapmayacağız.

15. Tebrikler!

ASP.NET Core ve Kubernetes'i kullanarak bu basit başlangıç codelab'ini burada tamamlamış olduk. Bu teknolojinin henüz yeni temelini ele aldık. Kendi kapsülleriniz, replika denetleyicileriniz ve hizmetlerinizle daha fazla araştırma yapmanızı, ayrıca yayın durumu kontrollerini (durum denetimleri) kontrol etmenizi ve doğrudan Kubernetes API'yi kullanmayı düşünmeniz önerilir.

Temizleme

İşte bu kadar. Kullanılan kaynakları biraz temizlemenin zamanı geldi (maliyet tasarrufu yapmak ve iyi bir bulut vatandaşı olmak için).

Dağıtımı (çalışan kapsülleri de siler) ve hizmeti (bu işlem 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, görüntülerinizi 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 projeyi tamamen silebilirsiniz ancak yaptığınız faturalandırma ayarlarını kaybedersiniz (önce proje faturalandırmasının devre dışı bırakılması gerekir). Ayrıca, bir projeyi silmek yalnızca geçerli faturalandırma döngüsü sona erdikten sonra tüm faturalandırmaları durdurur.

İşlediklerimiz

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ı kapsüle dağıtma.
Kapsülünüze harici trafiğe izin verme.
Hizmetinizin ölçeğini artırma ve yükseltmeyi kullanıma sunma
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.