KubeVPN

https://kubevpn.dev/docs/
Admin
KubeVPN provides a Cloud Native Dev Environment, allowing developers to connect to Kubernetes...
Tokens:20,179
Snippets:248
Trust Score:5.9
Update:8 months ago
Show doc for...
Tokens:
Raw
### Install KubeVPN Client using Script

Source: https://kubevpn.dev/docs/quickstart

Installs the KubeVPN client by downloading and executing an installation script. This method is cross-platform and suitable for various operating systems.

```bash
curl -fsSL https://kubevpn.dev/install.sh | sh
```

--------------------------------

### Install KubeVPN Client using Snap (Linux)

Source: https://kubevpn.dev/docs/quickstart

Installs the KubeVPN client on Linux systems using the Snap package manager. This provides a sandboxed and easily manageable installation.

```bash
sudo snap install kubevpn
```

--------------------------------

### Install KubeVPN Client using Scoop (Windows)

Source: https://kubevpn.dev/docs/quickstart

Installs the KubeVPN client on Windows using the Scoop package manager. This command adds the necessary bucket and installs the KubeVPN client.

```bash
scoop bucket add extras
scoop install kubevpn
```

--------------------------------

### Install KubeVPN Client using Brew (macOS)

Source: https://kubevpn.dev/docs/quickstart

Installs the KubeVPN client on macOS using the Homebrew package manager. This is a convenient method for macOS users to install and manage the client.

```bash
brew install kubevpn
```

--------------------------------

### Install KubeVPN Client using Krew

Source: https://kubevpn.dev/docs/quickstart

Installs the KubeVPN client using `kubectl krew`, the Kubernetes plugin manager. This method integrates KubeVPN directly into your kubectl command-line experience.

```bash
kubectl krew index add kubevpn https://github.com/kubenetworks/kubevpn.git
kubectl krew install kubevpn/kubevpn
```

--------------------------------

### Install KubeVPN Server with Private Registry

Source: https://kubevpn.dev/docs/quickstart

Installs the KubeVPN server using Helm, specifying a private Docker registry for the image. This is useful for environments with restricted access to public registries.

```bash
helm install kubevpn kubevpn/kubevpn --set image.repository=[YOUR_PRIVATE_REGISTRY]/kubevpn/kubevpn --set 'imagePullSecrets[0].name=registry' -n default --debug --set image.tag=v2.2.2
```

--------------------------------

### SSH Configuration Example

Source: https://kubevpn.dev/docs/blog/run_mode

This example demonstrates how to configure SSH connections in the ~/.ssh/config file. It shows how to set hostnames, usernames, ports, and identity files for specific hosts. It also illustrates the use of Include for modular configuration and ProxyJump for chained SSH connections.

```sshconfig
Include /Users/bytedance/.ssh/configtest

Host ry-dev
    Hostname 36.110.140.184
    User root
    Port 22
    IdentityFile /bytedance/.ssh/ry.pem

Host ry-dev-agd
    ProxyJump ry-dev
    Hostname 10.1.1.154
    User root
    Port 22
    IdentityFile /bytedance/.ssh/ry-dev-agd
```

--------------------------------

### Install KubeVPN Server with Helm

Source: https://kubevpn.dev/docs/quickstart

Installs the KubeVPN server into your Kubernetes cluster using Helm. This command deploys the KubeVPN server components, enabling cluster connectivity.

```bash
helm install kubevpn kubevpn/kubevpn
```

--------------------------------

### Add KubeVPN Helm Repository

Source: https://kubevpn.dev/docs/quickstart

Adds the KubeVPN Helm chart repository to your local Helm configuration. This is a prerequisite for installing the KubeVPN server using Helm.

```bash
helm repo add kubevpn https://raw.githubusercontent.com/kubenetworks/kubevpn/master/charts
```

--------------------------------

### Apply Bookinfo Demo Application

Source: https://kubevpn.dev/docs/quickstart

Applies the Bookinfo sample application to your Kubernetes cluster. This is a common demo application used to test KubeVPN's connectivity features.

```yaml
kubectl apply -f https://raw.githubusercontent.com/kubenetworks/kubevpn/master/samples/bookinfo.yaml
```

--------------------------------

### Search for KubeVPN Helm Chart

Source: https://kubevpn.dev/docs/quickstart

Searches your configured Helm repositories for the KubeVPN chart. This command helps verify that the repository was added correctly and shows available chart versions.

```bash
helm search repo kubevpn
```

--------------------------------

### Delete Bookinfo Demo Application

Source: https://kubevpn.dev/docs/quickstart

Deletes the Bookinfo sample application from your Kubernetes cluster. This command is used for cleanup after testing KubeVPN.

```yaml
kubectl delete -f https://raw.githubusercontent.com/kubenetworks/kubevpn/master/samples/bookinfo.yaml
```

--------------------------------

### Kubevpn Proxy Command Examples

Source: https://kubevpn.dev/docs/architecture/gvisor_mesh

Demonstrates how to use the `kubevpn proxy` command to route traffic to a service ('authors') with specific HTTP headers. This allows different users to proxy the same service to their local machines.

```bash
kubevpn proxy deployment/authors --headers user=A
kubevpn proxy deployment/authors --headers user=B
```

--------------------------------

### KubeVPN Deployment and Testing with a Go Application

Source: https://kubevpn.dev/docs/functions/dind

This snippet demonstrates the process of running KubeVPN to inject a sidecar into a Kubernetes deployment, building and running a simple Go HTTP server within the container, and testing its accessibility via curl.

```bash
➜  ~ docker run -it --privileged --sysctl net.ipv6.conf.all.disable_ipv6=0 -v /var/run/docker.sock:/var/run/docker.sock -v /tmp:/tmp -v ~/.kube/vke:/root/.kube/config --platform linux/amd64 naison/kubevpn:latest
...
/opt/microservices # cat > hello.go <<EOF
package main  
  
import (  
    "fmt"  
    "io"  
    "net/http"  
)  
  
func main() {
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        _, _ = io.WriteString(writer, "Hello world!")
        fmt.Println(">> Container Received request: %s %s from %s\n", request.Method, request.RequestURI, request.RemoteAddr)
    })
    fmt.Println("Start listening http port 9080 ...")
    _ = http.ListenAndServe(":9080", nil)
}
EOF
/opt/microservices # go build hello.go
/opt/microservices # ./hello &
/opt/microservices # curl localhost:9080
Hello world!
/opt/microservices # curl authors:9080/health -H "foo: bar"
Hello world!
```

--------------------------------

### Run Deployment in Sync Mode with Kubevpn

Source: https://kubevpn.dev/docs/functions/sync_mode

This command initiates a synchronization process for a specified deployment. It allows traffic interception based on headers and synchronizes local code to a designated deployment within the Kubernetes cluster. Ensure Kubevpn is installed and configured.

```bash
kubevpn sync deployment/authors -c authors --headers foo=bar --sync ~/GolandProjects/bookinfo-authors:/app/code
```

--------------------------------

### Initial Docker Daemon Configuration (Before Modification)

Source: https://kubevpn.dev/docs/faq/3

This snippet displays the initial content of the Docker daemon configuration file (`~/.docker/daemon.json`) before any modifications are made. It serves as a reference to understand the starting state of the configuration, which might be missing the `bip` setting that causes network conflicts with Kubevpn.

```json
{
  "builder": {
    "gc": {
      "defaultKeepStorage": "20GB",
      "enabled": true
    }
  },
  "experimental": false,
  "features": {
    "buildkit": true
  },
  "insecure-registries": [
  ]
}
```

--------------------------------

### Run KubeVPN in Docker with Volume Mounts and Network Sharing

Source: https://kubevpn.dev/docs/functions/dind

This command initiates KubeVPN in a Docker container using Docker-in-Docker. It includes essential volume mounts for `/tmp`, Docker socket, and kubeconfig, along with privileged access and network sharing for development purposes.

```bash
docker run -it --privileged --sysctl net.ipv6.conf.all.disable_ipv6=0 -v /var/run/docker.sock:/var/run/docker.sock -v /tmp:/tmp -v ~/.kube/config:/root/.kube/config --platform linux/amd64 naison/kubevpn:latest
```

--------------------------------

### Test Service Connection using Curl

Source: https://kubevpn.dev/docs/functions/connect_to_k8s_cluster_network

This command uses `curl` to test the connection to a Kubernetes service by accessing its ClusterIP and port. The example shows a successful connection to the 'productpage' service, returning an HTML snippet.

```bash
➜  ~ curl 172.21.10.49:9080  
<!DOCTYPE html>  
<html>  
  <head>  
    <title>Simple Bookstore App</title>  
<meta charset="utf-8">  
<meta http-equiv="X-UA-Compatible" content="IE=edge">  
<meta name="viewport" content="width=device-width, initial-scale=1">  


```

--------------------------------

### Kubevpn Alias Configuration Example (YAML)

Source: https://kubevpn.dev/docs/commands/kubevpn_alias

This YAML configuration defines two aliases, 'dev' and 'jumper', for Kubevpn. The 'dev' alias depends on the 'jumper' alias, indicating that 'jumper' should be connected first. Each alias specifies connection flags like kubeconfig path and namespace.

```yaml
Name: dev  
Needs: jumper  
Flags:  
  - connect  
  - --kubeconfig=~/.kube/config  
  - --namespace=default  
---
  
Name: jumper  
Flags:  
  - connect  
  - --kubeconfig=~/.kube/jumper_config  
  - --namespace=test  
  - --extra-hosts=xxx.com  

```

--------------------------------

### Develop Workloads with HTTP Header Filtering using Kubevpn

Source: https://kubevpn.dev/docs/commands/kubevpn_run

This command allows for targeted traffic development by specifying HTTP headers. When the 'foo=bar' header is present, traffic will be directed to the local development environment; otherwise, it will not affect the local setup. This is useful for testing specific request paths or features within a service mesh.

```bash
kubevpn run service/productpage --headers foo=bar
```

--------------------------------

### Create a Local Go Web Server

Source: https://kubevpn.dev/docs/functions/reverse_proxy

This Go program creates a simple HTTP server that listens on port 9080 and responds with 'Hello world!'. It also logs incoming requests to standard output. Save this code as `hello.go` and compile it using `go build hello.go`.

```go
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
		_, _ = io.WriteString(writer, "Hello world!")
		fmt.Printf(">>Received request: %s %s from %s\n", request.Method, request.RequestURI, request.RemoteAddr)
	})
	_ = http.ListenAndServe(":9080", nil)
}
```

--------------------------------

### Compile and Run Local Go Application

Source: https://kubevpn.dev/docs/functions/reverse_proxy

Instructions to compile the `hello.go` program into an executable and run it in the background. This prepares the local application to be accessed from within the Kubernetes cluster.

```bash
go build hello.go
./hello &
```

--------------------------------

### Install and Enable systemd-resolved Service

Source: https://kubevpn.dev/docs/faq/7

Installs and enables the `systemd-resolved` service, which is crucial for managing DNS resolution on Linux systems. This is a prerequisite for resolving network connectivity issues when using Kubevpn.

```shell
dnf install systemd-resolved

```

```shell
pacman -S systemd

```

```shell
apt install systemd

```

```shell
systemctl enable systemd-resolved.service

```

```shell
systemctl start systemd-resolved.service

```

--------------------------------

### Kubernetes Service Definition for gVisor Mode

Source: https://kubevpn.dev/docs/architecture/gvisor_mesh

An example Kubernetes Service definition for the 'authors' application. In gVisor mode, the `targetPort` is modified to the envoy listener port, enabling service-level proxying.

```yaml
apiVersion: v1
kind: Service
metadata:
  labels:
    app: authors
    service: authors
  name: authors
  namespace: default
spec:
  clusterIP: 172.21.5.157
  clusterIPs:
    - 172.21.5.157
  ports:
    - name: http
      port: 9080
      protocol: TCP
      targetPort: 64071
  selector:
    app: authors
  sessionAffinity: None
  type: ClusterIP
```

--------------------------------

### Proxy via SSH Alias

Source: https://kubevpn.dev/docs/commands/kubevpn_proxy

Proxies traffic using an SSH alias defined in the user's SSH configuration file. This simplifies the process of connecting through complex SSH jump host setups.

```bash
kubevpn proxy service/productpage --ssh-alias <alias> --headers foo=bar
```

--------------------------------

### List Services and their IPs using kubectl

Source: https://kubevpn.dev/docs/functions/connect_to_k8s_cluster_network

This command lists all services in the Kubernetes cluster, including their ClusterIP, external IP (if any), ports, and selectors. This is useful for finding the IP address of a specific service, such as 'productpage'.

```bash
➜  ~ kubectl get services -o wide  
NAME                      TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)                              AGE     SELECTOR  
authors                   ClusterIP   172.21.5.160    <none>        9080/TCP                             114d    app=authors  
details                   ClusterIP   172.21.6.183    <none>        9080/TCP                             114d    app=details  
kubernetes                ClusterIP   172.21.0.1      <none>        443/TCP                              319d    <none>  kubevpn-traffic-manager  ClusterIP   172.21.2.86     <none>        8422/UDP,10800/TCP,9002/TCP,80/TCP   2m28s   app=kubevpn-traffic-manager  
productpage               ClusterIP   172.21.10.49    <none>        9080/TCP                             114d    app=productpage  
ratings                   ClusterIP   172.21.3.247    <none>        9080/TCP                             114d    app=ratings  
reviews                   ClusterIP   172.21.8.24     <none>        9080/TCP                             114d    app=reviews  


```

--------------------------------

### Print Kubevpn Client Version

Source: https://kubevpn.dev/docs/commands/kubevpn_version

This command prints the client version information for Kubevpn. It displays details such as the CLI version, daemon version, Docker image used, Git branch and commit, build time, operating system and architecture, and the Go version.

```bash
kubevpn version
```

```text
KubeVPN: CLI  
    Version: v2.2.17  
    Daemon: v2.2.17  
    Image: docker.io/naison/kubevpn:v2.2.17  
    Branch: master  
    Git commit: ac918b5  
    Built time: 2024-09-03 20:31:08  
    Built OS/Arch: darwin/arm64  
    Built Go version: go1.22.6  
```

--------------------------------

### Access Service Using Short Domain Name with Curl

Source: https://kubevpn.dev/docs/functions/short_domain_resolve

Demonstrates how to access a service within a Kubernetes cluster using its short domain name. This method is useful for internal service-to-service communication. It requires `curl` to be installed on the client machine.

```shell
#!/bin/bash
curl productpage:9080
```

```html
<!DOCTYPE html>
<html>
  <head>
    <title>Simple Bookstore App</title>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
...
```

--------------------------------

### SSH Authentication with GSSAPI

Source: https://kubevpn.dev/docs/commands/kubevpn_connect

Demonstrates connecting to a Kubernetes cluster via SSH using GSSAPI authentication. Supports authentication using a keytab file, a cache file, or a password.

```bash
kubevpn connect --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-keytab /path/to/keytab
```

```bash
kubevpn connect --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-cache /path/to/cache
```

```bash
kubevpn connect --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-password <PASSWORD>
```

--------------------------------

### Develop Workloads via Bastion/Jump Host with Kubevpn

Source: https://kubevpn.dev/docs/commands/kubevpn_run

This command facilitates development when the Kubernetes API server is accessible only through a bastion host or SSH jump host. It allows specifying the SSH address, username, and private key file to establish a secure connection through the intermediate host to reach the API server.

```bash
kubevpn run deployment/productpage --ssh-addr 192.168.1.100:22 --ssh-username root --ssh-keyfile ~/.ssh/ssh.pem
```

--------------------------------

### Connecting to KubeVPN with a Private Image

Source: https://kubevpn.dev/docs/faq/1

Shows how to use the `kubevpn connect` command with the `--image` flag to specify a custom image located in a private Docker registry. This is the final step of Solution 1.

```bash
➜  ~ kubevpn connect --image [docker registry]/[namespace]/[repo]:[tag]  
Starting connect  
Getting network CIDR from cluster info...  
Getting network CIDR from CNI...  
Getting network CIDR from services...  
...  

```

--------------------------------

### Run Kubernetes Workloads Locally with Kubevpn

Source: https://kubevpn.dev/docs/commands/kubevpn_run

This command executes a Kubernetes deployment or service within a local Docker container. It automatically mounts specified volumes, configures the container's network to match the cluster, and synchronizes environment variables from the Kubernetes pod. This enables local development and debugging of applications as if they were running in the cluster.

```bash
kubevpn run deployment/productpage
```

--------------------------------

### Support SSH GSSAPI Authentication with Kubevpn

Source: https://kubevpn.dev/docs/commands/kubevpn_run

This command demonstrates how to use GSSAPI (Generic Security Services Application Program Interface) for SSH authentication when connecting to the Kubernetes API server. It supports authentication using a keytab file, a credential cache, or a password, providing flexible and secure access methods.

```bash
kubevpn run deployment/authors -n default --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-keytab /path/to/keytab --entrypoint /bin/bash
```

```bash
kubevpn run deployment/authors -n default --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-cache /path/to/cache --entrypoint /bin/bash
```

```bash
kubevpn run deployment/authors -n default --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-password <PASSWORD> --entrypoint /bin/bash
```

--------------------------------

### Develop Workloads via SSH Alias with Kubevpn

Source: https://kubevpn.dev/docs/commands/kubevpn_run

This command enables development by leveraging pre-configured SSH aliases for connecting to the Kubernetes API server. This simplifies the connection process when using complex SSH configurations, such as multiple jump hosts (ProxyJump), by referencing a defined alias.

```bash
kubevpn run deployment/productpage --ssh-alias <alias>
```

--------------------------------

### List Pods and their IPs using kubectl

Source: https://kubevpn.dev/docs/functions/connect_to_k8s_cluster_network

This command lists all pods in the Kubernetes cluster along with their IP addresses, node assignments, and readiness status. This is useful for identifying the IP of a specific pod, such as 'productpage-788df7ff7f-jpkcs'.

```bash
➜  ~ kubectl get pods -o wide  
NAME                                       READY   STATUS             RESTARTS   AGE     IP                NODE              NOMINATED NODE   READINESS GATES  
authors-dbb57d856-mbgqk                    3/3     Running            0          7d23h   172.29.2.132      192.168.0.5       <none>           <none>  
details-7d8b5f6bcf-hcl4t                   1/1     Running            0          61d     172.29.0.77       192.168.104.255   <none>           <none>   Кубеvpn-traffic-manager-66d969fd45-9zlbp   3/3     Running            0          74s     172.29.2.136      192.168.0.5       <none>           <none>  
productpage-788df7ff7f-jpkcs               1/1     Running            0          61d     172.29.2.134      192.168.0.5       <none>           <none>  
ratings-77b6cd4499-zvl6c                   1/1     Running            0          61d     172.29.0.86       192.168.104.255   <none>           <none>  
reviews-85c88894d9-vgkxd                   1/1     Running            0          24d     172.29.2.249      192.168.0.5       <none>           <none>  


```

--------------------------------

### Run Workloads in Terminal Mode with Kubevpn

Source: https://kubevpn.dev/docs/commands/kubevpn_run

This command allows for interactive terminal sessions within a Kubernetes pod, executed in a local Docker container. It forwards stdin, stdout, and stderr between the client and a specified entrypoint command (e.g., '/bin/bash') inside the container. This is useful for debugging and executing commands directly within the pod's environment.

```bash
kubevpn run deployment/authors -n default --kubeconfig ~/.kube/config --ssh-alias dev --entrypoint /bin/bash
```

--------------------------------

### Connecting to KubeVPN with --transfer-image

Source: https://kubevpn.dev/docs/faq/1

Illustrates how to use the `kubevpn connect` command with both the `--transfer-image` and `--image` flags. This enables KubeVPN to automatically transfer the specified image from a default location to the provided custom registry address, as per Solution 2.

```bash
➜  ~ kubevpn connect --transfer-image --image nocalhost-team-docker.pkg.coding.net/nocalhost/public/kubevpn:v2.0.0  
v2.0.0: Pulling from naison/kubevpn  
Digest: sha256:450446850891eb71925c54a2fab5edb903d71103b485d6a4a16212d25091b5f4  
Status: Image is up to date for naison/kubevpn:v2.0.0  
The push refers to repository [nocalhost-team-docker.pkg.coding.net/nocalhost/public/kubevpn]  
ecc065754c15: Preparing  
f2b6c07cb397: Pushed  
448eaa16d666: Pushed  
f5507edfc283: Pushed  
3b6ea9aa4889: Pushed  
ecc065754c15: Pushed  
feda785382bb: Pushed  
v2.0.0: digest: sha256:85d29ebb53af7d95b9137f8e743d49cbc16eff1cdb9983128ab6e46e0c25892c size: 2000  
Starting connect  
Got network CIDR from cache  
Use exist traffic manager  
Forwarding port...  
Connected tunnel  
Adding route...  
Configured DNS service  
Now you can access resources in the kubernetes cluster !  
➜  ~  

```

--------------------------------

### Execute Kubevpn Alias (CLI)

Source: https://kubevpn.dev/docs/commands/kubevpn_alias

This command demonstrates how to use the configured Kubevpn alias 'dev'. It will connect to the 'jumper' cluster first due to the defined dependency, and then connect to the 'dev' cluster.

```bash
kubevpn alias dev  

```

--------------------------------

### Access Local Application via Service Name

Source: https://kubevpn.dev/docs/functions/reverse_proxy

Demonstrates accessing the locally proxied service using its Kubernetes service name and fully qualified domain name (FQDN). This method is typically used for accessing services within the cluster by their service abstraction.

```bash
curl productpage:9080
curl productpage.default.svc.cluster.local:9080
```

--------------------------------

### Query Kubevpn Status by Alias

Source: https://kubevpn.dev/docs/commands/kubevpn_status

Queries the Kubevpn connection status using a specified alias configuration name. This is useful for managing multiple Kubevpn configurations.

```bash
kubevpn status --alias dev_new
```

--------------------------------

### Connect to Kubernetes Cluster using Kubevpn

Source: https://kubevpn.dev/docs/functions/connect_to_k8s_cluster_network

This command connects to your Kubernetes cluster network. It requires your computer password to enable root operations for creating a tun device. The output shows the process of setting up the network, deploying necessary components, and establishing the connection.

```bash
➜  ~ kubevpn connect  
Password:  
Starting connect  
Getting network CIDR from cluster info...  
Getting network CIDR from CNI...  
Getting network CIDR from services...  
Labeling Namespace default  
Creating ServiceAccount kubevpn-traffic-manager  
Creating Roles kubevpn-traffic-manager  
Creating RoleBinding kubevpn-traffic-manager  
Creating Service kubevpn-traffic-manager  
Creating MutatingWebhookConfiguration kubevpn-traffic-manager  
Creating Deployment kubevpn-traffic-manager  
  
Pod kubevpn-traffic-manager-66d969fd45-9zlbp is Pending  
Container     Reason            Message  
control-plane ContainerCreating  
vpn           ContainerCreating  
webhook       ContainerCreating  
  
Pod kubevpn-traffic-manager-66d969fd45-9zlbp is Running  
Container     Reason           Message  
control-plane ContainerRunning  
vpn           ContainerRunning  
webhook       ContainerRunning  
  
Forwarding port...  
Connected tunnel  
Adding route...  
Configured DNS service  
Now you can access resources in the kubernetes cluster !  
➜  ~  
```

--------------------------------

### Show Kubevpn Connection Status and Resources

Source: https://kubevpn.dev/docs/commands/kubevpn_status

Displays the current connection status and lists proxy or sync resources managed by Kubevpn. Checks the 'status' field and 'netif' to determine health; an empty 'netif' indicates an unhealthy tun device. Also shows route information.

```bash
kubevpn status
```

--------------------------------

### SSH Jump with Inline Configuration

Source: https://kubevpn.dev/docs/commands/kubevpn_connect

Connects to a Kubernetes cluster using an inline SSH jump configuration. This allows specifying complex SSH jump paths directly within the command.

```bash
kubevpn connect --ssh-jump "--ssh-addr jump.naison.org --ssh-username naison --gssapi-password xxx" --ssh-username root --ssh-addr 127.0.0.1:22 --ssh-keyfile "~/.ssh/dst.pem"
```

--------------------------------

### Test Kubernetes Service Resolution with cURL

Source: https://kubevpn.dev/docs/functions/full_domain_resolve

Demonstrates how to test DNS resolution for a Kubernetes service named 'productpage' in the 'default' namespace using the cURL command. This verifies that the service is accessible via its fully qualified domain name.

```shell
curl productpage.default.svc.cluster.local:9080
```

--------------------------------

### Connect to Kubernetes Cluster Network

Source: https://kubevpn.dev/docs/commands/kubevpn_connect

Establishes a connection to the Kubernetes cluster network, allowing local access to pods and services within the cluster. This enables direct interaction with cluster resources as if you were inside the cluster.

```bash
kubevpn connect
```

--------------------------------

### Connect using SSH Alias

Source: https://kubevpn.dev/docs/commands/kubevpn_connect

Connects to the Kubernetes cluster using SSH configuration defined in the `~/.ssh/config` file. This simplifies connection by leveraging pre-configured SSH aliases.

```bash
kubevpn connect --ssh-alias <alias>
```

--------------------------------

### Reverse Proxy with Service Mesh and Headers

Source: https://kubevpn.dev/docs/commands/kubevpn_proxy

Enables reverse proxying with a service mesh, directing traffic to the local PC only if specific HTTP headers are present. This allows for selective traffic routing for debugging.

```bash
kubevpn proxy service/productpage --headers foo=bar
```

```bash
kubevpn proxy service/productpage --headers foo=bar --headers env=dev
```

--------------------------------

### Test Pod Connectivity using Ping

Source: https://kubevpn.dev/docs/functions/connect_to_k8s_cluster_network

This command uses the `ping` utility to test network connectivity to a specific pod's IP address within the Kubernetes cluster. It verifies that the pod is reachable and measures the round-trip time for packets.

```bash
➜  ~ ping 172.29.2.134  
PING 172.29.2.134 (172.29.2.134): 56 data bytes  
64 bytes from 172.29.2.134: icmp_seq=0 ttl=63 time=55.727 ms  
64 bytes from 172.29.2.134: icmp_seq=1 ttl=63 time=56.270 ms  
64 bytes from 172.29.2.134: icmp_seq=2 ttl=63 time=55.228 ms  
64 bytes from 172.29.2.134: icmp_seq=3 ttl=63 time=54.293 ms  
^C  
--- 172.29.2.134 ping statistics ---  
4 packets transmitted, 4 packets received, 0.0% packet loss  
round-trip min/avg/max/stddev = 54.293/55.380/56.270/0.728 ms  


```

--------------------------------

### Execute Single Kubevpn Alias (CLI)

Source: https://kubevpn.dev/docs/commands/kubevpn_alias

This command shows how to execute a single Kubevpn alias named 'jumper'. It will directly connect to the 'jumper' cluster using the flags defined in its configuration.

```bash
kubevpn alias jumper  

```

--------------------------------

### Kubevpn Uninstall - Specific Namespace

Source: https://kubevpn.dev/docs/commands/kubevpn_uninstall

This command uninstalls Kubevpn from a specified namespace. It targets and removes all Kubevpn-related resources within that particular namespace.

```bash
kubevpn uninstall -n test
```

--------------------------------

### Accessing Local Service with Specific Header

Source: https://kubevpn.dev/docs/functions/reverse_proxy_with_mesh

This command shows how to access a local service through the Kubevpn reverse proxy by including a specific HTTP header ('foo: bar'). This routes the request to the local machine, allowing for local development and testing of services exposed via the proxy. The output indicates the request was received locally.

```bash
➜  ~ curl productpage:9080 -H "foo: bar"  
>>Received request: GET / from xxx.xxx.xxx.xxx:51296  
Hello world!    

```

--------------------------------

### Kubevpn Uninstall - Default Namespace

Source: https://kubevpn.dev/docs/commands/kubevpn_uninstall

This command uninstalls Kubevpn and cleans up all resources in the default Kubernetes namespace. It removes deployments, services, and other related Kubernetes objects.

```bash
kubevpn uninstall
```

--------------------------------

### Kubevpn Uninstall - GSSAPI Authentication

Source: https://kubevpn.dev/docs/commands/kubevpn_uninstall

These commands demonstrate uninstalling Kubevpn using GSSAPI authentication for SSH. Supported methods include using a keytab file, a cache file, or a password.

```bash
kubevpn uninstall --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-keytab /path/to/keytab
```

```bash
kubevpn uninstall --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-cache /path/to/cache
```

```bash
kubevpn uninstall --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-password <PASSWORD>
```

--------------------------------

### Proxy Multiple Kubernetes Workloads

Source: https://kubevpn.dev/docs/commands/kubevpn_proxy

Allows proxying traffic for multiple Kubernetes deployments simultaneously. This is useful for scenarios involving interconnected services that need to be debugged together.

```bash
kubevpn proxy deployment/authors deployment/productpage
```

```bash
kubevpn proxy deployment authors productpage
```

--------------------------------

### Format Kubevpn Status Output as YAML

Source: https://kubevpn.dev/docs/commands/kubevpn_status

Retrieves the Kubevpn status information and formats the output as a YAML document. This provides a human-readable and structured representation of the status.

```bash
kubevpn status -o yaml
```

--------------------------------

### Sync current namespace deployment

Source: https://kubevpn.dev/docs/commands/kubevpn_sync

Synchronizes a specified deployment within the current Kubernetes namespace. This command is useful for testing different versions of a deployment in isolation.

```bash
kubevpn sync deployment/productpage
```

--------------------------------

### Sync deployment in a specific namespace

Source: https://kubevpn.dev/docs/commands/kubevpn_sync

Synchronizes a specified deployment in a different Kubernetes namespace. This allows for testing deployments across different environments or projects.

```bash
kubevpn sync deployment/productpage -n test
```

--------------------------------

### Sync with mesh and specific headers

Source: https://kubevpn.dev/docs/commands/kubevpn_sync

Synchronizes a deployment and routes traffic with specific HTTP headers to the synchronized workloads. Traffic without these headers will hit the original workloads.

```bash
kubevpn sync deployment/productpage --headers foo=bar
```

--------------------------------

### Sync with SSH jump host and headers

Source: https://kubevpn.dev/docs/commands/kubevpn_sync

Synchronizes a deployment through an SSH jump host, enabling access to Kubernetes API servers behind firewalls or private networks. It also allows for header-based traffic routing.

```bash
kubevpn sync deployment/productpage --ssh-addr 192.168.1.100:22 --ssh-username root --ssh-keyfile ~/.ssh/ssh.pem --headers foo=bar
```

--------------------------------

### KubeVPN Version Information

Source: https://kubevpn.dev/docs/faq/1

Displays the current KubeVPN CLI and Daemon versions, including the default image used. This is useful for identifying the specific image that might be causing pull issues.

```bash
➜  ~ kubevpn version  
KubeVPN: CLI  
    Version: v2.0.0  
    DaemonVersion: v2.0.0  
    Image: docker.io/naison/kubevpn:v2.0.0  
    Branch: feature/daemon  
    Git commit: 7c3a87e  
    Built time: 2023-09-30 22:01:51  
    Built OS/Arch: darwin/arm64  
    Built Go version: go1.20.5  


```

--------------------------------

### Check Kubevpn Connection Status

Source: https://kubevpn.dev/docs/functions/connect_to_k8s_cluster_network

This command allows you to check the current status of your Kubevpn connection. It displays information such as the connection ID, cluster name, kubeconfig path, namespace, status, and the network interface used.

```bash
➜  ~ kubevpn status  
CURRENT   CONNECTION ID   CLUSTER                 KUBECONFIG                      NAMESPACE   STATUS      NETIF  
*         03dc50feb8c3    ccijorbccotmqodvr189g   /Users/naison/.kube/config      default     connected   utun4  
➜  ~  
```

--------------------------------

### Sync with GSSAPI SSH authentication

Source: https://kubevpn.dev/docs/commands/kubevpn_sync

Synchronizes workloads using GSSAPI for SSH authentication, supporting keytab, cache, or password methods. This is useful for environments with Kerberos or similar authentication mechanisms.

```bash
kubevpn sync service/productpage --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-keytab /path/to/keytab
```

```bash
kubevpn sync service/productpage --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-cache /path/to/cache
```

```bash
kubevpn sync service/productpage --ssh-addr <HOST:PORT> --ssh-username <USERNAME> --gssapi-password <PASSWORD>
```

--------------------------------

### Accessing Kubernetes Service Without Specific Header

Source: https://kubevpn.dev/docs/functions/reverse_proxy_with_mesh

This command demonstrates accessing a service within a Kubernetes cluster without any special headers. It retrieves the default response from the service. This is useful for verifying basic connectivity to the service.

```bash
➜  ~ curl productpage:9080  
<!DOCTYPE html>  
<html>  
  <head>  
    <title>Simple Bookstore App</title>  
<meta charset="utf-8">  
<meta http-equiv="X-UA-Compatible" content="IE=edge">  
<meta name="viewport" content="width=device-width, initial-scale=1">  
...  


```
Tokens:
Raw