logo
Alauda Container Platform
Navigation
Overview
Architecture
Release Notes
Install
Overview
Prepare for Installation
Prerequisites
Download
Node Preprocessing
Installing
Global Cluster Disaster Recovery
Upgrade
Overview
Pre-Upgrade Preparation
Upgrade the global cluster
Upgrade Workload Clusters
User Interface
Web Console
Overview
Accessing the Web Console
Customizing the Web Console
Customizing the Left Navigation
CLI Tools
Configure
Feature Gate
Clusters
Overview
Node Management
Overview
Add Nodes to On-Premises Clusters
Manage Nodes
Node Monitoring
Managed Clusters
overview
Import Clusters
Overview
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
Overview
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
Cluster Node Planning
How to
Add External Address for Built-in Registry
Choosing a Container Runtime
Updating Public Repository Credentials
Backup and Recovery
Overview
Install
Backup repository
Backup Management
ETCD Backup
Create an application backup schedule
Hooks
Recovery Management
Run an Application Restore Task
Image Registry Replacement
Networking
Introduction
Architecture
Understanding Kube-OVN
Understanding ALB
Understanding MetalLB
Concepts
Auth
Ingress-nginx Annotation Compatibility
TCP/HTTP Keepalive
ModSecurity
Comparison Among Different Ingress Method
HTTP Redirect
L4/L7 Timeout
GatewayAPI
OTel
Guides
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
How To
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
ALB Monitoring
Trouble Shooting
How to Solve Inter-node Communication Issues in ARM Environments?
Find Who Cause the Error
Storage
Introduction
Concepts
Core 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
Creating a PV
Creating PVCs
Using Volume Snapshots
How To
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
Storage
Ceph Distributed Storage
Introduction
Install
Create Standard Type Cluster
Create Stretch Type Cluster
Architecture
Concepts
Core 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 Storagge Disaster Recovery
Update the optimization parameters
Permissions
MinIO Object Storage
Introduction
Install
Architecture
Concepts
Core Concepts
Guides
Adding a Storage Pool
Monitoring & Alerts
How To
Data Disaster Recovery
TopoLVM Local Storage
Introduction
Install
Guides
Device Management
Monitoring and Alerting
Security
Security and Compliance
Compliance
Install
Alauda Compliance with Kyverno
API Refiner
Introduction
Install
Users and Roles
User
Introduction
Guides
Manage User Roles
Create User
User Management
Group
Introduction
Guides
Manage User Group Roles
Create Local User Group
Manage Local User Group Membership
Role
Introduction
Guides
Create Role
Manage Custom Roles
IDP
Introduction
Guides
LDAP Management
OIDC Management
Troubleshooting
Delete User
User Policy
Introduction
Multitenancy(Project)
Introduction
Guides
Create Project
Manage Project
Manage Project Cluster
Manage Project Members
Audit
Introduction
Telemetry
Install
Certificates
cert-manager
OLM Certificates
Certificate Monitoring
Rotate TLS Certs of Platform Access Addresses
Virtualization
Virtualization
Overview
Introduction
Features
Install
Images
Introduction
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
Permissions
Virtual Machine
Introduction
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
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
Network
Introduction
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
Introduction
Guides
Managing Virtual Disks
Backup and Recovery
Introduction
Guides
Using Snapshots
Developer
Overview
Introduction
Concepts
Resource Unit Description
Application Types
Workload Types
Features
Quick Start
Creating a simple application via image
Building Applications
Overview
Concepts
Understanding Parameters
Understanding Startup Commands
Understanding Environment Variables
Guides
Namespaces
Creating Namespaces
Importing Namespaces
Resource Quota
Limit Range
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
Health Checks
Application Observability
Monitoring Dashboards
Logs
Events
Workloads
Deployments
DaemonSets
StatefulSets
CronJobs
Jobs
Working with Helm charts
Pod
Introduction
Pod Parameters
Deleting Pods
Container
Introduction
Debug Container (Alpha)
Entering the Container via EXEC
How To
Setting Scheduled Task Trigger Rules
Registry
Introduction
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
Introduction
Install
Installing Alauda Container Platform Builds
Architecture
Guides
Managing applications created from Code
How To
Creating an application from Code
Node Isolation Strategy
Introduction
Architecture
Concepts
Core Concepts
Guides
Create Node Isolation Strategy
Permissions
FAQ
GitOps
Introduction
Install
Installing Alauda Build of Argo CD
Installing Alauda Container Platform GitOps
Upgrade
Upgrading Alauda Container Platform GitOps
Architecture
Concepts
GitOps
Argo CD Concept
Introduction
Application
ApplicationSet
Tool
Helm
Kustomize
Directory
Sync
Health
Alauda Container Platform GitOps Concepts
Introduction
Alauda Container Platform GitOps Sync and Health Status
Guides
Creating GitOps Application
Creating GitOps Application
Creating GitOps ApplicationSet
GitOps Observability
Argo CD Component Monitoring
GitOps Applications Ops
How To
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
Extend
Overview
Operator
Cluster Plugin
Chart Repository
Upload Packages
Observability
Overview
Introduction
Features
Monitoring
Introduction
Install
Architecture
Monitoring Module Architecture
Monitoring Component Selection Guide
Concepts
Guides
Management of Metrics
Management of Alert
Management of Notification
Manage 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
Permissions
Distributed Tracing
Introduction
Install
Architecture
Concepts
Guides
Query Tracing
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
Introduction
Install
Architecture
Log Module Architecture
Log Component Selection Guide
Log Component Capacity Planning
Concepts
Guides
Logs
How To
How to Archive Logs to Third-Party Storage
How to Interface with External ES Storage Clusters
Permissions
Events
Introduction
Events
Permissions
Inspection
Introduction
Architecture
Guides
Inspection
Component Health Status
Permissions
Hardware accelerators
Overview
Introduction
Features
Install
Application Development
Introduction
Guides
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
Introduction
Guides
Configure Hardware accelerator on GPU nodes
Resource Monitoring
Introduction
Guides
GPU Resource Monitoring
Alauda Service Mesh
About Alauda Service Mesh
Alauda AI
About Alauda AI
Alauda DevOps
About Alauda DevOps
Alauda Cost Management
About Alauda Cost Management
Alauda Application Services
Overview
Introduction
Architecture
Features
Install
Upgrade
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
Introduction
Parameter Template Management
Introduction
Guides
Parameter Template Management
Permissions
Backup Management
Introduction
Guides
External S3 Storage
Backup Management
Permissions
Inspection Management
Introduction
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
Redis BigKey
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
Permissions
Alert Management
Introduction
Guides
Relationship with Platform Capabilities
Permissions
Upgrade Management
Introduction
Guides
Instance Upgrade
Permissions
API Reference
Overview
Introduction
Kubernetes API Usage Guide
Advanced APIs
Alert APIs
AlertHistories [v1]
AlertHistoryMessages [v1]
AlertStatus [v2]
SilenceStatus [v2]
Event APIs
Search
Log APIs
Aggregation
Archive
Context
Search
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]
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]

#How to

Network Configuration for Import Clusters

    Fetch import cluster information

      Trust an insecure image registry

        Collect Network Data from Custom Named Network Cards

        Collect network data from custom named network cards
          📝 Edit this page
          Previous pageGoogle GKE Cluster Storage Initialization ConfigurationNext pageNetwork Configuration for Import Clusters

          View full docs as PDF