Testing the Kubernetes Setup

Oct 13, 2025 by magicalceylontours.com 75 views

=====================================================

As a developer, creating Kubernetes manifests for deploying a microservice is crucial for ensuring the application runs in a scalable and containerized environment. In this article, we will explore the process of creating Kubernetes manifests for deployment, including deployment.yaml, service.yaml, and ingress.yaml files.

Details and Assumptions

Before we dive into the process of creating Kubernetes manifests, let's outline the details and assumptions:

The microservice (/customers) should run inside a Kubernetes cluster.
Deployment will be managed using Kubernetes manifests:
- deployment.yaml → Defines Pods and ReplicaSets for the microservice.
- service.yaml → Exposes the microservice inside the cluster via a ClusterIP or LoadBalancer.
- ingress.yaml → Configures an Ingress resource to allow external access to the service.
The application should be deployed with at least 2 replicas for redundancy.
Environment variables and secrets should be properly configured in the deployment.yaml.
The service should be accessible via Ingress with a custom hostname.
The Kubernetes setup should be tested in a local K3S cluster first before moving to OpenShift.

Acceptance Criteria

To ensure the Kubernetes manifests are created correctly, we need to define the acceptance criteria:

Scenario: Deploy microservice using Kubernetes manifests  
  Given a Kubernetes cluster is running  
  When I apply the deployment, service, and ingress manifests  
  Then the microservice should be deployed successfully with 2 replicas  

Scenario: Expose the microservice internally  
  Given the microservice is running in Kubernetes  
  When a request is made to the Service’s ClusterIP  
  Then the request should be forwarded to a running pod  

Scenario: Access microservice externally via Ingress  
  Given the microservice is deployed in Kubernetes  
  When I access the specified hostname via Ingress  
  Then I should receive a valid response from the microservice

Creating the Deployment Manifest (deployment.yaml)

The deployment.yaml file defines the Pods and ReplicaSets for the microservice. Here's an example of what the file might look like:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: customers-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: customers
  template:
    metadata:
      labels:
        app: customers
    spec:
      containers:
      - name: customers
        image: <image-name>
        ports:
        - containerPort: 8080
        env:
        - name: CUSTOMERS_SERVICE_URL
          value: "http://localhost:8080"
        - name: CUSTOMERS_DB_URL
          value: "postgresql://user:password@localhost:5432/customers"
        - name: CUSTOMERS_DB_NAME
          value: "customers"
        - name: CUSTOMERS_DB_USER
          value: "user"
        - name: CUSTOMERS_DB_PASSWORD
          value: "password"

In this example, we define a Deployment named customers-deployment with 2 replicas. The Deployment selects Pods with the label app: customers. The template defines a container named customers that uses the specified image and exposes port 8080. We also define environment variables for the microservice, including the URL of the customers service, the database URL, and the database credentials.

Creating the Service Manifest (service.yaml)

The service.yaml file exposes the microservice inside the cluster via a ClusterIP or LoadBalancer. Here's an example of what the file might look like:

apiVersion: v1
kind: Service
metadata:
  name: customers-service
spec:
  selector:
    app: customers
  ports:
  - name: http
    port: 8080
    targetPort: 8080
  type: ClusterIP

In this example, we define a Service named customers-service that selects Pods with the label app: customers. The Service exposes port 8080 and uses the targetPort 8080. We also specify the type as ClusterIP, which means the Service will be accessible only within the cluster.

Creating the Ingress Manifest (ingress.yaml)

The ingress.yaml file configures an Ingress resource to allow external access to the service. Here's an example of what the file might look like:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: customers-ingress
spec:
  rules:
  - host: customers.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: customers-service
            port:
              number: 8080

In this example, we define an Ingress resource named customers-ingress that allows external access to the customers-service Service. We specify the hostname as customers.example.com and the path as /. The Ingress resource forwards requests to the customers-service Service on port 8080.

Testing the Kubernetes Setup

Before moving to OpenShift, we need to test the Kubernetes setup in a local K3S cluster. We can use tools like kubectl to apply the manifests and verify that the microservice is deployed successfully with 2 replicas.

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl apply -f ingress.yaml

We can then verify that the microservice is deployed successfully by checking the status of the Deployment and Service:

kubectl get deployments
kubectl get svc

We can also test the Ingress resource by accessing the specified hostname via Ingress:

curl http://customers.example.com/

This should return a valid response from the microservice.

Conclusion

In this article, we explored the process of creating Kubernetes manifests for deployment, including deployment.yaml, service.yaml, and ingress.yaml files. We outlined the details and assumptions, acceptance criteria, and created the manifests for the microservice. We also tested the Kubernetes setup in a local K3S cluster and verified that the microservice is deployed successfully with 2 replicas. By following these steps, you can create Kubernetes manifests for deploying your microservice in a scalable and containerized environment.

=============================================

In our previous article, we explored the process of creating Kubernetes manifests for deployment, including deployment.yaml, service.yaml, and ingress.yaml files. In this article, we will answer some frequently asked questions (FAQs) about Kubernetes manifests for deployment.

Q: What is the purpose of a Kubernetes manifest?

A: A Kubernetes manifest is a YAML or JSON file that defines the desired state of a Kubernetes resource, such as a Deployment, Service, or Ingress. The manifest specifies the configuration and settings for the resource, and Kubernetes uses it to create and manage the resource.

Q: What are the different types of Kubernetes manifests?

A: There are several types of Kubernetes manifests, including:

Deployment manifest: Defines a Deployment, which is a set of replicas of a Pod.
Service manifest: Defines a Service, which provides a network identity and load balancing for accessing a group of Pods.
Ingress manifest: Defines an Ingress, which provides a way to expose a Service to the outside world.
Pod manifest: Defines a Pod, which is a single instance of a container.

Q: How do I create a Kubernetes manifest?

A: To create a Kubernetes manifest, you can use a text editor or an IDE to write the YAML or JSON file. You can also use tools like kubectl to generate a manifest from a template.

Q: What is the difference between a YAML and JSON manifest?

A: YAML and JSON are both data serialization formats that can be used to create Kubernetes manifests. YAML is more human-readable and is often used for configuration files, while JSON is more compact and is often used for data exchange.

Q: How do I apply a Kubernetes manifest?

A: To apply a Kubernetes manifest, you can use the kubectl apply command, which creates or updates the resource specified in the manifest.

Q: How do I delete a Kubernetes manifest?

A: To delete a Kubernetes manifest, you can use the kubectl delete command, which deletes the resource specified in the manifest.

Q: What is the difference between a `deployment.yaml` and a `service.yaml` manifest?

A: A deployment.yaml manifest defines a Deployment, which is a set of replicas of a Pod. A service.yaml manifest defines a Service, which provides a network identity and load balancing for accessing a group of Pods.

Q: How do I configure environment variables in a Kubernetes manifest?

A: To configure environment variables in a Kubernetes manifest, you can use the env section in the manifest file. For example:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: customers-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: customers
  template:
    metadata:
      labels:
        app: customers
    spec:
      containers:
      - name: customers
        image: <image-name>
        env:
        - name: CUSTOMERS_SERVICE_URL
          value: "http://localhost:8080"
        - name: CUSTOMERS_DB_URL
          value: "postgresql://user:password@localhost:5432/customers"

Q: How do I configure secrets in a Kubernetes manifest?

A: To configure secrets in a Kubernetes manifest, you can use the secret section in the manifest file. For example:

apiVersion: v1
kind: Secret
metadata:
  name: customers-secret
type: Opaque
data:
  CUSTOMERS_DB_PASSWORD: <base64-encoded-password>

Q: How do I configure an Ingress resource in a Kubernetes manifest?

A: To configure an Ingress resource in a Kubernetes manifest, you can use the ingress section in the manifest file. For example:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: customers-ingress
spec:
  rules:
  - host: customers.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: customers-service
            port:
              number: 8080

Q: How do I test a Kubernetes manifest?

A: To test a Kubernetes manifest, you can use tools like kubectl to apply the manifest and verify that the resource is created correctly. You can also use tools like curl to test the Ingress resource.

Q: What are some best practices for creating Kubernetes manifests?

A: Some best practices for creating Kubernetes manifests include:

Use meaningful names: Use meaningful names for your resources, such as customers-deployment instead of deployment-1.
Use labels: Use labels to identify your resources, such as app: customers instead of app: unknown.
Use annotations: Use annotations to provide additional metadata for your resources, such as kubectl.kubernetes.io/last-applied-configuration.
Use environment variables: Use environment variables to configure your resources, such as CUSTOMERS_SERVICE_URL instead of hardcoding the value.
Use secrets: Use secrets to store sensitive data, such as database passwords.

By following these best practices and using the information in this article, you can create effective Kubernetes manifests for deploying your applications.