Configure Service Accounts for Pods

A service account provides an identity for processes that run in a Pod.

Note: This document is a user introduction to Service Accounts and describes how service accounts behave in a cluster set up as recommended by the Kubernetes project. Your cluster administrator may have customized the behavior in your cluster, in which case this documentation may not apply.

When you (a human) access the cluster (for example, using kubectl), you are authenticated by the apiserver as a particular User Account (currently this is usually admin, unless your cluster administrator has customized your cluster). Processes in containers inside pods can also contact the apiserver. When they do, they are authenticated as a particular Service Account (for example, default).

Before you begin

You need to have a Kubernetes cluster, and the kubectl command-line tool must be configured to communicate with your cluster. If you do not already have a cluster, you can create one by using minikube or you can use one of these Kubernetes playgrounds:

To check the version, enter kubectl version.

Use the Default Service Account to access the API server.

When you create a pod, if you do not specify a service account, it is automatically assigned the default service account in the same namespace. If you get the raw json or yaml for a pod you have created (for example, kubectl get pods/<podname> -o yaml), you can see the spec.serviceAccountName field has been automatically set.

You can access the API from inside a pod using automatically mounted service account credentials, as described in Accessing the Cluster. The API permissions of the service account depend on the authorization plugin and policy in use.

In version 1.6+, you can opt out of automounting API credentials for a service account by setting automountServiceAccountToken: false on the service account:

  1. apiVersion: v1
  2. kind: ServiceAccount
  3. metadata:
  4.   name: build-robot
  5. automountServiceAccountToken: false
  6. ...

In version 1.6+, you can also opt out of automounting API credentials for a particular pod:

  1. apiVersion: v1
  2. kind: Pod
  3. metadata:
  4.   name: my-pod
  5. spec:
  6.   serviceAccountName: build-robot
  7.   automountServiceAccountToken: false
  8.   ...

The pod spec takes precedence over the service account if both specify a automountServiceAccountToken value.

Use Multiple Service Accounts.

Every namespace has a default service account resource called default. You can list this and any other serviceAccount resources in the namespace with this command:

  1. kubectl get serviceaccounts

The output is similar to this:

  1. NAME      SECRETS    AGE
  2. default   1          1d

You can create additional ServiceAccount objects like this:

  1. kubectl apply -f - <<EOF
  2. apiVersion: v1
  3. kind: ServiceAccount
  4. metadata:
  5.   name: build-robot
  6. EOF

The name of a ServiceAccount object must be a valid DNS subdomain name.

If you get a complete dump of the service account object, like this:

  1. kubectl get serviceaccounts/build-robot -o yaml

The output is similar to this:

  1. apiVersion: v1
  2. kind: ServiceAccount
  3. metadata:
  4.   creationTimestamp: 2015-06-16T00:12:59Z
  5.   name: build-robot
  6.   namespace: default
  7.   resourceVersion: "272500"
  8.   uid: 721ab723-13bc-11e5-aec2-42010af0021e
  9. secrets:
  10. - name: build-robot-token-bvbk5

then you will see that a token has automatically been created and is referenced by the service account.

You may use authorization plugins to set permissions on service accounts.

To use a non-default service account, simply set the spec.serviceAccountName field of a pod to the name of the service account you wish to use.

The service account has to exist at the time the pod is created, or it will be rejected.

You cannot update the service account of an already created pod.

You can clean up the service account from this example like this:

  1. kubectl delete serviceaccount/build-robot

Manually create a service account API token.

Suppose we have an existing service account named “build-robot” as mentioned above, and we create a new secret manually.

  1. kubectl apply -f - <<EOF
  2. apiVersion: v1
  3. kind: Secret
  4. metadata:
  5.   name: build-robot-secret
  6.   annotations:
  7.     kubernetes.io/service-account.name: build-robot
  8. type: kubernetes.io/service-account-token
  9. EOF

Now you can confirm that the newly built secret is populated with an API token for the “build-robot” service account.

Any tokens for non-existent service accounts will be cleaned up by the token controller.

  1. kubectl describe secrets/build-robot-secret

The output is similar to this:

  1. Name:           build-robot-secret
  2. Namespace:      default
  3. Labels:         <none>
  4. Annotations:    kubernetes.io/service-account.name=build-robot
  5.                 kubernetes.io/service-account.uid=da68f9c6-9d26-11e7-b84e-002dc52800da
  7. Type:   kubernetes.io/service-account-token
  9. Data
  10. ====
  11. ca.crt:         1338 bytes
  12. namespace:      7 bytes
  13. token:          ...

Note: The content of token is elided here.

Add ImagePullSecrets to a service account

Create an imagePullSecret

  • Create an imagePullSecret, as described in Specifying ImagePullSecrets on a Pod.

    1. kubectl create secret docker-registry myregistrykey --docker-server=DUMMY_SERVER \
    2.         --docker-username=DUMMY_USERNAME --docker-password=DUMMY_DOCKER_PASSWORD \
    3.         --docker-email=DUMMY_DOCKER_EMAIL

  • Verify it has been created.

    1. kubectl get secrets myregistrykey

    The output is similar to this:

    1. NAME             TYPE                              DATA    AGE
    2. myregistrykey    kubernetes.io/.dockerconfigjson   1       1d

Add image pull secret to service account

Next, modify the default service account for the namespace to use this secret as an imagePullSecret.

  1. kubectl patch serviceaccount default -p '{"imagePullSecrets": [{"name": "myregistrykey"}]}'

You can instead use kubectl edit, or manually edit the YAML manifests as shown below:

  1. kubectl get serviceaccounts default -o yaml > ./sa.yaml

The output of the sa.yaml file is similar to this:

  1. apiVersion: v1
  2. kind: ServiceAccount
  3. metadata:
  4.   creationTimestamp: 2015-08-07T22:02:39Z
  5.   name: default
  6.   namespace: default
  7.   resourceVersion: "243024"
  8.   uid: 052fb0f4-3d50-11e5-b066-42010af0d7b6
  9. secrets:
  10. - name: default-token-uudge

Using your editor of choice (for example vi), open the sa.yaml file, delete line with key resourceVersion, add lines with imagePullSecrets: and save.

The output of the sa.yaml file is similar to this:

  1. apiVersion: v1
  2. kind: ServiceAccount
  3. metadata:
  4.   creationTimestamp: 2015-08-07T22:02:39Z
  5.   name: default
  6.   namespace: default
  7.   uid: 052fb0f4-3d50-11e5-b066-42010af0d7b6
  8. secrets:
  9. - name: default-token-uudge
  10. imagePullSecrets:
  11. - name: myregistrykey

Finally replace the serviceaccount with the new updated sa.yaml file

  1. kubectl replace serviceaccount default -f ./sa.yaml

Verify imagePullSecrets was added to pod spec

Now, when a new Pod is created in the current namespace and using the default ServiceAccount, the new Pod has its spec.imagePullSecrets field set automatically:

  1. kubectl run nginx --image=nginx --restart=Never
  2. kubectl get pod nginx -o=jsonpath='{.spec.imagePullSecrets[0].name}{"\n"}'

The output is:

  1. myregistrykey

Service Account Token Volume Projection

FEATURE STATE: Kubernetes v1.20 [stable]

Note:

To enable and use token request projection, you must specify each of the following command line arguments to kube-apiserver:

  • --service-account-issuer
  • --service-account-key-file
  • --service-account-signing-key-file
  • --api-audiences

The kubelet can also project a service account token into a Pod. You can specify desired properties of the token, such as the audience and the validity duration. These properties are not configurable on the default service account token. The service account token will also become invalid against the API when the Pod or the ServiceAccount is deleted.

This behavior is configured on a PodSpec using a ProjectedVolume type called ServiceAccountToken. To provide a pod with a token with an audience of “vault” and a validity duration of two hours, you would configure the following in your PodSpec:

pods/pod-projected-svc-token.yaml Configure Service Accounts for Pods - 图1

  1. apiVersion: v1
  2. kind: Pod
  3. metadata:
  4.   name: nginx
  5. spec:
  6.   containers:
  7.   - image: nginx
  8.     name: nginx
  9.     volumeMounts:
  10.     - mountPath: /var/run/secrets/tokens
  11.       name: vault-token
  12.   serviceAccountName: build-robot
  13.   volumes:
  14.   - name: vault-token
  15.     projected:
  16.       sources:
  17.       - serviceAccountToken:
  18.           path: vault-token
  19.           expirationSeconds: 7200
  20.           audience: vault

Create the Pod:

  1. kubectl create -f https://k8s.io/examples/pods/pod-projected-svc-token.yaml

The kubelet will request and store the token on behalf of the pod, make the token available to the pod at a configurable file path, and refresh the token as it approaches expiration. Kubelet proactively rotates the token if it is older than 80% of its total TTL, or if the token is older than 24 hours.

The application is responsible for reloading the token when it rotates. Periodic reloading (e.g. once every 5 minutes) is sufficient for most use cases.

Service Account Issuer Discovery

FEATURE STATE: Kubernetes v1.20 [beta]

The Service Account Issuer Discovery feature is enabled by enabling the ServiceAccountIssuerDiscovery feature gate and then enabling the Service Account Token Projection feature as described above.

Note:

The issuer URL must comply with the OIDC Discovery Spec. In practice, this means it must use the https scheme, and should serve an OpenID provider configuration at {service-account-issuer}/.well-known/openid-configuration.

If the URL does not comply, the ServiceAccountIssuerDiscovery endpoints will not be registered, even if the feature is enabled.

The Service Account Issuer Discovery feature enables federation of Kubernetes service account tokens issued by a cluster (the identity provider) with external systems (relying parties).

When enabled, the Kubernetes API server provides an OpenID Provider Configuration document at /.well-known/openid-configuration and the associated JSON Web Key Set (JWKS) at /openid/v1/jwks. The OpenID Provider Configuration is sometimes referred to as the discovery document.

When enabled, the cluster is also configured with a default RBAC ClusterRole called system:service-account-issuer-discovery. No role bindings are provided by default. Administrators may, for example, choose whether to bind the role to system:authenticated or system:unauthenticated depending on their security requirements and which external systems they intend to federate with.

Note: The responses served at /.well-known/openid-configuration and /openid/v1/jwks are designed to be OIDC compatible, but not strictly OIDC compliant. Those documents contain only the parameters necessary to perform validation of Kubernetes service account tokens.

The JWKS response contains public keys that a relying party can use to validate the Kubernetes service account tokens. Relying parties first query for the OpenID Provider Configuration, and use the jwks_uri field in the response to find the JWKS.

In many cases, Kubernetes API servers are not available on the public internet, but public endpoints that serve cached responses from the API server can be made available by users or service providers. In these cases, it is possible to override the jwks_uri in the OpenID Provider Configuration so that it points to the public endpoint, rather than the API server’s address, by passing the --service-account-jwks-uri flag to the API server. Like the issuer URL, the JWKS URI is required to use the https scheme.

What’s next

See also: