Document Center

    Container Service for Kubernetes

    • Bulletin
      • Announcement about ACK errors that are caused by exceptions of ECS OpenAPI on February 23, 2021
      • Professional managed Kubernetes cluster is officially released for commercial use
      • Announcement about adjustments to the navigation panes in the ACK console
      • CCM upgrade notice
      • Upgrade the CoreDNS version to 1.6.2
      • Helm v2 upgrade notice
      • Support for Container Service Swarm is ending
      • Upgraded the Terway network plugin
      • Kubernetes version support policy
      • A notice about the ACK security policy upgrade
      • Fixes the issue where data disks fail to be mounted to a multi-zone ACK cluster
      • Alibaba Cloud charges for the elastic container instances that support ASK clusters
      • ACK reduces the permissions of worker RAM roles in managed Kubernetes clusters
      • Security bulletins
        • 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
        • Linux kernel vulnerability fix: CVE-2019-11477
        • Vulnerability fix: CVE-2019-11246 related to kubectl cp
        • Announcement about fixing the CVE-2019-11249 vulnerability
        • Security advisory for CVE-2019-11251
        • 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
        • Release notes
        • Release notes for Kubernetes 1.18
        • Kubernetes 1.16 release notes
        • Kubernetes 1.12 release notes
      • Release notes for OS images
      • Release notes for Runtime
        • Containerd release notes
        • Docker release notes
        • Sandboxed-Container release notes
      • System Component change Records
        • Core components
          • Cloud Controller Manager
          • edge-controller-manager
        • Application management
          • appcenter
          • progressive-delivery-tool
        • Logs and monitoring
          • alicloud-monitor-controller
          • metrics-server
          • ack-node-problem-detector
          • ack-node-repairer
            • Introduction to ack-node-repairer
          • ags-metrics-collector
        • 存储
          • csi-local-plugin
          • node-resource-manager
        • Networking
          • Terway
          • Ingress-Nginx
          • kube-flannel-ds
          • ACK NodeLocal DNSCache
        • Security
          • aliyun-acr-credential-helper
          • kritis-validation-hook release notes
            • kritis-validation-hook introduction
            • Release notes
          • Release notes for security-inspector
            • Overview
            • Release notes for security-inspector
          • Release notes for gatekeeper
            • Introduction
            • Release notes
        • Other SQL statements
          • ack-virtual-node
          • sgx-device-plugin
          • aesm
          • sandboxed-container-controller
            • Introduction and release notes for sandboxed-container-controller
            • Introduction and release notes for sandboxed-container-helper
          • migrate-controller
          • ack-virtual-node
            • Introduction
            • Release notes
          • aliyun-acr-acceleration-suite
          • resource-controller
    • Product Introduction
      • What is Container Service for Kubernetes?
      • Benefits
      • Scenarios
      • Terms
      • Limits
      • Open source projects
      • Kubernetes version support policy
      • Comparison between Container Service for Kubernetes terms and native Kubernetes terms
    • Pricing
      • Billing method
    • Quick Start
      • Quick start for first-time users
      • Quick start
      • Basic operations
        • Create a managed Kubernetes cluster
        • Deploy a stateless application from an image
        • Deploy a stateful application from an image
        • Deploy WordPress with MySQL
        • Deploy WordPress from App Catalog
        • Deploy the WordPress application from Helm CLI
      • Advanced operations
        • Create an application from a private image repository
    • User Guide for Kubernetes Clusters
      • Overview
      • Authorization management
        • Overview
        • Create a custom RAM policy
        • Assign RBAC roles to a RAM user
        • ACK default roles
        • The service linked role for ACK
        • FAQ about authorization
      • Cluster
        • Hot migration from standard managed Kubernetes clusters to professional managed Kubernetes clusters
        • Create Kubernetes clusters
          • Create a dedicated Kubernetes cluster
          • Create a managed Kubernetes cluster
          • Create a Kubernetes cluster by using a custom image
        • Access clusters
          • Use kubectl to connect to an ACK cluster
          • Generate API request parameters
          • Use kubectl on Cloud Shell to manage ACK clusters
          • Use SSH to connect to an ACK cluster
          • Access ACK clusters with Service Account tokens
          • Use SSH key pairs to connect to an ACK cluster
          • Control internal access to the API server by using SLB
          • Access the Kubernetes API server over the Internet
        • Upgrade cluster
          • Upgrade a cluster
          • Install the metrics-server component
          • Manage system components
        • Expand an ACK cluster
        • View cluster information
        • Update expired certificates of a Kubernetes cluster
        • Update the Kubernetes cluster certificates that are about to expire
        • Delete an ACK cluster
        • Cluster lifecycle
        • FAQ
      • Professional Kubernetes clusters
        • Introduction
        • Create a professional managed Kubernetes cluster
        • Resource scheduling
          • Topology-aware CPU scheduling
        • GPU Resource scheduling
          • cGPU Professional Edition
            • Overview
            • Install and use ack-ai-installer and the GPU scheduling inspection tool
            • Enable GPU sharing
            • Use cGPU to achieve GPU sharing based on multiple GPUs
            • Use node pools to control cGPU
        • Workload scheduling
        • Managed node pools
          • Overview
          • Manage managed node pools
          • Schedule an application pod to a specified node pool
        • Use KMS to encrypt Kubernetes secrets at rest in the etcd
        • Customize the settings of control plane components in professional managed Kubernetes clusters
      • Node management
        • Node
          • Add existing ECS instances to an ACK cluster
          • Monitor nodes
          • Manage node labels
          • Mark a node as unschedulable
          • Manage nodes in batches
          • Upgrade the configurations of a master node
          • Add worker nodes
          • Mount a data disk to the Docker data directory
          • Attach a data disk to a node
          • Manage taints
          • Collect diagnostic logs
          • View node resource request rate and usage
          • View nodes
          • Remove nodes from an ACK cluster
        • Node pool management
          • Overview
          • Create a node pool
          • Scale out a node pool
          • Schedule an application pod to a specified node pool
          • Set the ratio of preemptible instances to existing instances in a node pool
        • FAQ
      • Network
        • Overview
        • Plan CIDR blocks for an ACK cluster
        • Container network
          • Work with Terway
          • Create vSwitches for an ACK cluster that has Terway installed
          • Use network policies for access control
          • Use the host network
          • Associate an EIP with a pod
          • Configure SNAT entries for existing ACK clusters
          • 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
          • Overview
          • Basic operations of an Ingress
          • Configure an Ingress
          • Use Ingresses to implement canary releases
          • Enable Tracing Analysis for Ingresses
          • Monitor and analyze the logs 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 SLB instance
          • Deploy multiple ingress controllers on a cluster
          • Use an Ingress controller to mirror network traffic
          • Ingress FAQ
        • Service discovery DNS
          • Overview
          • Introduction and configuration of the DNS service in ACK clusters
          • Optimize DNS resolution for an ACK cluster
          • Deploy Node Local DNS in an ACK cluster
        • FAQ
      • Application management
        • Workloads
          • Deploy a stateless application from an image
          • Deploy a stateful application from an image
          • Create a Job application by using an image
          • View pods in ACK clusters
          • Object Browser
        • Image
          • Create an image
          • Use aliyun-acr-credential-helper to pull images without a password
          • Use kritis-validation-hook to automatically verify the signatures of container images
        • Application Scheduling Deployment
          • Schedule a pod to a specific node
          • Use an application trigger to redeploy an application
          • Simplify Kubernetes application deployment by using Helm
          • Use OpenKruise to deploy cloud-native applications
          • Deploy, release, and monitor applications in the ACK console
        • Configuration items and key
          • Create a ConfigMap
          • Use a ConfigMap in a pod
          • Create a Secret
          • Use a Secret in a pod
        • Back up and restore applications in Kubernetes clusters
        • FAQ
        • Use an orchestration template to create a Linux application
        • Manage applications by using the CLI
        • Change pod configurations
        • Use an image secret
        • Scale an application
        • Query images
        • View a ConfigMap
        • Update a ConfigMap
        • Delete a ConfigMap
        • View a Secret
        • Modify a Secret
        • Delete a Secret
        • Pull an image without a password
      • Storage management-CSI
        • Overview
        • Install the CSI plug-in
        • Disk volumes
          • Use Alibaba Cloud disks that are mounted as PVs
          • Mount a cloud disk as a static volume by using a YAML template
          • Provision Alibaba Cloud disks as dynamic PVs
          • Configure StorageClasses
          • Use CSI to dynamically expand a disk volume in ACK
          • Use volume snapshots created from disks
        • NAS volumes
          • Use NAS file systems provided by Apsara File Storage NAS
          • Mount a NAS file system as a static PV by using YAML files
          • Mount a NAS file system as a dynamic volume
        • OSS volumes
          • Provision OSS buckets as PVs
          • Provision OSS buckets as static PVs by using YAML files
        • CPFS volumes
          • Static volumes
          • Dynamic volumes
        • Local storage volumes
          • Overview
          • Use hostPath volumes
          • Use local volumes
          • Use LVs
          • Use memory volumes
      • Storage management-Flexvolume
        • Overview
        • Volume plug-ins
        • Install plug-ins
        • Disk volumes
          • Use Alibaba Cloud disks as volumes
          • Use static volumes
          • Dynamically provision an Alibaba Cloud disk as a PV by using the CLI
          • Use disks to create dynamically provisioned persistent volumes in the ACK console
          • Use static disks to create PVs for stateful services
          • Use dynamic disks to create PVs for stateful services
          • Use FlexVolume to dynamically expand a disk volume in ACK
        • NAS volumes
          • Use NAS volumes
          • Statically provisioned NAS volumes
          • Dynamic NAS volumes
          • Use a NAS file system to store data of a stateful service
        • OSS volumes
          • Use an OSS volume
          • Use statically provisioned OSS volumes
          • Use OSS buckets to create PVs for stateful services
        • CPFS volumes
          • Use CPFS volumes in ACK clusters
        • Create a PVC
        • Use a PVC
        • FAQ
      • Security management
        • Security system overview
        • Infrastructure security
          • Access applications in an ACK cluster through HTTPS
          • Renew cluster certificates
          • Renew a certificate
          • Revoke a KubeConfig credential
          • Enable service account token volume projection
          • Use pod security policies
          • Introduction to ack-kubernetes-webhook-injector
        • Security
          • Use a PSP
          • Enable cluster auditing
          • Use the inspection feature to check for security risks in the workloads of an ACK cluster
          • Use Runtime Security to monitor ACK clusters and configure alerts
        • FAQ about security groups
      • Observability
        • Overview of observability
        • Log management
          • Application log management
          • Use Log Service to collect container logs
          • Use Log-pilot to collect ACK cluster logs
          • Configure Log4jAppender for Kubernetes and Log Service
          • Collect log data of control plane components from a managed Kubernetes cluster
        • Monitoring management
          • Monitor basic resources
          • Monitor application performance
          • Event monitoring
          • Use Prometheus to monitor a Kubernetes cluster
          • Enable ARMS Prometheus
          • Ingress Dashboard
          • Delete ARMS Prometheus and ACK Prometheus
      • Auto Scaling
        • Overview
        • Auto scaling of nodes
        • HPA
        • CronHPA
        • Implement horizontal auto scaling based on Alibaba Cloud metrics
        • Vertical pod autoscaling
        • ACK KEDA
        • HPA FAQ
      • Release management
        • Use Ingresses to implement canary releases
        • Use an SLB instance to enable a Layer 4 phased release
        • Manage a Helm-based release
      • 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
          • Create a Knative Service
          • Create a revision
          • Set up a custom domain name for Knative Serving
          • Delete a revision
          • Delete a Knative Service
        • Knative event processing
          • Use Knative to manage GitHub events
          • Use Knative to handle MnsOss event sources
        • Best practices
          • Configure monitoring and alerting on Knative
          • Collect application logs
          • Use ECI in Knative services
          • Use ARMS Prometheus to collect the concurrent pod requests metric 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
        • GPU resource scheduling
        • NPU resource scheduling
          • Create an ACK cluster to schedule NPU resources
        • Observability
          • Monitor GPU errors
        • Operations & Maintenance (O&M) Management
          • Upgrade the Docker runtime of a GPU node
          • 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
        • GPU/NPU FAQ
      • Scheduling
        • Introduction to Component Installation and Functions
          • ack-ai-installer
            • Install the ack-ai-installer component
            • Description of labels for GPU-accelerated nodes
          • ack-cgpu
            • Install a shared GPU
            • Disable cGPU
          • resource-controller
        • Resource scheduling
          • Topology-aware CPU scheduling
          • Use resource-controller to dynamically modify the upper limit of resources for a pod
        • GPU scheduling
          • Configure a Kubernetes GPU cluster to support GPU scheduling
          • Use labels to schedule pods to GPU nodes
          • Shared GPU scheduling
            • Overview
            • Enable GPU sharing
            • Monitor and isolate GPU resources
            • Use node pools to control cGPU
          • GPU topology-aware scheduling
            • Overview
            • Activate GPU topology-aware scheduling in distributed training scenarios
        • Workload scheduling
          • Gang scheduling
        • Node scheduling
          • Use ECI elastic scheduling
      • Namespace and Quotas
        • Create a namespace
        • Set resource quotas and limits
      • ASM
      • Application marketplace
        • Template management
          • Create an orchestration template
          • Update 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
        • Run a job by using a virtual node
        • Use an Ingress to enable external access to applications on a virtual node
        • Enable a virtual node to discover Services by using Alibaba Cloud DNS PrivateZone
        • Install the virtual-kubelet-autoscaler add-on in an ACK cluster
        • Deploy and use ack-kubernetes-elastic-workload in an ACK cluster
      • Windows container
        • Create a node pool that runs Windows
        • Create a Windows application
        • Use Logtail to collect application logs from Windows nodes
        • Mount Alibaba Cloud disks to Windows containers
        • Mount SMB file systems to Windows containers
      • Multi-cloud and hybrid cloud management
        • Overview
        • Management of registered clusters
          • Overview of registered clusters
          • Create a cluster registration proxy and register an on-premises cluster
          • Create a hybrid cluster
          • Install and configure container network plug-ins
          • Use a custom script to add cluster nodes
          • Create and scale out a node pool
          • Configure auto scaling
        • Register cluster observability access
          • Enable Log Service for an external Kubernetes cluster
          • Create a Kubernetes event center 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
          • Install and use logtail-ds
        • Add a virtual node to an external cluster
        • Switch traffic to the Kubernetes application
          • Install migrate-controller
          • Use migrate-controller to back up and restore applications
          • Use migrate-controller to migrate applications across clusters
      • 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 an ACK 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 the Intel SGX SDK to develop and build an application
    • User Guide for Serverless Kubernetes Clusters
      • Introduction
      • Features
      • Quick start
        • Create an ASK cluster
        • Deploy NGINX applications in ASK clusters
      • Integration with ECI
        • Connect Kubernetes to Elastic Container Instance
        • Migrate existing Kubernetes applications to Elastic Container Instance
        • Use ECI in Serverless Kubernetes
      • ECI Pod
        • ECI overview
        • Specify CPU and memory specifications to create an ECI
        • Create an ECI from a specified ECS instance type
        • Use preemptible instances
        • Use GPU-accelerated ECIs
        • Use reserved instances
        • Create ECIs across zones
        • Configure pod annotations
        • 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
        • Best practices
          • Update expired certificates of a Kubernetes cluster
          • Assign CIDR blocks to resources in a Kubernetes cluster under a VPC
          • Configure the time zone for a cluster
      • Application
        • Manage applications by using the CLI
        • Create an application from an image
        • Create a Service
        • Delete a Service
        • View pods
        • View a Service
      • ConfigMaps and Secrets
        • Create a ConfigMap
      • Storage management-Flexvolume
        • Volume plug-ins
        • Overview
        • Install plug-ins
        • Disk volumes
          • Use Alibaba Cloud disks as volumes
          • Use a statically provisioned disk
          • Use the CLI to dynamically provision a disk as a PV
          • Use a dynamically provisioned disk in the ACK console
        • NAS volumes
          • Use NAS volumes
          • Statically provisioned NAS file systems
        • Create a PVC
        • Use a PVC
        • FAQ
      • Storage management-CSI
        • Volume plug-ins
        • Overview
        • Install CSI
        • Disk volumes
          • Use Alibaba Cloud disks that are mounted as PVs
          • Mount a cloud disk as a static volume by using a YAML template
          • Use a statically provisioned disk in the ACK console
          • Provision Alibaba Cloud disks as dynamic volumes
          • Configure StorageClasses
        • NAS volumes
          • Use Alibaba Cloud NAS as volumes
          • Mount a NAS file system as a static PV by using YAML files
          • Use a statically provisioned NAS file system in the ACK console
      • Network management
        • Container Network (CNI)
          • Bind an EIP to a pod
          • Change the image of a pod with the IP address unchanged
        • Service Management
          • Considerations for configuring a LoadBalancer type Service
          • Use annotations to configure load balancing
          • Access services by using SLB instances
        • SLB Ingress management
          • Overview
          • Install the SLB Ingress controller
          • 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 usage
        • Best practices
          • Use the service discovery feature based on Alibaba Cloud DNS PrivateZone in ASK clusters
      • Log management
        • Collect logs through Log Service
        • Parse user logs in the JSON format
      • Monitoring management
        • Enable ARMS for a serverless Kubernetes cluster
        • Enable ARMS Prometheus
      • Knative
        • Overview
        • Knative community version
        • Knative version release notes
          • Knative 0.18.3
        • Component management
          • Deploy Knative in an ASK cluster
          • Uninstall Knative components from an ACK cluster
        • Service management
          • Knative Gateway
          • Add a custom route
          • Configure SSL certificates
          • Reserved instances
          • Implement pod auto scaling based on the number of requests
          • Use HPA in Knative
          • Configure schedule-based autoscaling in Knative
          • Deploy a service in Knative by using functions
        • 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
        • Use GPU-based ECIs
        • Bind an EIP to a pod
        • Use the service discovery feature based on Alibaba Cloud DNS PrivateZone in ASK clusters
        • Deploy Jenkins in a serverless Kubernetes cluster and build an application delivery pipeline
        • Run a GPU-based TensorFlow training job
        • Run a Spark application
        • 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 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 cluster
        • Expand an edge cluster
        • ECS instances in an edge cluster
      • ACK@Edge Pro edition cluster
        • Resource scheduling
          • Gang scheduling
      • 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 (public preview)
        • Use the UnitedDeployment controller to deploy applications
        • Configure a Service topology
      • Node management
        • Add an edge node
        • Set the node autonomy attribute
        • Remove edge nodes
      • Application management
        • Enhance the monitoring on edge Kubernetes clusters
        • Autonomy of edge nodes
        • Cloud-edge tunneling
    • User Guide for Genomics Service
      • Overview
      • AGS acceleration API
        • Use AGS to perform WGS tasks
        • Use AGS to analyze tumor samples
        • Use AGS to perform virus sequencing
      • 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
    • Best Practices
      • Cluster
        • Select ECS instances to create the master and worker nodes of an ACK cluster
        • Recommended configurations for high reliability
        • Assign CIDR blocks to resources in a Kubernetes cluster under a VPC
        • Use Alibaba Cloud Linux 2, a container-optimized operating system
        • Deploy a Kubernetes cluster in a hybrid cloud
        • 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
        • StatefulSet applications
      • Operation and maintenance
        • Use cluster check to troubleshoot cluster issues
        • Set up an LDAP authentication source for ACK
      • ESS
        • Use ack-autoscaling-placeholder to scale pods in seconds
      • Istio
        • Use Istio route rules to manage inbound TCP traffic in a unified manner
        • 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 execute a pipeline on Kubernetes
        • 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 user-created 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
      • Deep learning solution
        • Overview
        • Preparations
          • Install the latest version of Arena
          • Configure a shared NAS volume
          • Configure a shared CPFS volume
        • 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
        • Best practice for using Arena in a multi-tenancy scenario
      • 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
    • API Reference
      • Use the Kubernetes API
      • API overview
      • Request method
      • Signature method
      • RAM authentication
      • Common parameters
      • OpenAckService
      • Clusters
        • Create a cluster
          • CreateCluster
          • CreateCluster
          • Create a serverless cluster
          • Create a managed edge cluster
          • Create an ACK cluster that supports sandboxed containers
        • Expand a cluster
          • Add worker nodes to a cluster
          • Add worker nodes to a managed edge cluster
          • Add worker nodes to a cluster that supports sandboxed containers
        • DescribeClustersV1
        • DescribeClusterDetail
        • DescribeClusterResources
        • DescribeExternalAgent
        • DescribeClusterLogs
        • DescribeTaskInfo
        • DescribeClusterUserKubeconfig
        • DescribeKubernetesVersionMetadata
        • DescribeUserQuota
        • ModifyCluster
        • MigrateCluster
        • DeleteCluster
      • Permissions
        • DescribeUserPermission
        • GrantPermissions
      • Nodes
        • DescribeClusterNodes
        • AttachInstances
        • AttachInstances
        • DescribeClusterAttachScripts
        • DeleteClusterNodes
      • Node pools
        • Create a node pool
        • ScaleClusterNodePool
        • Update node pool information
        • Query node pools
        • Query the details of a node pool
        • DeleteClusterNodepool
      • Upgrades
        • Upgrade a cluster
        • Query the upgrade status of a cluster
        • Suspend the upgrade of a cluster
        • Cancel the upgrade of a cluster
        • Resume the upgrade of a cluster
      • Applications
        • Create an application deployment template
        • Query application deployment templates
        • Query the details of an orchestration template
        • Update an application deployment template
        • Delete an application deployment template
        • Create a trigger
        • Query triggers
        • Delete a trigger
      • Add-ons
        • InstallClusterAddons
        • DescribeAddons
        • DescribeClusterAddonsUpgradeStatus
        • ModifyClusterConfiguration
        • UpgradeClusterAddons
        • DescribeClusterAddonsVersion
        • UnInstallClusterAddons
      • Tag
        • TagResources
        • ModifyClusterTags
        • ListTagResources
        • UntagResources
      • Commonly used parameters
    • SDK examples (new)
      • Introduction of the new ACK SDK
      • Install ACK SDK
      • SDK examples
        • Cluster management
    • CLI reference (new version)
      • Overview
      • Cluster
        • Query detailed information about a cluster
        • Scale out a cluster
        • Delete a cluster
      • Node
        • Add existing ECS instances to a cluster
        • Query nodes in 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
      • Components
        • Install a component in a cluster
        • Query the list of components that can be installed 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
    • Use Container Service through CLI
      • Overview
      • View all clusters
      • View information about a cluster
      • Create a cluster
      • Scale out a cluster
      • Add existing ECS instances to a cluster
      • Delete a cluster
    • Agreements
      • Disclaimer
      • Container Service for Kubernetes Service-level Agreement
 
All Products
Search
  • Document Center
  • Container Service for Kubernetes
  • Release notes
  • Kubernetes release notes
  • Release notes

This Product

  • This Product
  • All Products

    Release notes

    Document Center
    Product Details

    Release notes

    Last Updated: Nov 19, 2020

    This topic provides release notes for Alibaba Cloud Container Service for Kubernetes (ACK).

    ACK has released the following versions:
    • ACK 1.12 release notes
    • Kubernetes 1.16 release notes
    • Release notes for Kubernetes 1.18

    Previous: Release notes Next: Release notes for Kubernetes 1.18

    How helpful was this page?

    What might be the problems?

      More suggestions?

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