Alauda Container Platform

English

English

Alauda Container Platform

Overview

Install

Prepare for Installation

Node Preprocessing

Global Cluster Disaster Recovery

Upgrade

Pre-Upgrade Preparation

Upgrade the global cluster

Upgrade Workload Clusters

User Interface

Web Console

Accessing the Web Console

Customizing the Web Console

Customizing the Left Navigation

CLI Tools

ACP CLI (ac)

Getting Started with ACP CLI

Configuring ACP CLI

Usage of ac and kubectl Commands

Managing CLI Profiles

Extending ACP CLI with Plugins

AC CLI Developer Command Reference

AC CLI Administrator Command Reference

Configure

Clusters

Immutable Infrastructure

Node Management

Add Nodes to On-Premises Clusters

Node Monitoring

Managed Clusters

Import Clusters

Import Standard Kubernetes Cluster

Import OpenShift Cluster

Import Amazon EKS Cluster

Import GKE Cluster

Import Huawei Cloud CCE Cluster (Public Cloud)

Import Azure AKS Cluster

Import Alibaba Cloud ACK Cluster

Import Tencent Cloud TKE Cluster

Register Cluster

Public Cloud Cluster Initialization

Network Initialization

AWS EKS Cluster Network Initialization Configuration

AWS EKS Supplementary Information

Huawei Cloud CCE Cluster Network Initialization Configuration

Azure AKS Cluster Network Initialization Configuration

Google GKE Cluster Network Initialization Configuration

Storage Initialization

AWS EKS Cluster Storage Initialization Configuration

Huawei Cloud CCE Cluster Storage Initialization Configuration

Azure AKS Cluster Storage Initialization Configuration

Google GKE Cluster Storage Initialization Configuration

How to

Network Configuration for Import Clusters

Fetch import cluster information

Trust an insecure image registry

Collect Network Data from Custom Named Network Cards

Creating an On-Premise Cluster

Hosted Control Plane

Cluster Node Planning

etcd Encryption

How to

Add External Address for Built-in Registry

Choosing a Container Runtime

Optimize Pod Performance with Manager Policies

Updating Public Repository Credentials

Backup and Recovery

Backup repository

Backup Management

Create an application backup schedule

Recovery Management

Run an Application Restore Task

Image Registry Replacement

Networking

Guides

Configure Domain

Creating Certificates

Configure Services

Configure Ingresses

Configure Subnets

Configure MetalLB

Configure GatewayAPI Gateway

Configure GatewayAPI Route

Configure NodeLocal DNSCache

Configure CoreDNS

How To

Tasks for Ingress-Nginx

Tasks for Envoy Gateway

Soft Data Center LB Solution (Alpha)

Kube OVN

Understanding Kube-OVN CNI

Preparing Kube-OVN Underlay Physical Network

Automatic Interconnection of Underlay and Overlay Subnets

Cluster Interconnection (Alpha)

Configure Egress Gateway

Configure IPPool

Configuring Kube-OVN Network to Support Pod Multi-Network Interfaces (Alpha)

Configure Endpoint Health Checker

alb

Trouble Shooting

How to Solve Inter-node Communication Issues in ARM Environments?

Find Who Cause the Error

Storage

Concepts

Persistent Volume

Access Modes and Volume Modes

Guides

Creating CephFS File Storage Type Storage Class

Creating CephRBD Block Storage Class

Create TopoLVM Local Storage Class

Creating an NFS Shared Storage Class

Deploy Volume Snapshot Component

Using Volume Snapshots

How To

Generic ephemeral volumes

Using an emptyDir

Configuring Persistent Storage Using Local volumes

Configuring Persistent Storage Using NFS

Third‑Party Storage Capability Annotation Guide

Troubleshooting

Recover From PVC Expansion Failure

Object Storage

Guides

Creating a BucketClass for Ceph RGW

Creating a BucketClass for MinIO

Create a Bucket Request

How To

Control Access & Quotas for COSI Buckets with CephObjectStoreUser (Ceph Driver)

Machine Configuration

Scalability and Performance

Evaluating Resources for Workload Cluster

Disk Configuration

Evaluating Resources for Global Cluster

Improving Kubernetes Stability for Large-Scale Clusters

Storage

Ceph Distributed Storage

Install

Create Standard Type Cluster

Create Stretch Type Cluster

Concepts

Guides

Accessing Storage Services

Managing Storage Pools

Node-specific Component Deployment

Adding Devices/Device Classes

Monitoring and Alerts

How To

Configure a Dedicated Cluster for Distributed Storage

Cleanup Distributed Storage

Disaster Recovery

File Storage Disaster Recovery

Block Storage Disaster Recovery

Object Storage Disaster Recovery

Update the optimization parameters

Create Ceph Object Store User

Setting Storage Pool Quotas

MinIO Object Storage

Concepts

Guides

Adding a Storage Pool

Monitoring & Alerts

How To

Data Disaster Recovery

TopoLVM Local Storage

Guides

Device Management

Monitoring and Alerting

How To

Backup and Restore TopoLVM Filesystem PVCs with Velero

Configuring Striped Logical Volumes

Networking

Networking Operators

MetalLB Operator

Ingress Nginx Operator

Envoy Gateway Operator

ALB Operator

Understanding ALB

Deploy High Available VIP for ALB

Bind NIC in ALB

Decision‑Making for ALB Performance Selection

Load Balancing Session Affinity Policy in ALB

Header Modification

TCP/HTTP Keepalive

ALB with Ingress-NGINX Annotation Compatibility

Network Security

Understanding Network Policy APIs

Admin Network Policy

Ingress and Load Balancing

Ingress and Load Balancing with Envoy Gateway

Network Observability

Security

Alauda Container Security

Security and Compliance

Compliance

Install Alauda Container Platform Compliance with Kyverno

HowTo

Private Registry Access Configuration

Image Signature Verification Policy

Image Signature Verification Policy with Secrets

Image Registry Validation Policy

Container Escape Prevention Policy

Security Context Enforcement Policy

Network Security Policy

Volume Security Policy

API Refiner

Install Alauda Container Platform API Refiner

About Alauda Container Platform Compliance Service

Users and Roles

User

Guides

Manage User Roles

User Management

Group

Guides

Manage User Group Roles

Create Local User Group

Manage Local User Group Membership

Role

Guides

Create Kubernetes Roles

Manage Roles After the RBAC Refactor

IDP

Guides

LDAP Management

OIDC Management

Troubleshooting

User Policy

Multitenancy(Project)

Guides

Manage Project Quotas

Manage Project Cluster

Manage Project Members

Audit

Telemetry

Certificates

Automated Kubernetes Certificate Rotation

OLM Certificates

Certificate Monitoring

Rotate TLS Certs of Platform Access Addresses

Virtualization

Virtualization

Overview

Images

Guides

Adding Virtual Machine Images

Update/Delete Virtual Machine Images

Update/Delete Image Credentials

How To

Creating Windows Images Based on ISO using KubeVirt

Creating Linux Images Based on ISO Using KubeVirt

Exporting Virtual Machine Images

Virtual Machine

Guides

Creating Virtual Machines/Virtual Machine Groups

Batch Operations on Virtual Machines

Logging into the Virtual Machine using VNC

Managing Key Pairs

Managing Virtual Machines

Monitoring and Alerts

Quick Location of Virtual Machines

How To

Configuring USB host passthrough

Virtual Machine Hot Migration

Virtual Machine Recovery

Clone Virtual Machines on KubeVirt

Physical GPU Passthrough Environment Preparation

Configuring High Availability for Virtual Machines

Create a VM Template from an Existing Virtual Machine

Troubleshooting

Pod Migration and Recovery from Abnormal Shutdown of Virtual Machine Nodes

Hot Migration Error Messages and Solutions

Network

Guides

Configure Network

How To

Control Virtual Machine Network Requests Through Network Policy

Configuring SR-IOV

Configuring Virtual Machines to Use Network Binding Mode for IPv6 Support

Storage

Guides

Managing Virtual Disks

Backup and Recovery

Guides

Using Snapshots

Developer

Quick Start

Creating a simple application via image

Building Applications

Build application architecture

Concepts

Application Types

Custom Applications

Understanding Parameters

Understanding Environment Variables

Understanding Startup Commands

Resource Unit Description

Namespaces

Creating Namespaces

Importing Namespaces

Pod Security Policies

UID/GID Assignment

Overcommit Ratio

Managing Namespace Members

Updating Namespaces

Deleting/Removing Namespaces

Creating Applications

Creating applications from Image

Creating applications from Chart

Creating applications from YAML

Creating applications from Code

Creating applications from Operator Backed

Creating applications by using CLI

Operation and Maintaining Applications

Application Rollout

Installing Alauda Container Platform Argo Rollouts

Application Blue Green Deployment

Application Canary Deployment

Status Description

KEDA(Kubernetes Event-driven Autoscaling)

Installing KEDA

How To

Integrating ACP Monitoring with Prometheus Plugin

Pausing Autoscaling in KEDA

Configuring HPA

Starting and Stopping Applications

Configuring VerticalPodAutoscaler (VPA)

Configuring CronHPA

Updating Applications

Exporting Applications

Updating and deleting Chart Applications

Version Management for Applications

Deleting Applications

Handling Out of Resource Errors

Workloads

Working with Helm charts

Configurations

Configuring ConfigMap

Configuring Secrets

Application Observability

Monitoring Dashboards

How To

Setting Scheduled Task Trigger Rules

Add ImagePullSecrets to ServiceAccount

Images

Overview of images

How To

Creating images

Managing images

Registry

Install

Install Via YAML

Install Via Web UI

How To

Common CLI Command Operations

Using Alauda Container Platform Registry in Kubernetes Clusters

Source to Image

Overview

Lifecycle Policy

Install

Installing Alauda Container Platform Builds

Upgrade

Upgrading Alauda Container Platform Builds

Guides

Managing applications created from Code

How To

Creating an application from Code

Node Isolation Strategy

Concepts

Guides

Create Node Isolation Strategy

Alauda Container Platform GitOps

About Alauda Container Platform GitOps

Extend

Chart Repository

Upload Packages

Observability

Monitoring

Architecture

Monitoring Module Architecture

Monitoring Component Selection Guide

Monitor Component Capacity Planning

Guides

Management of Metrics

Management of Alert

Management of Notification

Management of Monitoring Dashboards

Management of Probe

How To

Backup and Restore of Prometheus Monitoring Data

VictoriaMetrics Backup and Recovery of Monitoring Data

Collect Network Data from Custom-Named Network Interfaces

Distributed Tracing

Guides

Query Trace Logs

How To

Non-Intrusive Integration of Tracing in Java Applications

Business Log Associated with the TraceID

Troubleshooting

Unable to Query the Required Tracing

Incomplete Tracing Data

Logs

About Logging Service

Events

Inspection

Guides

Component Health Status

Hardware accelerators

About Alauda Build of Hami

About Alauda Build of NVIDIA GPU Device Plugin

Alauda Service Mesh

Service Mesh 1.x

Service Mesh 2.x

Alauda AI

About Alauda AI

Alauda DevOps

About Alauda DevOps

Alauda Cost Management

About Alauda Cost Management

Alauda Application Services

Overview

Alauda Database Service for MySQL

About Alauda Database Service for MySQL-MGR

About Alauda Database Service for MySQL-PXC

Alauda Cache Service for Redis OSS

About Alauda Cache Service for Redis OSS

Alauda Streaming Service for Kafka

About Alauda Streaming Service for Kafka

Alauda Streaming Service for RabbitMQ

About Alauda Streaming Service for RabbitMQ

Alauda support for PostgreSQL

About Alauda support for PostgreSQL

Operations Management

Parameter Template Management

Guides

Parameter Template Management

Backup Management

Guides

External S3 Storage

Backup Management

Inspection Management

Guides

Create Inspection Task

Exec Inspection Task

Update and Delete Inspection Tasks

How To

How to set Inspection scheduling?

Inspection Optimization Recommendations

MySQL

MySQL IO Load Optimization

MySQL Memory Usage Optimization

MySQL Storage Space Optimization

MySQL Active Thread Count Optimization

MySQL Row Lock Optimization

Redis

High CPU Usage in Redis

High Memory Usage in Redis

Kafka

High CPU Utilization in Kafka

Kafka Rebalance Optimization

Kafka Memory Usage Optimization

Kafka Storage Space Optimization

RabbitMQ

RabbitMQ Mnesia Database Exception Handling

Alert Management

Guides

Relationship with Platform Capabilities

Upgrade Management

Guides

Instance Upgrade

API Reference

Overview

Kubernetes API Usage Guide

Advanced APIs

Alert APIs

AlertHistories [v1]

AlertHistoryMessages [v1]

AlertStatus [v2]

SilenceStatus [v2]

Event APIs

GitOps APIs

Log APIs

Monitoring APIs

Indicators [monitoring.alauda.io/v1beta1]

Metrics [monitoring.alauda.io/v1beta1]

Variables [monitoring.alauda.io/v1beta1]

Kubernetes APIs

Alert APIs

AlertTemplate [alerttemplates.aiops.alauda.io/v1beta1]

PrometheusRule [prometheusrules.monitoring.coreos.com/v1]

AutoScaling APIs

HorizontalPodAutoscaler [autoscaling/v2]

Configuration APIs

Inspection APIs

Inspection [inspections.ait.alauda.io/v1alpha1]

MachineConfiguration APIs

MachineConfig [machineconfiguration.alauda.io/v1alpha1]

MachineConfigPool [machineconfiguration.alauda.io/v1alpha1]

MachineConfiguration [machineconfiguration.alauda.io/v1alpha1]

ModulePlugin APIs

ModuleConfig [moduleconfigs.cluster.alauda.io/v1alpha1]

ModuleInfo [moduleinfoes.cluster.alauda.io/v1alpha1]

ModulePlugin [moduleplugins.cluster.alauda.io/v1alpha1]

Namespace APIs

LimitRange [v1]

ResourceQuota [v1]

Networking APIs

HTTPRoute [httproutes.gateway.networking.k8s.io/v1]

VpcEgressGateway [vpc-egress-gateways.kubeovn.io/v1]

Vpc [vpcs.kubeovn.io/v1]

Notification APIs

Notification [notifications.ait.alauda.io/v1beta1]

NotificationGroup [notificationgroups.ait.alauda.io/v1beta1]

NotificationTemplate [notificationtemplates.ait.alauda.io/v1beta1]

Operator APIs

Operator [operators.operators.coreos.com/v1]

Workload APIs

Cronjob [batch/v1]

DameonSet [apps/v1]

Deployment [apps/v1]

Replicaset [apps/v1]

ReplicationController [v1]

Statefulset [apps/v1]

Logs

About Logging Service

📝 Edit this page on GitHub

Previous PageIncomplete Tracing Data

Next PageAbout Logging Service

View full docs as PDF