How to use the command 'kubectl expose' (with examples)

The kubectl expose command is an essential tool within Kubernetes, designed to create a service that exposes a resource, typically a pod or a deployment, to the network. This service acts as an abstract way to expose an application running on a set of pods as a network service. Whether you need to create a load balancer, open an internal service, or expose a specific port, kubectl expose provides a flexible mechanism to route external traffic into your Kubernetes cluster.

Use case 1: Create a service for a resource, which will be served from container port to node port

Code:

kubectl expose pod mypod --port=8080 --target-port=80

Motivation:

There are scenarios where you want to expose an application running inside a pod to the outside world. For example, suppose you have an application that listens on port 80 inside its container, but you want to access it externally on port 8080. By exposing a pod as a service, you can easily route traffic from a node port to the intended container port.

Explanation:

• kubectl expose: Initiates the command to expose the resource.
• pod mypod: Specifies the resource type (pod) and the name of the resource (mypod) you wish to expose.
• --port=8080: This is the port on the node where clients can connect. It allows traffic to be received at this node port.
• --target-port=80: This specifies the port on the container to which the traffic is directed. In this case, the application inside the pod listens on port 80.

Example Output:

service/mypod exposed

This output confirms that the service has been successfully created and is now routing traffic from node port 8080 to the container port 80 within the pod mypod.

Use case 2: Create a service for a resource identified by a file

Code:

kubectl expose -f path/to/application.yml --port=8080 --target-port=80

Motivation:

When working with Kubernetes, it’s common to define resources using YAML configuration files. This allows for a more structured and reproducible setup process. By using a configuration file, you can manage complex configurations more easily, facilitating the deployment and management of services. Exposing a service through a file-based resource ensures that all configurations and deployments are systematically defined and can be version-controlled.

Explanation:

• kubectl expose: Begins the process of exposing a resource.
• -f path/to/application.yml: Specifies the configuration file that identifies the resource to expose. The -f flag indicates file usage, pointing to the YAML file defining the resource’s specifications.
• --port=8080: Denotes the node port for external connections, facilitating client access to the service.
• --target-port=80: Directs the inbound traffic to the specified container port within the service, allowing the internal application to receive the traffic correctly.

Example Output:

service/application exposed

This output indicates that the resource defined in application.yml has been successfully exposed as a service, with traffic being directed from node port 8080 to the target container port 80.

Use case 3: Create a service with a name, to serve to a node port which will be the same for the container port

Code:

kubectl expose deployment mydeployment --port=80 --name=my-custom-service

Motivation:

Customizing service names allows for better organization and clarity, especially when managing multiple services within a Kubernetes cluster. Assigning a meaningful name to a service can enhance clarity and facilitate easier service routing and management. In this scenario, exposing a deployment with a specific service name while using the same node and container port simplifies network routing and ensures consistency in service exposure.

Explanation:

• kubectl expose: Initiates the command to create the service.
• deployment mydeployment: Specifies the resource type (deployment) and the name of the resource to expose (mydeployment).
• --port=80: Defines both the node port and the container port, making external access uniform and straightforward.
• --name=my-custom-service: Specifies a custom name for the service, my-custom-service, making it easier to identify and manage within the cluster.

Example Output:

service/my-custom-service exposed

This output signifies that the mydeployment has been exposed and is now accessible as my-custom-service, routing traffic directly through port 80 for both node and container levels.

Conclusion:

The kubectl expose command is a versatile tool for exposing Kubernetes resources as services, enabling external access and consistent traffic routing. By understanding and utilizing its functionality, you can effectively manage and orchestrate network access and service exposure within your Kubernetes clusters. Whether working with resource files or custom service names, kubectl expose offers the flexibility and control needed to streamline application deployment and service management.