Az Azure RBAC használata Azure Arc-kompatibilis Kubernetes-fürtökön (előzetes verzió)

  • Cikk

A Kubernetes ClusterRoleBinding és a RoleBinding objektumtípusok segítenek natív módon meghatározni az engedélyezést a Kubernetesben. Ezzel a funkcióval Microsoft Entra-azonosítókat és szerepkör-hozzárendeléseket használhat az Azure-ban a fürt engedélyezési ellenőrzésének szabályozásához. Az Azure-szerepkör-hozzárendelésekkel részletesen szabályozhatja, hogy mely felhasználók olvashatják, írhatják és törölhetik a Kubernetes-objektumokat, például az üzembe helyezést, a podot és a szolgáltatást.

A funkció elméleti áttekintését az Azure Arc-kompatibilis Kubernetes azure RBAC-jén tekintheti meg.

Fontos

Az Azure Arc-kompatibilis Kubernetes előzetes verziójú funkciói önkiszolgáló, opt-in alapon érhetők el. Az előzetes verziókat "ahogy van" és "rendelkezésre állóként" biztosítjuk, és a szolgáltatási szerződésekből és a korlátozott jótállásból kizárjuk őket. Az Azure Arc-kompatibilis Kubernetes-előzetes verziókat részben az ügyfélszolgálat támogatja a legjobb munkával.

Előfeltételek

  • Telepítse vagy frissítse az Azure CLI-t a legújabb verzióra.

  • Telepítse az Azure CLI-bővítmény legújabb verzióját connectedk8s :

    az extension add --name connectedk8s

    Ha a connectedk8s bővítmény már telepítve van, az alábbi paranccsal frissítheti a legújabb verzióra:

    az extension update --name connectedk8s

  • Meglévő Azure Arc-kompatibilis Kubernetes-fürt csatlakoztatása:

Feljegyzés

Nem állíthatja be ezt a funkciót a Red Hat OpenShifthez vagy olyan felhőszolgáltatók felügyelt Kubernetes-ajánlataihoz, mint az Elastic Kubernetes Service vagy a Google Kubernetes Engine, ahol a felhasználó nem rendelkezik hozzáféréssel a fürt API-kiszolgálóhoz. Az Azure Kubernetes Service- (AKS-) fürtök esetében ez a funkció natív módon érhető el, és nem igényli az AKS-fürt Azure Archoz való csatlakoztatását.

Microsoft Entra alkalmazások beállítása

Kiszolgálóalkalmazás létrehozása

  1. Hozzon létre egy új Microsoft Entra-alkalmazást, és szerezze be az appId értékét. Ezt az értéket a rendszer a későbbi lépésekben a következőképpen serverApplicationIdhasználja: .

    CLUSTER_NAME="<name-of-arc-connected-cluster>"
TENANT_ID="<tenant>"
SERVER_UNIQUE_SUFFIX="<identifier_suffix>"
SERVER_APP_ID=$(az ad app create --display-name "${CLUSTER_NAME}Server" --identifier-uris "api://${TENANT_ID}/${SERVER_UNIQUE_SUFFIX}" --query appId -o tsv)
echo $SERVER_APP_ID

  2. Ha "Bejelentkezési és olvasási felhasználói profil" API-engedélyeket szeretne adni a kiszolgálóalkalmazásnak, másolja ki ezt a JSON-t, és mentse egy oauth2-permissions.json nevű fájlba:

    {
    "oauth2PermissionScopes": [
        {
            "adminConsentDescription": "Sign in and read user profile",
            "adminConsentDisplayName": "Sign in and read user profile",
            "id": "<paste_the_SERVER_APP_ID>",
            "isEnabled": true,
            "type": "User",
            "userConsentDescription": "Sign in and read user profile",
            "userConsentDisplayName": "Sign in and read user profile",
            "value": "User.Read"
        }
    ]
}

  3. Frissítse az alkalmazás csoporttagsági jogcímeit. Futtassa a parancsokat a fájllal oauth2-permissions.json megegyező könyvtárban. Az Azure Arc-kompatibilis Kubernetes signInAudience RBAC-nek azureADMyOrg értékre kell állítania:

    az ad app update --id "${SERVER_APP_ID}" --set groupMembershipClaims=All
az ad app update --id ${SERVER_APP_ID} --set  api=@oauth2-permissions.json
az ad app update --id ${SERVER_APP_ID} --set  signInAudience=AzureADMyOrg
SERVER_OBJECT_ID=$(az ad app show --id "${SERVER_APP_ID}" --query "id" -o tsv)
az rest --method PATCH --headers "Content-Type=application/json" --uri https://graph.microsoft.com/v1.0/applications/${SERVER_OBJECT_ID}/ --body '{"api":{"requestedAccessTokenVersion": 1}}'

  4. Hozzon létre egy szolgáltatásnevet, és kérje le a password mező értékét. Ezt az értéket később kell megadni, mint serverApplicationSecret amikor engedélyezi ezt a funkciót a fürtön. Ez a titkos kód alapértelmezés szerint egy évig érvényes, és ezt követően el kell forgatni. Egyéni lejárati időtartam beállításához használja a következőt az ad sp credential reset:

    az ad sp create --id "${SERVER_APP_ID}"
SERVER_APP_SECRET=$(az ad sp credential reset --id "${SERVER_APP_ID}"  --query password -o tsv)

  5. Adjon "Bejelentkezési és olvasási felhasználói profil" API-engedélyeket az alkalmazásnak a következő használatával az ad app permission:

    az ad app permission add --id "${SERVER_APP_ID}" --api 00000003-0000-0000-c000-000000000000 --api-permissions e1fe6dd8-ba31-4d61-89e7-88639da4683d=Scope
az ad app permission grant --id "${SERVER_APP_ID}" --api 00000003-0000-0000-c000-000000000000 --scope User.Read

    Feljegyzés

    Ezt a lépést egy Azure-alkalmazás rendszergazdájának kell futtatnia.

    A funkció éles környezetben való használatához javasoljuk, hogy minden fürthöz hozzon létre egy másik kiszolgálóalkalmazást.

Ügyfélalkalmazás létrehozása

  1. Hozzon létre egy új Microsoft Entra-alkalmazást, és szerezze be az appId értékét. Ezt az értéket a rendszer a későbbi lépésekben a következőképpen clientApplicationIdhasználja: .

    CLIENT_UNIQUE_SUFFIX="<identifier_suffix>" 
CLIENT_APP_ID=$(az ad app create --display-name "${CLUSTER_NAME}Client" --is-fallback-public-client --public-client-redirect-uris "api://${TENANT_ID}/${CLIENT_UNIQUE_SUFFIX}" --query appId -o tsv)
echo $CLIENT_APP_ID

  2. Hozzon létre egy egyszerű szolgáltatást ehhez az ügyfélalkalmazáshoz:

    az ad sp create --id "${CLIENT_APP_ID}"

  3. oAuthPermissionId A kiszolgálóalkalmazás értékének lekérése:

        az ad app show --id "${SERVER_APP_ID}" --query "api.oauth2PermissionScopes[0].id" -o tsv

  4. Adja meg az ügyfélalkalmazáshoz szükséges engedélyeket. Az Azure Arc-kompatibilis Kubernetes signInAudience RBAC-nek azureADMyOrg értékre kell állítania:

        az ad app permission add --id "${CLIENT_APP_ID}" --api "${SERVER_APP_ID}" --api-permissions <oAuthPermissionId>=Scope
    RESOURCE_APP_ID=$(az ad app show --id "${CLIENT_APP_ID}"  --query "requiredResourceAccess[0].resourceAppId" -o tsv)
    az ad app permission grant --id "${CLIENT_APP_ID}" --api "${RESOURCE_APP_ID}" --scope User.Read
    az ad app update --id ${CLIENT_APP_ID} --set  signInAudience=AzureADMyOrg
    CLIENT_OBJECT_ID=$(az ad app show --id "${CLIENT_APP_ID}" --query "id" -o tsv)
    az rest --method PATCH --headers "Content-Type=application/json" --uri https://graph.microsoft.com/v1.0/applications/${CLIENT_OBJECT_ID}/ --body '{"api":{"requestedAccessTokenVersion": 1}}'

Szerepkör-hozzárendelés létrehozása a kiszolgálóalkalmazás számára

A kiszolgálóalkalmazásnak szüksége van az Microsoft.Authorization/*/read engedélyekre, hogy megerősíthesse, hogy a kérést küldő felhasználó jogosult-e a kérelemben szereplő Kubernetes-objektumokra.

  1. Hozzon létre egy accessCheck.json nevű fájlt a következő tartalommal:

    {
"Name": "Read authorization",
"IsCustom": true,
"Description": "Read authorization",
"Actions": ["Microsoft.Authorization/*/read"],
"NotActions": [],
"DataActions": [],
"NotDataActions": [],
"AssignableScopes": [
  "/subscriptions/<subscription-id>"
  ]
}

    Cserélje le <subscription-id> a tényleges előfizetés-azonosítóra.

  2. Futtassa a következő parancsot az új egyéni szerepkör létrehozásához:

    ROLE_ID=$(az role definition create --role-definition ./accessCheck.json --query id -o tsv)

  3. Hozzon létre egy szerepkör-hozzárendelést a kiszolgálóalkalmazásban assignee a létrehozott szerepkör használatával:

    az role assignment create --role "${ROLE_ID}" --assignee "${SERVER_APP_ID}" --scope /subscriptions/<subscription-id>

Az Azure RBAC engedélyezése a fürtben

Engedélyezze az Azure szerepköralapú hozzáférés-vezérlést (RBAC) az Azure Arc-kompatibilis Kubernetes-fürtön az alábbi parancs futtatásával:

az connectedk8s enable-features -n <clusterName> -g <resourceGroupName> --features azure-rbac --app-id "${SERVER_APP_ID}" --app-secret "${SERVER_APP_SECRET}"

Feljegyzés

Az előző parancs futtatása előtt győződjön meg arról, hogy a kubeconfig gépen lévő fájl arra a fürtre mutat, amelyen engedélyezni fogja az Azure RBAC szolgáltatást.

Használja --skip-azure-rbac-list az előző paranccsal a felhasználónevek, e-mailek és OpenID-kapcsolatok vesszővel tagolt listáját, amelyek engedélyezési ellenőrzéseken mennek keresztül az Azure RBAC helyett natív Kubernetes-natív ClusterRoleBinding és RoleBinding objektumok használatával.

Általános fürt, ahol nem fut egyeztető a apiserver specifikáción

  1. SSH a fürt minden fő csomópontjára, és hajtsa végre a következő lépéseket:

    Ha a pod kube-apiserver statikus:

    1. A azure-arc-guard-manifests névtér titkos kube-system kódja két fájlt tartalmaz: guard-authn-webhook.yaml és guard-authz-webhook.yaml. Másolja ezeket a fájlokat a /etc/guard csomópont könyvtárába.

      sudo mkdir -p /etc/guard
kubectl get secrets azure-arc-guard-manifests -n kube-system -o json | jq -r '.data."guard-authn-webhook.yaml"' | base64 -d > /etc/guard/guard-authn-webhook.yaml
kubectl get secrets azure-arc-guard-manifests -n kube-system -o json | jq -r '.data."guard-authz-webhook.yaml"' | base64 -d > /etc/guard/guard-authz-webhook.yaml

    2. Nyissa meg a apiserver jegyzékfájlt szerkesztési módban:

      sudo vi /etc/kubernetes/manifests/kube-apiserver.yaml

    3. Adja hozzá a következő specifikációt a következő területen volumes:

      - name: azure-rbac
    hostPath:
    path: /etc/guard
    type: Directory

    4. Adja hozzá a következő specifikációt a következő területen volumeMounts:

      - mountPath: /etc/guard
    name: azure-rbac
    readOnly: true

    Ha az Ön kube-apiserver nem statikus pod:

    1. Nyissa meg a apiserver jegyzékfájlt szerkesztési módban:

      sudo vi /etc/kubernetes/manifests/kube-apiserver.yaml

    2. Adja hozzá a következő specifikációt a következő területen volumes:

      - name: azure-rbac
    secret:
    secretName: azure-arc-guard-manifests

    3. Adja hozzá a következő specifikációt a következő területen volumeMounts:

      - mountPath: /etc/guard
    name: azure-rbac
    readOnly: true

  2. Adja hozzá a következő apiserver argumentumokat:

    - --authentication-token-webhook-config-file=/etc/guard/guard-authn-webhook.yaml
- --authentication-token-webhook-cache-ttl=5m0s
- --authorization-webhook-cache-authorized-ttl=5m0s
- --authorization-webhook-config-file=/etc/guard/guard-authz-webhook.yaml
- --authorization-webhook-version=v1
- --authorization-mode=Node,RBAC,Webhook

    Ha a Kubernetes-fürt 1.19.0-s vagy újabb verziójú, a következő apiserver argumentumot is be kell állítania:

    - --authentication-token-webhook-version=v1

  3. Mentse és zárja be a szerkesztőt a pod frissítéséhez apiserver .

Fürt API használatával létrehozott fürt

  1. Másolja a számítási feladatfürt hitelesítési és engedélyezési webhook konfigurációs fájljait tartalmazó védőtitkot a gépére:

    kubectl get secret azure-arc-guard-manifests -n kube-system -o yaml > azure-arc-guard-manifests.yaml

  2. Módosítsa az namespaceazure-arc-guard-manifests.yaml fájl mezőjét a felügyeleti fürt névterére, ahol az egyéni erőforrásokat alkalmazza számítási feladatok fürtjeinek létrehozásához.

  3. A jegyzék alkalmazása:

    kubectl apply -f azure-arc-guard-manifests.yaml

  4. Az objektum szerkesztése a KubeadmControlPlane következő futtatásával kubectl edit kcp <clustername>-control-plane:

    1. Adja hozzá a következő kódrészletet a következő alatt files:

      - contentFrom:
    secret:
      key: guard-authn-webhook.yaml
      name: azure-arc-guard-manifests
  owner: root:root
  path: /etc/kubernetes/guard-authn-webhook.yaml
  permissions: "0644"
- contentFrom:
    secret:
      key: guard-authz-webhook.yaml
      name: azure-arc-guard-manifests
  owner: root:root
  path: /etc/kubernetes/guard-authz-webhook.yaml
  permissions: "0644"

    2. Adja hozzá a következő kódrészletet a következő alatt apiServer>extraVolumes:

      - hostPath: /etc/kubernetes/guard-authn-webhook.yaml
    mountPath: /etc/guard/guard-authn-webhook.yaml
    name: guard-authn
    readOnly: true
- hostPath: /etc/kubernetes/guard-authz-webhook.yaml
    mountPath: /etc/guard/guard-authz-webhook.yaml
    name: guard-authz
    readOnly: true

    3. Adja hozzá a következő kódrészletet a következő alatt apiServer>extraArgs:

      authentication-token-webhook-cache-ttl: 5m0s
authentication-token-webhook-config-file: /etc/guard/guard-authn-webhook.yaml
authentication-token-webhook-version: v1
authorization-mode: Node,RBAC,Webhook
authorization-webhook-cache-authorized-ttl: 5m0s
authorization-webhook-config-file: /etc/guard/guard-authz-webhook.yaml
authorization-webhook-version: v1

    4. Mentse és zárja be az objektum frissítését KubeadmControlPlane . Várja meg, amíg ezek a módosítások megjelennek a számítási feladatfürtön.

Szerepkör-hozzárendelések létrehozása a felhasználók számára a fürt eléréséhez

Az Azure Arc-kompatibilis Kubernetes-erőforrás tulajdonosai beépített szerepkörök vagy egyéni szerepkörök használatával hozzáférést biztosíthatnak más felhasználóknak a Kubernetes-fürthöz.

Beépített szerepkörök

Szerepkör Leírás
Azure Arc Kubernetes Viewer Az írásvédett hozzáférés lehetővé teszi a névtérben lévő objektumok többségének megtekintését. Ez a szerepkör nem teszi lehetővé a titkos kódok megtekintését, mert read a titkos kódokra vonatkozó engedély lehetővé tenné a névtérben lévő hitelesítő adatokhoz ServiceAccount való hozzáférést. Ezek a hitelesítő adatok lehetővé tennék az API-hozzáférést ezen ServiceAccount az értéken keresztül (a jogosultságok eszkalálásának egy formája).
Azure Arc Kubernetes-író Olvasási/írási hozzáférést tesz lehetővé a névtérben lévő legtöbb objektumhoz. Ez a szerepkör nem teszi lehetővé a szerepkörök vagy szerepkörkötések megtekintését vagy módosítását. Ez a szerepkör azonban lehetővé teszi a titkos kódok elérését és a podok bármely értékként ServiceAccount való futtatását a névtérben, így a névtér bármely ServiceAccount értékének API-hozzáférési szintjeinek megszerzésére használható.
Azure Arc Kubernetes Rendszergazda Engedélyezi a rendszergazdai hozzáférést. A névtéren RoleBindingbelül a következő módon adható meg: . Ha a névtérben RoleBindinghasználja, olvasási/írási hozzáférést biztosít a névtérben lévő legtöbb erőforráshoz, beleértve a szerepkörök és szerepkör-kötések létrehozását a névtérben. Ez a szerepkör nem teszi lehetővé az erőforráskvóta vagy a névtér írási hozzáférését.
Azure Arc Kubernetes-fürt Rendszergazda Lehetővé teszi, hogy a felügyelő bármilyen műveletet végrehajtson bármely erőforráson. Amikor használatban ClusterRoleBindingvan, teljes körű vezérlést biztosít a fürtben és az összes névtérben lévő összes erőforrás felett. Amikor ezt használja RoleBinding, teljes körű vezérlést biztosít a szerepkör-kötés névterében lévő összes erőforrás felett, beleértve magát a névteret is.

A fürterőforrás Hozzáférés-vezérlés (IAM) paneljén az Azure Portalon létrehozhat szerepkör-hozzárendeléseket az Azure Arc-kompatibilis Kubernetes-fürtre. A következő Azure CLI-parancsokat is használhatja:

az role assignment create --role "Azure Arc Kubernetes Cluster Admin" --assignee <AZURE-AD-ENTITY-ID> --scope $ARM_ID

Ezekben a parancsokban AZURE-AD-ENTITY-ID lehet felhasználónév (például testuser@mytenant.onmicrosoft.com) vagy akár egy appId szolgáltatásnév értéke is.

Íme egy másik példa egy szerepkör-hozzárendelés létrehozására, amely egy adott névtérre terjed ki a fürtben:

az role assignment create --role "Azure Arc Kubernetes Viewer" --assignee <AZURE-AD-ENTITY-ID> --scope $ARM_ID/namespaces/<namespace-name>

Feljegyzés

A fürtre vonatkozó szerepkör-hozzárendeléseket az Azure Portal vagy az Azure CLI használatával hozhat létre. Azonban csak az Azure CLI használható a névterekre hatókörrel rendelkező szerepkör-hozzárendelések létrehozására.

Egyéni szerepkörök

Saját szerepkördefiníciót hozhat létre a szerepkör-hozzárendelésekben való használatra.

Tekintse át az alábbi példát egy olyan szerepkördefinícióra, amely lehetővé teszi a felhasználó számára, hogy csak az üzemelő példányokat olvassa. További információkért tekintse meg a szerepkördefiníciók létrehozásához használható adatműveletek teljes listáját.

Másolja a következő JSON-objektumot egy custom-role.json nevű fájlba. Cserélje le a <subscription-id> helyőrzőt a tényleges előfizetés-azonosítóra. Az egyéni szerepkör az egyik adatműveletet használja, és lehetővé teszi az összes üzembe helyezés megtekintését abban a hatókörben (fürtben vagy névtérben), ahol a szerepkör-hozzárendelés létrejön.

{
    "Name": "Arc Deployment Viewer",
    "Description": "Lets you view all deployments in cluster/namespace.",
    "Actions": [],
    "NotActions": [],
    "DataActions": [
        "Microsoft.Kubernetes/connectedClusters/apps/deployments/read"
    ],
    "NotDataActions": [],
    "assignableScopes": [
        "/subscriptions/<subscription-id>"
    ]
}

  1. Hozza létre a szerepkördefiníciót a következő parancs futtatásával abból a mappából, amelyben custom-role.json mentette:

    az role definition create --role-definition @custom-role.json

  2. Szerepkör-hozzárendelés létrehozása ezzel az egyéni szerepkördefinícióval:

    az role assignment create --role "Arc Deployment Viewer" --assignee <AZURE-AD-ENTITY-ID> --scope $ARM_ID/namespaces/<namespace-name>

Kubectl konfigurálása felhasználói hitelesítő adatokkal

Kétféleképpen szerezheti be a kubeconfig fájlt, amelyhez hozzá kell férnie a fürthöz:

Fürtcsatlakozás használata

Futtassa a következő parancsot a proxyfolyamat elindításához:

az connectedk8s proxy -n <clusterName> -g <resourceGroupName>

A proxyfolyamat futtatása után megnyithat egy másik lapot a konzolon, hogy elkezdje elküldeni a kéréseket a fürtnek.

Megosztott kubeconfig-fájl használata

A megosztott kubeconfig használata a Kubernetes verziójától függően kissé eltérő lépéseket igényel.

  1. Futtassa a következő parancsot a felhasználó hitelesítő adatainak beállításához:

    kubectl config set-credentials <testuser>@<mytenant.onmicrosoft.com> \
--auth-provider=azure \
--auth-provider-arg=environment=AzurePublicCloud \
--auth-provider-arg=client-id=<clientApplicationId> \
--auth-provider-arg=tenant-id=<tenantId> \
--auth-provider-arg=apiserver-id=<serverApplicationId>

  2. Nyissa meg a korábban létrehozott kubeconfig fájlt. A csoportban contextsellenőrizze, hogy a fürthöz társított környezet az előző lépésben létrehozott felhasználói hitelesítő adatokra mutat-e. Az aktuális környezetnek a felhasználói hitelesítő adatokra való beállításához futtassa a következő parancsot:

    kubectl config set-context --current=true --user=<testuser>@<mytenant.onmicrosoft.com>

  3. Adja hozzá a konfigurációs mód beállítását a következő területen user>config:

    name: testuser@mytenant.onmicrosoft.com
user:
    auth-provider:
    config:
        apiserver-id: $SERVER_APP_ID
        client-id: $CLIENT_APP_ID
        environment: AzurePublicCloud
        tenant-id: $TENANT_ID
        config-mode: "1"
    name: azure

Feljegyzés

Az Exec beépülő modul egy Kubernetes-hitelesítési stratégia, amely lehetővé teszi kubectl egy külső parancs futtatását a felhasználói hitelesítő adatok fogadásához.apiserver A Kubernetes 1.26-os verziójától kezdve az alapértelmezett Azure-engedélyezési beépülő modul már nem szerepel az és a client-gokubectl. A későbbi verziókban az exec beépülő modul felhasználói hitelesítő adatok fogadásához az Azure Kubelogin hitelesítő (exec) beépülő modult kell használnia, client-go amely az Azure-hitelesítést implementálja.

  1. Az Azure Kubelogin telepítése:

    • Windows vagy Mac esetén kövesse az Azure Kubelogin telepítési utasításait.

    • Linux vagy Ubuntu esetén töltse le a kubelogin legújabb verzióját, majd futtassa a következő parancsokat:

      curl -LO https://github.com/Azure/kubelogin/releases/download/"$KUBELOGIN_VERSION"/kubelogin-linux-amd64.zip 

unzip kubelogin-linux-amd64.zip 

sudo mv bin/linux_amd64/kubelogin /usr/local/bin/ 

sudo chmod +x /usr/local/bin/kubelogin

  2. Konvertálja a kubelogint a megfelelő bejelentkezési mód használatára. Például egy Microsoft Entra-felhasználóval való eszközkód-bejelentkezés esetén a parancsok a következők:

    export KUBECONFIG=/path/to/kubeconfig

kubelogin convert-kubeconfig

Kérelmek küldése a fürtnek

  1. Futtassa bármelyik kubectl parancsot. Példa:

    • kubectl get nodes
    • kubectl get pods

  2. Miután a rendszer böngészőalapú hitelesítést kér, másolja ki az eszköz bejelentkezési URL-címét (https://microsoft.com/devicelogin) és nyissa meg a webböngészőben.

  3. Írja be a konzolra nyomtatott kódot. Másolja és illessze be a kódot a terminálon az eszközhitelesítési bemenet kérésébe.

  4. Adja meg a felhasználónevet (testuser@mytenant.onmicrosoft.com) és a hozzá tartozó jelszót.

  5. Ha ilyen hibaüzenet jelenik meg, az azt jelenti, hogy nem fér hozzá a kért erőforráshoz:

    Error from server (Forbidden): nodes is forbidden: User "testuser@mytenant.onmicrosoft.com" cannot list resource "nodes" in API group "" at the cluster scope: User doesn't have access to the resource in Azure. Update role assignment to allow access.

    A rendszergazdának létre kell hoznia egy új szerepkör-hozzárendelést, amely engedélyezi a felhasználó számára az erőforráshoz való hozzáférést.

Feltételes hozzáférés használata a Microsoft Entra-azonosítóval

Ha a Microsoft Entra ID-t az Azure Arc-kompatibilis Kubernetes-fürttel integrálja, a feltételes hozzáféréssel is szabályozhatja a fürthöz való hozzáférést.

Feljegyzés

A Microsoft Entra feltételes hozzáférés a Microsoft Entra ID P2 képessége.

Példa feltételes hozzáférési szabályzat létrehozásához a fürthöz:

  1. Az Azure Portal tetején keresse meg és válassza ki a Microsoft Entra-azonosítót.

  2. A bal oldali Microsoft Entra ID menüben válassza a Nagyvállalati alkalmazások lehetőséget.

  3. A bal oldali vállalati alkalmazások menüjében válassza a Feltételes hozzáférés lehetőséget.

  4. A bal oldalon a Feltételes hozzáférés menüben válassza a Szabályzatok>új szabályzata lehetőséget.

    Képernyőkép a feltételes hozzáférési szabályzat azure portalon való hozzáadásáról.

  5. Adja meg a szabályzat nevét, például az arc-k8s-policy nevet.

  6. Válassza a Felhasználók és csoportok elemet. A Belefoglalás csoportban válassza a Felhasználók és csoportok kiválasztása lehetőséget. Ezután válassza ki azokat a felhasználókat és csoportokat, ahol alkalmazni szeretné a szabályzatot. Ebben a példában válassza ki ugyanazt a Microsoft Entra-csoportot, amely rendszergazdai hozzáféréssel rendelkezik a fürthöz.

    Képernyőkép a feltételes hozzáférési szabályzat alkalmazásához kiválasztott felhasználókról vagy csoportokról.

  7. Válassza a Felhőalkalmazások vagy műveletek lehetőséget. A Belefoglalás csoportban válassza az Alkalmazások kiválasztása lehetőséget. Ezután keresse meg és válassza ki a korábban létrehozott kiszolgálóalkalmazást.

    Képernyőkép egy kiszolgálóalkalmazás kiválasztásáról az Azure Portalon.

  8. A Hozzáférés-vezérlés csoportban válassza a Támogatás lehetőséget. Válassza a Hozzáférés>megadása: Az eszköz megfelelőként való megjelölésének megkövetelése.

    Képernyőkép arról, hogyan engedélyezhet csak megfelelő eszközöket az Azure Portalon.

  9. A Házirend engedélyezése csoportban válassza a Létrehozás gombot>.

    Képernyőkép a feltételes hozzáférési szabályzat azure portalon való engedélyezéséről.

Ismét elérheti a fürtöt. Futtassa például a parancsot a kubectl get nodes fürt csomópontjainak megtekintéséhez:

kubectl get nodes

Az utasításokat követve jelentkezzen be újra. Egy hibaüzenet azt jelzi, hogy sikeresen bejelentkezett, de a rendszergazda megköveteli, hogy a hozzáférést kérő eszközt a Microsoft Entra ID kezelje az erőforrás eléréséhez. Tegye a következők egyikét:

  1. Az Azure Portalon nyissa meg a Microsoft Entra-azonosítót.

  2. Válassza a Vállalati alkalmazások elemet. Ezután a Tevékenység csoportban válassza a Bejelentkezések lehetőséget.

  3. A felső bejegyzés a feltételes hozzáférés állapota és sikeres végrehajtásasikertelenségétmutatja. Jelölje ki a bejegyzést, majd válassza a Feltételes hozzáférés lehetőséget a Részletek területen. Figyelje meg, hogy a feltételes hozzáférési szabályzat szerepel a listában.

    Képernyőkép egy sikertelen bejelentkezési bejegyzésről az Azure Portalon.

Igény szerint fürthozzáférés konfigurálása a Microsoft Entra-azonosítóval

A fürthozzáférés-vezérlés másik lehetősége a Privileged Identity Management (PIM) használata az igény szerinti kérelmekhez.

Feljegyzés

A Microsoft Entra PIM egy Microsoft Entra ID P2 képesség. A Microsoft Entra ID termékváltozatairól további információt a díjszabási útmutatóban talál.

A fürthöz tartozó igény szerint történő hozzáférési kérelmek konfigurálásához hajtsa végre a következő lépéseket:

  1. Az Azure Portal tetején keresse meg és válassza ki a Microsoft Entra-azonosítót.

  2. Jegyezze fel a bérlőazonosítót. Az utasítások további részében az azonosítót <tenant-id>a következőképpen fogjuk hivatkozni: .

    Képernyőkép a Microsoft Entra-azonosító részleteiről az Azure Portalon.

  3. A bal oldali Microsoft Entra ID menü Kezelés csoportjában válassza az Új csoportok csoport> lehetőséget.

  4. Győződjön meg arról, hogy a Biztonság csoporttípushoz van kiválasztva. Adjon meg egy csoportnevet, például a myJITGroup nevet. A Microsoft Entra-szerepkörök ehhez a csoporthoz (előzetes verzió) rendelhetők hozzá, válassza az Igen lehetőséget. Végül válassza a Létrehozás lehetőséget.

    Képernyőkép az új csoport részleteiről az Azure Portalon.

  5. Visszakerül a Csoportok lapra. Jelölje ki az újonnan létrehozott csoportot, és jegyezze fel az objektumazonosítót. Az utasítások további részében erre az azonosítóra <object-id>fogjuk hivatkozni.

    Képernyőkép az új csoport objektumazonosítójáról az Azure Portalon.

  6. Az Azure Portal bal oldali Tevékenység menüjében válassza a Privileged Access (Előzetes verzió) lehetőséget. Ezután válassza a Privileged Access engedélyezése lehetőséget.

    Képernyőkép a kiemelt hozzáférés Azure Portalon való engedélyezéséhez szükséges beállításokról.

  7. Válassza a Hozzárendelések hozzáadása lehetőséget a hozzáférés megadásának megkezdéséhez.

    Képernyőkép az aktív hozzárendelések Azure Portalon való hozzáadásáról.

  8. Válassza ki a tag szerepkörét, és jelölje ki azokat a felhasználókat és csoportokat, akiknek fürthozzáférést szeretne biztosítani. A csoport rendszergazdája bármikor módosíthatja ezeket a hozzárendeléseket. Ha készen áll a továbblépésre, válassza a Tovább gombot.

    Képernyőkép a hozzárendelések Azure Portalon való hozzáadásáról.

  9. Válassza ki az Aktív hozzárendelés típusát, válassza ki a kívánt időtartamot, és adjon meg egy indoklást. Ha készen áll a folytatásra, válassza a Hozzárendelés lehetőséget. A hozzárendeléstípusokról további információt a Privileged Identity Management jogosultságának hozzárendelése (előzetes verzió) című témakörben talál.

    Képernyőkép a hozzárendelés tulajdonságairól az Azure Portalon.

A hozzárendelések elvégzése után ellenőrizze, hogy az igény szerinti hozzáférés működik-e a fürt elérésével. A parancs használatával például megtekintheti a kubectl get nodes fürt csomópontjait:

kubectl get nodes

Jegyezze fel a hitelesítési követelményt, és kövesse a hitelesítés lépéseit. Ha a hitelesítés sikeres, az alábbihoz hasonló kimenetnek kell megjelennie:

To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code AAAAAAAAA to authenticate.

NAME      STATUS   ROLES    AGE      VERSION
node-1    Ready    agent    6m36s    v1.18.14
node-2    Ready    agent    6m42s    v1.18.14
node-3    Ready    agent    6m33s    v1.18.14

A kiszolgálóalkalmazás titkos kódjának frissítése

Ha a kiszolgálóalkalmazás szolgáltatásnévének titkos kódja lejárt, el kell forgatnia.

SERVER_APP_SECRET=$(az ad sp credential reset --id "${SERVER_APP_ID}" --query password -o tsv)

Következő lépések