Complete Kubernetes Deployment Template Guide (With Example YAML)

In the fast-paced world of cloud computing, the need for efficient and scalable container orchestration solutions has never been greater. Enter Kubernetes, the open-source platform that has revolutionized the way we deploy, manage, and scale applications. But what if there was a way to simplify the process even further? That's where the magic of Kubernetes deployment templates comes in.

A Kubernetes deployment template is like a blueprint for your application, providing a standardized and repeatable way to define and deploy your containers. Whether you're a seasoned Kubernetes pro or just getting started with the Kubernetes basics, this powerful tool can streamline your workflow, saving you time and effort. In this blog, we'll dive headfirst into the world of Kubernetes deployment templates, exploring their benefits, best practices, and everything in between. So grab your favorite beverage, settle into your comfiest chair, and let's embark on a journey to unlock the full potential of Kubernetes deployment templates.

Complete Kubernetes Deployment Template Guide

In the field of cloud computing and container orchestration, Kubernetes has emerged as a dominant force. Its ability to efficiently manage and scale containerized applications has made it a favorite among developers and operations teams. Deploying applications on Kubernetes can be a complex task. That's where deployment templates come into play. In this section, we will explore the power and versatility of Kubernetes deployment templates and provide you with a comprehensive understanding of how to use them effectively.

1. Understanding Deployment Templates

At its core, a Kubernetes deployment template is a declarative configuration file that defines how your application should be deployed and managed on a Kubernetes cluster. It specifies the desired state of your application and allows Kubernetes to handle the necessary operations to achieve that state. By using deployment templates, you can automate the deployment, scaling, and management of your application, saving both time and effort.

2. Anatomy of a Deployment Template

A typical deployment template consists of several key components:

Metadata

This section provides information about the deployment, such as the name and labels associated with it. Labels are crucial for organizing and categorizing your deployments.

Spec

The spec section is where you define the desired state of your application. It includes details like the number of replicas, the container image to use, and any required environment variables or secret references.

Selector

This section specifies the criteria for selecting the pods that are managed by the deployment. It typically uses labels to identify the appropriate pods.

Template

The template section defines the pod template used by the deployment. It includes information such as the container image, ports, and resource requirements.

3. Deploying Your Application

To deploy your application using a deployment template, you need to follow these steps:

Create a deployment YAML file

Start by creating a YAML file that contains the necessary specifications for your deployment. Be sure to include details like the container image, ports, and any required environment variables.

Apply the deployment

Use the `kubectl apply` command to apply the deployment YAML file to your Kubernetes cluster. This will create the necessary resources and start the deployment process.

Verify the deployment

After applying the deployment, you can use the `kubectl get deployments` command to check the status of your deployment. It will show you information like the number of replicas, available updates, and current state.

4. Scaling and Updating Your Deployment

One of the key benefits of using deployment templates is the ability to easily scale and update your application. Here's how you can do it:

Scaling

To scale your deployment, use the `kubectl scale` command and specify the desired number of replicas. Kubernetes will automatically adjust the number of pods to match the desired state.

Updating

When you need to update your application, simply modify the deployment YAML file with the desired changes and apply it again using `kubectl apply`. Kubernetes will perform a rolling update, ensuring zero downtime as it replaces the old pods with the new ones.

5. Rolling Back Changes

In case a deployment update introduces issues or errors, Kubernetes allows you to roll back to a previous version. To roll back, use the `kubectl rollout undo` command and specify the name of the deployment. Kubernetes will revert to the previous version, ensuring your application continues to run smoothly.

6. Advanced Deployment Strategies

Deployment templates offer a range of advanced strategies to manage application deployments:

Canary Deployments

With canary deployments, you can gradually roll out changes to a small subset of users while monitoring their performance. If everything goes well, you can continue the rollout to the entire user base.

Blue-Green Deployments

Blue-green deployments involve running two identical environments, one active (blue) and the other inactive (green). This allows you to switch between environments seamlessly, minimizing downtime during updates.

Kubernetes deployment templates are a powerful tool for automating the deployment, scaling, and management of your applications on a Kubernetes cluster. By understanding their structure and leveraging their capabilities, you can streamline your development process and ensure the smooth operation of your applications. With this guide, you now have the knowledge to harness the full potential of Kubernetes deployment templates and take your containerized applications to new heights.

Related Reading

• Kubernetes Deployment Environment Variables
• What Is Deployment In Kubernetes
• Kubernetes Backup Deployment
• Scale Down Deployment Kubernetes
• Kubernetes Deployment History
• Kubernetes Deployment Best Practices
• Deployment Apps

What Is Kubernetes?

In the container orchestration, Kubernetes takes center stage. With its powerful deployment templates, Kubernetes conducts a harmonious arrangement of containers, ensuring seamless scalability, efficient management, and fault-tolerant operations. Let us delve into the intricacies of Kubernetes and understand how it orchestrates the ballet of containers.

1. The Maestro of Container Orchestration

Kubernetes acts as a maestro, synchronizing and managing the deployment, scaling, and operations of containers. It provides a robust framework for automating the management of applications across diverse clusters of machines, all within a unified and cohesive environment.

2. The Artful Dance of Scalability

One of Kubernetes' defining features is its ability to effortlessly scale containerized applications. With its deployment templates, Kubernetes allows you to define the desired state of your application, specifying the number of replicas you wish to deploy. These templates serve as a blueprint, guiding Kubernetes in orchestrating the creation, scaling, and termination of containers, ensuring your application can gracefully handle fluctuations in demand.

3. A Symphony of Fault Tolerance

Kubernetes understands the unpredictability of the orchestration stage and ensures fault tolerance is woven into the fabric of your containerized applications. Its deployment templates enable the definition of health checks, allowing Kubernetes to continuously monitor the health of your containers. In the event of a failure, Kubernetes can automatically replace unhealthy containers, maintaining the stability and availability of your application.

4. The Choreography of Service Discovery

In microservices, service discovery is crucial for seamless communication between containers. Kubernetes provides a service abstraction that dynamically maps and balances network traffic to containers based on labels specified in the deployment templates. This allows containers to easily discover and connect to one another, enabling them to collaborate flawlessly in the performance of their tasks.

5. Securing the Performance

Security is a paramount concern in any orchestration platform. Kubernetes addresses this concern by providing mechanisms to secure communication between containers, restrict access to resources, and manage sensitive information such as passwords and API tokens. By incorporating these security measures into the deployment templates, Kubernetes helps protect your applications from potential vulnerabilities.

6. The Operatic Benefits of Portability

Kubernetes allows your applications to transcend the boundaries of infrastructure, providing a consistent environment across various cloud providers and on-premises. Deployment templates play a significant role here, encapsulating the configuration and specifications of your applications. This portability enables you to seamlessly move your applications between different environments, unlocking the flexibility to choose the most suitable infrastructure for your needs.

Kubernetes, with its deployment templates, orchestrates the symphony of containerization. It conducts the ballet of containers, harmonizing scalability, fault tolerance, service discovery, security, and portability. As the maestro, Kubernetes empowers organizations to embrace the full potential of container orchestration and compose a symphony of seamless applications. So, let Kubernetes guide you on this melodious journey, where your applications dance to the rhythm of scalability, resilience, and operational excellence.

How YAML Helps To Define and Configure Deployments

In Kubernetes, YAML holds a special place when it comes to defining and configuring deployments. This seemingly simple text format has the power to shape the entire infrastructure and orchestration of a Kubernetes cluster. Let's delve into the significance of YAML in this fascinating realm and explore the many reasons why it is essential for Kubernetes deployments.

1. Declarative Configuration

YAML, short for "YAML Ain't Markup Language," provides a declarative way to describe the desired state of a Kubernetes deployment. It allows developers and system administrators to express their intentions without specifying detailed instructions on how to achieve them. This declarative nature of YAML simplifies the deployment process and eliminates the need to manage low-level details manually.

2. Human-readable and Intuitive

YAML's syntax is designed to be human-readable and intuitive. It uses indentation and simple key-value pairs to represent data structures. This makes it easy for developers and operations teams to understand and modify deployment configurations. Unlike complex programming languages, YAML's simplicity allows for quick comprehension and reduces the chance of errors.

3. Structured Organization

YAML enables a structured organization of Kubernetes deployment configurations. It allows for the definition of multiple resources in a single file, such as pods, services, and volumes. This logical grouping of related resources promotes better maintainability and makes it easier to manage and track changes across deployments.

4. Version Control and Collaboration

YAML files can be easily version-controlled using tools like Git. This enables teams to collaborate effectively by tracking and managing changes to deployment configurations over time. With version control, it becomes effortless to revert to previous configurations, compare different versions, and maintain a clear history of modifications.

5. Integration with Continuous Deployment

YAML plays a crucial role in integrating Kubernetes deployments into a continuous deployment workflow. By defining deployment configurations in YAML files, developers can seamlessly integrate them into their CI/CD pipelines. This allows for automated and controlled deployment of applications, ensuring consistency and reproducibility across different environments.

6. Extensibility and Templating

YAML supports extensibility through the use of templates. Templating allows for the parameterization and reuse of deployment configurations. By defining variables and placeholders within YAML files, developers can generate multiple deployments with different configurations using a single template. This enhances flexibility and makes it easier to manage complex deployment scenarios.

7. Portability

YAML's adoption as the standard format for Kubernetes deployments ensures portability across different platforms and cloud providers. Kubernetes follows the principle of "write once, run anywhere," and YAML plays a crucial role in enabling this portability. Developers can create deployment configurations using YAML and then deploy them on any Kubernetes cluster, regardless of the underlying infrastructure.

YAML is the magic ingredient that gives Kubernetes deployments their shape and form. Its declarative nature, human-readable syntax, structured organization, and integration capabilities make it an indispensable tool for defining and configuring deployments. Embracing YAML empowers developers and operations teams to create scalable, maintainable, and portable deployments that bring their applications to life in the Kubernetes ecosystem.

Key Components of A Kubernetes YAML FIle

When it comes to deploying applications in a Kubernetes cluster, the key to success lies in the YAML file that defines the deployment template. This file acts as a blueprint, guiding Kubernetes on how to create and manage the resources necessary for the application to run smoothly. Let's dive into the key components of a Kubernetes YAML file and explore their role in the deployment process.

1. API Version

At the top of the YAML file, you'll find the API version. This field indicates which version of the Kubernetes API the file is written for. It ensures compatibility and helps Kubernetes understand the structure and semantics of the YAML file.

yaml
yaml
apiVersion: apps/v1

2. Kind

The "kind" field specifies the type of Kubernetes resource being defined. In the context of a deployment template, the value would be "Deployment". This tells Kubernetes that we are defining a deployment object and not some other resource like a pod or a service.

yaml
yaml
kind: Deployment

3. Metadata

Under the metadata section, you can provide additional information about the deployment template, such as its name, labels, and annotations. Labels are key-value pairs that help with grouping and selecting objects, while annotations provide additional metadata that can be used by tools or other components.

yaml
yaml
metadata:
  name: my-app-deployment
  labels:
    app: my-app
  annotations:
    my-app-version: v1.0.0

4. Spec

The spec section contains the desired state of the deployment. It includes information about the number of replicas, the container image to use, ports, volumes, and more. This is where you define how you want your application to run within the Kubernetes cluster.
‍

yaml
yaml
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app-container
          image: my-app-image:v1.0.0
          ports:
            - containerPort: 8080

5. Replicas

The replicas field specifies the desired number of identical copies of our application to run. Kubernetes will ensure that this desired state is maintained, scaling up or down as needed based on the current demand.
‍

yaml
yaml
spec:
  replicas: 3

6. Selector

The selector field defines how the deployment selects which pods it manages. In our example, we are using labels to match the pods with the deployment. This allows Kubernetes to keep track of which pods are part of the deployment and manage them accordingly.
‍

yaml
yaml
spec:
  selector:
    matchLabels:
      app: my-app

7. Template

The template section is where you define the pod template that Kubernetes will use to create individual pods. It includes metadata, such as labels, and the pod's specification, which defines which containers to run, volumes to mount, and other configurations.
‍

yaml
yaml
spec:
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app-container
          image: my-app-image:v1.0.0
          ports:
            - containerPort: 8080

These are the key components of a Kubernetes deployment template YAML file. Each component plays a vital role in defining the desired state of the deployment and guiding Kubernetes on how to create and manage the necessary resources. By understanding and utilizing these components effectively, you can ensure a smooth and successful deployment of your application in a Kubernetes cluster.

Specific Features In The Kubernetes Deployment Template

1. Replicas: Scaling Up the Application

The use of replicas in a Kubernetes deployment template allows you to define the desired number of instances of your application that should be running at any given time. By specifying the number of replicas, you can easily scale up or down your application as needed. Let's take a look at an example:
‍

yaml
yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:latest
        ports:
        - containerPort: 8080

In this example, the `replicas` field is set to 3, indicating that there should be three instances of the `my-app` application running.

2. Health Checks: Ensuring Application Availability

Health checks are essential for ensuring the availability of your application. Kubernetes provides two types of health checks: readiness probes and liveness probes. Let's see how they can be incorporated into a deployment template:
‍

yaml
yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:latest
        ports:
        - containerPort: 8080
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 15
          periodSeconds: 20

In this example, both a readiness probe and a liveness probe are defined for the `my-app` container. The readiness probe checks if the application is ready to receive traffic, while the liveness probe checks if the application is still running. These probes use HTTP GET requests to the `/health` endpoint on port 8080 and have specified initial delay and periodicity settings.

3. Rolling Updates: Seamless Deployment Upgrades

Kubernetes allows you to perform rolling updates, minimizing downtime during application upgrades. This is achieved by gradually replacing old instances with new ones. Let's see how rolling updates can be configured in a deployment template:

yaml
yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:latest
        ports:
        - containerPort: 8080

In this example, the `strategy` field is set to `RollingUpdate`, indicating that rolling updates should be used. The `maxSurge` field specifies the maximum number of additional pods that can be created during the update process, while the `maxUnavailable` field specifies the maximum number of pods that can be unavailable at any given time.

4. Resource Requests and Limits: Efficient Resource Allocation

To ensure efficient resource allocation, Kubernetes allows you to specify resource requests and limits for your containers. Resource requests define the minimum amount of resources that a container needs, while limits define the maximum amount of resources that a container can use. Let's take a look at an example:

yaml
yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: "100m"
            memory: "256Mi"
          limits:
            cpu: "200m"
            memory: "512Mi"

In this example, the `requests` field specifies that the container requires a minimum of 100 milliCPU and 256 megabytes of memory. The `limits` field specifies that the container cannot exceed 200 milliCPU and 512 megabytes of memory.

By exploring these features of a Kubernetes deployment template, you can effectively manage and scale your applications while ensuring their availability, seamless upgrades, and efficient resource allocation.

How The Kubernetes Deployment Template Addresses Scalability Concerns Within Kubernetes Deployments

Kubernetes is a powerful container orchestration platform that provides built-in mechanisms for scaling applications. These mechanisms allow applications to handle increased traffic and workload, ensuring optimal performance and availability. Let's explore some strategies and configurations recommended for achieving scalability within Kubernetes deployments.

1. Horizontal Pod Autoscaling (HPA)

Kubernetes provides the Horizontal Pod Autoscaling (HPA) feature, which automatically adjusts the number of pods in a deployment based on CPU utilization or custom metrics. HPA ensures that the application can scale up or down to meet fluctuations in demand. By defining resource requirements and target CPU utilization, the HPA controller can dynamically adjust the number of running pods.

2. Cluster Autoscaler

The Cluster Autoscaler is a Kubernetes add-on that automatically adjusts the size of the cluster based on the demand for pods. It ensures that there are enough resources to accommodate scaling needs. When the demand for pods exceeds the capacity of the cluster, the Cluster Autoscaler provisions additional nodes. Conversely, when the demand decreases, it removes unnecessary nodes to optimize resource utilization.

3. StatefulSets for Stateful Applications

StatefulSets are a Kubernetes controller used for deploying and managing stateful applications. They provide guarantees for unique network identities, ordered and graceful scaling, and persistent storage. StatefulSets allow for scalable deployment of stateful applications such as databases, where each instance requires stable network identities and persistent storage volumes.

4. Load Balancing

Kubernetes provides built-in load-balancing mechanisms to distribute traffic across multiple pods within a deployment. By using a service and defining a load balancer, Kubernetes ensures that incoming requests are evenly distributed among the available pods. This helps to achieve scalability by effectively utilizing the resources of the deployment.

5. Resource Limits and Requests

Setting appropriate resource limits and requests for containers within a deployment is crucial for achieving scalability. By defining these values based on the application's resource requirements, Kubernetes can schedule and allocate resources efficiently. This helps prevent resource contention and ensures that pods can scale as needed without affecting the overall performance of the cluster.

6. Rolling Updates and Deployments

Kubernetes supports rolling updates and deployments, allowing for seamless updates to the application without downtime. By gradually replacing old pods with new ones, the application can be scaled up or down while maintaining availability. This ensures that the application can handle increased traffic during updates without causing disruptions.

Kubernetes provides various strategies and configurations to address scalability concerns within deployments. By leveraging features such as Horizontal Pod Autoscaling, Cluster Autoscaler, StatefulSets, load balancing, resource limits and requests, and rolling updates, Kubernetes allows applications to scale efficiently and handle fluctuations in demand. These mechanisms help optimize resource utilization and ensure high availability and performance in Kubernetes deployments.

Troubleshooting Tips for The Kubernetes Deployment Template

Resolving Pod Scheduling Issues

When working with Kubernetes Deployment Templates, it is not uncommon to encounter pod scheduling issues. These problems can arise due to various factors, such as resource constraints or node affinity rules. To troubleshoot and resolve pod scheduling issues, consider the following tips and techniques:

1. Evaluating Resource Requirements

One common cause of pod scheduling issues is insufficient resources. By examining the resource requirements specified in the deployment template, you can identify whether the pods require more CPU or memory than what is available in the cluster. Adjusting the resource requests and limits can help ensure successful pod scheduling.

2. Analyzing Node Affinity and Anti-Affinity

Node affinity rules define preferences for scheduling pods on specific nodes based on various attributes, such as labels or taints. If pod scheduling issues persist, review the node affinity rules in the deployment template to ensure they align with the available nodes in the cluster. Adjustments to these rules might be necessary to facilitate successful scheduling.

3. Considering NodeSelector

NodeSelector is another mechanism that can impact pod scheduling. It allows you to specify a set of key-value pairs to match against node labels. If the deployment template includes NodeSelector constraints, verify that the nodes in the cluster possess the required labels. Adjusting these constraints can help resolve scheduling issues.

Managing Service Discovery Problems

Service discovery is crucial for enabling communication between various components in a Kubernetes cluster. Issues with service discovery can hinder the proper functioning of the deployment template. Here are some troubleshooting tips and techniques to address common service discovery problems:

1. Verifying Service Definitions

Ensure that the deployment template includes accurate and up-to-date service definitions. Verify that the service names, ports, and endpoints are correctly specified. Incorrectly defined services can lead to connectivity issues between pods.

2. Checking DNS Resolution

DNS resolution plays a vital role in service discovery within a Kubernetes cluster. If pods are unable to resolve service names, it can indicate a problem with DNS configuration. Check the DNS settings in the cluster and ensure that DNS resolution is functioning correctly.

3. Investigating Network Policies

Network policies can restrict communication between pods and services. If a pod is unable to access a service, examine the network policies in the deployment template to identify any potential restrictions. Adjusting the network policies or adding appropriate rules can resolve service discovery problems.

Troubleshooting Persistent Volume Claims

Persistent Volume Claims (PVCs) are essential for data persistence in Kubernetes. Issues with PVCs can arise, impacting the functioning of the deployment template. Here are some troubleshooting tips and techniques to address common PVC problems:

1. Checking Storage Provisioner Status

Ensure that the storage provisioner used for PVCs is functioning correctly. If the provisioner is not available or encountering errors, PVC creation and binding might fail. Verify the status of the storage provisioner and resolve any issues to enable successful PVC usage.

2. Inspecting Access Mode Requirements

PVCs can have different access modes, such as ReadWriteOnce or ReadOnlyMany. If a pod fails to mount a PVC, validate that the access mode specified in the deployment template matches the requirements of the pod. Adjusting the access mode can help resolve mounting issues.

3. Verifying Storage Class Availability

Storage classes define different types of storage available in the cluster. If the deployment template specifies a particular storage class for PVCs, confirm that the storage class exists and is accessible. Provisioning failures can occur if the specified storage class is unavailable.

Troubleshooting issues with Kubernetes Deployment Templates requires a systematic approach to identify and address common problems. By evaluating pod scheduling, managing service discovery, and resolving persistent volume claim issues, you can ensure the smooth functioning of your deployment templates in a Kubernetes cluster.

Related Reading

• Kubernetes Restart Deployment
• Kubernetes Deployment Vs Pod
• Kubernetes Canary Deployment
• Kubernetes Update Deployment
• Kubernetes Deployment Logs
• Kubernetes Continuous Deployment
• Kubernetes Blue Green Deployment
• Kubernetes Delete Deployment
• Kubernetes Cheat Sheet
• Kubernetes Daemonset Vs Deployment
• Kubernetes Deployment Types
• Kubernetes Deployment Strategy Types
• Kubernetes Deployment Update Strategy
• Kubernetes Update Deployment With New Image
• Kubernetes Restart All Pods In Deployment
• Kubernetes Deployment Tools

Become a 1% Developer Team With Zeet

Are you a startup or small business looking to optimize your cloud and Kubernetes investments? Look no further than Zeet. Our cutting-edge platform is designed to help your engineering team become strong individual contributors, empowering them to get the most out of their cloud and Kubernetes deployments.

Efficiency Unleashed

At Zeet, we understand the unique challenges that startups and small businesses face in today's fast-paced digital landscape. Limited resources and tight budgets can make it difficult to effectively leverage the power of cloud computing and Kubernetes. That's where our expertise comes in.

Customization Made Easy

With Zeet, you gain access to a comprehensive suite of tools and services that streamline the deployment process and maximize efficiency. Our Kubernetes deployment templates are pre-configured with best practices and industry standards, ensuring a seamless and error-free deployment every time. These templates can be easily customized to meet your specific needs, saving you time and effort.

Empowering Your Team

But our services go beyond just providing deployment templates. We also offer comprehensive training and support to help your engineering team become proficient in managing and scaling Kubernetes deployments. We will guide you through the process, empowering your team to take ownership of their deployments and become strong individual contributors.

Scaling with Confidence

Whether you're a startup with just a handful of employees or a mid-market company with hundreds, Zeet has the tools and expertise to help you get the most out of your cloud and Kubernetes investments. Our platform is designed to scale with your business, allowing you to grow and adapt without sacrificing performance or reliability.

Breaking Limits

Don't let limited resources hold you back. With Zeet, you can unlock the full potential of your cloud and Kubernetes deployments, while empowering your engineering team to become strong individual contributors. Get started with Zeet today and see the difference it can make for your business.

Related Reading

• Kubernetes Service Vs Deployment
• Kubernetes Rollback Deployment
• Deployment As A Service
• Kubernetes Deployment Env
• Deploy Kubernetes Dashboard