Managing Directories Demo

In this lesson we walk through managing Kubernetes manifests across multiple directories and show how Kustomize can simplify deployments and keep manifests modular as your project grows. Project layout

A top-level k8s/ directory containing three subfolders:
- api/ — Kubernetes manifests for the API service
- cache/ — Kubernetes manifests for Redis
- db/ — Kubernetes manifests for MongoDB

Each folder contains the typical resources: Deployments, Services, and ConfigMaps. Below are representative snippets and the commands used during the demo. Project structure (quick reference)

Directory	Purpose	Example resources
`k8s/api`	API service manifests	`api-deploy.yaml`, `api-service.yaml`
`k8s/cache`	Redis (cache) manifests	`redis-config.yaml`, `redis-deploy.yaml`, `redis-service.yaml`
`k8s/db`	MongoDB (database) manifests	`db-config.yaml`, `db-deploy.yaml`, `db-service.yaml`

Example Deployment (Mongo)

This is a complete Deployment manifest for the MongoDB container (example shows environment variables sourced from a ConfigMap named db-credentials).

apiVersion: apps/v1
kind: Deployment
metadata:
  name: db-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      component: db
  template:
    metadata:
      labels:
        component: db
    spec:
      containers:
        - name: mongo
          image: mongo
          env:
            - name: MONGO_INITDB_ROOT_USERNAME
              valueFrom:
                configMapKeyRef:
                  name: db-credentials
                  key: username
            - name: MONGO_INITDB_ROOT_PASSWORD
              valueFrom:
                configMapKeyRef:
                  name: db-credentials
                  key: password

Example Service (Redis ClusterIP)

apiVersion: v1
kind: Service
metadata:
  name: redis-cluster-ip-service
spec:
  type: ClusterIP
  selector:
    component: redis
  ports:
    - port: 6379
      targetPort: 6379
      protocol: TCP

Manual apply without Kustomize

The simplest approach is to apply each directory directly with kubectl apply -f <dir>. This is straightforward for small projects.

# Apply API manifests
kubectl apply -f k8s/api

# Apply cache (Redis) manifests
kubectl apply -f k8s/cache

# Apply db (Mongo) manifests
kubectl apply -f k8s/db

You can also pass multiple -f flags in one command:

kubectl apply -f k8s/db -f k8s/cache -f k8s/api

Example (cleaned) console output from applying directories:

# kubectl apply -f k8s/api
deployment.apps/api-deployment created
service/api-service created

# kubectl apply -f k8s/cache
configmap/redis-credentials created
deployment.apps/redis-deployment created
service/redis-cluster-ip-service created

# kubectl apply -f k8s/db
configmap/db-credentials created
deployment.apps/db-deployment created
service/db-service created

This manual approach works, but it becomes tedious and error-prone as manifests and directories increase. Using Kustomize — single root Kustomization.yaml

A common way to consolidate manifests is to add a Kustomization.yaml at the root of k8s/ that lists resources from subdirectories. This produces a single combined set of YAML documents.

Example k8s/Kustomization.yaml (single root approach):

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - api/api-deploy.yaml
  - api/api-service.yaml
  - cache/redis-config.yaml
  - cache/redis-deploy.yaml
  - cache/redis-service.yaml
  - db/db-config.yaml
  - db/db-deploy.yaml
  - db/db-service.yaml

Preview the combined manifests (no apply):

kustomize build k8s/

The build prints the full combined YAML for all resources (excerpt):

apiVersion: v1
kind: ConfigMap
metadata:
  name: db-credentials
data:
  username: root
  password: example
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: redis-credentials
data:
  username: redis
  password: password123
---
apiVersion: v1
kind: Service
metadata:
  name: api-service
spec:
  ports:
    - port: 80
      targetPort: 3000
  selector:
    component: api
---
# ... more resources ...

Apply the generated manifests to the cluster:

kustomize build k8s/ | kubectl apply -f -

Example (cleaned) apply output:

configmap/db-credentials created
configmap/redis-credentials created
service/api-service created
service/db-service created
service/redis-cluster-ip-service created
deployment.apps/api-deployment created
deployment.apps/db-deployment created
deployment.apps/redis-deployment created

Note: kubectl includes built-in Kustomize support, so you can do the same with:

kubectl apply -k k8s

You can use either the standalone kustomize CLI piped into kubectl apply -f - or the built-in kubectl apply -k <directory>. Both produce the same result.

Verify pods are running:

kubectl get pods

Example output:

NAME                                 READY   STATUS    RESTARTS   AGE
api-deployment-64dd567b46-lmw4c      1/1     Running   0          27s
db-deployment-657c8ffbd8-vmjs7       1/1     Running   0          26s
redis-deployment-587fd758cf-7pt57    1/1     Running   0          26s

Using Kustomize — per-directory Kustomization.yaml (recommended)

For better modularity and maintainability, create a Kustomization.yaml inside each subdirectory (api/, cache/, db/) and then have the root k8s/Kustomization.yaml reference those directories. Kustomize will read the subdirectory Kustomization.yaml files.

Example api/Kustomization.yaml:

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - api-deploy.yaml
  - api-service.yaml

Example cache/Kustomization.yaml:

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - redis-config.yaml
  - redis-deploy.yaml
  - redis-service.yaml

Example db/Kustomization.yaml:

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - db-config.yaml
  - db-deploy.yaml
  - db-service.yaml

Then update the root k8s/Kustomization.yaml to reference the directories (Kustomize will look for their Kustomization.yaml files):

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - api
  - cache
  - db

Build and apply:

Build combined manifests:

kustomize build k8s/

Apply with kubectl (preferred shorthand):

kubectl apply -k k8s

Or:

kustomize build k8s/ | kubectl apply -f -

Example apply output:

configmap/db-credentials created
configmap/redis-credentials created
service/api-service created
service/db-service created
service/redis-cluster-ip-service created
deployment.apps/api-deployment created
deployment.apps/db-deployment created
deployment.apps/redis-deployment created

Verify:

kubectl get pods

Expected output:

NAME                                 READY   STATUS    RESTARTS   AGE
api-deployment-64dd567b46-lmw4c      1/1     Running   0          27s
db-deployment-657c8ffbd8-vmjs7       1/1     Running   0          26s
redis-deployment-587fd758cf-7pt57    1/1     Running   0          26s

Comparison: single root vs per-directory Kustomization

Approach	Pros	Cons
Single root `Kustomization.yaml`	Simple to set up for small projects; central list of all resources.	Can become large and harder to maintain as the project grows.
Per-directory `Kustomization.yaml` (recommended)	Modular, easier to manage, allows team ownership per component, supports overlays and environment-specific customizations.	Slightly more files to maintain, but much cleaner at scale.

Summary

Both a single root Kustomization.yaml and per-directory Kustomization.yaml files are valid. For growing projects, the per-directory (modular) approach is recommended.
Use kustomize build <dir> to preview merged manifests and apply with either kustomize build <dir> | kubectl apply -f - or the shorthand kubectl apply -k <dir>.

Links and references

Kustomize: https://learn.kodekloud.com/user/courses/kustomize
Kubernetes docs: https://kubernetes.io/docs/

Introduction

Core Concepts

Scheduling

Logging & Monitoring

Application Lifecycle Management

Cluster Maintenance

Security

Storage

Networking

Design and Install a Kubernetes Cluster

Install "Kubernetes the kubeadm way"

Troubleshooting

Helm Basics (2025 Updates)

Kustomize Basics (2025 Updates)

Other Topics

Mock Exams

Managing Directories Demo

Watch Video

Practice Lab