#AC CLI 开发者命令参考

# 更新 pod 'foo'，添加注解 'description'，值为 'my frontend'
# 如果同一注解被多次设置，只有最后一个值生效
ac annotate pods foo description='my frontend'

# 更新通过类型和名称标识的 pod，配置文件为 "pod.json"
ac annotate -f pod.json description='my frontend'

# 更新 pod 'foo'，添加注解 'description'，值为 'my frontend running nginx'，覆盖已有值
ac annotate --overwrite pods foo description='my frontend running nginx'

# 更新命名空间中的所有 pod
ac annotate pods --all description='my frontend running nginx'

# 仅当资源版本为 1 时更新 pod 'foo'
ac annotate pods foo description='my frontend running nginx' --resource-version=1

# 如果存在，删除 pod 'foo' 上名为 'description' 的注解
# 不需要 --overwrite 标志
ac annotate pods foo description-

# 打印支持的 API 资源
ac api-resources

# 打印支持的 API 资源及更多信息
ac api-resources -o wide

# 按列排序打印支持的 API 资源
ac api-resources --sort-by=name

# 打印支持的命名空间资源
ac api-resources --namespaced=true

# 打印支持的非命名空间资源
ac api-resources --namespaced=false

# 打印指定 APIGroup 的支持资源
ac api-resources --api-group=rbac.authorization.k8s.io

# 打印支持的 API 版本
ac api-versions

# 应用 pod.json 中的配置到 pod
ac apply -f ./pod.json

# 应用包含 kustomization.yaml 的目录资源，例如 dir/kustomization.yaml
ac apply -k dir/

# 从标准输入传入 JSON 并应用到 pod
cat pod.json | ac apply -f -

# 应用所有以 '.json' 结尾的文件中的配置
ac apply -f '*.json'

# 注意：--prune 仍处于 Alpha 阶段
# 应用 manifest.yaml 中匹配标签 app=nginx 的配置，并删除文件中未包含且匹配标签 app=nginx 的其他资源
ac apply --prune -f manifest.yaml -l app=nginx

# 应用 manifest.yaml 中的配置，并删除文件中未包含的所有 ConfigMap
ac apply --prune -f manifest.yaml --all --prune-allowlist=core/v1/ConfigMap

# 以 YAML 格式编辑指定类型/名称的 last-applied-configuration 注解
ac apply edit-last-applied deployment/nginx

# 以 JSON 格式编辑文件中的 last-applied-configuration 注解
ac apply edit-last-applied -f deploy.yaml -o json

# 设置资源的 last-applied-configuration 以匹配文件内容
ac apply set-last-applied -f deploy.yaml

# 针对目录中的每个配置文件执行 set-last-applied
ac apply set-last-applied -f path/

# 设置资源的 last-applied-configuration，若注解不存在则创建
ac apply set-last-applied -f deploy.yaml --create-annotation=true

# 以 YAML 格式查看指定类型/名称的 last-applied-configuration 注解
ac apply view-last-applied deployment/nginx

# 以 JSON 格式查看文件中的 last-applied-configuration 注解
ac apply view-last-applied -f deploy.yaml -o json

# 获取运行中 pod mypod 的输出；使用 'ac.kubernetes.io/default-container' 注解选择容器，否则选择第一个容器
ac attach mypod

# 获取 pod mypod 中 ruby-container 的输出
ac attach mypod -c ruby-container

# 切换到原始终端模式；将 stdin 发送到 pod mypod 中 ruby-container 的 'bash'，并将 stdout/stderr 返回客户端
ac attach mypod -c ruby-container -i -t

# 获取名为 nginx 的 replica set 的第一个 pod 的输出
ac attach rs/nginx

# 检查是否可以在所有命名空间创建 pods
ac auth can-i create pods --all-namespaces

# 检查是否可以在当前命名空间列出 deployments
ac auth can-i list deployments.apps

# 检查命名空间 "dev" 中的服务账户 "foo" 是否可以在命名空间 "prod" 列出 pods
# 需要允许使用全局选项 "--as" 的模拟
ac auth can-i list pods --as=system:serviceaccount:dev:foo -n prod

# 检查是否可以在当前命名空间执行所有操作（"*" 表示全部）
ac auth can-i '*' '*'

# 检查是否可以获取命名空间 "foo" 中名为 "bar" 的 job
ac auth can-i list jobs.batch/bar -n foo

# 检查是否可以读取 pod 日志
ac auth can-i get pods --subresource=log

# 检查是否可以访问 URL /logs/
ac auth can-i get /logs/

# 检查是否可以批准 certificates.k8s.io
ac auth can-i approve certificates.k8s.io

# 列出命名空间 "foo" 中所有允许的操作
ac auth can-i --list --namespace=foo

# 从文件对齐 RBAC 资源
ac auth reconcile -f my-rbac-rules.yaml

# 获取你的主体属性
ac auth whoami

# 以 JSON 格式获取你的主体属性
ac auth whoami -o json

# 自动扩缩部署 "foo"，pod 数量在 2 到 10 之间，未指定目标 CPU 利用率，使用默认自动扩缩策略
ac autoscale deployment foo --min=2 --max=10

# 自动扩缩 ReplicationController "foo"，pod 数量在 1 到 5 之间，目标 CPU 利用率为 80%
ac autoscale rc foo --max=5 --cpu-percent=80

# 打印控制平面和集群服务地址
ac cluster-info

# 导出当前集群状态到标准输出
ac cluster-info dump

# 导出当前集群状态到 /path/to/cluster-state
ac cluster-info dump --output-directory=/path/to/cluster-state

# 导出所有命名空间到标准输出
ac cluster-info dump --all-namespaces

# 导出指定命名空间集合到 /path/to/cluster-state
ac cluster-info dump --namespaces default,kube-system --output-directory=/path/to/cluster-state

# 在 macOS 使用 homebrew 安装 bash 补全
## 如果使用 macOS 自带的 Bash 3.2
brew install bash-completion
## 或者使用 Bash 4.1+
brew install bash-completion@2
## 如果通过 homebrew 安装 ac，补全应立即生效
## 如果通过其他方式安装，可能需要将补全脚本添加到补全目录
ac completion bash > $(brew --prefix)/etc/bash_completion.d/ac


# 在 Linux 安装 bash 补全
## 如果未安装 bash-completion，请通过发行版包管理器安装 'bash-completion' 包
## 加载 ac 的 bash 补全代码到当前 shell
source <(ac completion bash)
## 将 bash 补全代码写入文件并在 .bash_profile 中 source
ac completion bash > ~/.kube/completion.bash.inc
printf "
# ac shell completion
source '$HOME/.kube/completion.bash.inc'
" >> $HOME/.bash_profile
source $HOME/.bash_profile

# 加载 zsh[1] 的 ac 补全代码到当前 shell
source <(ac completion zsh)
# 设置 zsh[1] 的 ac 补全代码开机自动加载
ac completion zsh > "${fpath[1]}/_ac"


# 加载 fish[2] 的 ac 补全代码到当前 shell
ac completion fish | source
# 要在每个会话加载补全，执行一次：
ac completion fish > ~/.config/fish/completions/ac.fish

# 加载 powershell 的 ac 补全代码到当前 shell
ac completion powershell | Out-String | Invoke-Expression
# 设置 powershell 补全代码开机自动运行
## 保存补全代码到脚本并在配置文件中执行
ac completion powershell > $HOME\.kube\completion.ps1
Add-Content $PROFILE "$HOME\.kube\completion.ps1"
## 在配置文件中执行补全代码
Add-Content $PROFILE "if (Get-Command ac -ErrorAction SilentlyContinue) {
ac completion powershell | Out-String | Invoke-Expression
}"
## 直接将补全代码添加到 $PROFILE 脚本
ac completion powershell >> $PROFILE

# 显示当前上下文
ac config current-context

# 删除 minikube 集群
ac config delete-cluster minikube

# 删除 minikube 集群的上下文
ac config delete-context minikube

# 删除 minikube 用户
ac config delete-user minikube

# 列出 ac 已知的集群
ac config get-clusters

# 列出 kubeconfig 文件中的所有上下文
ac config get-contexts

# 描述 kubeconfig 文件中的一个上下文
ac config get-contexts my-context

# 列出所有配置的 ACP 会话
ac config get-sessions

# 列出 ac 已知的用户
ac config get-users

# 将上下文 'old-name' 重命名为 'new-name'
ac config rename-context old-name new-name

# 将 my-cluster 集群的 server 字段设置为 https://1.2.3.4
ac config set clusters.my-cluster.server https://1.2.3.4

# 设置 my-cluster 集群的 certificate-authority-data 字段
ac config set clusters.my-cluster.certificate-authority-data $(echo "cert_data_here" | base64 -i -)

# 将 my-context 上下文的 cluster 字段设置为 my-cluster
ac config set contexts.my-context.cluster my-cluster

# 使用 --set-raw-bytes 选项设置 cluster-admin 用户的 client-key-data 字段
ac config set users.cluster-admin.client-key-data cert_data_here --set-raw-bytes=true

# 仅设置 e2e 集群条目的 server 字段，不修改其他值
ac config set-cluster e2e --server=https://1.2.3.4

# 为 e2e 集群条目嵌入证书授权数据
ac config set-cluster e2e --embed-certs --certificate-authority=~/.kube/e2e/kubernetes.ca.crt

# 禁用 e2e 集群条目的证书校验
ac config set-cluster e2e --insecure-skip-tls-verify=true

# 设置 e2e 集群条目的自定义 TLS 服务器名称用于验证
ac config set-cluster e2e --tls-server-name=my-cluster-name

# 设置 e2e 集群条目的代理 URL
ac config set-cluster e2e --proxy-url=https://1.2.3.4

# 设置 gce 上下文条目的用户字段，不修改其他值
ac config set-context gce --user=cluster-admin

# 仅设置 cluster-admin 条目的 "client-key" 字段，不修改其他值
ac config set-credentials cluster-admin --client-key=~/.kube/admin.key

# 设置 cluster-admin 条目的基本认证
ac config set-credentials cluster-admin --username=admin --password=uXFGweU9l35qcif

# 在 cluster-admin 条目中嵌入客户端证书数据
ac config set-credentials cluster-admin --client-certificate=~/.kube/admin.crt --embed-certs=true

# 启用 cluster-admin 条目的 Google Compute Platform 认证提供者
ac config set-credentials cluster-admin --auth-provider=gcp

# 启用 cluster-admin 条目的 OpenID Connect 认证提供者并添加参数
ac config set-credentials cluster-admin --auth-provider=oidc --auth-provider-arg=client-id=foo --auth-provider-arg=client-secret=bar

# 移除 cluster-admin 条目中 OpenID Connect 认证提供者的 "client-secret" 配置值
ac config set-credentials cluster-admin --auth-provider=oidc --auth-provider-arg=client-secret-

# 启用 cluster-admin 条目的新 exec 认证插件
ac config set-credentials cluster-admin --exec-command=/path/to/the/executable --exec-api-version=client.authentication.k8s.io/v1beta1

# 启用 cluster-admin 条目的新 exec 认证插件并开启交互模式
ac config set-credentials cluster-admin --exec-command=/path/to/the/executable --exec-api-version=client.authentication.k8s.io/v1beta1 --exec-interactive-mode=Never

# 为 cluster-admin 条目定义新的 exec 认证插件参数
ac config set-credentials cluster-admin --exec-arg=arg1 --exec-arg=arg2

# 为 cluster-admin 条目创建或更新 exec 认证插件环境变量
ac config set-credentials cluster-admin --exec-env=key1=val1 --exec-env=key2=val2

# 移除 cluster-admin 条目的 exec 认证插件环境变量
ac config set-credentials cluster-admin --exec-env=var-to-remove-

# 基于当前上下文同步会话
ac config sync

# 同步指定会话
ac config sync --session prod

# 同步所有会话
ac config sync --all

# 取消设置 current-context
ac config unset current-context

# 取消设置 foo 上下文中的 namespace
ac config unset contexts.foo.namespace

# 切换到 workload-a 集群的现有上下文
ac config use-cluster workload-a

# 为 workload-b 创建带命名空间的新上下文
ac config use-cluster workload-b --namespace my-app

# 切换到 global 集群
ac config use-cluster global

# 使用 minikube 集群的上下文
ac config use-context minikube

# 切换到 staging 会话（默认 global 集群）
ac config use-session staging

# 切换到指定集群的生产会话
ac config use-session prod --cluster workload-b

# 切换到指定集群和命名空间的会话
ac config use-session staging --cluster workload-a --namespace my-app

# 显示合并的 kubeconfig 设置
ac config view

# 显示合并的 kubeconfig 设置，包含原始证书数据和暴露的密钥
ac config view --raw

# 获取 e2e 用户的密码
ac config view -o jsonpath='{.users[?(@.name == "e2e")].user.password}'

# !!!重要提示!!!
# 需要容器镜像中存在 'tar' 二进制文件
# 如果容器中没有 'tar'，'ac cp' 将失败
#
# 对于高级用例，如符号链接、通配符扩展或文件模式保留，建议使用 'ac exec'

# 将本地文件 /tmp/foo 复制到命名空间 <some-namespace> 中远程 pod 的 /tmp/bar
tar cf - /tmp/foo | ac exec -i -n <some-namespace> <some-pod> -- tar xf - -C /tmp/bar

# 将远程 pod 的 /tmp/foo 复制到本地 /tmp/bar
ac exec -n <some-namespace> <some-pod> -- tar cf - /tmp/foo | tar xf - -C /tmp/bar

# 将本地目录 /tmp/foo_dir 复制到默认命名空间远程 pod 的 /tmp/bar_dir
ac cp /tmp/foo_dir <some-pod>:/tmp/bar_dir

# 将本地文件 /tmp/foo 复制到远程 pod 中指定容器的 /tmp/bar
ac cp /tmp/foo <some-pod>:/tmp/bar -c <specific-container>

# 将本地文件 /tmp/foo 复制到命名空间 <some-namespace> 中远程 pod 的 /tmp/bar
ac cp /tmp/foo <some-namespace>/<some-pod>:/tmp/bar

# 将远程 pod 的 /tmp/foo 复制到本地 /tmp/bar
ac cp <some-namespace>/<some-pod>:/tmp/foo /tmp/bar

# 使用 pod.json 中的数据创建 pod
ac create -f ./pod.json

# 基于标准输入传入的 JSON 创建 pod
cat pod.json | ac create -f -

# 编辑 registry.yaml 中的数据（JSON 格式），然后使用编辑后的数据创建资源
ac create -f registry.yaml --edit -o json

# 创建名为 "pod-reader" 的集群角色，允许用户对 pods 执行 "get"、"watch" 和 "list"
ac create clusterrole pod-reader --verb=get,list,watch --resource=pods

# 创建名为 "pod-reader" 的集群角色，指定 ResourceName
ac create clusterrole pod-reader --verb=get --resource=pods --resource-name=readablepod --resource-name=anotherpod

# 创建名为 "foo" 的集群角色，指定 API Group
ac create clusterrole foo --verb=get,list,watch --resource=rs.apps

# 创建名为 "foo" 的集群角色，指定 SubResource
ac create clusterrole foo --verb=get,list,watch --resource=pods,pods/status

# 创建名为 "foo" 的集群角色，指定 NonResourceURL
ac create clusterrole "foo" --verb=get --non-resource-url=/logs/*

# 创建名为 "monitoring" 的集群角色，指定 AggregationRule
ac create clusterrole monitoring --aggregation-rule="rbac.example.com/aggregate-to-monitoring=true"

# 使用 cluster-admin 集群角色为 user1、user2 和 group1 创建集群角色绑定
ac create clusterrolebinding cluster-admin --clusterrole=cluster-admin --user=user1 --user=user2 --group=group1

# 基于目录 bar 创建名为 my-config 的新 config map
ac create configmap my-config --from-file=path/to/bar

# 创建名为 my-config 的 config map，指定键而非文件名
ac create configmap my-config --from-file=key1=/path/to/bar/file1.txt --from-file=key2=/path/to/bar/file2.txt

# 创建名为 my-config 的 config map，包含 key1=config1 和 key2=config2
ac create configmap my-config --from-literal=key1=config1 --from-literal=key2=config2

# 从文件中的键值对创建名为 my-config 的 config map
ac create configmap my-config --from-file=path/to/bar

# 从 env 文件创建名为 my-config 的 config map
ac create configmap my-config --from-env-file=path/to/foo.env --from-env-file=path/to/bar.env

# 创建定时任务
ac create cronjob my-job --image=busybox --schedule="*/1 * * * *"

# 创建带命令的定时任务
ac create cronjob my-job --image=busybox --schedule="*/1 * * * *" -- date

# 创建名为 my-dep 的部署，运行 busybox 镜像
ac create deployment my-dep --image=busybox

# 创建带命令的部署
ac create deployment my-dep --image=busybox -- date

# 创建名为 my-dep 的部署，运行 nginx 镜像，副本数为 3
ac create deployment my-dep --image=nginx --replicas=3

# 创建名为 my-dep 的部署，运行 busybox 镜像，暴露端口 5701
ac create deployment my-dep --image=busybox --port=5701

# 创建名为 my-dep 的部署，运行多个容器
ac create deployment my-dep --image=busybox:latest --image=ubuntu:latest --image=nginx

# 创建名为 'simple' 的单 ingress，将 foo.com/bar 的请求转发到 svc1:8080，使用 TLS 证书 "my-cert"
ac create ingress simple --rule="foo.com/bar=svc1:8080,tls=my-cert"

# 创建 catch-all ingress，路径为 "/path"，指向服务 svc:port，Ingress 类为 "otheringress"
ac create ingress catch-all --class=otheringress --rule="/path=svc:port"

# 创建带两个注解的 ingress：ingress.annotation1 和 ingress.annotation2
ac create ingress annotated --class=default --rule="foo.com/bar=svc:port" \
--annotation ingress.annotation1=foo \
--annotation ingress.annotation2=bla

# 创建同一主机多个路径的 ingress
ac create ingress multipath --class=default \
--rule="foo.com/=svc:port" \
--rule="foo.com/admin/=svcadmin:portadmin"

# 创建多主机且 pathType 为 Prefix 的 ingress
ac create ingress ingress1 --class=default \
--rule="foo.com/path*=svc:8080" \
--rule="bar.com/admin*=svc2:http"

# 创建启用 TLS 的 ingress，使用默认 ingress 证书和不同路径类型
ac create ingress ingtls --class=default \
--rule="foo.com/=svc:https,tls" \
--rule="foo.com/path/subpath*=othersvc:8080"

# 创建启用 TLS 的 ingress，使用指定 secret，pathType 为 Prefix
ac create ingress ingsecret --class=default \
--rule="foo.com/*=svc:8080,tls=secret1"

# 创建带默认后端的 ingress
ac create ingress ingdefault --class=default \
--default-backend=defaultsvc:http \
--rule="foo.com/*=svc:8080,tls=secret1"

# 创建 job
ac create job my-job --image=busybox

# 创建带命令的 job
ac create job my-job --image=busybox -- date

# 从名为 "a-cronjob" 的 cronjob 创建 job
ac create job test-job --from=cronjob/a-cronjob

# 创建名为 my-namespace 的新命名空间
ac create namespace my-namespace

# 创建名为 my-pdb 的 pod 中断预算，选择所有带有 app=rails 标签的 pods，要求至少有一个可用
ac create poddisruptionbudget my-pdb --selector=app=rails --min-available=1

# 创建名为 my-pdb 的 pod 中断预算，选择所有带有 app=nginx 标签的 pods，要求至少半数可用
ac create pdb my-pdb --selector=app=nginx --min-available=50%

# 创建名为 high-priority 的优先级类
ac create priorityclass high-priority --value=1000 --description="high priority"

# 创建名为 default-priority 的优先级类，作为全局默认优先级
ac create priorityclass default-priority --value=1000 --global-default=true --description="default priority"

# 创建名为 high-priority 的优先级类，禁止抢占优先级较低的 pods
ac create priorityclass high-priority --value=1000 --description="high priority" --preemption-policy="Never"

# 创建名为 my-quota 的新资源配额
ac create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3,replicationcontrollers=2,resourcequotas=1,secrets=5,persistentvolumeclaims=10

# 创建名为 best-effort 的新资源配额
ac create quota best-effort --hard=pods=100 --scopes=BestEffort

# 创建名为 "pod-reader" 的角色，允许用户对 pods 执行 "get"、"watch" 和 "list"
ac create role pod-reader --verb=get --verb=list --verb=watch --resource=pods

# 创建名为 "pod-reader" 的角色，指定 ResourceName
ac create role pod-reader --verb=get --resource=pods --resource-name=readablepod --resource-name=anotherpod

# 创建名为 "foo" 的角色，指定 API Group
ac create role foo --verb=get,list,watch --resource=rs.apps

# 创建名为 "foo" 的角色，指定 SubResource
ac create role foo --verb=get,list,watch --resource=pods,pods/status

# 使用 admin 集群角色为 user1、user2 和 group1 创建角色绑定
ac create rolebinding admin --clusterrole=admin --user=user1 --user=user2 --group=group1

# 使用 admin 角色为服务账户 monitoring:sa-dev 创建角色绑定
ac create rolebinding admin-binding --role=admin --serviceaccount=monitoring:sa-dev

# 如果没有 .dockercfg 文件，直接创建 dockercfg secret
ac create secret docker-registry my-secret --docker-server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL

# 从 ~/.docker/config.json 创建名为 my-secret 的新 secret
ac create secret docker-registry my-secret --from-file=path/to/.docker/config.json

# 创建名为 my-secret 的新 secret，包含目录 bar 中每个文件的键
ac create secret generic my-secret --from-file=path/to/bar

# 创建名为 my-secret 的 secret，指定键而非文件名
ac create secret generic my-secret --from-file=ssh-privatekey=path/to/id_rsa --from-file=ssh-publickey=path/to/id_rsa.pub

# 创建名为 my-secret 的 secret，包含 key1=supersecret 和 key2=topsecret
ac create secret generic my-secret --from-literal=key1=supersecret --from-literal=key2=topsecret

# 使用文件和字面值组合创建名为 my-secret 的 secret
ac create secret generic my-secret --from-file=ssh-privatekey=path/to/id_rsa --from-literal=passphrase=topsecret

# 从 env 文件创建名为 my-secret 的 secret
ac create secret generic my-secret --from-env-file=path/to/foo.env --from-env-file=path/to/bar.env

# 创建名为 tls-secret 的 TLS secret，指定密钥对
ac create secret tls tls-secret --cert=path/to/tls.crt --key=path/to/tls.key

# 创建名为 my-cs 的 ClusterIP 服务
ac create service clusterip my-cs --tcp=5678:8080

# 创建名为 my-cs 的 ClusterIP 服务（无头模式）
ac create service clusterip my-cs --clusterip="None"

# 创建名为 my-ns 的 ExternalName 服务
ac create service externalname my-ns --external-name bar.com

# 创建名为 my-lbs 的 LoadBalancer 服务
ac create service loadbalancer my-lbs --tcp=5678:8080

# 创建名为 my-ns 的 NodePort 服务
ac create service nodeport my-ns --tcp=5678:8080

# 创建名为 my-service-account 的新服务账户
ac create serviceaccount my-service-account

# 请求当前命名空间中服务账户 "myapp" 的令牌，用于认证 kube-apiserver
ac create token myapp

# 请求自定义命名空间中服务账户的令牌
ac create token myapp --namespace myns

# 请求带自定义过期时间的令牌
ac create token myapp --duration 10m

# 请求带自定义受众的令牌
ac create token myapp --audience https://example.com

# 请求绑定到 Secret 对象实例的令牌
ac create token myapp --bound-object-kind Secret --bound-object-name mysecret

# 请求绑定到具有特定 UID 的 Secret 对象实例的令牌
ac create token myapp --bound-object-kind Secret --bound-object-name mysecret --bound-object-uid 0d4691ed-659b-4935-a832-355f77ee47cc

# 使用 pod.json 中指定的类型和名称删除 pod
ac delete -f ./pod.json

# 从包含 kustomization.yaml 的目录删除资源，例如 dir/kustomization.yaml
ac delete -k dir

# 删除所有以 '.json' 结尾的文件中的资源
ac delete -f '*.json'

# 基于标准输入传入的 JSON 删除 pod
cat pod.json | ac delete -f -

# 删除名称为 "baz" 和 "foo" 的 pods 和 services
ac delete pod,service baz foo

# 删除标签为 name=myLabel 的 pods 和 services
ac delete pods,services -l name=myLabel

# 立即删除 pod foo
ac delete pod foo --now

# 强制删除死节点上的 pod foo
ac delete pod foo --force

# 删除所有 pods
ac delete pods --all

# 仅在用户确认删除时删除所有 pods
ac delete pods --all --interactive

# 描述节点
ac describe nodes kubernetes-node-emt8.c.myproject.internal

# 描述 pod
ac describe pods/nginx

# 描述通过类型和名称标识的 pod，配置文件为 "pod.json"
ac describe -f pod.json

# 描述所有 pods
ac describe pods

# 按标签 name=myLabel 描述 pods
ac describe pods -l name=myLabel

# 描述由 'frontend' replication controller 管理的所有 pods
# （rc 创建的 pods 名称以 rc 名称为前缀）
ac describe pods frontend

# 比较 pod.json 中的资源
ac diff -f pod.json

# 比较从标准输入读取的文件
cat service.yaml | ac diff -f -

# 编辑名为 'registry' 的服务
ac edit svc/registry

# 使用替代编辑器
KUBE_EDITOR="nano" ac edit svc/registry

# 以 JSON 格式使用 v1 API 编辑 job 'myjob'
ac edit job.v1.batch/myjob -o json

# 以 YAML 格式编辑部署 'mydeployment'，并将修改后的配置保存到注解中
ac edit deployment/mydeployment -o yaml --save-config

# 编辑 'mydeployment' 部署的 'status' 子资源
ac edit deployment mydeployment --subresource='status'

# 列出默认命名空间的近期事件
ac events

# 列出所有命名空间的近期事件
ac events --all-namespaces

# 列出指定 pod 的近期事件，并持续监听新事件
ac events --for pod/web-pod-13je7 --watch

# 以 YAML 格式列出近期事件
ac events -oyaml

# 仅列出类型为 'Warning' 或 'Normal' 的近期事件
ac events --types=Warning,Normal

# 从 pod mypod 的第一个容器获取 'date' 命令输出
ac exec mypod -- date

# 从 pod mypod 的 ruby-container 容器获取 'date' 命令输出
ac exec mypod -c ruby-container -- date

# 切换到原始终端模式；将 stdin 发送到 pod mypod 中 ruby-container 的 'bash'，并将 stdout/stderr 返回客户端
ac exec mypod -c ruby-container -i -t -- bash -il

# 列出 pod mypod 第一个容器的 /usr 目录内容，并按修改时间排序
# 如果命令参数与 ac exec 参数有冲突，需使用 -- 分隔
ac exec mypod -i -t -- ls -t /usr

# 从部署 mydeployment 的第一个 pod 获取 'date' 命令输出，默认使用第一个容器
ac exec deploy/mydeployment -- date

# 从服务 myservice 的第一个 pod 获取 'date' 命令输出，默认使用第一个容器
ac exec svc/myservice -- date

# 获取资源及其字段的文档
ac explain pods

# 获取资源中所有字段
ac explain pods --recursive

# 获取支持的 api 版本中 deployment 的说明
ac explain deployments --api-version=apps/v1

# 获取资源特定字段的文档
ac explain pods.spec.containers

# 以不同格式获取资源文档
ac explain deployment --output=plaintext-openapiv2

# 为复制的 nginx 创建服务，端口为 80，连接容器端口 8000
ac expose rc nginx --port=80 --target-port=8000

# 为通过类型和名称指定的 replication controller 创建服务，端口为 80，连接容器端口 8000
ac expose -f nginx-controller.yaml --port=80 --target-port=8000

# 为 pod valid-pod 创建服务，端口为 444，服务名为 "frontend"
ac expose pod valid-pod --port=444 --name=frontend

# 基于上述服务创建第二个服务，暴露容器端口 8443 为端口 443，服务名为 "nginx-https"
ac expose service nginx --port=443 --target-port=8443 --name=nginx-https

# 为复制的流媒体应用创建服务，端口为 4100，负载 UDP 流量，服务名为 'video-stream'
ac expose rc streamer --port=4100 --protocol=UDP --name=video-stream

# 为复制的 nginx 创建基于 replica set 的服务，端口为 80，连接容器端口 8000
ac expose rs nginx --port=80 --target-port=8000

# 为 nginx 部署创建服务，端口为 80，连接容器端口 8000
ac expose deployment nginx --port=80 --target-port=8000

# 以 ps 输出格式列出所有 pods
ac get pods

# 以 ps 输出格式列出所有 pods，显示更多信息（如节点名称）
ac get pods -o wide

# 以 ps 输出格式列出指定名称的 replication controller
ac get replicationcontroller web

# 以 JSON 输出格式列出 "apps" API 组 "v1" 版本的 deployments
ac get deployments.v1.apps -o json

# 以 JSON 输出格式列出单个 pod
ac get -o json pod web-pod-13je7

# 以 JSON 输出格式列出通过类型和名称指定的 pod，配置文件为 "pod.yaml"
ac get -f pod.yaml -o json

# 从包含 kustomization.yaml 的目录获取资源，例如 dir/kustomization.yaml
ac get -k dir/

# 仅返回指定 pod 的 phase 值
ac get -o template pod/web-pod-13je7 --template={{.status.phase}}

# 以自定义列格式列出 pod test-pod 的资源信息
ac get pod test-pod -o custom-columns=CONTAINER:.spec.containers[0].name,IMAGE:.spec.containers[0].image

# 以 ps 输出格式列出所有 replication controllers 和 services
ac get rc,services

# 按类型和名称列出一个或多个资源
ac get rc/web service/frontend pods/web-pod-13je7

# 列出单个 pod 的 'status' 子资源
ac get pod web-pod-13je7 --subresource status

# 列出命名空间 'backend' 中的所有 deployments
ac get deployments.apps --namespace backend

# 列出所有命名空间中存在的所有 pods
ac get pods --all-namespaces

# 构建当前工作目录
ac kustomize

# 构建共享配置目录
ac kustomize /home/config/production

# 从 github 构建
ac kustomize https://github.com/kubernetes-sigs/kustomize.git/examples/helloWorld?ref=v1.0.6

# 更新 pod 'foo'，添加标签 'unhealthy'，值为 'true'
ac label pods foo unhealthy=true

# 更新 pod 'foo'，添加标签 'status'，值为 'unhealthy'，覆盖已有值
ac label --overwrite pods foo status=unhealthy

# 更新命名空间中的所有 pod
ac label pods --all status=unhealthy

# 更新通过类型和名称标识的 pod，配置文件为 "pod.json"
ac label -f pod.json status=unhealthy

# 仅当资源版本为 1 时更新 pod 'foo'
ac label pods foo status=unhealthy --resource-version=1

# 如果存在，删除 pod 'foo' 上名为 'bar' 的标签
# 不需要 --overwrite 标志
ac label pods foo bar-

# 交互式登录（提示缺失参数）
ac login https://example.com --name prod

# 通过参数标志登录
ac login https://example.com --name prod --username=myuser --password=mypassword

# 使用环境变量登录（适合自动化）
AC_LOGIN_PLATFORM_URL=https://example.com AC_LOGIN_SESSION=prod \
AC_LOGIN_USERNAME=myuser AC_LOGIN_PASSWORD=mypassword ac login

# 使用特定身份提供者登录
ac login https://example.com --name prod --idp ldap-test

# 登录并设置特定集群和命名空间
ac login https://example.com --name prod --cluster=my-cluster --namespace=my-namespace

# 使用自定义 kubeconfig 文件登录
ac login https://example.com --name prod --kubeconfig=/path/to/kubeconfig

# 登出当前 ACP 平台会话
ac logout

# 登出指定会话
ac logout --session prod

# 登出所有会话
ac logout --all

# 返回单容器 pod nginx 的快照日志
ac logs nginx

# 返回 pod nginx 的快照日志，前缀为源 pod 和容器名称
ac logs nginx --prefix

# 返回 pod nginx 的快照日志，限制输出为 500 字节
ac logs nginx --limit-bytes=500

# 返回 pod nginx 的快照日志，等待最多 20 秒以启动运行
ac logs nginx --pod-running-timeout=20s

# 返回多容器 pod nginx 的快照日志
ac logs nginx --all-containers=true

# 返回部署 nginx 中所有 pods 的快照日志
ac logs deployment/nginx --all-pods=true

# 返回标签 app=nginx 定义的所有 pods 中所有容器的快照日志
ac logs -l app=nginx --all-containers=true

# 返回标签 app=nginx 定义的所有 pods 的快照日志，限制并发日志请求为 10 个 pods
ac logs -l app=nginx --max-log-requests=10

# 返回 pod web-1 中先前终止的 ruby 容器日志快照
ac logs -p -c ruby web-1

# 开始流式输出 pod nginx 的日志，即使发生错误也继续
ac logs nginx -f --ignore-errors=true

# 开始流式输出 pod web-1 中 ruby 容器的日志
ac logs -f -c ruby web-1

# 开始流式输出标签 app=nginx 定义的所有 pods 中所有容器的日志
ac logs -f -l app=nginx --all-containers=true

# 仅显示 pod nginx 最近 20 行日志
ac logs --tail=20 nginx

# 显示 pod nginx 最近一小时内的所有日志
ac logs --since=1h nginx

# 显示 pod nginx 从 2024 年 8 月 30 日 06:00:00 UTC 开始带时间戳的日志
ac logs nginx --since-time=2024-08-30T06:00:00Z --timestamps=true

# 显示 kubelet 的日志，跳过过期的服务证书校验
ac logs --insecure-skip-tls-verify-backend nginx

# 返回名为 hello 的 job 的第一个容器日志快照
ac logs job/hello

# 返回部署 nginx 中容器 nginx-1 的日志快照
ac logs deployment/nginx -c nginx-1

# 显示当前命名空间和上下文信息
ac namespace

# 切换到不同的命名空间
ac namespace my-namespace

# 切换到默认命名空间
ac namespace default

# 使用战略合并补丁部分更新节点，补丁为 JSON 格式
ac patch node k8s-node-1 -p '{"spec":{"unschedulable":true}}'

# 使用战略合并补丁部分更新节点，补丁为 YAML 格式
ac patch node k8s-node-1 -p $'spec:\n unschedulable: true'

# 使用战略合并补丁部分更新通过类型和名称指定的节点，配置文件为 "node.json"
ac patch -f node.json -p '{"spec":{"unschedulable":true}}'

# 更新容器镜像；spec.containers[*].name 是合并键
ac patch pod valid-pod -p '{"spec":{"containers":[{"name":"kubernetes-serve-hostname","image":"new image"}]}}'

# 使用 JSON 补丁更新容器镜像，数组使用位置索引
ac patch pod valid-pod --type='json' -p='[{"op": "replace", "path": "/spec/containers/0/image", "value":"new image"}]'

# 通过 'scale' 子资源使用合并补丁更新部署副本数
ac patch deployment nginx-deployment --subresource='scale' --type='merge' -p '{"spec":{"replicas":2}}'

# 列出所有可用插件
ac plugin list

# 仅列出可用插件的二进制名称，不含路径
ac plugin list --name-only

# 列出所有可用插件
ac plugin list

# 仅列出可用插件的二进制名称，不含路径
ac plugin list --name-only

# 本地监听端口 5000 和 6000，转发到 pod 中的 5000 和 6000 端口
ac port-forward pod/mypod 5000 6000

# 本地监听端口 5000 和 6000，转发到由部署选择的 pod 中的 5000 和 6000 端口
ac port-forward deployment/mydeployment 5000 6000

# 本地监听端口 8443，转发到由服务选择的 pod 中名为 "https" 的服务端口的 targetPort
ac port-forward service/myservice 8443:https

# 本地监听端口 8888，转发到 pod 中的 5000 端口
ac port-forward pod/mypod 8888:5000

# 本地监听所有地址的端口 8888，转发到 pod 中的 5000 端口
ac port-forward --address 0.0.0.0 pod/mypod 8888:5000

# 本地监听 localhost 和指定 IP 的端口 8888，转发到 pod 中的 5000 端口
ac port-forward --address localhost,10.19.21.23 pod/mypod 8888:5000

# 本地监听随机端口，转发到 pod 中的 5000 端口
ac port-forward pod/mypod :5000

# 将 template.json 文件转换为资源列表并传递给 create
ac process -f template.json | ac apply -f -

# 本地处理文件而非联系服务器
ac process -f template.json -o yaml

# 处理模板时传递用户定义的标签
ac process -f template.json -l name=mytemplate

# 将存储的模板转换为资源列表
ac process foo

# 通过设置/覆盖参数值将存储的模板转换为资源列表
ac process foo -p PARM1=VALUE1 -p PARM2=VALUE2

# 将存储在不同命名空间的模板转换为资源列表
ac process cpaas-system//foo

# 将 template.json 转换为资源列表
cat template.json | ac process -f -

# 代理所有 Kubernetes API，且不代理其他内容
ac proxy --api-prefix=/

# 代理部分 Kubernetes API 及一些静态文件
# 可通过 'curl localhost:8001/api/v1/pods' 获取 pods 信息
ac proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/

# 以不同根路径代理整个 Kubernetes API
# 可通过 'curl localhost:8001/custom/api/v1/pods' 获取 pods 信息
ac proxy --api-prefix=/custom/

# 在端口 8011 运行 Kubernetes API 代理，静态内容来自 ./local/www/
ac proxy --port=8011 --www=./local/www/

# 在任意本地端口运行 Kubernetes API 代理
# 服务器选择的端口将输出到标准输出
ac proxy --port=0

# 运行 Kubernetes API 代理，修改 API 前缀为 k8s-api
# 例如 pods API 可通过 localhost:8001/k8s-api/v1/pods/ 访问
ac proxy --api-prefix=/k8s-api

# 使用 pod.json 中的数据替换 pod
ac replace -f ./pod.json

# 基于标准输入传入的 JSON 替换 pod
cat pod.json | ac replace -f -

# 更新单容器 pod 的镜像版本（标签）为 v4
ac get pod mypod -o yaml | sed 's/\(image: myimage\):.*$/\1:v4/' | ac replace -f -

# 强制替换，先删除再重新创建资源
ac replace --force -f ./pod.json

# 回滚到上一个部署版本
ac rollout undo deployment/abc

# 检查 daemonset 的发布状态
ac rollout status daemonset/foo

# 重启部署
ac rollout restart deployment/abc

# 重启带有标签 'app=nginx' 的部署
ac rollout restart deployment --selector=app=nginx

# 查看部署的发布历史
ac rollout history deployment/abc

# 查看 daemonset 第 3 版的详细信息
ac rollout history daemonset/abc --revision=3

# 将 nginx 部署标记为暂停
# 部署当前状态继续运行；暂停期间新更新不会生效
ac rollout pause deployment/nginx

# 重启 test-namespace 命名空间中的所有部署
ac rollout restart deployment -n test-namespace

# 重启部署
ac rollout restart deployment/nginx

# 重启 daemonset
ac rollout restart daemonset/abc

# 重启带有标签 app=nginx 的部署
ac rollout restart deployment --selector=app=nginx

# 恢复已暂停的部署
ac rollout resume deployment/nginx

# 监视部署的发布状态
ac rollout status deployment/nginx

# 回滚到上一个部署版本
ac rollout undo deployment/abc

# 回滚到 daemonset 第 3 版
ac rollout undo daemonset/abc --to-revision=3

# 以 dry-run 模式回滚到上一个部署版本
ac rollout undo --dry-run=server deployment/abc

# 启动 nginx pod
ac run nginx --image=nginx

# 启动 hazelcast pod，并让容器暴露端口 5701
ac run hazelcast --image=hazelcast/hazelcast --port=5701

# 启动 hazelcast pod，在容器中设置环境变量 "DNS_DOMAIN=cluster" 和 "POD_NAMESPACE=default"
ac run hazelcast --image=hazelcast/hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"

# 启动 hazelcast pod，在容器中设置标签 "app=hazelcast" 和 "env=prod"
ac run hazelcast --image=hazelcast/hazelcast --labels="app=hazelcast,env=prod"

# dry run；打印对应的 API 对象但不创建
ac run nginx --image=nginx --dry-run=client

# 启动 nginx pod，使用默认命令，但用自定义参数替代（arg1 .. argN）
ac run nginx --image=nginx -- <arg1> <arg2> ... <argN>

# 启动 nginx pod，使用不同命令和自定义参数
ac run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>

# 启动 busybox pod，保持前台运行，退出时不重启
ac run -i -t busybox --image=busybox --restart=Never

# 将名为 'foo' 的 replica set 扩缩到 3
ac scale --replicas=3 rs/foo

# 将通过类型和名称指定的资源（配置文件为 "foo.yaml"）扩缩到 3
ac scale --replicas=3 -f foo.yaml

# 如果名为 mysql 的部署当前规模为 2，则扩缩到 3
ac scale --current-replicas=2 --replicas=3 deployment/mysql

# 扩缩多个 replication controllers
ac scale --replicas=5 rc/example1 rc/example2 rc/example3

# 将名为 'web' 的 stateful set 扩缩到 3
ac scale --replicas=3 statefulset/web

# 更新部署 'registry'，添加新环境变量
ac set env deployment/registry STORAGE_DIR=/local

# 列出部署 'sample-build' 中定义的环境变量
ac set env deployment/sample-build --list

# 列出所有 pods 中定义的环境变量
ac set env pods --all --list

# 输出修改后的部署 YAML，不修改服务器上的对象
ac set env deployment/sample-build STORAGE_DIR=/data -o yaml

# 更新项目中所有 replication controllers 的所有容器，设置 ENV=prod
ac set env rc --all ENV=prod

# 从 secret 导入环境变量
ac set env --from=secret/mysecret deployment/myapp

# 从 config map 导入环境变量，添加前缀
ac set env --from=configmap/myconfigmap --prefix=MYSQL_ deployment/myapp

# 从 config map 导入指定键
ac set env --keys=my-example-key --from=configmap/myconfigmap deployment/myapp

# 从所有部署配置中删除容器 'c1' 的环境变量 ENV
ac set env deployments --all --containers="c1" ENV-

# 从磁盘上的部署定义中删除环境变量 ENV，并更新服务器上的部署配置
ac set env -f deploy.json ENV-

# 将本地 shell 环境中的部分变量导入部署配置
env | grep RAILS_ | ac set env -e - deployment/registry

# 设置部署中 nginx 容器镜像为 'nginx:1.9.1'，busybox 容器镜像为 'busybox'
ac set image deployment/nginx busybox=busybox nginx=nginx:1.9.1

# 更新所有部署和 rc 中 nginx 容器镜像为 'nginx:1.9.1'
ac set image deployments,rc nginx=nginx:1.9.1 --all

# 更新 daemonset abc 中所有容器镜像为 'nginx:1.9.1'
ac set image daemonset abc *=nginx:1.9.1

# 打印本地文件更新 nginx 容器镜像的结果（yaml 格式），不访问服务器
ac set image -f path/to/file.yaml nginx=nginx:1.9.1 --local -o yaml

# 设置部署 nginx 容器的 cpu 限制为 "200m"，内存限制为 "512Mi"
ac set resources deployment nginx -c=nginx --limits=cpu=200m,memory=512Mi

# 设置 nginx 中所有容器的资源请求和限制
ac set resources deployment nginx --limits=cpu=200m,memory=512Mi --requests=cpu=100m,memory=256Mi

# 移除 nginx 容器的资源请求
ac set resources deployment nginx --limits=cpu=0,memory=0 --requests=cpu=0,memory=0

# 打印本地文件更新 nginx 容器限制的结果（yaml 格式），不访问服务器
ac set resources -f path/to/file.yaml --limits=cpu=200m,memory=512Mi --local -o yaml

# 在创建部署/服务对之前设置标签和选择器
ac create service clusterip my-svc --clusterip="None" -o yaml --dry-run=client | ac set selector --local -f - 'environment=qa' -o yaml | ac create -f -
ac create deployment my-dep -o yaml --dry-run=client | ac label --local -f - environment=qa -o yaml | ac create -f -

# 设置部署 nginx-deployment 的服务账户为 serviceaccount1
ac set serviceaccount deployment nginx-deployment serviceaccount1

# 打印本地文件更新 nginx 部署服务账户的结果（YAML 格式），不访问 API 服务器
ac set sa -f nginx-deployment.yaml serviceaccount1 --local --dry-run=client -o yaml

# 更新集群角色绑定，指定服务账户 serviceaccount1
ac set subject clusterrolebinding admin --serviceaccount=namespace:serviceaccount1

# 更新角色绑定，指定用户 user1、user2 和组 group1
ac set subject rolebinding admin --user=user1 --user=user2 --group=group1

# 打印本地文件更新角色绑定主体的结果（YAML 格式），不访问服务器
ac create rolebinding admin --role=admin --user=admin -o yaml --dry-run=client | ac set subject --local -f - --user=foo -o yaml

# 打印客户端和服务器版本信息
ac version

# 仅打印客户端版本
ac version --client

# 以 JSON 格式打印版本信息
ac version -o json

# 等待 pod "busybox1" 包含类型为 "Ready" 的状态条件
ac wait --for=condition=Ready pod/busybox1

# 状态条件默认值为 true；可等待其他目标，等号右侧比较时忽略大小写
ac wait --for=condition=Ready=false pod/busybox1

# 等待 pod "busybox1" 的状态 phase 为 "Running"
ac wait --for=jsonpath='{.status.phase}'=Running pod/busybox1

# 等待 pod "busybox1" 的 Ready 状态条件为 True
ac wait --for='jsonpath={.status.conditions[?(@.type=="Ready")].status}=True' pod/busybox1

# 等待服务 "loadbalancer" 拥有 ingress
ac wait --for=jsonpath='{.status.loadBalancer.ingress}' service/loadbalancer

# 等待 secret "busybox1" 被创建，超时 30 秒
ac create secret generic busybox1
ac wait --for=create secret/busybox1 --timeout=30s

# 删除 pod "busybox1" 后等待其被删除，超时 60 秒
ac delete pod/busybox1
ac wait --for=delete pod/busybox1 --timeout=60s