Document Center

    Container Service for Kubernetes

    • Bulletin
      • Announcement overview
      • [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 to V1.6.2 or later
      • [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-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
        • containerd release notes
        • Docker release notes
        • 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
        • Logs and monitoring
          • alicloud-monitor-controller
          • ack-node-problem-detector
          • Introduction to ack-node-repairer
          • metrics-server
          • ags-metrics-collector
          • logtail-windows
        • Storage
          • alicloud-disk-controller
          • csi-plugin
          • csi-provisioner
          • FlexVolume
          • storage-operator
          • csi-local-plugin
          • node-resource-manager
        • 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-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 for first-time users
      • 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 from a private image repository
    • User Guide for Kubernetes Clusters
      • Overview
      • Authorization management
        • Authorization overview
        • Create a custom RAM policy
        • Assign RBAC roles to RAM users
        • ACK default roles
        • The service linked role for ACK
        • 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
          • Access the Kubernetes API server over the Internet
          • Control internal access to the API server by using SLB
          • Revoke a KubeConfig credential
          • 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
        • Manage clusters
          • View cluster information
          • Cluster certificates
            • Renew cluster certificates
            • Update the Kubernetes cluster certificates that are about to expire
            • Update expired certificates of a Kubernetes cluster
          • Upgrade a cluster
          • Expand an ACK cluster
          • Install the metrics-server component
          • Delete an ACK cluster
        • Use cluster check 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
        • GPU scheduling
          • cGPU Professional Edition
            • Overview of cGPU Professional Edition
            • 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
          • 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
        • Task scheduling
        • Use KMS to encrypt Kubernetes Secrets
        • 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
          • 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 nodes from an ACK cluster
        • Node pool management
          • Node pool overview
          • Manage node pools
          • Schedule an application to a specific node pool
          • Set the ratio of preemptible instances to existing instances in a node pool
        • Managed node pools
          • Overview
          • Manage managed node pools
          • Schedule an application pod to a specified node pool
          • Configure custom kubelet parameters of a managed 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
          • FAQ about Services
        • Ingress management
          • Ingress overview
          • Create an Ingress
          • Advanced Ingress configurations
          • Use Ingresses to implement canary 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 on a cluster
          • Use an Ingress controller to mirror network traffic
          • FAQ about Ingresses
        • 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
          • kritis-validation-hook introduction
          • Manage images
          • Use aliyun-acr-credential-helper 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 application management
      • Component
        • Manage system components
      • Storage management-CSI
        • Storage overview
        • Storage basics
        • Install and upgrade the CSI plug-in
        • Disk volumes
          • Overview
          • Use a statically provisioned disk volume
          • Use a dynamically provisioned disk volume
          • Automatically expand a disk volume
          • Manually expand a disk volume
          • Automatically expand a disk volume
          • Use volume snapshots created from disks
          • Encrypt a disk volume
        • NAS volumes
          • Overview
          • Use a statically provisioned NAS volume
          • Use a dynamically provisioned NAS volume
          • Set quotas on the subdirectories of NAS volumes
        • OSS volumes
          • Overview
          • Mount a statically provisioned OSS volume
          • Encrypt an OSS volume
        • CPFS volumes
          • Static volumes
          • Dynamic 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 the storage resources of an ACK cluster
          • 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
        • FAQ about CSI
      • Storage management-Flexvolume
        • Overview
        • Install and upgrade FlexVolume
        • Disk volumes
          • Usage notes for disk volumes
          • Mount a statically provisioned disk
          • 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
        • NAS volumes
          • Use NAS volumes
          • Statically provisioned NAS volumes
          • Dynamic NAS volumes
          • Use NAS volumes for shared persistent storage
        • OSS volumes
          • Mount OSS volumes
          • Use statically provisioned OSS volumes
          • Use OSS volumes for persistent storage
        • 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
          • Enable 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 for a managed Kubernetes cluster
        • Security
          • Configure and enforce pod security policies
          • Use the inspection feature to detect security risks in the workloads of an ACK cluster
          • Use Runtime Security 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 and analyze the log of CoreDNS
        • 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
        • Cost analysis
      • 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 HPA
      • 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
          • Shared GPU scheduling
            • cGPU overview
            • Install the cGPU component
            • Enable GPU sharing
            • Monitor and isolate GPU resources
            • Disable the memory isolation capability of cGPU
            • Use node pools to control cGPU
          • Topology-aware GPU scheduling
        • 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 for 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
      • Namespace and Quotas
        • Manage namespaces
        • Set resource quotas and limits
      • 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
        • Create a trigger to automate application updates when the base image is updated
      • Disaster recovery center
        • Install the application backup component
        • 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
        • Run a job by using a virtual node
        • 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 log from Windows nodes
        • Mount Alibaba Cloud disks to Windows containers
        • Mount SMB file systems to 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
          • Install and configure container network plug-ins
          • 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
        • 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 managed Kubernetes cluster for confidential computing
        • Use confidential containers to implement remote attestation in a managed Kubernetes cluster for confidential computing
    • User Guide for Serverless Kubernetes Clusters
      • Introduction
      • Features
      • Quick start
        • Create an ASK cluster
        • 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 reserved instances
        • Create ECIs across zones
        • Pod annotations supported by Elastic Container Instance
        • 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 an image cache CRD to accelerate pod creation
      • 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
          • Use Alibaba Cloud disks as volumes
          • 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
      • Storage management-CSI
        • Volume plug-ins
        • Overview
        • Install CSI
        • Disk volumes
          • Use Alibaba Cloud disks that are mounted as PVs
          • Use a statically provisioned disk volume
          • Statically provision disks in the ACK console
          • Provision Alibaba Cloud disks as dynamic volumes
          • Configure StorageClasses
        • NAS volumes
          • Overview
          • Use a statically provisioned NAS volume
          • Statically provision a NAS file system in the ACK console
      • 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
        • 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
      • Log management
        • Collect log files by using Log Service
        • 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
        • Autonomy of edge nodes
        • Cloud-edge tunneling
        • Use LVM to manage local storage
    • 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 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
      • 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
        • 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
      • API overview
      • Request method
      • Signature method
      • 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
        • Query information about all clusters
        • DescribeClusterDetail
        • Query resources in a cluster
        • DescribeClusterNamespaces
        • DescribeExternalAgent
        • DescribeClusterLogs
        • Query nodes in a cluster
        • DescribeTaskInfo
        • DescribeClusterUserKubeconfig
        • DescribeKubernetesVersionMetadata
        • DescribeUserQuota
        • Query events in a cluster
        • Scale out a cluster
        • Scale out a managed edge Kubernetes 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
        • DescribeClusterNodePools
        • DescribeClusterNodePoolDetail
        • AttachInstances
        • DescribeClusterAttachScripts
        • Remove nodes from node pools
        • DeleteClusterNodepool
      • Upgrades
        • UpgradeCluster
        • GetUpgradeStatus
        • PauseClusterUpgrade
        • CancelClusterUpgrade
        • ResumeUpgradeCluster
      • Applications
        • CreateTemplate
        • DescribeTemplates
        • DescribeTemplateAttribute
        • UpdateTemplate
        • DeleteTemplate
      • 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
        • Scale out 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
      • 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
      • Delete a cluster
 
All Products
Search

This Product

  • This Product
  • All Products

    Container Service for Kubernetes Service-level Agreement

    Document Center
    Product Details

    Container Service for Kubernetes Service-level Agreement

    Last Updated: Apr 24, 2021

    For more information, see Container Service for Kubernetes Service-level Agreement.

    Next: Announcement overview

    How helpful was this page?

    What might be the problems?

      More suggestions?

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