Alauda Container Platform

Prepare for Installation

Node Preprocessing

Global Cluster Disaster Recovery

Pre-Upgrade Preparation

Upgrade the global cluster

Upgrade Workload Clusters

Accessing the Web Console

Customizing the Web Console

Customizing the Left Navigation

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

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

Cluster Node Planning

Add External Address for Built-in Registry

Choosing a Container Runtime

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

Understanding Kube-OVN

Understanding ALB

Understanding MetalLB

Ingress-nginx Annotation Compatibility

TCP/HTTP Keepalive

Comparison Among Different Ingress Method

Creating Services

Creating Ingresses

Configure Gateway

Creating a Domain Name

Creating Certificates

Creating External IP Address Pool

Creating BGP Peers

Configure Subnets

Configure Network Policies

Creating Admin Network Policies

Configure Cluster Network Policies

Deploy High Available VIP for ALB

Soft Data Center LB Solution (Alpha)

Preparing Kube-OVN Underlay Physical Network

Automatic Interconnection of Underlay and Overlay Subnets

Use OAuth Proxy with ALB

Creating GatewayAPI Gateway

Configure a Load Balancer

How to properly allocate CPU and memory resources

Forwarding IPv6 Traffic to IPv4 Addresses within the Cluster

Calico Network Supports WireGuard Encryption

Kube-OVN Overlay Network Supports IPsec Encryption

Trouble Shooting

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

Find Who Cause the Error

Persistent Volume

Access Modes and Volume Modes

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

Setting the naming rules for subdirectories in the NFS Shared Storage Class

Generic ephemeral volumes

Using an emptyDir

How to Annotate Third-Party Storage Capabilities

Troubleshooting

Recover From PVC Expansion Failure

Scalability and Performance

Evaluating Resources for Global Cluster

Evaluating Resources for Workload Cluster

Improving Kubernetes Stability for Large-Scale Clusters

Disk Configuration

Ceph Distributed Storage

Create Standard Type Cluster

Create Stretch Type Cluster

Accessing Storage Services

Managing Storage Pools

Node-specific Component Deployment

Adding Devices/Device Classes

Monitoring and Alerts

Configure a Dedicated Cluster for Distributed Storage

Cleanup Distributed Storage

Disaster Recovery

File Storage Disaster Recovery

Block Storage Disaster Recovery

Object Storagge Disaster Recovery

Update the optimization parameters

MinIO Object Storage

Adding a Storage Pool

Monitoring & Alerts

Data Disaster Recovery

TopoLVM Local Storage

Device Management

Monitoring and Alerting

Security and Compliance

Alauda Compliance with Kyverno

Users and Roles

Manage User Roles

User Management

Manage User Group Roles

Create Local User Group

Manage Local User Group Membership

Manage Custom Roles

LDAP Management

OIDC Management

Troubleshooting

Multitenancy(Project)

Manage Project Cluster

Manage Project Members

OLM Certificates

Certificate Monitoring

Rotate TLS Certs of Platform Access Addresses

Adding Virtual Machine Images

Update/Delete Virtual Machine Images

Update/Delete Image Credentials

Creating Windows Images Based on ISO using KubeVirt

Creating Linux Images Based on ISO Using KubeVirt

Exporting Virtual Machine Images

Virtual Machine

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

Configuring USB host passthrough

Virtual Machine Hot Migration

Virtual Machine Recovery

Virtual Machine Clone

Physical GPU Passthrough Environment Preparation

Troubleshooting

Pod Migration and Recovery from Abnormal Shutdown of Virtual Machine Nodes

Hot Migration Error Messages and Solutions

Configure Network

Control Virtual Machine Network Requests Through Network Policy

Configuring SR-IOV

Configuring Virtual Machines to Use Network Binding Mode for IPv6 Support

Managing Virtual Disks

Backup and Recovery

Using Snapshots

Resource Unit Description

Application Types

Creating a simple application via image

Building Applications

Understanding Parameters

Understanding Startup Commands

Understanding Environment Variables

Creating Namespaces

Importing Namespaces

Pod Security Admission

Overcommit Ratio

Managing Namespace Members

Updating Namespaces

Deleting/Removing Namespaces

Pre-Application-Creation Preparation

Configuring ConfigMap

Configuring Secrets

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

Post-Application-Creation Configuration

Configuring HPA

Configuring VerticalPodAutoscaler (VPA)

Configuring CronHPA

Operation and Maintenance

Status Description

Starting and Stopping Applications

Updating Applications

Exporting Applications

Updating and deleting Chart Applications

Version Management for Applications

Deleting Applications

Application Observability

Monitoring Dashboards

Working with Helm charts

Debug Container (Alpha)

Entering the Container via EXEC

Setting Scheduled Task Trigger Rules

Install Via YAML

Install Via Web UI

Common CLI Command Operations

Using Alauda Container Platform Registry in Kubernetes Clusters

Source to Image

Installing Alauda Container Platform Builds

Managing applications created from Code

Creating an application from Code

Node Isolation Strategy

Create Node Isolation Strategy

Installing Alauda Build of Argo CD

Installing Alauda Container Platform GitOps

Upgrading Alauda Container Platform GitOps

Argo CD Concept

Alauda Container Platform GitOps Concepts

Alauda Container Platform GitOps Sync and Health Status

Creating GitOps Application

Creating GitOps Application

Creating GitOps ApplicationSet

GitOps Observability

Argo CD Component Monitoring

GitOps Applications Ops

Integrating Code Repositories via Argo CD dashboard

Creating an Argo CD Application via Argo CD dashboard

Creating an Argo CD Application via the web console

How to Obtain Argo CD Access Information

Troubleshooting

Chart Repository

Upload Packages

Monitoring Module Architecture

Monitoring Component Selection Guide

Management of Metrics

Management of Alert

Management of Notification

Manage Dashboards

Management of Probe

Backup and Restore of Prometheus Monitoring Data

VictoriaMetrics Backup and Recovery of Monitoring Data

Collect Network Data from Custom-Named Network Interfaces

Distributed Tracing

Query Trace Logs

Non-Intrusive Integration of Tracing in Java Applications

Business Log Associated with the TraceID

Troubleshooting

Unable to Query the Required Tracing

Incomplete Tracing Data

Log Module Architecture

Log Component Selection Guide

Log Component Capacity Planning

How to Archive Logs to Third-Party Storage

How to Interface with External ES Storage Clusters

Component Health Status

Hardware accelerators

Application Development

CUDA Driver and Runtime Compatibility

Add Custom Devices Using ConfigMap

Troubleshooting

Troubleshooting float16 is only supported on GPUs with compute capability at least xx Error in vLLM

Paddle Autogrow Memory Allocation Crash on GPU-Manager

Configuration Management

Configure Hardware accelerator on GPU nodes

Resource Monitoring

GPU Resource Monitoring

Alauda Service Mesh

About Alauda Service Mesh

About Alauda AI

About Alauda DevOps

Alauda Cost Management

About Alauda Cost Management

Alauda Application Services

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

Parameter Template Management

Backup Management

External S3 Storage

Backup Management

Inspection Management

Create Inspection Task

Exec Inspection Task

Update and Delete Inspection Tasks

How to set Inspection scheduling?

Inspection Optimization Recommendations

MySQL IO Load Optimization

MySQL Memory Usage Optimization

MySQL Storage Space Optimization

MySQL Active Thread Count Optimization

MySQL Row Lock Optimization

High CPU Usage in Redis

High Memory Usage in Redis

High CPU Utilization in Kafka

Kafka Rebalance Optimization

Kafka Memory Usage Optimization

Kafka Storage Space Optimization

RabbitMQ Mnesia Database Exception Handling

Alert Management

Relationship with Platform Capabilities

Upgrade Management

Instance Upgrade

Kubernetes API Usage Guide

AlertHistories [v1]

AlertHistoryMessages [v1]

AlertStatus [v2]

SilenceStatus [v2]

Monitoring APIs

Indicators [monitoring.alauda.io/v1beta1]

Metrics [monitoring.alauda.io/v1beta1]

Variables [monitoring.alauda.io/v1beta1]

Kubernetes APIs

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

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

Inspection APIs

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

Notification APIs

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

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

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

Source to Image

Introduction

Introduction

Source to Image Concept
Core Features
Core Benefits
Application scenarios
Usage Limitations

Install

Installing Alauda Container Platform Builds

Prerequisites
Procedure

Architecture

Architecture

Guides

Managing applications created from Code

Key Features
Advantages
Prerequisites
Procedure
Related operations

How To

Creating an application from Code

Prerequisites
Procedure

📝 Edit this page

Previous pageUsing Alauda Container Platform Registry in Kubernetes Clusters Next pageIntroduction

View full docs as PDF