Skip to main content
skill CX Codex

tencentcloud-tke — Claude Code skill: what it does, how to install

tencentcloud-tke manages Tencent Kubernetes Engine clusters and workloads using the Python SDK alongside kubectl. Useful for rollout restarts and node pool audits.

Apache-2.0 217 installs ★ 17 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add AceDataCloud/Skills --skill tencentcloud-tke -a claude-code
Open on GitHub

What tencentcloud-tke does

This skill automates Tencent Kubernetes Engine tasks through a bundled helper script, scripts/tke.py. It uses tencentcloud-sdk-python to inspect cluster metadata and download credentials for IDs like cls-xxxxxxxx.

In-cluster workload management routes straight to kubectl. The skill can inspect pod statuses and initiate rolling updates for deployments.

You must install kubectl manually in your system sandbox because Python dependencies do not bundle the binary. If external cluster endpoint access is disabled, fetching credentials with IsExtranet=True fails and requires running inside the cluster VPC with IsExtranet=False.

What it helps with

  • retrieve cluster kubeconfig credentials
  • trigger a rolling restart for a deployment
  • inspect node pool health and CVM instance status
  • track down pod failures using recent events and container logs

Example prompts for the agent

  • List all TKE clusters in the ap-hongkong region
  • Save kubeconfig for cluster cls-xxxxxxxx to ~/.kube/config-tke
  • Scale deployment platform-backend to 4 replicas in namespace acedatacloud

How to install tencentcloud-tke

1Skills CLI (Vercel)

npx skills add AceDataCloud/Skills --skill tencentcloud-tke -a claude-code

2Manually: put the files in place

~/.claude/skills/tencentcloud-tke/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/tencentcloud-tke/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about tencentcloud-tke

How to install tencentcloud-tke in Claude Code?

Run npx skills add AceDataCloud/Skills --skill tencentcloud-tke -a claude-code in your terminal.

What dependencies are required for tencentcloud-tke?

You need the tencentcloud-sdk-python library and a standalone kubectl binary installed in your environment.

Why does fetching kubeconfig with IsExtranet fail?

Many TKE clusters do not expose a public API endpoint by default. Set IsExtranet=False and execute your commands from a machine inside the same VPC.

Source text

SKILL.md · Apache-2.0
---
name: tencentcloud-tke
description: |
  Manage Tencent Cloud TKE (Tencent Kubernetes Engine) clusters and
  workloads. Use when the user asks to: list clusters, check cluster /
  node health, list pods or services, scale a Deployment, do a rolling
  restart, fetch kubeconfig, view recent K8s events, manage node pools.
  Combines the official tencentcloud-sdk-python TKE client (cluster
  metadata) with kubectl for in-cluster operations.
license: Apache-2.0
metadata:
  author: acedatacloud
  version: "1.0"
connections: [tencentcloud]
---

# Tencent Cloud TKE (Kubernetes)

Manage TKE clusters and the workloads inside them.

> **Setup:** See [tencentcloud authentication](../_shared/tencentcloud.md). Cluster discovery and kubeconfig retrieval go through the SDK; everything inside the cluster (pods, services, scale, restart) goes through `kubectl` against the kubeconfig we fetch.

## CLI (preferred)

The skill ships [`scripts/tke.py`](scripts/tke.py) — wraps cluster discovery, kubeconfig retrieval, and the most common in-cluster operations.

```bash
# $SKILL_DIR can point at another skill loaded this turn — anchor on our own
# script (re-run this at the top of every fresh-shell Bash block).
TKE="$SKILL_DIR/scripts/tke.py"; [ -f "$TKE" ] || TKE=$(find /tmp -maxdepth 8 -path '*/skills/*/scripts/tke.py' 2>/dev/null | head -1)
[ -f "$TKE" ] || { echo "tencentcloud-tke script not found (SKILL_DIR=$SKILL_DIR)" >&2; exit 1; }

python3 $TKE clusters                                              # list clusters
python3 $TKE cluster cls-xxxxxxxx                                  # one cluster's details
python3 $TKE nodes cls-xxxxxxxx
python3 $TKE pools cls-xxxxxxxx                                    # node pools
python3 $TKE kubeconfig cls-xxxxxxxx --save ~/.kube/config-tke     # write kubeconfig
python3 $TKE workloads cls-xxxxxxxx -n my-namespace
python3 $TKE pods cls-xxxxxxxx -n my-namespace
python3 $TKE events cls-xxxxxxxx -n my-namespace                   # recent events
python3 $TKE scale cls-xxxxxxxx -n my-namespace --name my-deploy --replicas 4
python3 $TKE restart cls-xxxxxxxx -n my-namespace --name my-deploy
```

In-cluster commands shell out to `kubectl` against an SDK-fetched kubeconfig. `kubectl` must be installed in the sandbox (`pip install` doesn't ship it).

## When to Use

- List TKE clusters across regions
- Check node health and node-pool resource usage
- List Deployments / StatefulSets / DaemonSets in a namespace
- List Services / Pods / recent Events
- Scale a workload up or down
- Rolling restart a Deployment (e.g. after a config change)
- Fetch kubeconfig for ad-hoc `kubectl` work

## Dependencies

```bash
pip install tencentcloud-sdk-python
brew install kubectl   # macOS;  apt install kubectl on Debian/Ubuntu
```

## Quick start — list clusters

```python
import os
from tencentcloud.common import credential
from tencentcloud.tke.v20180525 import tke_client, models

cred = credential.EnvironmentVariableCredential().get_credential()
client = tke_client.TkeClient(cred, os.environ["TENCENTCLOUD_REGION"])

req = models.DescribeClustersRequest()
req.Limit = 100
resp = client.DescribeClusters(req)
for c in resp.Clusters:
    print(c.ClusterId, c.ClusterName, c.ClusterStatus, c.ClusterVersion)
```

> Cluster IDs look like `cls-xxxxxxxx`. The `ap-hongkong` region typically holds the production clusters; `DescribeClusters` is region-scoped — call it per region you care about.

## Workflows

### Get cluster details + worker node count

```python
req = models.DescribeClustersRequest()
req.ClusterIds = ["cls-xxxxxxxx"]
resp = client.DescribeClusters(req)
c = resp.Clusters[0]
print(c.ClusterName, c.ClusterStatus, c.ClusterNodeNum, c.ClusterVersion)
```

### List worker nodes (and their CVM instance types)

```python
req = models.DescribeClusterInstancesRequest()
req.ClusterId = "cls-xxxxxxxx"
req.Limit = 100
resp = client.DescribeClusterInstances(req)
for i in resp.InstanceSet:
    print(i.InstanceId, i.InstanceRole, i.InstanceState, i.NodePoolId)
```

### Fetch kubeconfig

```python
req = models.DescribeClusterKubeconfigRequest()
req.ClusterId = "cls-xxxxxxxx"
req.IsExtranet = True            # False for VPC-internal kubeconfig
resp = client.DescribeClusterKubeconfig(req)

# Save and use immediately
import os, pathlib
kubeconfig = pathlib.Path(os.path.expanduser("~/.kube/config-tke-cls-xxxxxxxx"))
kubeconfig.parent.mkdir(parents=True, exist_ok=True)
kubeconfig.write_text(resp.Kubeconfig)
print("export KUBECONFIG=" + str(kubeconfig))
```

> Many TKE clusters expose only the **internal** API endpoint by default. If `IsExtranet=True` returns an empty / unusable config, the cluster's public API access isn't enabled — set `IsExtranet=False` and run `kubectl` from a host inside the same VPC (e.g. CVM, jump host).

### Run kubectl commands (with the fetched kubeconfig)

```python
import subprocess

KUBECONFIG = os.path.expanduser("~/.kube/config-tke-cls-xxxxxxxx")
NS = "acedatacloud"

def kubectl(*args):
    return subprocess.run(
        ["kubectl", f"--kubeconfig={KUBECONFIG}", *args],
        check=True, capture_output=True, text=True,
    ).stdout

print(kubectl("get", "pods", "-n", NS))
print(kubectl("get", "deploy", "-n", NS))
print(kubectl("get", "svc", "-n", NS))
print(kubectl("get", "events", "-n", NS, "--sort-by=.lastTimestamp"))
```

### Describe a misbehaving pod

```python
print(kubectl("describe", "pod", "<pod-name>", "-n", NS))
print(kubectl("logs", "<pod-name>", "-n", NS, "--tail=200"))
```

### Scale a Deployment

```python
# To 4 replicas. Confirm with the user before running for prod workloads.
print(kubectl("scale", "deploy/platform-backend", "-n", NS, "--replicas=4"))
```

### Rolling restart a Deployment

```python
# Forces every pod to recycle through the rolling-update strategy.
print(kubectl("rollout", "restart", "deploy/platform-backend", "-n", NS))
print(kubectl("rollout", "status", "deploy/platform-backend", "-n", NS, "--timeout=300s"))
```

### List node pools (TKE concept above raw nodes)

```python
req = models.DescribeClusterNodePoolsRequest()
req.ClusterId = "cls-xxxxxxxx"
resp = client.DescribeClusterNodePools(req)
for np in resp.NodePoolSet:
    print(np.NodePoolId, np.Name, np.LifeState, np.DesiredNodesNum, np.AutoscalingGroupId)
```

## Troubleshooting flow

```
1. python: DescribeClusters → cluster status / version
2. python: DescribeClusterInstances → any nodes "failed" / "running"
3. kubectl get events → recent failures (image pulls, scheduling, OOM)
4. kubectl get pods → which pod is in CrashLoopBackOff / ImagePullBackOff
5. kubectl describe pod <name> → conditions, events on the pod
6. kubectl logs <name> --tail=200 → application logs
7. (optional) tencentcloud-cls skill → CLS query for the same window
```

## Important reminders

- **Confirm scale / restart actions** with the user before running for production workloads. A `replicas=0` typo takes the service down.
- **Kubeconfigs contain a long-lived bearer token.** Treat the file like a credential — `chmod 600`, never commit, regenerate after offboarding people.
- **Internal vs external endpoint:** `IsExtranet=False` gives a kubeconfig usable only from inside the cluster VPC. From a laptop, use `IsExtranet=True` and ensure the cluster has a public API endpoint enabled (TKE console → Cluster → Basic Info → API Server access).
- **Region matters.** Cluster `cls-xxxxxxxx` in `ap-hongkong` is invisible from a TKE client constructed for `ap-guangzhou`.

## Console links

- TKE console: <https://console.cloud.tencent.com/tke2/cluster>
- API reference: <https://www.tencentcloud.com/document/product/457/31862>

© acedatacloud · Apache-2.0 · AceDataCloud/Skills

Similar skills

All skills for Cloud: AWS, Azure, GCP →

From the same set67

The whole set →
microsoft-onedrive microsoft-onedrive is a Claude Code skill for listing, searching, downloading, and uploading OneDrive and SharePoint files through Microsoft Graph. CX Codex +1 219installs gpt-image-2 Generates and composites graphics using OpenAI gpt-image-2 through the AceDataCloud API. Blends existing logos, screenshots, and QR codes into scenes while keeping exact shapes. CX Codex +1 219installs tencentcloud-dns tencentcloud-dns edits DNSPod records through the Tencent Cloud API: creates A, AAAA, CNAME, MX and TXT entries, finds them, deletes the stale ones. Handy when DNS work belongs in the terminal or an agent chat. CX Codex +1 218installs github Controls GitHub issues, pull requests, releases, and code search using the gh CLI. Useful whenever an agent needs to review a PR or update issues directly. CX Codex +1 218installs tencentcloud-edgeone Manage Tencent Cloud EdgeOne zones, CDN cache, DNS records, and WAF settings from a coding agent. Use it for post-deploy cache work or configuration checks. CX Codex +1 217installs google-tasks Reads and manages Google Tasks lists and items via the Tasks v1 REST API using curl and jq. Surfaces overdue tasks, groups todos, and builds recaps. CX Codex +1 216installs tencentcloud-cls-alarm This skill manages Tencent Cloud CLS alarms, notification groups, mute shields, and firing history. Use it to configure alerts or inspect what fired. CX Codex +1 216installs linkedin Publishes text and link posts to a personal LinkedIn feed through the Posts API. It asks for confirmation before sending. CX Codex +1 215installs

Project sponsors

Companies that keep this analytics open