Configure credential injection for Agent Sandbox egress traffic

Procedure

1. Create a RAM role, such as ack-agent-identity-sample-role, in the RAM console.

2. Configure the trust policy of the RAM role to authorize the ack-agent-identity add-on to assume the role through RRSA. Replace <oidc_issuer_url> and <oidc_provider_arn> in the following template with the RRSA OIDC information of the cluster. You can find this information in the RRSA OIDC section of the Basic Information page of the cluster.

   {
     "Statement": [
       {
         "Action": "sts:AssumeRole",
         "Condition": {
           "StringEquals": {
             "oidc:aud": "sts.aliyuncs.com",
             "oidc:iss": "<oidc_issuer_url>",
             "oidc:sub": [
               "system:serviceaccount:ack-agent-identity:credential-provider"
             ]
           }
         },
         "Effect": "Allow",
         "Principal": {
           "Federated": [
             "<oidc_provider_arn>"
           ]
         }
       }
     ],
     "Version": "1"
   }

3. Grant the RAM role the required access policy, such as AliyunCSReadOnlyAccess.

4. Save the following content as credential-provider-sts.yaml, and run kubectl apply -f to create a CredentialProvider that references the preceding RAM role. The policy field defines the permission scope of the issued STS token and must be a subset of the role permissions.

   apiVersion: agentidentity.alibabacloud.com/v1alpha1
   kind: CredentialProvider
   metadata:
     name: aliyun-cs-readonly
     namespace: <YOUR_NAMESPACE>
   spec:
     type: RAM
     ram:
       source:
         provider: RRSA
         rrsa:
           roleName: ack-agent-identity-sample-role
           policy: |
             {
               "Statement": [
                 {
                   "Action": [
                     "cs:Describe*",
                     "cs:Get*",
                     "cs:List*"
                   ],
                   "Effect": "Allow",
                   "Resource": ["*"]
                 }
               ],
               "Version": "1"
             }

   policy supports template variables that dynamically adjust permissions for each Sandbox instance. For variable definitions, see CredentialProvider template variables.

5. Save the following content as agent-role-sts.yaml, and run kubectl apply -f to authorize the agent identity to retrieve credentials from the CredentialProvider.

   apiVersion: agentidentity.alibabacloud.com/v1alpha1
   kind: AgentRole
   metadata:
     name: get-aliyun-sts
     namespace: <YOUR_NAMESPACE>
   spec:
     rules:
     - effect: Allow
       action: "GetResourceCredential"
       resource: "CredentialProvider/aliyun-cs-readonly"
   ---
   apiVersion: agentidentity.alibabacloud.com/v1alpha1
   kind: AgentRoleBinding
   metadata:
     name: my-agent-get-aliyun-sts
     namespace: <YOUR_NAMESPACE>
   spec:
     agentRoleRef:
       apiGroup: agentidentity.alibabacloud.com
       kind: AgentRole
       name: get-aliyun-sts
     subjects:
     - authorizationType: "Agent"
       agentAuthorizationConfiguration:
         agentName: my-agent

6. Save the following content as security-profile-sts.yaml, and run kubectl apply -f to create a SecurityProfile that configures a tokenTransformation rule.

   apiVersion: agents.kruise.io/v1alpha1
   kind: SecurityProfile
   metadata:
     name: aliyun-sts-injection
     namespace: <YOUR_NAMESPACE>
   spec:
     selector:
       matchLabels:
         inject-sts: "true"
     rules:
     - name: inject-aliyun-sts
       match:
       - domains:
         - "*.aliyuncs.com"
       actions:
         tokenTransformation:
           type: AliyunSTS
           credentialRef:
             kind: CredentialProvider
             name: aliyun-cs-readonly

   For descriptions of the key fields, see tokenTransformation field reference.

7. Save the following content as sandboxset-sts.yaml, and run kubectl apply -f to create a SandboxSet. Set a fake AccessKey ID and AccessKey secret as environment variables. The Alibaba Cloud SDK in the Sandbox sends requests with these fake credentials, and the gateway replaces them with real credentials when it forwards the requests.

   apiVersion: agents.kruise.io/v1alpha1
   kind: SandboxSet
   metadata:
     name: sts-test
     namespace: <YOUR_NAMESPACE>
   spec:
     replicas: 2
     runtimes:
     - name: csi
     - name: agent-runtime
     template:
       metadata:
         annotations:
           network.alibabacloud.com/network-policy-mode: enhanced-traffic-policy
         labels:
           alibabacloud.com/acs: "true"
       spec:
         automountServiceAccountToken: false
         containers:
         - name: sandbox
           image: registry-cn-hangzhou.ack.aliyuncs.com/acs/acs-ephemeraljob-tools-asi:v0.6   # Replace with the actual workload image.
           env:
           - name: ALIBABA_CLOUD_ACCESS_KEY_ID
             value: "FAKE_AK"               # Fake AK. The gateway replaces it automatically.
           - name: ALIBABA_CLOUD_ACCESS_KEY_SECRET
             value: "FAKE_SK"               # Fake SK. The gateway replaces it automatically.
           - name: ALIBABA_CLOUD_REGION
             value: "cn-hangzhou"            # Replace with the actual region.
           resources:
             requests:
               cpu: "2"
               memory: 2Gi
             limits:
               cpu: "2"
               memory: 2Gi

   Wait for the Pods to become ready. Confirm that the Sandboxes are in the Running state:

   kubectl get sandbox -n <YOUR_NAMESPACE>

   Expected output:

   NAME              STATUS    AGE    CLAIMED
   sts-test-xxxxx    Running   60s    false
   sts-test-yyyyy    Running   60s    false

8. Save the following content as sandboxclaim-sts.yaml, and run kubectl apply -f to create a SandboxClaim that allocates a Sandbox and associates an agent identity.

   apiVersion: agents.kruise.io/v1alpha1
   kind: SandboxClaim
   metadata:
     name: sts-test-claim
     namespace: <YOUR_NAMESPACE>
   spec:
     templateName: sts-test
     replicas: 1
     claimTimeout: 5m
     ttlAfterCompleted: 15m
     annotations:
       # Must match the name of the AgentIdentity CR created earlier.
       security.agents.kruise.io/agent-name: my-agent
     labels:
       inject-sts: "true"

   Confirm that the CLAIMED state of one Sandbox changes to true, and check the token issuance status:

   CLAIMED_POD=$(kubectl get sandbox -n <YOUR_NAMESPACE> \
     -l agents.kruise.io/sandbox-claimed=true,agents.kruise.io/sandbox-template=sts-test \
     -o jsonpath='{.items[0].metadata.name}')
   kubectl get sandbox $CLAIMED_POD -n <YOUR_NAMESPACE> -o yaml | grep token-status

   The expected output contains the token expiration time:

   security.agents.kruise.io/token-status: '{"accessTokenExpiration":"2026-06-05T04:41:40Z"}'

9. Verification: Enter the claimed Sandbox Pod, install the Alibaba Cloud CLI, and use fake credentials to verify STS credential injection.

   kubectl exec -it $CLAIMED_POD -n <YOUR_NAMESPACE> -c sandbox -- bash

   Run the following commands in the Sandbox:

   # 1. Install the Alibaba Cloud CLI.
   /bin/bash -c "$(curl -fsSL https://aliyuncli.alicdn.com/install.sh)"
   
   # 2. Configure fake credentials.
   mkdir -p ~/.aliyun
   cat > ~/.aliyun/config.json << 'EOF'
   {
     "current": "default",
     "profiles": [{
       "name": "default",
       "mode": "AK",
       "access_key_id": "FAKE_AK",
       "access_key_secret": "FAKE_SK",
       "region_id": "cn-hangzhou",
       "output_format": "json",
       "language": "en"
     }]
   }
   EOF
   
   # 3. Call the authorized CS API. The request is expected to succeed.
   aliyun cs GET /api/v1/clusters

   The command is expected to return a JSON list of clusters. This indicates that the gateway transparently replaced the fake credentials with real temporary credentials obtained through the STS AssumeRoleWithOIDC operation.