Lingkungan - Sumber daya Kubernetes

Layanan Azure DevOps | Azure DevOps Server 2022 | Azure DevOps Server 2020

Tampilan sumber daya Kubernetes menunjukkan status objek dalam namespace layanan yang dipetakan ke sumber daya. Tampilan sumber daya juga melapisi keterlacakan alur sehingga Anda dapat melacak kembali dari objek Kubernetes ke alur, lalu kembali ke penerapan.

Gunakan sumber daya Kubernetes untuk menargetkan kluster Kubernetes di lingkungan untuk penyebaran. Gunakan alur untuk menyebarkan ke Azure Kubernetes Service (AKS) dan kluster dari penyedia cloud lainnya.

Anda dapat menggunakan sumber daya Kubernetes dengan kluster publik atau privat. Untuk informasi selengkapnya tentang cara kerja sumber daya, lihat sumber daya di YAML dan keamanan dengan sumber daya.

Gambaran Umum

Lihat keuntungan berikut menggunakan tampilan sumber daya Kubernetes dalam lingkungan:

• Keterlacakan alur - Tugas manifes Kubernetes, yang digunakan untuk penyebaran, menambahkan lebih banyak anotasi untuk menampilkan keterlacakan alur dalam tampilan sumber daya. Keterlacakan alur membantu mengidentifikasi organisasi, proyek, dan alur Azure DevOps yang berasal yang bertanggung jawab atas pembaruan yang dibuat pada objek dalam namespace layanan.

  

• Mendiagnosis kesehatan sumber daya - Status beban kerja dapat berguna untuk men-debug kesalahan atau regresi yang diperkenalkan dengan penyebaran baru dengan cepat. Misalnya, untuk imagePullSecrets yang tidak dikonfigurasi yang mengakibatkan kesalahan ImagePullBackOff, informasi status pod dapat membantu Anda mengidentifikasi akar penyebab masalah.

  

• Tinjau Aplikasi - Tinjau Aplikasi berfungsi dengan menyebarkan setiap permintaan pull dari repositori Git Anda ke sumber daya Kubernetes dinamis di bawah lingkungan. Peninjau dapat melihat tampilan perubahan tersebut dan bekerja dengan layanan dependen lainnya sebelum digabungkan ke cabang target dan disebarkan ke produksi.

Menggunakan Azure Kubernetes Service

ServiceAccount akan dibuat di kluster dan namespace yang Anda pilih saat Anda menggunakan Azure Kubernetes Service (AKS). Untuk kluster berkemampuan RBAC Kubernetes, RoleBinding juga dibuat untuk membatasi cakupan akun layanan yang dibuat ke namespace yang dipilih. Untuk kluster yang dinonaktifkan RBAC Kubernetes, ServiceAccount yang dibuat memiliki hak istimewa di seluruh kluster (di seluruh namespace).

Menambahkan sumber daya AKS Kubernetes

1. Di halaman detail lingkungan, pilih Tambahkan sumber daya dan pilih Kubernetes.

2. Pilih Azure Kubernetes Service di menu dropdown Penyedia.

3. Pilih langganan, kluster, dan namespace Layanan Azure (baru/yang sudah ada).

4. Pilih Validasi dan buat untuk membuat sumber daya Kubernetes.

5. Verifikasi bahwa Anda melihat kluster untuk lingkungan Anda. Anda akan melihat teks "Tidak pernah disebarkan" jika Anda belum menyebarkan kode ke kluster Anda.

   

Menggunakan akun layanan yang sudah ada

Azure Kubernetes Service memetakan sumber daya Kubernetes dalam lingkungan Anda ke namespace layanan.

Untuk informasi selengkapnya tentang menyiapkan koneksi layanan Kubernetes di luar lingkungan, lihat bagian koneksi layanan Kubernetes di Koneksi layanan.

Menambahkan sumber daya Kubernetes non-AKS

1. Di halaman detail lingkungan, pilih Tambahkan sumber daya dan pilih Kubernetes.

2. Pilih Penyedia generik (akun layanan yang sudah ada) untuk penyedia Anda.

3. Tambahkan nama kluster dan nilai namespace layanan.

4. Tambahkan URL server. Anda bisa mendapatkan URL dengan perintah berikut:

   kubectl config view --minify -o 'jsonpath={.clusters[0].cluster.server}'
   

5. Untuk mendapatkan objek rahasia.

   Kubernetes 1.22+

   Ganti service-account-name dengan nama akun Anda.

   kubectl get secret -n <namespace>  -o jsonpath='{.items[?(@.metadata.annotations.kubernetes\.io/service-account\.name==\"service-account-name\")]}'
   

   Jika Anda tidak mendapatkan apa-apa, lihat Membuat token API berumur panjang secara manual untuk ServiceAccount.

   Kubernetes 1.22 ke bawah:

   1. Menemukan nama rahasia akun layanan

   kubectl get serviceAccounts <service-account-name> -n <namespace> -o 'jsonpath={.secrets[*].name}'
   

   2. ganti <service-account-secret-name> dengan nilai dalam perintah sebelumnya dalam perintah ini

   kubectl get secret <service-account-secret-name> -n <namespace> -o json
   

6. Dapatkan objek rahasia menggunakan output dari langkah sebelumnya.

   kubectl get secret <service-account-secret-name> -n <namespace> -o json
   

7. Salin dan tempel objek Rahasia yang diambil dalam formulir JSON ke bidang Rahasia.

8. Pilih Validasi dan buat untuk membuat sumber daya Kubernetes.

Mereferensikan sumber daya Kubernetes Anda dalam alur

Jika Anda menggunakan Azure Kubernetes Service dan membangun alur YAML, cara term mudah untuk mengonfigurasi alur Anda adalah dengan menggunakan templat. Sambungkan ke repositori Anda dan pilih salah satu dari dua opsi Kubernetes Service berikut:

• Menyebarkan ke templat Azure Kubernetes Services
• Menyebarkan ke Kubernetes - Tinjau Aplikasi dengan Azure DevSpaces

Templat memungkinkan Anda menyiapkan Tinjau Aplikasi tanpa perlu menulis kode YAML dari awal atau membuat pengikatan peran eksplisit secara manual.

Menyiapkan Aplikasi Tinjauan

Dalam contoh berikut, pekerjaan penyebaran pertama dijalankan untuk cabang non-PR dan melakukan penyebaran terhadap sumber daya Kubernetes reguler di bawah lingkungan. Pekerjaan kedua hanya berjalan untuk cabang PR dan menyebarkan terhadap Tinjau sumber daya Aplikasi (namespace di dalam kluster Kubernetes) yang dihasilkan sesuai permintaan. Sumber daya diberi label dengan "Tinjau" dalam tampilan daftar sumber daya lingkungan. Tentukan variabel yang akan digunakan dalam alur. Jika Anda menggunakan templat Sebarkan ke Azure Kubernetes Services, variabel ini akan ditentukan untuk Anda.

# Build and push image to Azure Container Registry; Deploy to Azure Kubernetes Service
trigger:
- main

resources:
- repo: self

variables:

  # Container registry service connection established during pipeline creation
  dockerRegistryServiceConnection: '12345' # Docker service connection identifier
  envName: 'myEnv' # name of your environment
  imageRepository: 'name-of-image-repository' # name of image repository
  containerRegistry: 'mycontainer.azurecr.io' # path to container registry
  dockerfilePath: '**/Dockerfile'
  tag: '$(Build.BuildId)'
  imagePullSecret: 'my-app-secret' # image pull secret

  # Agent VM image name
  vmImageName: 'ubuntu-latest'

  # Name of the new namespace being created to deploy the PR changes.
  k8sNamespaceForPR: 'review-app-$(System.PullRequest.PullRequestId)'

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: Build
    displayName: Build
    pool:
      vmImage: $(vmImageName)
    steps:
    - task: Docker@2
      displayName: Build and push an image to container registry
      inputs:
        command: buildAndPush
        repository: $(imageRepository)
        dockerfile: $(dockerfilePath)
        containerRegistry: $(dockerRegistryServiceConnection)
        tags: |
          $(tag)

    - upload: manifests
      artifact: manifests

- stage: Production
  displayName: Deploy stage
  dependsOn: Build

  jobs:
  - deployment: Production
    condition: and(succeeded(), not(startsWith(variables['Build.SourceBranch'], 'refs/pull/')))
    displayName: Production
    pool:
      vmImage: $(vmImageName)
    environment: 
      name: $(envName).$(resourceName)
      resourceType: Kubernetes 
    strategy:
      runOnce:
        deploy:
          steps:
          - task: KubernetesManifest@0
            displayName: Create imagePullSecret
            inputs:
              action: createSecret
              secretName: $(imagePullSecret)
              dockerRegistryEndpoint: $(dockerRegistryServiceConnection)

          - task: KubernetesManifest@0
            displayName: Deploy to Kubernetes cluster
            inputs:
              action: deploy
              manifests: |
                $(Pipeline.Workspace)/manifests/deployment.yml
                $(Pipeline.Workspace)/manifests/service.yml
              imagePullSecrets: |
                $(imagePullSecret)
              containers: |
                $(containerRegistry)/$(imageRepository):$(tag)

  - deployment: DeployPullRequest
    displayName: Deploy Pull request
    condition: and(succeeded(), startsWith(variables['Build.SourceBranch'], 'refs/pull/'))
    pool:
      vmImage: $(vmImageName)

    environment: 
      name: $(envName).$(resourceName)
      resourceType: Kubernetes
    strategy:
      runOnce:
        deploy:
          steps:
          - reviewApp: default

          - task: Kubernetes@1
            displayName: 'Create a new namespace for the pull request'
            inputs:
              command: apply
              useConfigurationFile: true
              inline: '{ "kind": "Namespace", "apiVersion": "v1", "metadata": { "name": "$(k8sNamespaceForPR)" }}'

          - task: KubernetesManifest@0
            displayName: Create imagePullSecret
            inputs:
              action: createSecret
              secretName: $(imagePullSecret)
              namespace: $(k8sNamespaceForPR)
              dockerRegistryEndpoint: $(dockerRegistryServiceConnection)

          - task: KubernetesManifest@0
            displayName: Deploy to the new namespace in the Kubernetes cluster
            inputs:
              action: deploy
              namespace: $(k8sNamespaceForPR)
              manifests: |
                $(Pipeline.Workspace)/manifests/deployment.yml
                $(Pipeline.Workspace)/manifests/service.yml
              imagePullSecrets: |
                $(imagePullSecret)
              containers: |
                $(containerRegistry)/$(imageRepository):$(tag)

          - task: Kubernetes@1
            name: get
            displayName: 'Get services in the new namespace'
            continueOnError: true
            inputs:
              command: get
              namespace: $(k8sNamespaceForPR)
              arguments: svc
              outputFormat: jsonpath='http://{.items[0].status.loadBalancer.ingress[0].ip}:{.items[0].spec.ports[0].port}'

          # Getting the IP of the deployed service and writing it to a variable for posting comment
          - script: |
              url="$(get.KubectlOutput)"
              message="Your review app has been deployed"
              if [ ! -z "$url" -a "$url" != "http://:" ]
              then
                message="${message} and is available at $url.<br><br>[Learn More](https://aka.ms/testwithreviewapps) about how to test and provide feedback for the app."
              fi
              echo "##vso[task.setvariable variable=GITHUB_COMMENT]$message"

Untuk menggunakan pekerjaan ini dalam alur yang ada, koneksi layanan yang mendukung sumber daya lingkungan Kubernetes reguler harus dimodifikasi menjadi "Gunakan kredensial admin kluster". Jika tidak, pengikatan peran harus dibuat untuk akun layanan yang mendasar ke namespace Tinjau Aplikasi.

Langkah berikutnya

Artikel terkait

• Sebarkan
• Menyebarkan aplikasi ASP.NET Core ke Azure Kubernetes Service dengan Azure DevOps Starter
• REST API: Kubernetes dengan Azure DevOps