How to apply kubernetes manifests

Introduction

This comprehensive tutorial explores the process of applying Kubernetes manifests, providing developers and system administrators with essential skills for deploying and managing containerized applications. By understanding manifest files and Kubernetes deployment techniques, you'll gain the knowledge needed to efficiently orchestrate complex infrastructure and streamline application delivery.

Skills Graph

Manifest Basics

What are Kubernetes Manifests?

Kubernetes manifests are declarative configuration files that define the desired state of Kubernetes resources. These files describe how you want your applications and infrastructure to be deployed and managed within a Kubernetes cluster.

Key Characteristics of Manifests

Manifests are typically written in YAML format and specify:

• Resource types (Deployments, Services, Pods)
• Configuration details
• Desired state of applications

Manifest File Structure

A typical Kubernetes manifest contains several key sections:

Basic Manifest Example

Here's a simple Pod manifest example:

apiVersion: v1
kind: Pod
metadata:
  name: example-pod
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80

Manifest File Types

Kubernetes supports various manifest file types:

• Pod manifests
• Deployment manifests
• Service manifests
• ConfigMap manifests
• Secret manifests

Benefits of Using Manifests

1. Declarative configuration
2. Version control
3. Reproducible deployments
4. Easy infrastructure management

Best Practices

• Use meaningful names
• Include appropriate labels
• Keep manifests version-controlled
• Use namespace management
• Validate manifests before deployment

By understanding these basics, you'll be well-prepared to work with Kubernetes manifests in LabEx's cloud-native environment.

Writing Manifest Files

Understanding Manifest File Anatomy

Basic Structure Components

A Kubernetes manifest typically includes four main sections:

Creating Different Resource Manifests

Pod Manifest Example

apiVersion: v1
kind: Pod
metadata:
  name: web-pod
  labels:
    app: frontend
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80

Deployment Manifest Example

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

Manifest Writing Best Practices

Validation Techniques

1. Use kubectl dry-run
2. Utilize YAML linters
3. Implement schema validation

Advanced Configuration Techniques

Environment-Specific Configurations

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  DATABASE_HOST: production-db.example.com
  LOG_LEVEL: info

Resource Constraints

resources:
  requests:
    cpu: 100m
    memory: 128Mi
  limits:
    cpu: 250m
    memory: 256Mi

Common Manifest Writing Tools

Error Handling and Debugging

Common Validation Commands

## Validate manifest syntax
kubectl apply --dry-run=client -f manifest.yaml

## Check resource status
kubectl describe pod web-pod

LabEx Recommendation

When writing manifests in LabEx's cloud-native environments, always:

• Use consistent naming conventions
• Implement proper resource management
• Follow security best practices

Deploying to Kubernetes

Deployment Workflow

Deployment Methods

1. Direct Kubectl Deployment

## Deploy a single manifest
kubectl apply -f deployment.yaml

## Deploy multiple manifests
kubectl apply -f ./manifests/

## Deploy from directory
kubectl apply -R -f ./kubernetes/

2. Deployment Strategies

Advanced Deployment Techniques

Resource Management

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%

Health Checks and Probes

livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 10

readinessProbe:
  tcpSocket:
    port: 8080
  initialDelaySeconds: 15
  periodSeconds: 5

Deployment Verification

Checking Deployment Status

## List deployments
kubectl get deployments

## Describe specific deployment
kubectl describe deployment web-app

## View deployment rollout status
kubectl rollout status deployment/web-app

Scaling Applications

## Manual scaling
kubectl scale deployment web-app --replicas=5

## Autoscaling
kubectl autoscale deployment web-app \
  --min=2 --max=10 --cpu-percent=70

Rollback and Version Management

## View deployment history
kubectl rollout history deployment/web-app

## Rollback to previous version
kubectl rollout undo deployment/web-app

## Rollback to specific revision
kubectl rollout undo deployment/web-app --to-revision=2

Deployment Best Practices

1. Use declarative configurations
2. Implement resource limits
3. Configure proper health checks
4. Use namespaces for organization
5. Implement monitoring and logging

LabEx Deployment Recommendations

• Leverage LabEx's cloud-native infrastructure
• Use consistent naming conventions
• Implement comprehensive monitoring
• Regularly validate and update manifests

Common Deployment Challenges

Troubleshooting Deployment Issues

## View pod logs
kubectl logs pod-name

## Describe pod details
kubectl describe pod pod-name

## Check cluster events
kubectl get events

Summary

Mastering Kubernetes manifest application is crucial for modern cloud-native development. By learning how to write, validate, and deploy manifest files, you can effectively manage containerized applications, ensure consistent infrastructure deployment, and leverage Kubernetes' powerful orchestration capabilities across diverse computing environments.