Document Center

    Container Service for Kubernetes

    • Bulletin
      • Announcement overview
      • [Product Changes] ACK API enhances user authentication
      • [System Restoration] ECS OpenAPI errors on February 23, 2021 are fixed
      • [Product Changes] Alibaba Cloud charges for professional Kubernetes clusters
      • [Product Changes] Optimize the navigation pane in the ACK console
      • ACK ends support for Kubernetes Dashboard
      • [Kubernetes Versions] ACK ends support for Kubernetes 1.12.6 and earlier
      • [Component Upgrades] Upgrade the cloud controller manager
      • [Component Upgrades] Upgrade CoreDNS
      • [Component Upgrades] Upgrade Helm V2 to V3
      • [Product Changes] ACK ends support for Swarm
      • [Component Upgrades] Upgrade Terway
      • [Kubernetes Versions] Release the support policy for Kubernetes versions
      • [Product Changes] Update the security policies for cluster authorizations
      • [System Restoration] The issue where data disks fail to be mounted to a multi-zone ACK cluster is fixed
      • [Product Changes] Alibaba Cloud charges for elastic container instances used by ASK clusters
      • [Product Changes] ACK reduces the permissions of worker RAM roles in managed Kubernetes clusters
      • Security bulletins
        • Vulnerability CVE-2021-25741 in Kubernetes
        • Vulnerability fixed: CVE-2021-25740
        • Vulnerability CVE-2021-25738
        • Vulnerability fixed: CVE-2021-25737
        • Vulnerability fixed: CVE-2021-30465
        • Vulnerability CVE-2021-3121
        • Vulnerability CVE-2020-8562
        • Vulnerability fixed: CVE-2021-25735
        • Vulnerability fixed: CVE-2021-1056 in NVIDIA GPU drivers
        • Vulnerability fixed: CVE-2020-8554
        • Vulnerability fixed: CVE-2020-15257
        • Vulnerability fixed: CVE-2018-18264 in Kubernetes Dashboard
        • Vulnerability fixed: CVE-2018-1002105 in Kubernetes
        • Announcement about fixing the runC vulnerability CVE-2019-5736
        • Vulnerability fix: CVE-2019-11246 related to kubectl cp
        • Announcement about fixing the CVE-2019-11249 vulnerability
        • Announcement about fixing the Kubernetes vulnerability CVE-2019-11253
        • Vulnerability fixed: CVE-2019-16276 in Golang
        • Vulnerability fixed: CVE-2019-1002101 in kubectl cp
        • Vulnerability fixed: CVE-2020-8555 in kube-controller-manager
        • Vulnerability fix: CVE-2020-8558
        • Vulnerability fixed: CVE-2020-13401
        • Vulnerability fixed: CVE-2020-8559 for kube-apiserver
        • Vulnerability fixed: CVE-2020-8557 for kubelet
        • Vulnerability updates: CVE-2020-14386
        • Vulnerability fix: CVE-2020-8564, CVE-2020-8565, and CVE-2020-8566
    • Release notes
      • Release notes
      • Kubernetes release notes
        • Overview of Kubernetes versions supported by ACK
        • Kubernetes 1.20 release notes
        • Kubernetes 1.18 release notes
        • Kubernetes 1.16 release notes
        • Kubernetes 1.12 release notes
      • Release notes for OS images
      • Release notes for Runtime
        • Release notes for containerd
        • Release notes for Docker
        • Release notes of Sandboxed-Container
      • System Component change Records
        • Core components
          • Kube API Server
          • Kube Controller Manager
          • Cloud Controller Manager
          • edge-controller-manager
        • Application management
          • appcenter
          • progressive-delivery-tool
          • OpenKruise
        • Logs and monitoring
          • alicloud-monitor-controller
          • ack-node-problem-detector
          • ack-node-repairer
          • logtail-ds
          • metrics-server
          • ack-arms-prometheus
          • ags-metrics-collector
          • logtail-windows
        • Storage
          • csi-plugin
          • csi-provisioner
          • storage-operator
          • alicloud-disk-controller
          • FlexVolume
          • csi-local-plugin
          • node-resource-manager
          • flexvolume-windows
        • Networking
          • Terway
          • Flannel
          • Nginx Ingress controller
          • kube-flannel-ds
          • ACK NodeLocal DNSCache
          • CoreDNS
          • kube-flannel-ds-windows
        • Security
          • aliyun-acr-credential-helper
          • kritis-validation-hook
          • security-inspector
          • gatekeeper
          • ack-kubernetes-webhook-injector
        • Other SQL statements
          • ack-arena
          • ack-kubernetes-cronhpa-controller
          • ack-virtual-node
          • sgx-device-plugin
          • Intel SGX AESM
          • sandboxed-container-controller
          • sandboxed-container-helper
          • yurt-app-manager
          • migrate-controller
          • aliyun-acr-acceleration-suite
          • managed-kube-proxy-windows
          • resource-controller
          • ack-cost-exporter
          • directx-device-plugin-windows
    • Product Introduction
      • What is Container Service for Kubernetes?
      • Benefits
      • Scenarios
      • Basic concepts
      • Supported regions
      • Limits
      • Open source projects
      • Kubernetes versions
    • Billing
    • Quick Start
      • Quick start
      • Basic operations
        • Create a managed Kubernetes cluster
        • Deploy a stateless application from an image
        • Use a StatefulSet to create a stateful application
        • Deploy WordPress from App Catalog
        • Deploy a WordPress application by using the Helm CLI
      • Advanced operations
        • Create an application by using a private image repository
    • User Guide for Kubernetes Clusters
      • ACK cluster overview
      • Quick start for first-time users
      • Authorization management
        • Authorization overview
        • Create a custom RAM policy
        • Assign RBAC roles to RAM users
        • ACK default roles
        • FAQ about authorization management
      • Cluster
        • Migrate to professional managed Kubernetes clusters
          • Hot migration from standard managed Kubernetes clusters to professional managed Kubernetes clusters
          • Hot migration from dedicated Kubernetes clusters to professional managed Kubernetes clusters
        • Operating system
          • CIS reinforcement
          • Use Alibaba Cloud Linux 2
        • Create Kubernetes clusters
          • Create a dedicated Kubernetes cluster
          • Create a managed Kubernetes cluster
          • Create a Kubernetes cluster by using a custom image
          • Generate API request parameters
        • Access clusters
          • Connect to ACK clusters by using kubectl
          • Use kubectl on Cloud Shell to manage ACK clusters
          • Cluster access control
            • Configure network ACLs for the API server of an ACK cluster
            • Control public access to the API server of a cluster
            • Revoke a KubeConfig credential
          • More connection methods
            • Connect to the master nodes of a dedicated Kubernetes cluster by using SSH
            • Use service account tokens to access ACK clusters
        • Manage clusters
          • View cluster information
          • Cluster certificates
            • Renew cluster certificates
            • Renew expiring Kubernetes cluster certificates
            • Update expired certificates of a Kubernetes cluster
          • Upgrade the Kubernetes version of an ACK cluster
          • Expand an ACK cluster
          • Install the metrics-server component
          • Delete an ACK cluster
        • Use the global check feature to troubleshoot cluster issues
        • Use the cluster diagnosis feature to troubleshoot cluster issues
        • FAQ about cluster management
      • Professional Kubernetes clusters
        • Introduction to professional managed Kubernetes clusters
        • Create a professional managed Kubernetes cluster
        • Topology-aware CPU scheduling
        • Topology-aware GPU scheduling
        • cGPU Professional Edition
        • Task scheduling
        • Use load-aware pod scheduling
        • Use KMS to encrypt Kubernetes Secrets
        • Customize the parameters of control plane components in professional Kubernetes clusters
      • Node management
        • Node
          • Add existing ECS instances to an ACK cluster
          • Monitor nodes
          • Manage node labels
          • Set node schedulability
          • Manage nodes in batches
          • Upgrade the configurations of a master node
          • Upgrade worker node configurations
          • Mount a data disk to the Docker data directory
          • Mount a data disk to a node
          • Manage taints
          • Collect diagnostic logs
          • View node resource request rate and usage
          • View nodes
          • Remove a node
        • Node pool management
          • Node pool overview
          • Manage node pools
          • Schedule an application to a specific node pool
          • Set the ratio of preemptible instances to pay-as-you-go instances
          • Check whether a preemptible instance is about to expire
          • Check the scalability of a node pool
        • Managed node pools
          • Overview
          • Manage managed node pools
          • Schedule an application pod to a specified node pool
        • FAQ about node management
      • Network
        • Overview
        • Plan CIDR blocks for an ACK cluster
        • Container network
          • Use the Terway plug-in
          • Increase the number of vSwitches in a cluster that uses the Terway plug-in
          • Add a vSwitch to a cluster based on a secondary CIDR block
          • Use network policies
          • Use the host network
          • Associate an EIP with a pod
          • Configure multiple route tables for a VPC
          • Enable an existing ACK cluster to access the Internet by using SNAT
          • FAQ about container networks
        • Service Management
          • Considerations for configuring a LoadBalancer type Service
          • Use annotations to configure load balancing
          • Use an existing SLB instance to expose an application
          • Use an automatically created SLB instance to expose an application
          • Manage Services
          • Service FAQ
        • Ingress management
          • Ingress overview
          • Create an Ingress
          • Nginx Ingress Management
            • Advanced Ingress configurations
            • Use Ingresses to implement canary releases and blue-green releases
            • Enable Tracing Analysis for Ingresses
            • Monitor nginx-ingress and analyze the access log of nginx-ingress
            • Deploy Ingress controllers in high-load scenarios
            • Deploy Ingresses in a high-reliability architecture
            • Configure an Ingress controller to use an internal-facing SLB instance
            • Deploy multiple Ingress controllers in a cluster
            • Use an Ingress controller to mirror network traffic
            • Use an Ingress controller to access gRPC services
          • ALB Ingress Management
          • Ingress FAQ
        • Service discovery DNS
          • Overview
          • Introduction and configuration of the DNS service in ACK clusters
          • Optimize DNS resolution for an ACK cluster
          • Use NodeLocal DNSCache in an ACK cluster
          • Use ACK CoreDNS DNSTAP Analyser to diagnose CoreDNS resolution errors
          • Precautions for upgrading CoreDNS
        • FAQ about network management
      • Application management
        • Workloads
          • Create a stateless application by using a Deployment
          • Use a StatefulSet to create a stateful application
          • Create a DaemonSet
          • Create a Job
          • Create a CronJob
          • Manage pods
          • Manage custom resources
        • Image
          • Introduction to kritis-validation-hook
          • Manage images
          • Use the aliyun-acr-credential-helper component to pull images without a password
          • Use kritis-validation-hook to automatically verify the signatures of container images
        • Configuration items and key
          • Manage ConfigMaps
          • Configure a pod to use a ConfigMap
          • Manage Secrets
          • Use a Secret in a pod
        • Application Scheduling Deployment
          • Schedule pods to specific nodes
          • Optimize pod scheduling by using descheduler
          • Use an application trigger to redeploy an application
          • Use Helm to simplify application deployment
          • Deploy, release, and monitor applications in the ACK console
        • FAQ about applications
      • Component
        • Component overview
        • Manage system components
        • FAQ about metrics-server
        • FAQ about ack-arms-prometheus
      • Storage management-CSI
        • CSI overview
        • Storage basics
        • Install and upgrade the CSI plug-in
        • Disk volumes
          • Disk volume overview
          • Use a statically provisioned disk volume
          • Use a dynamically provisioned disk volume
          • Expand a disk volume without service interruptions
          • Manually expand a disk volume
          • Automatically expand a disk volume (public preview)
          • Use volume snapshots created from disks
          • Encrypt a disk volume
          • FAQ about disk volumes
        • NAS volumes
          • NAS volume overview
          • Mount a statically provisioned NAS volume
          • Mount a dynamically provisioned NAS volume
          • Set quotas on the subdirectories of NAS volumes
          • FAQ about NAS volumes
        • OSS volumes
          • OSS volume overview
          • Mount a statically provisioned OSS volume
          • Encrypt an OSS volume
          • FAQ about OSS volumes
        • CPFS volumes
          • CPFS volume overview
          • Static volumes
          • Dynamically provisioned CPFS volumes
        • Local storage volumes
          • Overview
          • Use hostPath volumes
          • Use local volumes
          • Use LVs
          • Use memory volumes
        • AEP non-volatile storage volumes
          • Use AEP in ACK clusters
          • Use AEP non-volatile memory to improve read and write performance
          • Use AEP as direct memory to deploy a Redis database
        • Container Storage Monitoring
          • Use csi-plugin to monitor storage resources at the node side
          • Use storage-operator to monitor the storage resources of an ACK cluster
        • Container Storage O&M
          • Use Storage Operator to deploy and upgrade storage components
        • Container Network File System
          • CNFS overview
          • Use CNFS to manage NAS file systems
          • Use CNFS to automatically expand NAS volumes
          • Use CNFS to share a dynamically provisioned NAS volume
          • Use the recycle bin feature of CNFS to restore data
        • FAQ about CSI
      • Storage management-Flexvolume
        • FlexVolume overview
        • Install and upgrade FlexVolume
        • Disk volumes
          • Disk volume overview
          • Mount a statically provisioned disk volume
          • Dynamically provision a disk volume by using the CLI
          • Use a dynamically provisioned disk volume in the ACK console
          • Use statically provisioned disk volumes for persistent storage
          • Use dynamically provisioned disks for stateful applications
          • Use FlexVolume to dynamically expand a disk volume in ACK
          • Manually expand a disk volume
          • FAQ about disk volumes
        • NAS volumes
          • NAS volume overview
          • Mount a statically provisioned NAS volume
          • Mount a dynamically provisioned NAS volume
          • Use NAS volumes for shared persistent storage
          • FAQ about NAS volumes
        • OSS volumes
          • OSS volume overview
          • Mount a statically provisioned OSS volume
          • Use OSS volumes for persistent storage
          • FAQ about OSS volumes
        • CPFS volumes
          • Use CPFS volumes in ACK clusters
        • Create a PVC
        • Use a PVC
        • FAQ about FlexVolume
      • Security management
        • Security system overview
        • Infrastructure security
          • Access applications in an ACK cluster through HTTPS
          • Use cluster auditing
          • Enable service account token volume projection
          • Use pod security policies
          • Use security-inspector to audit the CIS Kubernetes Benchmark
          • Use ack-kubernetes-webhook-injector to dynamically add the IP address of a pod to the whitelists of Alibaba Cloud services
          • Customize the SAN of the API server certificate when you create an ACK cluster
        • Security
          • Configure and enforce pod security policies
          • Use the inspection feature to detect security risks in the workloads of an ACK cluster
          • Use the runtime security feature to monitor ACK clusters and configure alerts
        • FAQ about container security
      • Observability
        • Observability overview
        • Log management
          • Log overview
          • Collect log files from containers by using Log Service
          • Configure Log4jAppender for Kubernetes and Log Service
          • Collect the logs of control plane components in a managed Kubernetes cluster
          • Monitor CoreDNS and analyze the CoreDNS log
        • Monitoring management
          • Monitor basic resources
          • Monitor application performance
          • Event monitoring
          • Use Prometheus to monitor a Kubernetes cluster
          • Enable ARMS Prometheus
          • Ingress Dashboard
          • Implement network observability by using ACK Terway Hubble
          • Delete ARMS Prometheus and ACK Prometheus
        • Alert management
      • Cost analysis
        • Cluster cost analysis
      • Auto Scaling
        • Auto scaling overview
        • Auto scaling of nodes
        • HPA
        • CronHPA
        • Vertical pod autoscaling
        • Implement horizontal auto scaling based on Alibaba Cloud metrics
        • Use ECI elastic scheduling
        • ACK KEDA
        • FAQ about auto scaling
      • Release management
        • Use OpenKruise to deploy cloud-native applications
        • Use Ingresses to implement canary releases
        • Implement Layer 4 canary releases by using SLB instances
        • Manage releases by using Helm
      • Knative
        • Overview
        • Knative version release notes
          • Knative 0.18.3
        • Manage Knative components
          • Deploy Knative
          • Deploy a Knative component
          • Upgrade a Knative component
          • Collect log data of Knative components
          • Configure alerts for Knative components
          • Uninstall Knative components
          • Uninstall Knative from an ACK cluster
        • Manage Knative services
          • Use Knative to deploy serverless applications
          • Create a revision
          • Set a custom domain name for Knative Serving
          • Delete a revision
          • Delete a Knative Service
          • Deploy a canary release for a Knative Service
        • Knative event processing
          • Overview
          • Use Knative to manage GitHub events
          • Use Knative to manage MnsOss event sources
        • Best practices
          • Configure alerting on Knative
          • Collect application logs
          • Use elastic container instances in Knative
          • Use ARMS Prometheus to collect pod request-related metrics from a Knative Service
          • Use HPA in Knative
          • Enable automatic scaling for pods based on the number of requests
      • GPU/NPU
        • Create heterogeneous computing clusters
          • Create a managed Kubernetes cluster with GPU-accelerated nodes
          • Create a dedicated Kubernetes cluster with GPU-accelerated nodes
          • Create a Kubernetes cluster with NPU-accelerated nodes
          • Create a managed Kubernetes cluster with FPGA-acceleated nodes
        • GPU scheduling
          • Use GPU scheduling for ACK clusters
          • Use labels to schedule pods to GPU-accelerated nodes
          • Labels used by ACK to control GPUs
          • GPU topology-aware scheduling
            • Overview of topology-aware GPU scheduling
            • Install ack-ai-installer
            • Use topology-aware GPU scheduling to achieve optimal GPU acceleration for TensorFlow distributed jobs
            • Use topology-aware GPU scheduling to achieve optimal GPU acceleration for PyTorch distributed jobs
        • cGPU
          • cGPU overview
          • cGPU Basic Edition
            • Install ack-cgpu
            • Use cGPU
            • Monitor and isolate GPU resources
            • Disable the memory isolation capability of cGPU
            • Use node pools to control cGPU
          • cGPU Professional Edition
            • Install and use ack-ai-installer and the GPU inspection tool
            • Enable GPU sharing
            • Use cGPU to achieve GPU sharing based on multiple GPUs
            • Use node pools to control cGPU
            • Upgrade cGPU Basic Edition to cGPU Professional Edition in a professional Kubernetes cluster
        • Observability
          • Use the Kubernetes event center to monitor GPU errors
          • Use ARMS Prometheus to monitor the GPU resources of a Kubernetes cluster
        • Operations & Maintenance (O&M) Management
          • Upgrade the Docker runtime of a GPU node
          • Upgrade the cGPU version on a node
          • Troubleshoot issues in GPU monitoring
          • Use a node pool to create a node with a custom NVIDIA driver version
          • Use a node pool to upgrade the NVIDIA driver for a node
          • Manually upgrade the NVIDIA driver of a node
          • Fix the issue that the IDs of GPUs are changed after a GPU-accelerated ECS instance is restarted or replaced
          • Renew the NVIDIA driver license of a vGPU-accelerated instance in an ACK cluster
        • NPU resource scheduling
          • Perform NPU scheduling in a Kubernetes cluster
        • Use the MIG feature of NVIDIA A100 GPUs in an ACK cluster
        • GPU/NPU FAQ
      • Scheduling
        • Resource scheduling
          • Topology-aware CPU scheduling
          • Use resource-controller to dynamically modify the upper limit of resources for a pod
          • Use the L3 cache and MBA to improve the resource isolation of tasks with different priorities
          • Dynamically adjust resource water marks to improve the resource utilization of workloads with different priorities
        • GPU scheduling
        • FPGA scheduling
          • Use labels to schedule pods to FPGA-accelerated nodes
        • Workload scheduling
          • Gang scheduling
          • Capacity Scheduling
        • Node scheduling
          • Use ECI elastic scheduling
        • Load-aware pod scheduling
      • Namespace and Quotas
        • Manage namespaces
        • Set resource quotas and limits
      • Application Center
        • Application Center overview
        • Application management
          • Create an application from an orchestration template
          • Create an application by using a Git repository
          • Manage applications
        • Triggers
          • Trigger overview
          • Use a trigger to enable automatic application update
          • Use the Jenkins CI pipeline to enable automatic application update
        • Application releases across clusters
          • Use an orchestration template to deploy an application to multiple clusters
          • Perform canary releases of an application in clusters across regions
      • Application center
        • Overview
        • Install the Application Center controller
        • Configuration management
          • Configure a certificate
          • Connect to a repository
          • Add an ACK cluster to Application Center
        • Application management
          • Deploy an application in Application Center
          • View applications in Application Center
          • Update an application in Application Center
          • Roll back an application in Application Center
          • Delete an application from Application Center
        • Triggers
          • Overview
          • Manage triggers
          • Use triggers
        • Deploy and manage an application in clusters across regions
      • Disaster recovery center
        • Backup center overview
        • Enable cluster backup
        • Back up and restore applications
        • Migrate applications across clusters
      • Application marketplace
        • Container Registry
        • Template management
          • Create an orchestration template
          • Modify an orchestration template
          • Save an orchestration template as a new one
          • Download an orchestration template
          • Delete an orchestration template
        • App catalog management
          • Overview
          • View the application catalog
      • Virtual nodes and ECI
        • Deploy the virtual node controller and use it to create Elastic Container Instance-based pods
        • Configure an Elastic Container Instance profile
        • Use an elastic container instance to run a Job
        • Deploy applications that provide services by using Ingresses
        • Use ECI elastic scheduling
        • Enable a virtual node to discover Services by using Alibaba Cloud DNS PrivateZone
        • Install virtual-kubelet-autoscaler
        • Install the elastic workload component
      • Windows container
        • Create a Windows node pool
        • Create a Windows application
        • Use Logtail to collect application logs from Windows nodes
        • Mount disks and SMB file systems to Windows pods
        • Enable GPU acceleration for DirectX in Windows containers
      • Multi-cloud and hybrid cloud management
        • Overview of the multi-cloud and hybrid cloud solution
        • Management of external clusters
          • Overview of registered clusters
          • Create a cluster registration proxy and register an on-premises cluster
          • Create a hybrid cluster
          • Configure the Terway network plug-in
          • Create a script to add cluster nodes
          • Create and scale out a node pool
          • Configure auto scaling
          • Pull images without a password in a self-managed Kubernetes cluster
          • Create Elastic Container Instance-based pods by using ack-virtual-node in a self-managed Kubernetes cluster
        • Observability of external clusters
          • Enable Log Service for an external Kubernetes cluster
          • Create a Kubernetes event center for an external Kubernetes cluster
          • Set up alerting for an external Kubernetes cluster
          • Enable ARMS for an external Kubernetes cluster
          • Enable ARMS Prometheus for an external Kubernetes cluster
          • Deploy alibaba-cloud-metrics-adapter in an external Kubernetes cluster
          • Use the inspection feature to check for security risks in the workloads of a registered Kubernetes cluster
          • Use the cluster auditing feature in a registered Kubernetes cluster
        • FAQ about multi-cloud and hybrid cloud
      • Sandboxed-Container management
        • Sandboxed-Container overview
        • Differences between runC and runV
        • Comparison of Docker, containerd, and Sandboxed-Container
        • Benefits of Sandboxed-Container
        • Create a security sandbox cluster
          • Create a managed Kubernetes cluster that runs sandboxed containers
          • Create a dedicated Kubernetes cluster that runs sandboxed containers
        • Expand a cluster that runs sandboxed containers
        • Create an application that runs in sandboxed containers
        • Upgrade the Sandboxed-Container runtime
        • Security Sandbox configuration
          • Configure an ACK cluster that runs both sandboxed and Docker containers
          • Set kernel parameters for a sandboxed pod
        • Security Sandbox storage
          • Mount a NAS file system to a sandboxed container
          • Mount a disk to a sandboxed container
        • Compatibility notes
      • TEE-based confidential computing
        • TEE-based confidential computing
        • Create a managed Kubernetes cluster for confidential computing
        • Create a node pool that supports confidential computing
        • Use TEE SDK to develop and build Intel SGX 2.0 applications
        • Deploy confidential containers in TEE-based ACK clusters
        • Use confidential containers to implement remote attestation in TEE-based ACK clusters
    • User Guide for Serverless Kubernetes Clusters
      • ASK overview
      • Features
      • Quick start
        • ASK quick start
        • Deploy NGINX applications in ASK clusters
      • ECI Pod
        • Elastic Container Instance overview
        • Specify CPU and memory specifications to create an elastic container instance
        • Create an ECI from a specified ECS instance type
        • Use preemptible instances
        • Use GPU-accelerated ECIs
        • Use AMD instances
        • Use reserved instances
        • Create ECIs across zones
        • ECI Pod Annotation
        • Configure NTP for pods
        • Configure a time zone for a pod
        • View core dump files
      • Cluster
        • Create an ASK cluster
        • Create an ASK cluster by using Alibaba Cloud CLI
        • Delete an ASK cluster
        • Manage and access clusters
          • Use kubectl to connect to an ASK cluster
          • Use kubectl on Cloud Shell to manage ASK clusters
          • Access the Kubernetes API server over the Internet
        • Best practices
          • Assign CIDR blocks to resources in a Kubernetes cluster under a VPC
      • Images
        • Configure password-free access to pull images from a Container Registry Enterprise Edition instance
        • Use the image cache CRD to accelerate the pod creation process
      • Application
        • Manage applications by using a CLI
        • Create an application from an image
        • Create a Service
        • Delete a Service
        • View containers
        • View a Service
      • ConfigMaps and Secrets
        • Create a ConfigMap
      • Storage management-Flexvolume
        • Volume plug-ins
        • Overview
        • Install plug-ins
        • Disk volumes
          • Disk volume overview
          • Statically provision disks
          • Dynamically provision a disk volume by using the CLI
          • Dynamically provision disks in the ACK console
        • NAS volumes
          • Use NAS volumes
          • Statically provisioned NAS file systems
        • Create a PVC
        • Use a PVC
        • FAQ about FlexVolume
      • Storage management-CSI
        • Volume plug-ins
        • Overview
        • Install CSI
        • Disk volumes
          • Disk volume overview
          • Use a statically provisioned disk volume
          • Use a dynamically provisioned disk volume
          • Configure StorageClasses
        • NAS volumes
          • Overview
          • Mount a statically provisioned NAS volume
      • Network management
        • Service Management
          • Considerations for configuring a LoadBalancer type Service
          • Use annotations to configure load balancing
          • Use an existing SLB instance to expose an application
        • ALB Ingress Management
          • ALB Ingress overview
          • Manage the ALB Ingress controller
          • Access Services by using an ALB Ingress
        • SLB Ingress management
          • Overview
          • Manage SLB Ingress controllers
          • Use the automatically created SLB instance
          • Use an existing SLB instance
          • Use a Secret to configure TLS to enable HTTPS access
        • NGINX Ingress management
          • Overview
          • Install the NGINX Ingress controller
          • Basic operations of an Ingress
          • Advanced Ingress configurations
        • Best practices
          • Use the service discovery feature based on Alibaba Cloud DNS PrivateZone in ASK clusters
          • Configure a security group
      • Log management
        • Collect log files by using Log Service
        • Collect the log of a Job
        • Configure log collection for an elastic container instance
        • Parse user logs in the JSON format
      • Monitoring management
        • Enable ARMS for a serverless Kubernetes cluster
        • ARMS Prometheus
      • Knative
        • Overview
        • Knative community version
        • Knative version release notes
          • Knative 0.18.3
        • Knative version release notes
          • Knative 0.18.3
        • Component management
          • Enable Knative
          • Uninstall Knative components from an ACK cluster
        • Service management
          • Use Knative to deploy serverless applications
          • Knative Gateway
          • Add a custom route
          • Configure an SSL certificate
          • Reserved instances
          • Enable auto scaling to withstand traffic fluctuations
          • Use HPA in Knative
          • Configure schedule-based autoscaling in Knative
          • Use Knative to deploy a function as a Service
          • Deploy a canary release for a Knative Service
        • Knative Eventing
          • Overview
          • Deploy Knative Eventing
        • Best practices
          • Monitor the QPS, RT, and pod scaling trends of a Knative application
          • Monitor the CPU and memory usage of a Knative application
      • Serverless cluster best practices
        • Use ASK to run jobs
        • Use ASK to create Spark tasks
        • Associate an EIP with a pod
        • Deploy Jenkins in an ASK cluster and build an application delivery pipeline
        • Run a GPU-based TensorFlow training job
        • Run a Spark job in a Kubernetes cluster
        • Install and use WordPress
        • Run jobs on a preemptible instance
    • User Guide for Edge Container Service
      • ACK@Edge overview
      • Release notes on ACK@Edge
        • Release notes for ACK@Edge of Kubernetes 1.18
        • Release notes on ACK@Edge of Kubernetes 1.16
      • Edge cluster management
        • Create a managed edge Kubernetes cluster
        • Upgrade an edge cluster
        • Upgrade components in an edge Kubernetes cluster
        • Expand an edge cluster
        • ECS instances in an edge Kubernetes cluster
      • ACK@Edge Pro edition cluster
        • Introduction to professional edge Kubernetes clusters
        • Create a professional edge Kubernetes cluster
        • Resource scheduling
          • Gang scheduling
        • Use KMS to encrypt Kubernetes Secrets
        • Customize the settings of control plane components in professional edge Kubernetes clusters
      • Cell-based management at the edge
        • Overview of cell-based management at the edge
        • Manage edge node pools
          • Overview of edge node pools
          • Create an edge node pool
          • Add nodes to an edge node pool
          • Create an enhanced edge node pool
        • Use the UnitedDeployment controller to deploy applications
        • Configure a Service topology
      • Node management
        • Add an edge node
        • Configure node autonomy
        • Remove edge nodes
      • Application management
        • Network autonomy of edge nodes
        • Cloud-edge tunneling
        • Use LVM to manage local storage
    • User Guide for Genomics Service
      • AGS overview
      • AGS acceleration API
        • Use AGS to perform WGS tasks
        • Use AGS to analyze tumor samples
        • Use AGS to perform virus sequencing
        • AGS API reference
          • DescribeWorkflows
          • DescribeWorkflow
          • StartWorkflow
          • CancelWorkflow
          • RemoveWorkflow
      • AGS workflow
        • Create a workflow
        • Sample workflow templates
        • Enable the web-based workflow UI
        • Introduction to AGS CLI
        • AGS examples
        • Use AGS to speed up a workflow
      • WDL workflow
        • Create a WDL workflow
        • WDL examples
        • Use AGS to speed up a workflow
    • Cloud-native AI User Guide
      • Overview
      • Environment preparation
        • Deploy the cloud-native AI component set
        • Install Arena
        • Log on to cloud-native AI consoles by using LDAP
        • Configure external storage
          • Configure a shared NAS volume
          • Configure a shared CPFS volume
      • AI console usage guide
        • O&M
          • Access AI Dashboard
          • Work with AI dashboards
          • Manage users
          • Manage elastic quota groups
          • Manage datasets
          • View elastic jobs
        • Development
          • Log on to the AI development console
          • Configure datasets and source code repositories for a training job
          • Submit TensorFlow jobs and CronJobs
          • Create and use a Jupyter notebook
      • Elastic data set
        • Data acceleration
          • Overview of Fluid
          • Use JindoFS to accelerate access to OSS
          • Use JindoFS to accelerate ResNet-50 model training
      • Model training
        • Use Arena to submit standalone TensorFlow training jobs
        • Use Arena to submit distributed TensorFlow training jobs
        • Use Arena to submit standalone PyTorch training jobs
        • Use Arena to submit distributed PyTorch training jobs
        • Elastic training
      • Model-Based Reasoning
        • Submit an inference task to use shared GPU resources
        • Deploy a TensorFlow model as an inference service
        • Deploy a PyTorch model as an inference service
        • Elastic inference service
          • Elastic Container Instance-based elastic inference
          • Run elastic inference workloads on ECS instances
      • AI workload scheduling
      • Multi-tenant
        • Best practice for using Arena in a multi-tenancy scenario
    • Best Practices
      • Cluster
        • Select ECS instances to create the master and worker nodes of an ACK cluster
        • Recommended configurations for high reliability
        • Plan CIDR blocks for an ACK cluster
        • Increase the capacity of etcd for dedicated Kubernetes clusters
      • Network
        • Use AES to manage Ingresses
        • Use Ambassador to expose an application API
        • Improve the performance of the NetworkPolicy feature for a large ACK cluster in Terway mode
      • Storage
        • Enable a StatefulSet to support persistent storage
        • Use FlexVolume to enable a StatefulSet to support persistent storage
      • Operation and maintenance
        • Set up an LDAP authentication source for ACK
      • ESS
        • Use ack-autoscaling-placeholder to scale pods in seconds
        • Custom images
      • Istio
        • Use ASM to deploy an application in blue-green release mode and phased release mode
        • Use ASM to migrate TCP traffic
        • Enable distributed tracing in ASM
      • DevOps
        • Set up Jenkins to run pipeline jobs
        • Use GitLab CI to run a GitLab runner and run a pipeline on Kubernetes
        • Elastic and cost-effective CI/CD based on ASK
        • Use Bamboo to deploy a Bamboo agent in an ACK cluster and run a build plan
      • Migrate a self-built Kubernetes cluster to Container Service for Kubernetes
        • Before you start
        • Overview
        • Use a custom image to create an ACK cluster
        • Migrate source servers to Container Registry
        • Migrate container images
          • Use image-syncer to migrate container images
          • Synchronize images from a self-managed Harbor instance to Container Registry Default Instance Edition
          • Synchronize images from a self-managed Harbor project to Container Registry Enterprise Edition
        • Migrate applications to an ACK cluster
      • Migrate applications from a Swarm cluster to a Kubernetes cluster
        • Swarm cluster to Kubernetes Cluster features comparison
          • Overview
          • Concepts
          • Comparison of basic settings for creating an application from an image
          • Network configurations for deploying an application from an image
          • Volume and environment variables
          • Container configurations and labels for creating an application from an image
          • Health check and auto scaling configurations for creating an application from an image
          • YAML file configurations
          • Networks
          • Compare logging and monitoring in Container Service for Swarm and Container Service for Kubernetes
          • Access applications by using different methods
        • Overview
        • Attach an SLB instance to a Swarm cluster
        • Migrate cluster configurations
        • Migrate application configurations
          • Overview
          • Set up the environment
          • Pre-process Swarm Compose files
          • Convert Swarm compose files
          • Deploy Kubernetes resource files
          • Manually migrate application configurations
          • Debug application startup
          • Migrate logging settings of applications
          • Troubleshooting
        • Appendix: Parameter comparisons
          • Application configuration labels
          • Application release labels
          • Network configuration labels
          • Log configuration parameters
        • Appendix: Parameter configuration examples
        • Regression testing
        • Route traffic to a Kubernetes service
          • Overview
          • Create a NodePort Service in an ACK cluster
          • Verify the NodePort Service
          • Modify the configuration of the SLB instance that is attached to your Swarm cluster
        • Switch all production traffic to an ACK cluster
        • Delete a Swarm cluster
    • Solutions
      • Big data solutions
        • Run Apache Spark workloads on ACK
          • Overview
          • Set up a test environment
          • Write test code
          • Run Spark benchmarks on ACK
          • Analyze test results
          • Troubleshooting
          • Use LVM to manage local storage
    • FAQ
    • Terraform
      • Terraform overview
      • Use Terraform to create a managed Kubernetes cluster
      • Use Terraform to create an ACK cluster without a worker node
      • Use Terraform to create an auto-scaling node pool
    • API Reference
      • Use the Kubernetes API
      • List of operations by function
      • Endpoints
      • Request method
      • Sign API requests
      • RAM authorization
      • Common parameters
      • Activate ACK
      • Clusters
        • Create a cluster
          • Create a dedicated Kubernetes cluster
          • Create a managed Kubernetes cluster
          • Create an ASK cluster
          • Create a managed edge Kubernetes cluster
          • Create a dedicated Kubernetes cluster that supports sandboxed containers
          • Create a standard managed Kubernetes cluster that supports sandboxed containers
        • Query information about all clusters
        • DescribeClusterDetail
        • Query resources in a cluster
        • Query the namespaces of a specified cluster
        • DescribeExternalAgent
        • DescribeClusterLogs
        • Query nodes in a cluster
        • DescribeTaskInfo
        • Query the kubeconfig file of a cluster
        • DescribeKubernetesVersionMetadata
        • DescribeUserQuota
        • Query events in a cluster
        • Add existing ENS nodes to a managed edge Kubernetes cluster
        • Modify a cluster
        • MigrateCluster
        • Delete a cluster
      • Permissions
        • Query the permissions of a RAM user
        • GrantPermissions
      • Node pools
        • Create a node pool
        • ScaleClusterNodePool
        • Update node pool information
        • Query node pools
        • Query the details of a node pool
        • AttachInstances
        • Manually add an existing instance to a specified node pool
        • Remove nodes from node pools
        • Delete a node pool
      • Upgrades
        • UpgradeCluster
        • GetUpgradeStatus
        • PauseClusterUpgrade
        • CancelClusterUpgrade
        • ResumeUpgradeCluster
      • Applications
        • CreateTemplate
        • DescribeTemplates
        • DescribeTemplateAttribute
        • UpdateTemplate
        • DeleteTemplate
        • Create an application trigger
        • Query an application trigger
        • Delete an application trigger
      • Add-ons
        • Install a component in an ACK cluster
        • DescribeAddons
        • DescribeClusterAddonsUpgradeStatus
        • ModifyClusterConfiguration
        • UpgradeClusterAddons
        • Query components
        • UnInstallClusterAddons
      • Tag
        • TagResources
        • ModifyClusterTags
        • Query the labels of specified resources
        • UntagResources
      • Commonly used parameters
    • SDK examples
      • Introduction to the new ACK SDK
      • Install ACK SDK
      • SDK examples
        • Cluster management
        • Authorization management
    • CLI reference (new version)
      • Overview
      • Cluster
        • Create a cluster
          • Create a dedicated cluster
          • Create a managed cluster
          • Create a serverless cluster
        • View all clusters
        • Query detailed information about a cluster
        • Delete a cluster
      • Node
        • Add existing ECS instances to a cluster
        • Query nodes in a cluster
        • Remove nodes from a cluster
      • Node pools
        • Create a custom node pool
        • Create a managed node pool
        • Create a node pool that supports auto scaling
        • Create a managed node pool that supports auto scaling
        • Modify the configurations of a node pool
        • Add nodes to a node pool
        • Delete a node pool
      • Components
        • Install a component in a cluster
        • Query the list of components that can be installed in a cluster
        • Upgrade a component in a cluster
        • Query the upgrade status of a component in a cluster
        • Query the list of components that are supported by ACK
        • Uninstall a component from a cluster
      • Permissions
        • Query the permissions of a RAM user
        • Update authorization information of a RAM user
      • Orchestration templates
        • Create an orchestration template
        • Update an orchestration template
        • Query all of the orchestration templates
        • Query an orchestration template
        • Delete an orchestration template
      • Triggers
        • Create an application trigger
        • Query application triggers
        • Delete an application trigger
    • Use Container Service through CLI
      • Overview
      • View all clusters
      • View information about a cluster
      • Create a cluster
      • Add existing ECS instances
      • Delete a cluster
 
All Products
Search
  • Document Center
  • Container Service for Kubernetes
  • Release notes
  • Kubernetes release notes
  • Overview of Kubernetes versions supported by ACK

This Product

  • This Product
  • All Products

    Overview of Kubernetes versions supported by ACK

    Document Center
    Product Details

    Overview of Kubernetes versions supported by ACK

    Last Updated: Jul 13, 2021

    This topic lists the Kubernetes versions that are supported by Container Service for Kubernetes (ACK).

    The following Kubernetes versions are supported by ACK:
    • Kubernetes 1.20 release notes
    • Release notes for Kubernetes 1.18
    • Kubernetes 1.16 release notes
    • Kubernetes 1.12 release notes

    Alibaba Cloud periodically updates the list of Kubernetes versions that are supported by ACK. For more information about how ACK supports different Kubernetes versions, see Kubernetes versions.

    Previous: Release notes Next: Kubernetes 1.20 release notes

    How helpful was this page?

    What might be the problems?

      More suggestions?

      Thank you! We've received your feedback.
      Free Trial Free Trial