Deploy Your First Application on Kubernetes in 30 Minutes

A Kubernetes deployment is the process of distributing and running a containerized application on a Kubernetes cluster, where the system automatically orchestrates pod creation, network management, and high availability. Deploying a Kubernetes application as a beginner involves creating a YAML file describing the desired state, then applying it via kubectl apply.

TL;DR: This quickstart guides you step by step to complete your first Kubernetes deployment in under 30 minutes. You'll create a local cluster, deploy a web application, expose it via a Service, and verify it works. No prior experience required.

Developers who want to master these skills follow the LFD459 Kubernetes for Application Developers training.

Why Learn to Deploy a Kubernetes Application as a Beginner?

According to the CNCF Annual Survey 2025, 82% of container users run Kubernetes in production, up from 66% in 2023. This massive adoption means every Full-Stack developer must master deployment basics.

Remember: Kubernetes is no longer optional. It has become the de facto standard for orchestrating cloud-native applications.

To dive deeper into Kubernetes application development, start with this practical quickstart.

What Are the Prerequisites for This First Kubernetes Deployment?

Before starting, verify you have:

Install kubectl if not done:

# macOS
brew install kubectl

# Linux
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl && sudo mv kubectl /usr/local/bin/

# Windows (PowerShell admin)
choco install kubernetes-cli

Check our guide on essential kubectl commands for developers to master the CLI tool.

Step 1: How to Create a Local Kubernetes Cluster?

Launch Minikube to start a single-node cluster on your machine:

# Start the cluster with 2 CPUs and 4GB RAM
minikube start --cpus=2 --memory=4096

# Check status
minikube status

Expected output:

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

Remember: Minikube creates a complete local Kubernetes environment, ideal for learning and testing.

To understand the underlying architecture, explore our section on Kubernetes cluster administration.

Step 2: How to Write a Deployment Manifest?

A Deployment is a Kubernetes object describing your application's desired state. Create the file app-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
name: hello-kubernetes
labels:
app: hello-kubernetes
spec:
replicas: 3
selector:
matchLabels:
app: hello-kubernetes
template:
metadata:
labels:
app: hello-kubernetes
spec:
containers:
- name: hello-kubernetes
image: paulbouwer/hello-kubernetes:1.10
ports:
- containerPort: 8080
resources:
requests:
memory: "64Mi"
cpu: "100m"
limits:
memory: "128Mi"
cpu: "200m"

This manifest defines:

• 3 replicas for high availability
• Resource limits to prevent overconsumption
• Labels for Service routing

For deeper design insights, check the containerized application design guide for Kubernetes.

Step 3: How to Apply the Deployment with kubectl apply?

The kubectl apply command is the heart of the Kubernetes declarative workflow. Deploy your application:

# Apply the manifest
kubectl apply -f app-deployment.yaml

# Verify the deployment
kubectl get deployments

# Watch pod creation
kubectl get pods -w

Typical output:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
hello-kubernetes   3/3     3            3           45s

According to The Enterprisers Project: "Anybody can learn Kubernetes. With abundant documentation and development tools available online, teaching yourself Kubernetes is very much within reach."

Remember: The kubectl apply -f command is idempotent. Run it as many times as needed without side effects.

Step 4: How to Expose the Application via a Service?

A Kubernetes Service exposes your pods to the network. Create app-service.yaml:

apiVersion: v1
kind: Service
metadata:
name: hello-kubernetes-svc
spec:
type: NodePort
selector:
app: hello-kubernetes
ports:
- port: 80
targetPort: 8080
nodePort: 30080

Apply and test:

# Create the Service
kubectl apply -f app-service.yaml

# Get the access URL (Minikube)
minikube service hello-kubernetes-svc --url

You'll get a local URL (e.g., http://192.168.49.2:30080) to access your application.

For more complex architectures, explore microservices architecture on Kubernetes.

Step 5: How to Verify and Debug the Deployment?

Essential diagnostic commands:

# Full deployment details
kubectl describe deployment hello-kubernetes

# Logs from a specific pod
kubectl logs -l app=hello-kubernetes --tail=50

# Execute a shell in a pod
kubectl exec -it $(kubectl get pod -l app=hello-kubernetes -o jsonpath='{.items[0].metadata.name}') -- /bin/sh

# Recent cluster events
kubectl get events --sort-by='.lastTimestamp'

According to the Cloud Native Now report, IT teams spend an average of 34 working days per year resolving Kubernetes problems. Mastering these debug commands drastically reduces this time.

Step 6: How to Perform a Rolling Update?

Kubernetes allows updates without interruption. Modify the image:

# Update container image
kubectl set image deployment/hello-kubernetes hello-kubernetes=paulbouwer/hello-kubernetes:1.11

# Watch the rolling update
kubectl rollout status deployment/hello-kubernetes

# View revision history
kubectl rollout history deployment/hello-kubernetes

In case of problems, instant rollback:

kubectl rollout undo deployment/hello-kubernetes

Remember: Rolling updates guarantee zero downtime. Kubernetes progressively replaces old pods with new ones.

This declarative approach is part of cloud-native development patterns for Kubernetes.

Step 7: How to Clean Up Resources?

Properly delete your test resources:

# Delete deployment and service
kubectl delete -f app-deployment.yaml
kubectl delete -f app-service.yaml

# Verify deletion
kubectl get all

# Stop Minikube (optional)
minikube stop

What's the Next Step After This First Deployment?

You just completed your first Kubernetes deployment successfully. According to TealHQ: "Don't let your knowledge remain theoretical. Set up a real Kubernetes environment to solidify your skills."

To go further:

1. Master the APIs: Check our guide to master Kubernetes APIs for application development
2. Explore the complete catalog: Discover our Kubernetes Training: Complete Guide
3. Request guidance: Get your Kubernetes training quote

The Kubernetes market represents $2.57 billion USD in 2025 and will reach $8.41 billion USD by 2031 according to Mordor Intelligence, with a 21.85% CAGR. Investing in these skills now positions your career for the decade ahead.

Level Up with SFEIR Institute

This quickstart gave you the basics of Kubernetes deployment. To become a certified Full-Stack developer capable of designing robust cloud-native applications:

• LFD459 Kubernetes for Application Developers training: 3 intensive days preparing for CKAD certification
• Kubernetes Fundamentals: 1 day to discover the Kubernetes ecosystem
• LFS458 Kubernetes Administration training: 4 days to master cluster administration

Contact our advisors to build your personalized training path.