This page explains how to deploy a stateless Linux application using Google Kubernetes Engine (GKE). You can also learn how to deploy a stateless Windows application.
Overview
Stateless applications are applications which do not store data or application state to the cluster or to persistent storage. Instead, data and application state stay with the client, which makes stateless applications more scalable. For example, a frontend application is stateless: you deploy multiple replicas to increase its availability and scale down when demand is low, and the replicas have no need for unique identities.
Kubernetes uses the Deployment controller to deploy stateless applications as uniform, non-unique Pods. Deployments manage the desired state of your application: how many Pods should run your application, what version of the container image should run, what the Pods should be labelled, and so on. The desired state can be changed dynamically through updates to the Deployment's Pod specification.
Stateless applications are in contrast to stateful applications, which use persistent storage to save data and which use StatefulSets to deploy Pods with unique identities.
Before you begin
Before you start, make sure you have performed the following tasks:
- Enable the Google Kubernetes Engine API. Enable Google Kubernetes Engine API
- If you want to use the Google Cloud CLI for this task,
install and then
initialize the
gcloud CLI. If you previously installed the gcloud CLI, get the latest
version by running
gcloud components update.
Ensure your containerized application is stored in an image registry, such as Artifact Registry.
If you are new to GKE, you should complete the quickstart, in which you'll enable the GKE API and learn how the product works.
Anatomy of a Deployment
The following is an example of a simple Deployment manifest file. This
Deployment creates three replicated Pods labelled run=my-app that run the
hello-app image stored in Artifact Registry:
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-app
spec:
replicas: 3
selector:
matchLabels:
run: my-app
template:
metadata:
labels:
run: my-app
spec:
containers:
- name: hello-app
image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
In this example:
.spec.replicas: is the number of replicated Pods that the Deployment manages..spec.template.metadata.labels: is the label given to each Pod, which the Deployment uses to manage the Pods..spec.template.spec: is the Pod specification, which defines how each Pod should run.spec.containersincludes the name of the container to run in each Pod and the container image that should run.
For more information about the Deployment specification, refer to the Deployment API reference.
Creating a Deployment
You create a Deployment using one of the following methods:
- You can use the Deploy feature in the Google Cloud console's Workloads menu to create a simple Deployment from a container image you've stored in Artifact Registry
You can write a Deployment manifest and run
kubectl applyto create the resource
kubectl apply
You can declaratively create and update Deployments from manifest files
using kubectl apply. This method also retains updates made to live
resources without merging the changes back into the manifest files.
To create a Deployment from its manifest file, run the following command:
kubectl apply -f DEPLOYMENT_FILE
Replace DEPLOYMENT_FILE with the manifest file, such as config.yaml.
You can also use kubectl apply -f DIRECTORY/ to
create all objects (except existing ones) defined in manifest files stored a
directory.
Console
To create a Deployment, perform the following steps:
Go to the Workloads page in the Google Cloud console.
Click add_box Deploy.
Under Specify container, select one of the following:
Existing container image to choose a container image available from Artifact Registry or DockerHub. In Image path, enter the path to the container image and the version.
New container image to use an image created with Cloud Source Repositories and Cloud Build.
Optionally, configure your deployment with:
- Environment variables to pass into the container.
- Initial commands to customize the container's entrypoint at runtime.
Click Done, and then click Continue.
In the Configuration section, give your deployment an Application name and specify the Kubernetes Namespace to deploy it in.
Optionally, under Labels, you can add Kubernetes Labels to the deployment.
To save the YAML that creates this deployment to update it later, click View YAML. Copy and paste the YAML into a file, then save it and click Close on the YAML Output dialog.
From the Kubernetes Cluster drop-down menu, choose the desired cluster.
Click Deploy.
Inspecting the Deployment
After you create a Deployment, you can use one of the following methods to inspect it:
- You can use the Workloads menu
You can use
kubectl describeandkubectl get
kubectl
To get detailed information about the Deployment, run the following command:
kubectl describe deployment DEPLOYMENT_NAME
Replace DEPLOYMENT_NAME with the name of the Deployment.
To list the Pods created by the Deployment, run the following command:
kubectl get pods -l KEY=VALUE
In this command, the -l flag instructs kubectl to get all Pods with a
key-value label. For example, if you labelled the Deployment run: my-app,
you'd run kubectl get pods -l run=my-app to see Pods with that label.
To get information about a specific Pod:
kubectl describe pod POD_NAME
To view a Deployment's manifest, run the following command:
kubectl get deployments DEPLOYMENT_NAME -o yaml
This command displays the Deployment's live configuration in YAML format.
Console
To inspect a Deployment, perform the following steps:
Go to the Workloads page in the Google Cloud console.
In the workloads list, click the name of the Deployment you want to inspect.
On the Deployment details page, do any of the following:
- Click the Revision History tab to see the Deployment's revision history.
- Click the Events tab to see all events related to the Deployment.
- Click the Logs tab to see container activity logs in the Deployment.
- Click the YAML tab to see, copy, and download the YAML manifest for the Deployment.
Updating the Deployment
You can roll out updates to a Deployment's Pod specification, such as their image, resource usage/requests, or configuration.
You can update a Deployment using the following methods:
- You can use the Rolling update menu and YAML editor from the Google Cloud console Workloads menu.
- You can make changes to a manifest file and apply them with
kubectl apply. - You can update the Pod specification's
image,resources, orselectorfields usingkubectl set. You can update a Deployment directly from your shell or in a preferred editor using
kubectl edit.
kubectl apply
You can update the Deployment by applying a new or updated manifest file. This is useful for making various changes to your Deployment, such as for scaling or for specifying a new version of your application.
To update a Deployment, run the following command:
kubectl apply -f DEPLOYMENT_FILE
Replace DEPLOYMENT_FILE with the updated manifest file.
The kubectl apply command applies a manifest file to a resource. If the
specified resource does not exist, it is created by the command.
kubectl set
You can use kubectl set to change a Deployment's image, resources
(requests or limits), or selector fields.
To change a Deployment's image, run the following command:
kubectl set image deployment DEPLOYMENT_NAME IMAGE IMAGE:TAG
For example, to update a Deployment from nginx version 1.7.9 to 1.9.1, run
the following command:
kubectl set image deployment nginx nginx=nginx:1.9.1
Console
To access the Deployment's Rolling update menu:
Go to the Workloads page in the Google Cloud console.
In the workloads list, click the name of the Deployment you want to modify.
Click list Actions > Rolling update.
Configure the following optional parameters for the update strategy:
- Minimum seconds ready: Specifies the minimum number of seconds for which newly-created Pods should be ready to be considered available.
- Maximum surge: Specifies the maximum number of Pods that can be created over the desired number of Pods. Value can be an absolute number or a percentage.
- Maximum unavailable: Specifies the maximum number of Pods that can be unavailable during the update process. Value can be an absolute number or a percentage.
Under Container images, enter the image path and version for the updated container image.
Click Update.
Rolling back an update
You can roll back an update using
kubectl rollout undo.
You can roll back an in-progress or completed update to its previous revision:
kubectl rollout undo deployment my-deployment
You can also roll back to a specific revision:
kubectl rollout undo deployment my-deployment --to-revision=3
Scaling a Deployment
You can manually scale a Deployment using the Google Cloud console or
kubectl scale.
You can learn more about autoscaling Deployments.
kubectl
kubectl scale can be used at any time to scale your Deployment.
To manually scale a Deployment, run the following command:
kubectl scale deployment DEPLOYMENT_NAME --replicas NUMBER_OF_REPLICAS
Replace NUMBER_OF_REPLICAS with the desired number of replicated Pods.
Console
To scale a Deployment, perform the following steps:
Go to the Workloads page in the Google Cloud console.
In the workloads list, click the name of the Deployment you want to modify.
Click list Actions > Scale > Edit replicas
Enter the new number of Replicas for the Deployment.
Click Scale.
Deleting a Deployment
You can delete a Deployment using the Google Cloud console or
kubectl delete.
kubectl
To delete a Deployment, run the following command:
kubectl delete deployment DEPLOYMENT_NAME
Console
To delete a Deployment, perform the following steps:
Go to the Workloads page in the Google Cloud console.
In the workloads list, select one or more Deployments to delete.
Click delete Delete.
When prompted to confirm, click Delete.