雲助手命令可以在多台ECS執行個體中批量執行Shell、Bat或者PowerShell指令碼。本文介紹如何通過ECS SDK運行雲助手命令和查詢雲助手命令執行結果。
前提條件
ECS執行個體狀態必須為運行中（
Running）且已安裝雲助手Agent。如未安裝，請參見安裝雲助手Agent。請確保代碼運行環境設定了環境變數
ALIBABA_CLOUD_ACCESS_KEY_ID和ALIBABA_CLOUD_ACCESS_KEY_SECRET。具體配置方法，請參見在Linux、macOS和Windows系統配置環境變數。說明為防止主帳號泄露AccessKey所帶來的安全風險，建議您建立RAM使用者，並為其授予Elastic Compute Service相關的存取權限。然後您可以使用該RAM使用者的AccessKey來調用SDK。具體操作，請參見RAM使用者。
為RAM使用者授予雲助手相關許可權，具體資訊，請參見授權RAM使用者使用雲助手。
準備好將要通過雲助手執行的命令（Shell、Bat 或 PowerShell 命令）。
在專案中引入ECS SDK依賴。具體資訊，請參見ECS_SDK。
情境樣本
在現代雲端運算環境中，營運管理系統是保障業務穩定啟動並執行重要工具。為確保ECS執行個體的效能與穩定性，定期檢查資源使用方式（如CPU、記憶體、磁碟等）至關重要。假設您正在開發一套自動化營運管理系統，該系統雲端式助手的免登入功能，能夠遠程在ECS執行個體中執行使用者指定的命令，從而靈活滿足多樣化的營運需求。通過傳入不同的命令內容，該系統能夠實現資源監控、日誌採集、故障排查等多項功能，顯著提升營運效率，並為業務的高效運行提供可靠支援。
import com.aliyun.ecs20140526.Client;
import com.aliyun.ecs20140526.models.*;
import com.aliyun.teaopenapi.models.Config;
import com.google.gson.Gson;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
public class CloudAssistantService {
/**
* 從環境變數中擷取AccessKeyId、AccessKeySecret
*/
private static final String ACCESS_KEY_ID = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID");
private static final String ACCESS_KEY_SECRET = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET");
private static final ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(1);
private static volatile Client ecsClient;
private CloudAssistantService() {
}
/**
* 初始化ECS用戶端
*
* @param regionId 地區ID，用於指定ECS用戶端所在的地區
* @return 返回初始化好的ECS用戶端執行個體
* <p>
* 該方法使用雙重檢查鎖定模式來確保安全執行緒地建立單例ECS用戶端。
* 它首先檢查用戶端是否已經存在，如果不存在，則在同步塊中再次檢查並建立新的用戶端執行個體。
*/
public static Client getEcsClient(String regionId) throws Exception {
if (ecsClient == null) {
synchronized (CloudAssistantService.class) {
if (ecsClient == null) {
Config config = new Config().setAccessKeyId(ACCESS_KEY_ID).setAccessKeySecret(ACCESS_KEY_SECRET).setRegionId(regionId);
ecsClient = new Client(config);
}
}
}
return ecsClient;
}
public static void main(String[] args_) {
try {
// 地區ID
String regionId = "cn-chengdu";
getEcsClient(regionId);
// 執行命令的ECS執行個體ID
List<String> instanceIds = Arrays.asList("i-2vcXXXXXXXXXXXXXXXb8", "i-2vcXXXXXXXXXXXXXXXot");
// 命令內容
String commandContent = "#!/bin/bash\n cat /proc/meminfo";
// 命令執行逾時時間
long commandTimeOut = 60;
// 執行命令
String invokeId = runCommand(commandContent, regionId, instanceIds, commandTimeOut);
// 查詢命令執行結果
DescribeInvocationsResponse invocationResult = describeInvocations(regionId, invokeId, commandTimeOut);
System.out.println("The command execution result:" + new Gson().toJson(invocationResult));
// 省略記錄記錄檔操作
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
SCHEDULER.shutdown();
}
}
/**
* 在指定執行個體上執行命令
*
* @param commandContent 要執行的命令內容
* @param regionId 執行個體所在的地區ID
* @param instanceIds 要執行命令的ECS執行個體ID集合
* @param commandTimeOut 命令執行的逾時時間
* @return 返回命令執行的調用ID
*/
public static String runCommand(String commandContent, String regionId, List<String> instanceIds, long commandTimeOut) {
try {
System.out.println("runCommand start...");
RunCommandRequest request = new RunCommandRequest();
request.setRegionId(regionId);
request.setType(Constants.COMMAND_TYPE.RUN_SHELL_SCRIPT);
request.setCommandContent(commandContent);
request.setInstanceId(instanceIds);
request.setTimeout(commandTimeOut);
RunCommandResponse runCommandResponse = ecsClient.runCommand(request);
return runCommandResponse.body.invokeId;
} catch (Exception e) {
throw new RuntimeException("runCommand failed", e);
}
}
/**
* 查詢雲助手命令執行結果
*
* @param regionId 地區ID，用於指定調用結果所屬的地區
* @param invokeId 調用ID，用於唯一標識一次調用
* @param commandTimeOut 命令執行的逾時時間
*/
public static DescribeInvocationsResponse describeInvocations(String regionId, String invokeId, long commandTimeOut) {
DescribeInvocationsRequest describeInvocationsRequest = new DescribeInvocationsRequest()
.setRegionId(regionId)
.setInvokeId(invokeId);
long delay = 2;
// 設定最大重試次數
int maxRetries = (int) (commandTimeOut / delay);
int retryCount = 0;
try {
while (retryCount < maxRetries) {
ScheduledFuture<DescribeInvocationsResponse> future = SCHEDULER.schedule(() ->
ecsClient.describeInvocations(describeInvocationsRequest), delay, TimeUnit.SECONDS);
DescribeInvocationsResponse results = future.get();
List<DescribeInvocationsResponseBody.DescribeInvocationsResponseBodyInvocationsInvocation> invocationList = results.body.invocations.invocation;
if (invocationList.isEmpty()) {
throw new RuntimeException("The command execution result was not found.");
}
DescribeInvocationsResponseBody.DescribeInvocationsResponseBodyInvocationsInvocation invocationResult = results.body.invocations.invocation.get(0);
String invocationStatus = invocationResult.invocationStatus;
switch (invocationStatus) {
case Constants.INVOCATION_STATUS.PENDING:
case Constants.INVOCATION_STATUS.RUNNING:
case Constants.INVOCATION_STATUS.STOPPING:
retryCount++;
continue;
default:
return results;
}
}
throw new RuntimeException("Max retries exceeded for command execution result.");
} catch (Exception e) {
throw new RuntimeException("describeInvocationResults failed", e);
}
}
public static class Constants {
// 命令類型
public static final class COMMAND_TYPE {
// 適用於Linux執行個體的Shell命令。
public static final String RUN_SHELL_SCRIPT = "RunShellScript";
// 適用於Windows執行個體的Bat命令。
public static final String RUN_BAT_SCRIPT = "RunBatScript";
// 適用於Windows執行個體的PowerShell命令。
public static final String RUN_POWERSHELL_SCRIPT = "RunPowerShellScript";
}
// 雲助手命令執行結果
public static final class INVOCATION_STATUS {
// 系統正在校正或發送命令。
public static final String PENDING = "Pending";
// 命令正在執行個體上執行。
public static final String RUNNING = "Running";
// 正在停止執行的命令。
public static final String STOPPING = "Stopping";
}
}
}import os
import time
import logging
from alibabacloud_ecs20140526 import models as ecs_20140526_models
from alibabacloud_ecs20140526.client import Client as Ecs20140526Client
from alibabacloud_tea_openapi import models as open_api_models
# 配置日誌
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
ACCESS_KEY_ID = os.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID")
ACCESS_KEY_SECRET = os.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")
if not ACCESS_KEY_ID or not ACCESS_KEY_SECRET:
raise EnvironmentError(
"Missing required environment variables: ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET")
def get_ecs_client(region_id):
config = open_api_models.Config(
access_key_id=ACCESS_KEY_ID,
access_key_secret=ACCESS_KEY_SECRET,
region_id=region_id
)
return Ecs20140526Client(config)
def execute_command(client, command_content, region_id, instance_ids, command_timeout, command_type):
if not instance_ids:
raise ValueError("Instance IDs list cannot be empty.")
valid_command_types = ["RunShellScript", "RunBatScript", "RunPowerShellScript"]
if command_type not in valid_command_types:
raise ValueError(f"Invalid command type: {command_type}. Valid types are {valid_command_types}.")
request = ecs_20140526_models.RunCommandRequest()
request.region_id = region_id
request.type = command_type
request.command_content = command_content
request.instance_ids = instance_ids
request.timeout = command_timeout
try:
run_command_response = client.run_command(request)
return run_command_response.to_map()['body']['InvokeId']
except Exception as e:
logging.error(f"Failed to execute command: {e}")
raise
def query_invocations(client, region_id, invoke_id):
request = ecs_20140526_models.DescribeInvocationsRequest()
request.region_id = region_id
request.invoke_ids = [invoke_id]
try:
describe_invocations_response = client.describe_invocations(request)
return describe_invocations_response.to_map()['body']
except Exception as e:
logging.error(f"Failed to query invocations: {e}")
raise
def wait_for_command_completion(client, region_id, invoke_id, max_retries, backoff_factor=2):
retry_count = 0
while retry_count < max_retries:
time.sleep(backoff_factor ** retry_count)
results = query_invocations(client, region_id, invoke_id)
invocation_list = results.get('Invocations', {}).get('Invocation', [])
if not invocation_list:
raise RuntimeError("The command execution result was not found.")
invocation_result = invocation_list[0]
invocation_status = invocation_result.get('InvocationStatus')
logging.info(f"Current invocation status: {invocation_status}")
if invocation_status == "Finished":
print("query_invocations result:", results)
break
elif invocation_status in ["Failed", "Stopped"]:
raise RuntimeError(f"Command execution failed with status: {invocation_status}")
else:
retry_count += 1
else:
raise TimeoutError("Command execution timed out.")
def main():
# 地區ID
region_id = "cn-chengdu"
# 執行命令的ECS執行個體ID
instance_ids = ["i-2vcXXXXXXXXXXXXXXXb8", "i-2vcXXXXXXXXXXXXXXXot"]
# 命令內容
command_content = "#!/bin/bash\n cat /proc/meminfo"
# 逾時時間
command_timeout = 60
# 命令類型，支援RunShellScript、RunBatScript、RunPowerShellScript
command_type = "RunShellScript"
client = get_ecs_client(region_id)
invoke_id = execute_command(client, command_content, region_id, instance_ids, command_timeout, command_type)
max_retries = max(int(command_timeout // 2), 1)
wait_for_command_completion(client, region_id, invoke_id, max_retries)
if __name__ == "__main__":
main()