10.5. Zero Trust Workload Identity Manager OIDC 联邦

流程

1. 使用以下命令，创建一个 Role 来提供路由器服务帐户权限来读取引用的 secret：

   $ oc create role secret-reader \
     --verb=get,list,watch \
     --resource=secrets \
     --resource-name=$TLS_SECRET_NAME \
     -n zero-trust-workload-identity-manager

2. 使用以下命令，创建一个 RoleBinding 资源，将 router 服务帐户与新创建的 Role 资源绑定：

   $ oc create rolebinding secret-reader-binding \
     --role=secret-reader \
     --serviceaccount=openshift-ingress:router \
     -n zero-trust-workload-identity-manager

3. 运行以下命令，配置 SpireOIDCDIscoveryProvider 自定义资源(CR)对象来引用上一步中生成的 Secret：

   $ oc patch SpireOIDCDiscoveryProvider cluster --type=merge -p='
   spec:
     externalSecretRef: ${TLS_SECRET_NAME}
   '

验证

1. 在 SpireOIDCDiscoveryProvider CR 中，运行以下命令来检查 ManageRouteReady 条件是否设置为 True ：

   $ oc wait --for=jsonpath='{.status.conditions[?(@.type=="ManagedRouteReady")].status}'=True SpireOIDCDiscoveryProvider/cluster --timeout=120s

2. 运行以下命令，验证 OIDC 端点可以通过 HTTPS 安全地访问：

   $ curl https://$JWT_ISSUER_ENDPOINT/.well-known/openid-configuration
   
   {
     "issuer": "https://$JWT_ISSUER_ENDPOINT",
     "jwks_uri": "https://$JWT_ISSUER_ENDPOINT/keys",
     "authorization_endpoint": "",
     "response_types_supported": [
       "id_token"
     ],
     "subject_types_supported": [],
     "id_token_signing_alg_values_supported": [
       "RS256",
       "ES256",
       "ES384"
     ]
   }%

流程

1. 运行以下命令来登录到 Azure：

   $ az login

2. 运行以下命令，为您的 Azure 订阅和租户配置变量：

   $ export SUBSCRIPTION_ID=$(az account list --query "[?isDefault].id" -o tsv) 

   1

   $ export TENANT_ID=$(az account list --query "[?isDefault].tenantId" -o tsv) 

   1

   $ export LOCATION=centralus 

   1

   1

   您的唯一订阅标识符。

   1

   Azure Active Directory 实例的 ID。

   1

   创建资源的 Azure 区域。

3. 运行以下命令来定义资源变量名称：

   $ export NAME=ztwim 

   1

   $ export RESOURCE_GROUP="${NAME}-rg" 

   1

   $ export STORAGE_ACCOUNT="${NAME}storage" 

   1

   $ export STORAGE_CONTAINER="${NAME}storagecontainer" 

   1

   $ export USER_ASSIGNED_IDENTITY_NAME="${NAME}-identity" 

   1

   1

   所有资源的基础名称。

   1

   资源组的名称。

   1

   存储帐户的名称。

   1

   存储容器的名称。

   1

   受管身份的名称。

4. 运行以下命令来创建资源组：

   $ az group create \
     --name "${RESOURCE_GROUP}" \
     --location "${LOCATION}"

流程

1. 运行以下命令，创建一个用于存储内容的新存储帐户：

   $ az storage account create \
     --name ${STORAGE_ACCOUNT} \
     --resource-group ${RESOURCE_GROUP} \
     --location ${LOCATION} \
     --encryption-services blob

2. 运行以下命令，获取新创建的存储帐户的存储 ID：

   $ export STORAGE_ACCOUNT_ID=$(az storage account show -n ${STORAGE_ACCOUNT} -g ${RESOURCE_GROUP} --query id --out tsv)

3. 运行以下命令，在新创建的存储帐户中创建存储容器，以提供支持 blob 存储的位置：

   $ az storage container create \
     --account-name ${STORAGE_ACCOUNT} \
     --name ${STORAGE_CONTAINER} \
     --auth-mode login

流程

1. 创建一个新的 User Managed Identity，然后运行以下命令来获取与 User Managed Identity 关联的相关服务主体的客户端 ID：

   $ az identity create \
     --name ${USER_ASSIGNED_IDENTITY_NAME} \
     --resource-group ${RESOURCE_GROUP}

   $ export IDENTITY_CLIENT_ID=$(az identity show --resource-group "${RESOURCE_GROUP}" --name "${USER_ASSIGNED_IDENTITY_NAME}" --query 'clientId' -otsv)

2. 运行以下命令，检索 Azure 用户提供的管理身份的 CLIENT_ID，并将它保存为环境变量：

   $ export IDENTITY_CLIENT_ID=$(az identity show --resource-group "${RESOURCE_GROUP}" --name "${USER_ASSIGNED_IDENTITY_NAME}" --query 'clientId' -otsv)

3. 运行以下命令，将角色与 User Managed Identity 关联的 Service Principal 关联：

   $ az role assignment create \
     --role "Storage Blob Data Contributor" \
     --assignee "${IDENTITY_CLIENT_ID}" \
     --scope ${STORAGE_ACCOUNT_ID}

1. 运行以下命令来设置应用程序名称和命名空间：

   $ export APP_NAME=workload-app

   $ export APP_NAMESPACE=demo

2. 运行以下命令创建命名空间：

   $ oc create namespace $APP_NAMESPACE

3. 运行以下命令来创建应用程序 Secret：

   $ oc apply -f - << EOF
   apiVersion: v1
   kind: Secret
   metadata:
     name: $APP_NAME
     namespace: $APP_NAMESPACE
   stringData:
     AAD_AUTHORITY: https://login.microsoftonline.com/
     AZURE_AUDIENCE: "api://AzureADTokenExchange"
     AZURE_TENANT_ID: "${TENANT_ID}"
     AZURE_CLIENT_ID: "${IDENTITY_CLIENT_ID}"
     BLOB_STORE_ACCOUNT: "${STORAGE_ACCOUNT}"
     BLOB_STORE_CONTAINER: "${STORAGE_CONTAINER}"
   EOF

流程

1. 要部署应用，请复制提供的整个命令块，并将它直接粘贴到终端中。按 Enter 键。

   $ oc apply -f - << EOF
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: $APP_NAME
     namespace: $APP_NAMESPACE
   ---
   kind: Deployment
   apiVersion: apps/v1
   metadata:
     name: $APP_NAME
     namespace: $APP_NAMESPACE
   spec:
     selector:
       matchLabels:
         app: $APP_NAME
     template:
       metadata:
         labels:
           app: $APP_NAME
           deployment: $APP_NAME
       spec:
         serviceAccountName: $APP_NAME
         containers:
           - name: $APP_NAME
             image: "registry.redhat.io/ubi9/python-311:latest"
             command:
               - /bin/bash
               - "-c"
               - |
                 #!/bin/bash
                 pip install spiffe azure-cli
   
                 cat << EOF > /opt/app-root/src/get-spiffe-token.py
                 #!/opt/app-root/bin/python
                 from spiffe import JwtSource
                 import argparse
                 parser = argparse.ArgumentParser(description='Retrieve SPIFFE Token.')
                 parser.add_argument("-a", "--audience", help="The audience to include in the token", required=True)
                 args = parser.parse_args()
                 with JwtSource() as source:
                   jwt_svid = source.fetch_svid(audience={args.audience})
                   print(jwt_svid.token)
                 EOF
   
                 chmod +x /opt/app-root/src/get-spiffe-token.py
                 while true; do sleep 10; done
             envFrom:
             - secretRef:
                 name: $APP_NAME
             env:
               - name: SPIFFE_ENDPOINT_SOCKET
                 value: unix:///run/spire/sockets/spire-agent.sock
             securityContext:
               allowPrivilegeEscalation: false
               capabilities:
                 drop:
                   - ALL
               readOnlyRootFilesystem: false
               runAsNonRoot: true
               seccompProfile:
                 type: RuntimeDefault
             ports:
               - containerPort: 8080
                 protocol: TCP
             volumeMounts:
               - name: spiffe-workload-api
                 mountPath: /run/spire/sockets
                 readOnly: true
         volumes:
           - name: spiffe-workload-api
             csi:
               driver: csi.spiffe.io
               readOnly: true
   EOF

验证

1. 运行以下命令，确保 workload-app pod 成功运行：

   $ oc get pods -n $APP_NAMESPACE

   输出示例

   NAME                             READY     STATUS      RESTARTS      AGE
   workload-app-5f8b9d685b-abcde    1/1       Running     0             60s

2. 检索 SPIFFE JWT 令牌 (SVID-JWT)：

   1. 运行以下命令来动态获取 pod 名称：

      $ POD_NAME=$(oc get pods -n $APP_NAMESPACE -l app=$APP_NAME -o jsonpath='{.items[0].metadata.name}')

   2. 运行以下命令，在 pod 中运行脚本：

      $ oc exec -it $POD_NAME -n $APP_NAMESPACE -- \
        /opt/app-root/src/get-spiffe-token.py -a "api://AzureADTokenExchange"

流程

1. 运行以下命令，从 SPIFFE Workload API 检索 JWT 令牌：

   $ oc rsh -n $APP_NAMESPACE deployment/$APP_NAME

2. 运行以下命令，创建并导出名为 TOKEN 的环境变量：

   $ export TOKEN=$(/opt/app-root/src/get-spiffe-token.py --audience=$AZURE_AUDIENCE)

3. 运行以下命令，登录到 pod 中包含的 Azure CLI：

   $ az login --service-principal \
     -t ${AZURE_TENANT_ID} \
     -u ${AZURE_CLIENT_ID} \
     --federated-token ${TOKEN}

4. 运行以下命令，使用应用程序工作负载 pod 创建新文件，并将文件上传到 Blob 存储：

   $ echo “Hello from OpenShift” > openshift-spire-federated-identities.txt

5. 运行以下命令，将文件上传到 Azure Blog Storage：

   $ az storage blob upload \
     --account-name ${BLOB_STORE_ACCOUNT} \
     --container-name ${BLOB_STORE_CONTAINER} \
     --name openshift-spire-federated-identities.txt \
     --file openshift-spire-federated-identities.txt \
     --auth-mode login

流程

1. 创建 vault-helm-value.yaml 文件。

   global:
     enabled: true
     openshift: true 

   1

   
     tlsDisable: true 

   2

   
   injector:
     enabled: false
   server:
     ui:
       enabled: true
     image:
       repository: docker.io/hashicorp/vault
       tag: "1.19.0"
     dataStorage:
       enabled: true 

   3

   
       size: 1Gi
     standalone:
       enabled: true 

   4

   
       config: |
         listener "tcp" {
           tls_disable = 1 

   5

   
           address = "[::]:8200"
           cluster_address = "[::]:8201"
         }
         storage "file" {
           path = "/vault/data"
         }
     extraEnvironmentVars: {}

   1

   针对特定于 OpenShift 的安全上下文优化部署。

   2

   为由 chart 创建的 Kubernetes 对象禁用 TLS。

   3

   创建一个 1Gi 持久性卷来存储 Vault 数据。

   4

   部署单个 Vault pod。

   5

   告知 Vault 服务器不使用 TLS。

2. 运行 helm install 命令：

   $ helm install vault hashicorp/vault \
     --create-namespace -n vault \
     --values ./vault-helm-value.yaml

3. 运行以下命令公开 Vault 服务：

   $ oc expose service vault -n vault

4. 将 VAULT_ADDR 环境变量设置为从新路由检索主机名，然后运行以下命令来导出它：

   $ export VAULT_ADDR="http://$(oc get route vault -n vault -o jsonpath='{.spec.host}')"

   注意

   带有 http:// 前缀，因为 TLS 被禁用。

1. 初始化和取消密封 Vault
2. 启用键值(KV) secret 引擎并存储测试 secret
3. 使用 SPIRE 配置 JSON Web 令牌(JWT)身份验证
4. 部署演示应用程序
5. 验证并检索 secret

流程

1. 运行以下命令，打开一个远程的到 vault pod 的 shell ：

   $ oc rsh -n vault statefulset/vault

2. 运行以下命令，初始化 Vault 以获取您的非密钥和 root 令牌：

   $ vault operator init -key-shares=1 -key-threshold=1 -format=json

3. 运行以下命令，导出您从之前命令接收的未密封密钥和 root 令牌：

   $ export UNSEAL_KEY=<Your-Unseal-Key>

   $ export ROOT_TOKEN=<Your-Root-Token>

4. 运行以下命令，使用您的非密钥取消密封 Vault：

   $ vault operator unseal -format=json $UNSEAL_KEY

5. 通过输入 exit 来退出 pod。

流程

1. 运行以下命令，在 Vault pod 中打开另一个 shell 会话：

   $ oc rsh -n vault statefulset/vault

2. 在此新会话中再次导出您的 root 令牌，并运行以下命令来登录：

   $ export ROOT_TOKEN=<Your-Root-Token>

   $ vault login "${ROOT_TOKEN}"

3. 运行以下命令，在 secret/ 路径中启用 KV secret 引擎并创建测试 secret：

   $ export NAME=ztwim

   $ vault secrets enable -path=secret kv

   $ vault kv put secret/$NAME version=v0.1.0

流程

1. 在本地机器上，运行以下命令来检索 SPIRE 证书颁发机构(CA)捆绑包并将其保存到文件中：

   $ oc get cm -n zero-trust-workload-identity-manager spire-bundle -o jsonpath='{ .data.bundle\.crt }' > oidc_provider_ca.pem

2. 返回到 Vault pod shell，通过运行以下命令创建一个临时文件，并将 oidc_provider_ca.pem 的内容粘贴到其中：

   $ cat << EOF > /tmp/oidc_provider_ca.pem
   -----BEGIN CERTIFICATE-----
   <Paste-Your-Certificate-Content-Here>
   -----END CERTIFICATE-----
   EOF

3. 运行以下命令，为 JWT 配置设置必要的环境变量：

   $ export APP_DOMAIN=<Your-App-Domain>

   $ export JWT_ISSUER_ENDPOINT="oidc-discovery.$APP_DOMAIN"

   $ export OIDC_URL="https://$JWT_ISSUER_ENDPOINT"

   $ export OIDC_CA_PEM="$(cat /tmp/oidc_provider_ca.pem)"

4. 运行以下命令来定义新环境变量：

   $ export ROLE="${NAME}-role"

5. 运行以下命令来启用 JWT 验证方法：

   $ vault auth enable jwt

6. 运行以下命令配置 ODIC 验证方法：

   $ vault write auth/jwt/config \
     oidc_discovery_url=$OIDC_URL \
     oidc_discovery_ca_pem="$OIDC_CA_PEM" \
     default_role=$ROLE

7. 运行以下命令，创建名为 ztwim-policy 的策略：

   $ export POLICY="${NAME}-policy"

8. 运行以下命令，授予之前创建的 secret 的读取访问权限：

   $ vault policy write $POLICY -<<EOF
   path "secret/$NAME" {
       capabilities = ["read"]
   }
   EOF

9. 运行以下命令来创建以下环境变量：

   $ export APP_NAME=client

   $ export APP_NAMESPACE=demo

   $ export AUDIENCE=$APP_NAME

10. 运行以下命令，创建一个 JWT 角色，将策略绑定到带有特定 SPIFFE ID 的工作负载：

    $ vault write auth/jwt/role/$ROLE -<<EOF
    {
      "role_type": "jwt",
      "user_claim": "sub",
      "bound_audiences": "$AUDIENCE",
      "bound_claims_type": "glob",
      "bound_claims": {
        "sub": "spiffe://$APP_DOMAIN/ns/$APP_NAMESPACE/sa/$APP_NAME"
      },
      "token_ttl": "24h",
      "token_policies": "$POLICY"
    }
    EOF

流程

1. 在本地机器上，运行以下命令为应用程序设置环境变量：

   $ export APP_NAME=client

   $ export APP_NAMESPACE=demo

   $ export AUDIENCE=$APP_NAME

2. 运行以下命令，应用 Kubernetes 清单，为 demo 应用创建命名空间、服务帐户和部署。这个部署挂载 SPIFFE CSI 驱动程序套接字。

   $ oc apply -f - <<EOF
   # ... (paste the full YAML from your provided code here) ...
   EOF

流程

1. 通过在运行的客户端 pod 中运行以下命令来获取 JWT-SVID：

   $ oc -n $APP_NAMESPACE exec -it $(oc get pod -o=jsonpath='{.items[*].metadata.name}' -l app=$APP_NAME -n $APP_NAMESPACE) \
     -- /opt/spire/bin/spire-agent api fetch jwt \
     -socketPath /run/spire/sockets/spire-agent.sock \
     -audience $AUDIENCE

2. 运行以下命令，从输出复制令牌并将其导出为本地机器上的环境变量：

   $ export IDENTITY_TOKEN=<Your-JWT-Token>

3. 运行以下命令来定义新环境变量：

   $ export ROLE="${NAME}-role"

4. 运行以下命令，使用 curl 将 JWT 令牌发送到 Vault 登录端点，以获取 Vault 客户端令牌：

   $ VAULT_TOKEN=$(curl -s --request POST --data '{ "jwt": "'"${IDENTITY_TOKEN}"'", "role": "'"${ROLE}"'"}' "${VAULT_ADDR}"/v1/auth/jwt/login | jq -r '.auth.client_token')