Autenticar usando um token do portador

Nesta página, explicamos como configurar a autenticação usando um token do portador para fazer login em clusters registrados fora do Google Cloud. Após a configuração, os administradores de cluster poderão fazer login nos clusters do console do Google Cloud. Há muitos tipos dele compatíveis, conforme especificado em Autenticação do Kubernetes. O método mais fácil é criar uma conta de serviço do Kubernetes (KSA, na sigla em inglês) no cluster e usar o token do portador para fazer login.

Outros métodos de autenticação

Como alternativa à configuração da autenticação usando um token do portador, é possível configurar um dos seguintes métodos de autenticação, dependendo das necessidades da sua organização:

  • Google Identity, que permite aos usuários fazer login usando a identidade do Google Cloud. Use essa opção se seus usuários já tiverem acesso ao Google Cloud com uma identidade do Google.

  • Se o cluster estiver configurado para usar um provedor de identidade OIDC, você poderá usá-lo para autenticar no cluster do Console do Google Cloud. Saiba como configurar os clusters do GKE para OIDC nos seguintes guias:

Se esses métodos de autenticação fornecidos pelo Google não forem adequados para sua organização, siga as instruções nesta página para configurar a autenticação usando um token do portador.

Conceder papéis do IAM para acesso pelo console do Google Cloud

Os usuários que querem visualizar clusters conectados usando o console do Google Cloud precisam ter, no mínimo, os seguintes papéis do IAM:

  • roles/container.viewer. Esse papel permite que os usuários visualizem recursos do contêiner no console do Google Cloud, incluindo a página Clusters do GKE. Para detalhes sobre as permissões incluídas nesse papel, consulte Papéis do Kubernetes Engine na documentação do IAM.

  • roles/gkehub.viewer. Com esse papel, os usuários podem ver os clusters fora do Google Cloud no console do Google Cloud. Os usuários não precisarão desse papel se a frota não incluir clusters fora do Google Cloud. Para ver detalhes sobre as permissões incluídas nesse papel, consulte Papéis do GKE Hub na documentação do IAM.

Execute os seguintes comandos para conceder esses papéis:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member='user:EMAIL_ADDRESS' \
    --role=roles/container.viewer
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member='user:EMAIL_ADDRESS' \
    --role=roles/gkehub.viewer

Substitua:

  • PROJECT_ID: o ID do projeto host da frota.

  • EMAIL_ADDRESS: o endereço de e-mail associado à conta do Google Cloud do usuário.

Para mais informações sobre a concessão de papéis do IAM, consulte Gerenciar o acesso a projetos, pastas e organizações na documentação do IAM.

Configurar o controle de acesso baseado em papéis

O acesso aos clusters é controlado com o controle de acesso baseado em papéis (RBAC, na sigla em inglês) do Kubernetes.

Recomendamos que você ou um administrador de cluster crie um KSA para cada usuário que faça login no cluster. Usar um token do portador é como usar uma senha, portanto, cada usuário precisa ter sua própria conta. Fazer login com o token do portador da KSA faz com que todas as operações sejam executadas como a KSA, restrita pelos papéis do RBAC retidos pela KSA.

A KSA precisa ter pelo menos os seguintes papéis do RBAC no cluster para acessá-lo pelo console:

Criar e aplicar o papel do RBAC cloud-console-reader

Os usuários autenticados que querem acessar os recursos de um cluster no Console do Google Cloud precisam ter as permissões relevantes do Kubernetes para fazer isso. Se você não quiser conceder a esses usuários permissões mais abrangentes, como as de um administrador de cluster, crie um papel personalizado de RBAC que inclua as permissões mínimas para visualizar os nós, volumes permanentes, pods e classes de armazenamento do cluster. Para definir esse conjunto de permissões, crie um recurso de RBAC ClusterRole, cloud-console-reader, no cluster.

cloud-console-reader concede aos usuários as permissões get, list e watch nos nós, volumes permanentes, pods e classes de armazenamento do cluster, o que permite que eles vejam detalhes sobre esses recursos.

kubectl

Para criar o ClusterRole do cloud-console-reader e aplicá-lo ao cluster, execute o seguinte comando:

cat <<EOF > cloud-console-reader.yaml
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: cloud-console-reader
rules:
- apiGroups: [""]
  resources: ["nodes", "persistentvolumes", "pods"]
  verbs: ["get", "list", "watch"]
- apiGroups: ["storage.k8s.io"]
  resources: ["storageclasses"]
  verbs: ["get", "list", "watch"]
EOF
kubectl apply -f cloud-console-reader.yaml

Depois, conceda esse papel às KSAs conforme descrito na próxima seção.

Criar e autorizar uma KSA

kubectl

Para criar uma KSA e vincular permissões a ela, siga estas etapas:

  1. Crie os recursos KSA e ClusterRoleBinding para vincular view e cloud-console-reader do Kubernetes RBAC ClusterRoles à KSA.

    KSA_NAME=KSA_NAME
kubectl create serviceaccount ${KSA_NAME}
kubectl create clusterrolebinding VIEW_BINDING_NAME \
   --clusterrole view --serviceaccount default:${KSA_NAME}
kubectl create clusterrolebinding CLOUD_CONSOLE_READER_BINDING_NAME \
   --clusterrole cloud-console-reader --serviceaccount default:${KSA_NAME}

    Substitua:

    • KSA_NAME: o nome escolhido para a KSA;
    • VIEW_BINDING_NAME: o nome escolhido para o recurso view ClusterRoleBinding, você pode dar o nome que quiser, mas pode achar mais fácil nomeá-lo após a KSA;
    • CLOUD_CONSOLE_READER_BINDING_NAME: o nome escolhido para o recurso cloud-console-reader ClusterRoleBinding, você pode dar o nome que quiser.

  2. Dependendo do acesso que a conta de serviço precisa ter, vincule outros papéis à KSA. Para mais opções, consulte os papéis padrão do Kubernetes.

    Por exemplo, se você quiser implantar um aplicativo do Kubernetes a partir do Cloud Marketplace, vincule o papel cluster-admin à KSA:

    kubectl create clusterrolebinding BINDING_NAME \
   --clusterrole cluster-admin --serviceaccount default:KSA_NAME

    Substitua BINDING_NAME pelo nome da vinculação de papel do cluster para a conta de serviço.

Autorizar outras contas

kubectl

Para que cada usuário ou conta de serviço tenha acesso ao cluster, crie recursos ClusterRoleBinding para vincular os papéis view e cloud-console-reader à conta:

  1. Vincule view e cloud-console-reader ClusterRoles:

    ACCOUNT_NAME=ACCOUNT_NAME
kubectl create clusterrolebinding VIEW_BINDING_NAME \
   --clusterrole view --serviceaccount default:${ACCOUNT_NAME}
kubectl create clusterrolebinding CLOUD_CONSOLE_READER_BINDING_NAME \
   --clusterrole cloud-console-reader --serviceaccount default:${ACCOUNT_NAME}

    Substitua:

    • ACCOUNT_NAME: a conta de serviço do Kubernetes;
    • VIEW_BINDING_NAME: o nome escolhido para o recurso view ClusterRoleBinding, você pode dar o nome que quiser, mas pode achar mais fácil nomeá-lo depois da conta de serviço ou usuário;
    • CLOUD_CONSOLE_READER_BINDING_NAME: o nome escolhido para o recurso view ClusterRoleBinding, você pode dar o nome que quiser.

  2. Vincule outros papéis, dependendo do acesso que a conta terá. Para mais opções, consulte os papéis padrão do Kubernetes.

    Por exemplo, para vincular o papel cluster-admin, execute o seguinte comando:

    kubectl create clusterrolebinding BINDING_NAME \
   --clusterrole cluster-admin --serviceaccount default:ACCOUNT_NAME

    Substitua BINDING_NAME pelo nome da vinculação de papel do cluster para a conta de serviço.

Conseguir o token do portador da KSA

kubectl

Para conseguir o token do portador da KSA, execute o seguinte comando:

SECRET_NAME=KSA_NAME-token

kubectl apply -f - << __EOF__
apiVersion: v1
kind: Secret
metadata:
  name: "${SECRET_NAME}"
  annotations:
    kubernetes.io/service-account.name: "${KSA_NAME}"
type: kubernetes.io/service-account-token
__EOF__

until [[ $(kubectl get -o=jsonpath="{.data.token}" "secret/${SECRET_NAME}") ]]; do
  echo "waiting for token..." >&2;
  sleep 1;
done

kubectl get secret ${SECRET_NAME} -o jsonpath='{$.data.token}' | base64 --decode

Substitua KSA_NAME pelo nome escolhido para a KSA.

Na saída desse comando, copie e salve o token para que os usuários possam usá-lo para fazer login no console do Google Cloud.