Linkerd

https://linkerd.io/2.18/
Admin
Linkerd is a service mesh for Kubernetes that provides runtime debugging, observability,...
Tokens:217,371
Snippets:3,040
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Setup Books Sample Application

Source: https://linkerd.io/2.18/tasks/fault-injection

Installs the books sample application and injects Linkerd. Ensure Linkerd and Linkerd-Viz are installed prior to running this command.

```bash
kubectl create ns booksapp && \
  linkerd inject https://run.linkerd.io/booksapp.yml | \
  kubectl -n booksapp apply -f -
```

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

### Install Sample Application for Traffic Splitting

Source: https://linkerd.io/2.18/tasks/linkerd-smi

Install a sample application, including a client and two server deployments (one failing, one successful), into a dedicated namespace. This setup is used to demonstrate traffic splitting.

```bash
# create a namespace for the sample application
kubectl create namespace trafficsplit-sample

# install the sample application
linkerd inject https://raw.githubusercontent.com/linkerd/linkerd2/main/test/integration/viz/trafficsplit/testdata/application.yaml | kubectl -n trafficsplit-sample apply -f -
```

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

### Setup Client Workload and Install Curl

Source: https://linkerd.io/2.18/tasks/configuring-rate-limiting/index.html

Deploys an Ubuntu workload, opens a shell into it, and installs curl for sending test requests. Leave this shell open for subsequent commands.

```bash
kubectl create deployment client --image ubuntu -- bash -c "sleep infinity"
kubectl exec -it client-xxx -- bash
root@client-xxx:/# apt-get update && apt-get install -y curl
```

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

### Install Gateway API

Source: https://linkerd.io/2.18/features/gateway-api/index.html

Install the Gateway API using the standard installation manifest from the official repository. Ensure the installed version is compatible with your Linkerd version.

```bash
kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.2.1/standard-install.yaml
```

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

### View Real-time Path Usage for Deployments

Source: https://linkerd.io/2.18/features/dashboard

Provides a real-time view of which paths are being called for deployments in the specified namespace. Assumes the emojivoto example application is installed.

```bash
linkerd -n emojivoto viz top deploy
```

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

### Install and Inject Emojivoto Application

Source: https://linkerd.io/2.18/tasks/restricting-access/index.html

Injects and installs the Emojivoto application into the cluster. Ensure Linkerd and its Viz extension are installed prior to running.

```bash
$ linkerd inject https://run.linkerd.io/emojivoto.yml | kubectl apply -f -
...
$ linkerd check -n emojivoto --proxy -o short
...
```

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

### Clone Linkerd Example Repository

Source: https://linkerd.io/2.18/tasks/gitops/index.html

Clone the example repository to your local machine to demonstrate Git operations.

```bash
git clone https://github.com/linkerd/linkerd-examples.git
```

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

### Tap Requests for a Specific Deployment

Source: https://linkerd.io/2.18/features/dashboard

Streams requests across a single pod, deployment, or the entire namespace. This example taps requests for the 'web' deployment in the emojivoto namespace. Assumes the emojivoto example application is installed.

```bash
linkerd -n emojivoto viz tap deploy/web
```

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

### Install Linkerd-SMI extension CLI

Source: https://linkerd.io/2.18/tasks/linkerd-smi

Download the SMI extension CLI binary. This is the first step to installing the extension.

```bash
curl -sL https://linkerd.github.io/linkerd-smi/install | sh
```

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

### Check Multicluster Installation

Source: https://linkerd.io/2.18/tasks/installing-multicluster

Verify that the multicluster components have started successfully on each cluster.

```bash
linkerd multicluster check

```

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

### Install Frontend Service Pointing to Backend A

Source: https://linkerd.io/2.18/tasks/configuring-dynamic-request-routing/index.html

Installs a 'frontend' podinfo instance in the 'test' namespace, configured to forward requests to the 'backend-a-podinfo' service.

```bash
helm install frontend -n test \
  --set backend=http://backend-a-podinfo:9898/env podinfo/podinfo
```

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

### Install Argo Rollouts

Source: https://linkerd.io/2.18/tasks/flagger

Install the Argo Rollouts controller and set up the GatewayAPI routing plugin with necessary RBAC permissions.

```bash
kubectl create namespace argo-rollouts && \
  kubectl apply -n argo-rollouts -f https://github.com/argoproj/argo-rollouts/releases/latest/download/install.yaml
```

```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: argo-rollouts-config # must be so name
  namespace: argo-rollouts # must be in this namespace
data:
  trafficRouterPlugins: |- 
    - name: "argoproj-labs/gatewayAPI"
      location: "https://github.com/argoproj-labs/rollouts-plugin-trafficrouter-gatewayapi/releases/download/v0.0.0-rc1/gateway-api-plugin-linux-amd64"
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: argo-controller-role
  namespace: argo-rollouts
rules:
  - apiGroups:
      - gateway.networking.k8s.io
    resources:
      - httproutes
    verbs:
      - "*"
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: argo-controller
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: argo-controller-role
subjects:
  - namespace: argo-rollouts
    kind: ServiceAccount
    name: argo-rollouts
```

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

### Install Linkerd and link clusters

Source: https://linkerd.io/2.18/tasks/multicluster-using-statefulsets

Install Linkerd and its multi-cluster extension, then link the 'east' and 'west' clusters together for service mirroring.

```bash
# Install Linkerd and multicluster, output to check should be a success
$ ./install.sh

# Next, link the two clusters together
$ ./link.sh

```

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

### Install Argo CD

Source: https://linkerd.io/2.18/tasks/gitops/index.html

Create the 'argocd' namespace and apply the Argo CD installation manifest.

```bash
kubectl create ns argocd
kubectl -n argocd apply -f \
  https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
```

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

### Install Linkerd and Link Clusters

Source: https://linkerd.io/2.18/tasks/multicluster-using-statefulsets/index.html

Install Linkerd and its multi-cluster extension, then link the 'east' and 'west' clusters together for service mirroring.

```bash
# Install Linkerd and multicluster, output to check should be a success
$ ./install.sh

# Next, link the two clusters together
$ ./link.sh
```

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

### Add Linkerd-SMI Helm repository and install

Source: https://linkerd.io/2.18/tasks/linkerd-smi

Add the Linkerd-SMI Helm chart repository and install the chart. This is an alternative method for installing the SMI extension.

```bash
helm repo add l5d-smi https://linkerd.github.io/linkerd-smi
helm install l5d-smi/linkerd-smi --generate-name
```

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

### Install cert-manager using Helm

Source: https://linkerd.io/2.18/tasks/automatically-rotating-control-plane-tls-credentials

Installs cert-manager using Helm. Ensure cert-manager is installed in the 'cert-manager' namespace.

```bash
helm repo add jetstack https://charts.jetstack.io --force-update

helm install \
  cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --set crds.enabled=true

kubectl rollout status -n cert-manager deploy
```

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

### Install or Upgrade Linkerd CLI (Edge Release)

Source: https://linkerd.io/2.18/tasks/upgrade/index.html

Use this command to install or upgrade to the latest edge release of the Linkerd CLI. It fetches the installation script and executes it.

```bash
curl --proto '=https' --tlsv1.2 -sSfL https://run.linkerd.io/install-edge | sh
```

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

### Install Emojivoto Demo Application

Source: https://linkerd.io/2.18/getting-started/index.html

Installs the Emojivoto application into the emojivoto namespace. This application will be used to demonstrate Linkerd's functionality.

```bash
curl --proto '=https' --tlsv1.2 -sSfL https://run.linkerd.io/emojivoto.yml \
  | kubectl apply -f -
```

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

### Install Linkerd with Custom Certificates (Helm)

Source: https://linkerd.io/2.18/tasks/generate-certificates/index.html

Installs Linkerd using Helm, providing the generated certificates via '--set-file' options. This method requires installing the 'linkerd-crds' chart first.

```bash
helm install linkerd-crds linkerd/linkerd-crds -n linkerd --create-namespace

helm install linkerd-control-plane -n linkerd \
  --set-file identityTrustAnchorsPEM=ca.crt \
  --set-file identity.issuer.tls.crtPEM=issuer.crt \
  --set-file identity.issuer.tls.keyPEM=issuer.key \
  linkerd/linkerd-control-plane

```

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

### Contour Installation and Configuration

Source: https://linkerd.io/2.18/tasks/using-ingress

Install Contour, optionally create a service account, and configure it to auto-mount the service account token and inject Linkerd.

```bash
# install Contour
kubectl apply -f https://projectcontour.io/quickstart/contour.yaml

# create a service account (optional)
kubectl apply -f - << EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: envoy
  namespace: projectcontour
EOF

# add service account to envoy (optional)
kubectl patch daemonset envoy -n projectcontour --type json -p='[{"op": "add", "path": "/spec/template/spec/serviceAccount", "value": "envoy"}]'

# auto mount the service account token (required)
kubectl patch daemonset envoy -n projectcontour --type json -p='[{"op": "replace", "path": "/spec/template/spec/automountServiceAccountToken", "value": true}]'

# inject linkerd first into the DaemonSet
kubectl -n projectcontour get daemonset -oyaml | linkerd inject - | kubectl apply -f -

```

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

### Install Argo Rollouts

Source: https://linkerd.io/2.18/tasks/flagger/index.html

Install the Argo Rollouts controller and create the necessary namespace. This command sets up Argo Rollouts for progressive delivery.

```bash
kubectl create namespace argo-rollouts && \
  kubectl apply -n argo-rollouts -f https://github.com/argoproj/argo-rollouts/releases/latest/download/install.yaml
```

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

### Install Books App

Source: https://linkerd.io/2.18/tasks/books

Installs the books application and its namespace. Downloads the Kubernetes resource manifest and applies it to your cluster.

```bash
kubectl create ns booksapp && \
  curl --proto '=https' --tlsv1.2 -sSfL https://run.linkerd.io/booksapp.yml \
  | kubectl -n booksapp apply -f -
```

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

### ExternalWorkload and Service Example

Source: https://linkerd.io/2.18/reference/external-workload/index.html

This example demonstrates an ExternalWorkload resource defining ports and an IP address, and a corresponding Service resource that selects it.

```yaml
apiVersion: workload.linkerd.io/v1beta1
kind: ExternalWorkload
metadata:
  name: external-workload
  namespace: mixed-env
  labels:
    location: vm
    workload_name: external-workload
spec:
  meshTLS:
    identity: "spiffe://root.linkerd.cluster.local/external-workload"
    serverName: "external-workload.cluster.local"
  workloadIPs:
    - ip: 193.1.4.11
  ports:
    - port: 80
      name: http
    - port: 9980
      name: admin
status:
  conditions:
    - type: Ready
      status: "True"
---
apiVersion: v1
kind: Service
metadata:
  name: external-workload
  namespace: mixed-env
spec:
  type: ClusterIP
  selector:
    workload_name: external-workload
  ports:
    - port: 80
      protocol: TCP
      name: http
    - port: 9980
      protocol: TCP
      name: admin

```

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

### Check Linkerd-SMI extension installation

Source: https://linkerd.io/2.18/tasks/linkerd-smi

Verify that the Linkerd-SMI extension has been installed correctly on your cluster.

```bash
linkerd smi check
```

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

### Example JSON Response from Podinfo

Source: https://linkerd.io/2.18/tasks/multicluster/index.html

An example JSON response from the podinfo service, demonstrating cluster-specific information like the hostname and message.

```json
{
  "hostname": "podinfo-5c8cf55777-zbfls",
  "version": "4.0.2",
  "revision": "b4138fdb4dce7b34b6fc46069f70bb295aa8963c",
  "color": "#6c757d",
  "logo": "https://raw.githubusercontent.com/stefanprodan/podinfo/gh-pages/cuddle_clap.gif",
  "message": "greetings from west",
  "goos": "linux",
  "goarch": "amd64",
  "runtime": "go1.14.3",
  "num_goroutine": "8",
  "num_cpu": "4"
}

```

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

### Install Linkerd Viz Extension on Multiple Clusters

Source: https://linkerd.io/2.18/tasks/multicluster/index.html

Installs the Linkerd Viz extension on both 'west' and 'east' clusters. The loop breaks if any command fails.

```bash
for ctx in west east; do
  linkerd --context=${ctx} viz install | \
    kubectl --context=${ctx} apply -f - || break
done
```

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

### Start a Sample Application Workload

Source: https://linkerd.io/2.18/tasks/adding-non-kubernetes-workloads

Launch a sample application (using 'buoyantio/bb') on the external machine to test connectivity through the Linkerd proxy. Ensure the application runs under a different user than the proxy.

```bash
docker run -p 80:80 buoyantio/bb:v0.0.5 terminus \
    --h1-server-port 80 \
    --response-text hello-from-external-vm

```

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

### Example failure: Control plane namespace already exists

Source: https://linkerd.io/2.18/tasks/troubleshooting

This indicates that the 'linkerd' namespace already exists, which is not allowed before installation.

```bash
× control plane namespace does not already exist
    The "linkerd" namespace already exists
```

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

### Set up demo components

Source: https://linkerd.io/2.18/tasks/flagger

Deploys the demo application components (load generator, deployment, frontend) into the 'test' namespace and adds them to the Linkerd data plane. This setup is used to demonstrate progressive rollouts.

```bash
kubectl create ns test && \
  kubectl apply -f https://run.linkerd.io/flagger.yml
```

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

### Install Podinfo Backend Services

Source: https://linkerd.io/2.18/tasks/configuring-dynamic-request-routing/index.html

Installs two instances of the podinfo application, 'backend-a' and 'backend-b', into the 'test' namespace. Each instance is configured to display a different message.

```bash
helm repo add podinfo https://stefanprodan.github.io/podinfo
helm install backend-a -n test \
  --set ui.message='A backend' podinfo/podinfo
helm install backend-b -n test \
  --set ui.message='B backend' podinfo/podinfo
```

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

### Linkerd Multicluster Check Output

Source: https://linkerd.io/2.18/tasks/federated-services/index.html

Example output from `linkerd check` for multicluster setup, verifying cluster connectivity and controller status.

```text
linkerd-multicluster
--------------------
√ Link CRD exists
√ Link resources are valid
        * east
        * north
√ remote cluster access credentials are valid
        * east
        * north
√ clusters share trust anchors
        * east
        * north
√ service mirror controller has required permissions
        * east
        * north
√ service mirror controllers are running
        * east
        * north
√ extension is managing controllers
        * east
        * north

```

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

### View Live Traffic Metrics for Deployments

Source: https://linkerd.io/2.18/features/dashboard

Displays "golden" metrics (success rates, request rates, latency percentiles) for each deployment in the specified namespace. Assumes the emojivoto example application is installed.

```bash
linkerd -n emojivoto viz stat deploy
```

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

### Bash Shell Completion Setup for Persistent Sessions

Source: https://linkerd.io/2.18/reference/cli/completion

Configure persistent shell completion for bash. On macOS, ensure `bash-completion` is installed and direct output to `$(brew --prefix)/etc/bash_completion.d/linkerd`. On Linux, direct output to `/etc/bash_completion.d/linkerd`.

```bash
# bash <= 3.2 on osx:
brew install bash-completion # ensure you have bash-completion 1.3+
linkerd completion bash > $(brew --prefix)/etc/bash_completion.d/linkerd
```

```bash
# bash >= 4.0 on osx:
brew install bash-completion@2
linkerd completion bash > $(brew --prefix)/etc/bash_completion.d/linkerd
```

```bash
# bash >= 4.0 on linux:
linkerd completion bash > /etc/bash_completion.d/linkerd
```

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

### Install Linkerd CNI Plugin via Helm

Source: https://linkerd.io/2.18/features/cni

Install the linkerd-cni DaemonSet using Helm. Ensure the CNI plugin is installed and ready before proceeding with Linkerd control plane installation.

```bash
# install the CNI plugin first
helm install linkerd-cni -n linkerd-cni --create-namespace linkerd/linkerd2-cni

# ensure the plugin is installed and ready
linkerd check --pre --linkerd-cni-enabled
```

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

### Install Books Demo App with Linkerd Injection

Source: https://linkerd.io/2.18/tasks/configuring-per-route-policy/index.html

Injects Linkerd into the Books demo application and applies it to the cluster. Ensure Linkerd is installed with the Viz extension beforehand.

```bash
$ kubectl create ns booksapp && \
  curl --proto '=https' --tlsv1.2 -sSfL https://run.linkerd.io/booksapp.yml \
  | linkerd inject - \
  | kubectl -n booksapp apply -f -
```

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

### Install Jaeger Extension

Source: https://linkerd.io/2.18/reference/cli/jaeger/index.html

Outputs the Kubernetes resources required to install the Jaeger extension. Pipe the output to `kubectl apply -f -` to perform the installation. The installation can be customized using various flags.

```bash
linkerd jaeger install | kubectl apply -f -
```

```bash
linkerd jaeger install --namespace custom | kubectl apply -f -
```

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

### Example successful proxy injection output

Source: https://linkerd.io/2.18/tasks/adding-your-service/index.html

This is an example of the expected output when verifying proxy injection, indicating that the `linkerd-proxy` container has been successfully added to the pod.

```text
linkerd-proxy CONTAINER
```

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

### Install Linkerd CRDs

Source: https://linkerd.io/2.18/reference/cli/install/index.html

Install the Custom Resource Definitions (CRDs) for Linkerd first. This is a prerequisite for installing the core control plane.

```bash
linkerd install --crds | kubectl apply -f -
```

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

### Get Project Details

Source: https://linkerd.io/2.18/tasks/gitops/index.html

Retrieve the details of the 'demo' project to confirm its correct deployment.

```bash
argocd proj get demo
```

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

### Check Linkerd-Buoyant CLI Installation

Source: https://linkerd.io/2.18/tasks/troubleshooting

Checks if the linkerd-buoyant CLI is installed and accessible in the system's PATH. If not found, it provides instructions to install it.

```bash
linkerd-buoyant check
```

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

### Install Linkerd with nft init container mode

Source: https://linkerd.io/2.18/features/nft/index.html

Use this command to install Linkerd and set the init container mode to `nft`. This ensures firewall rules are configured using `iptables-nft`.

```bash
linkerd install --set "proxyInit.iptablesMode=nft" | kubectl apply -f -
```

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

### Basic Kustomization File

Source: https://linkerd.io/2.18/tasks/customize-install

Create a `kustomization.yaml` file to define base resources and transformations for Kustomize.

```yaml
resources:
  - linkerd.yaml
```

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

### Verify Linkerd CLI Installation

Source: https://linkerd.io/2.18/getting-started/index.html

Check if the Linkerd CLI is installed and accessible. Initially, the server version will be unavailable until the control plane is installed.

```bash
linkerd version
```

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

### Install Linkerd CRDs with Helm

Source: https://linkerd.io/2.18/tasks/generate-certificates

When installing Linkerd using Helm, first install the `linkerd-crds` chart to set up the necessary Custom Resource Definitions.

```bash
helm install linkerd-crds linkerd/linkerd-crds -n linkerd --create-namespace

```

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

### Install Linkerd CNI Plugin via CLI

Source: https://linkerd.io/2.18/features/cni

Install the linkerd-cni DaemonSet using the Linkerd CLI. This command should be run before installing the Linkerd control plane.

```bash
linkerd install-cni | kubectl apply -f -
```

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

### Get Application Details

Source: https://linkerd.io/2.18/tasks/gitops/index.html

Retrieve the details of the 'main' application to confirm its successful deployment.

```bash
argocd app get main
```

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

### Set up Demo Environment for Traffic Shifting

Source: https://linkerd.io/2.18/tasks/traffic-shifting

Deploys a demo environment including two backend services (v1 and v2), a load balancer service, and a load generator (slow-cooker) into a Kubernetes cluster with Linkerd. This setup is used to demonstrate traffic shifting.

```yaml
cat <<EOF | linkerd inject - | kubectl apply -f -
---
apiVersion: v1
kind: Namespace
metadata:
  name: traffic-shift-demo
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: v1
  namespace: traffic-shift-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: bb
      version: v1
  template:
    metadata:
      labels:
        app: bb
        version: v1
    spec:
      containers:
      - name: terminus
        image: buoyantio/bb:v0.0.6
        args:
        - terminus
        - "--h1-server-port=8080"
        - "--response-text=v1"
        ports:
        - containerPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: v2
  namespace: traffic-shift-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: bb
      version: v2
  template:
    metadata:
      labels:
        app: bb
        version: v2
    spec:
      containers:
      - name: terminus
        image: buoyantio/bb:v0.0.6
        args:
        - terminus
        - "--h1-server-port=8080"
        - "--response-text=v2"
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: bb
  namespace: traffic-shift-demo
spec:
  ports:
  - name: http
    port: 8080
    targetPort: 8080
  selector:
    app: bb
    version: v1
---
apiVersion: v1
kind: Service
metadata:
  name: bb-v2
  namespace: traffic-shift-demo
spec:
  ports:
  - name: http
    port: 8080
    targetPort: 8080
  selector:
    app: bb
    version: v2
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: slow-cooker
  namespace: traffic-shift-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: slow-cooker
  template:
    metadata:
      labels:
        app: slow-cooker
    spec:
      containers:
      - args:
        - -c
        - |
          sleep 5 # wait for pods to start
          /slow_cooker/slow_cooker --qps 10 http://bb:8080
        command:
        - /bin/sh
        image: buoyantio/slow_cooker:1.3.0
        name: slow-cooker
EOF

```

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

### Install Linkerd CRDs with kubectl

Source: https://linkerd.io/2.18/tasks/generate-certificates

Before installing the Linkerd control plane with custom certificates using the CLI, you must first install the Linkerd Custom Resource Definitions (CRDs).

```bash
# first, install the Linkerd CRDs
linkerd install --crds | kubectl apply -f -

```

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

### Install Linkerd CRDs and Control Plane via CLI

Source: https://linkerd.io/2.18/tasks/install

Installs the Linkerd Custom Resource Definitions (CRDs) first, followed by the Linkerd control plane itself. This is the basic CLI installation method.

```bash
# install the CRDs first
linkerd install --crds | kubectl apply -f -

# install the Linkerd control plane once the CRDs have been installed
linkerd install | kubectl apply -f -

```

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

### Apply Project Configuration

Source: https://linkerd.io/2.18/tasks/gitops/index.html

Apply the project configuration defined in `gitops/project.yaml` to set up project access and permissions.

```bash
kubectl apply -f gitops/project.yaml
```

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

### Install Linkerd with Custom Certificates (CLI)

Source: https://linkerd.io/2.18/tasks/generate-certificates/index.html

Installs Linkerd using the CLI, providing the generated trust anchor and issuer certificates via flags. Ensure Linkerd CRDs are installed first.

```bash
# first, install the Linkerd CRDs
linkerd install --crds | kubectl apply -f - 

# install the Linkerd control plane, with the certificates we just generated.
linkerd install \
  --identity-trust-anchors-file ca.crt \
  --identity-issuer-certificate-file issuer.crt \
  --identity-issuer-key-file issuer.key \
  | kubectl apply -f - 

```

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

### Install Linkerd Control Plane with CLI using External Secrets

Source: https://linkerd.io/2.18/tasks/automatically-rotating-webhook-tls-credentials/index.html

Configure Linkerd to use TLS credentials managed by cert-manager during CLI installation. Ensure Linkerd CRDs are installed first.

```bash
# first, install the Linkerd CRDs
linkerd install --crds | kubectl apply -f -

# install the Linkerd control plane, using the credentials
# from cert-manager
linkerd install \
  --set policyValidator.externalSecret=true \
  --set-file policyValidator.caBundle=ca.crt \
  --set proxyInjector.externalSecret=true \
  --set-file proxyInjector.caBundle=ca.crt \
  --set profileValidator.externalSecret=true \
  --set-file profileValidator.caBundle=ca.crt \
  | kubectl apply -f -

# ignore if not using the viz extension
linkerd viz install \
  --set tap.externalSecret=true \
  --set-file tap.caBundle=ca.crt \
  --set tapInjector.externalSecret=true \
  --set-file tapInjector.caBundle=ca.crt \
  | kubectl apply -f -

# ignore if not using the jaeger extension
linkerd jaeger install \
  --set webhook.externalSecret=true \
  --set-file webhook.caBundle=ca.crt \
  | kubectl apply -f -
```

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

### Install Linkerd Multicluster Add-on

Source: https://linkerd.io/2.18/reference/cli/multicluster/index.html

Outputs Kubernetes configurations to install the Linkerd multicluster add-on. The output can be piped to kubectl for installation. Configuration can be customized using flags like --set.

```bash
linkerd multicluster install | kubectl apply -f -
```

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

### View Sample Application Deployments

Source: https://linkerd.io/2.18/tasks/linkerd-smi

Check the status of deployments within the `trafficsplit-sample` namespace to confirm the sample application has been installed correctly.

```bash
kubectl get deployments -n trafficsplit-sample
```

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

### Install Test Services on Clusters

Source: https://linkerd.io/2.18/tasks/multicluster/index.html

Deploy test services (frontend and podinfo) to multiple clusters. This script iterates through specified contexts, creates a 'test' namespace, and applies Kubernetes resources.

```bash
for ctx in west east;
do
  echo "Adding test services on cluster: ${ctx} ........."
  kubectl --context=${ctx} create ns test
  kubectl --context=${ctx} apply \
    -n test -k "github.com/linkerd/website/multicluster/${ctx}/"
  kubectl --context=${ctx} -n test \
    rollout status deploy/podinfo || break
  echo "-------------"
done

```

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

### Install Linkerd CRDs with Gateway API

Source: https://linkerd.io/2.18/features/gateway-api/index.html

Configure Linkerd to install the Gateway API CRDs bundled with Linkerd's own CRDs. This is done via Helm values or the --set flag during installation.

```bash
linkerd install --crds --set installGatewayAPI=true
```

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

### Zsh Shell Completion Setup

Source: https://linkerd.io/2.18/reference/cli/completion

Enable zsh shell completion by enabling `compinit` and `compinit` in `~/.zshrc`. Create a Linkerd plugins folder, add it to `$fpath`, and then load completions by executing `linkerd completion zsh > "${fpath[1]}/_linkerd" && exec $SHELL`.

```zsh
# If shell completion is not already enabled in your environment you will need
# to enable it.  You can execute the following once:

echo "autoload -U compinit && compinit" >> ~/.zshrc

# create a linkerd 'plugins' folder and add it to your $fpath
mkdir $ZSH/plugins/linkerd && echo "fpath=($ZSH/plugins/linkerd $fpath)" >> ~/.zshrc

# To load completions for each session, execute once:
linkerd completion zsh > "${fpath[1]}/_linkerd" && exec $SHELL
```

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

### Install Linkerd CRDs with Gateway API

Source: https://linkerd.io/2.18/features/gateway-api

When installing Linkerd's CRDs via Helm, set `installGatewayAPI=true` to have Linkerd install the Gateway API. This also means the Gateway API will be removed if Linkerd is uninstalled.

```bash
--set installGatewayAPI=true
```

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

### Example of accessing a service across clusters

Source: https://linkerd.io/2.18/tasks/multicluster-using-statefulsets/index.html

This example shows how a curl command can access a service in a different cluster, demonstrating successful cross-cluster communication.

```bash
$ curl nginx-set-0.nginx-svc-k3d-west.default.svc.east.cluster.local
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
    }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

```
```

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

### Download and install SPIRE

Source: https://linkerd.io/2.18/tasks/adding-non-kubernetes-workloads

Download the SPIRE binary from the GitHub releases page and extract it to a desired location.

```bash
wget https://github.com/spiffe/SPIRE/releases/download/v1.8.2/SPIRE-1.8.2-linux-amd64-musl.tar.gz
tar zvxf SPIRE-1.8.2-linux-amd64-musl.tar.gz
cp -r SPIRE-1.8.2/. /opt/SPIRE/
```

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

### Install Linkerd-Buoyant CLI

Source: https://linkerd.io/2.18/tasks/troubleshooting

Installs or updates the linkerd-buoyant CLI by downloading the latest version from the official source.

```bash
curl https://buoyant.cloud/install | sh
```

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

### Set up Circuit Breaking Demo

Source: https://linkerd.io/2.18/tasks/circuit-breakers/index.html

Deploys a demo environment with a healthy pod ('good') and an unhealthy pod ('bad'), along with a load generator ('slow-cooker') and a Kubernetes Service. Linkerd's injection is applied to include the pods in the data plane.

```yaml
apiVersion: v1
kind: Namespace
metadata:
  name: circuit-breaking-demo
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: good
  namespace: circuit-breaking-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      class: good
  template:
    metadata:
      labels:
        class: good
        app: bb
    spec:
      containers:
      - name: terminus
        image: buoyantio/bb:v0.0.6
        args:
        - terminus
        - "--h1-server-port=8080"
        ports:
        - containerPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: bad
  namespace: circuit-breaking-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      class: bad
  template:
    metadata:
      labels:
        class: bad
        app: bb
    spec:
      containers:
      - name: terminus
        image: buoyantio/bb:v0.0.6
        args:
        - terminus
        - "--h1-server-port=8080"
        - "--percent-failure=100"
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: bb
  namespace: circuit-breaking-demo
spec:
  ports:
  - name: http
    port: 8080
    targetPort: 8080
  selector:
    app: bb
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: slow-cooker
  namespace: circuit-breaking-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: slow-cooker
  template:
    metadata:
      labels:
        app: slow-cooker
    spec:
      containers:
      - args:
        - -c
        - |
          sleep 5 # wait for pods to start
          /slow_cooker/slow_cooker --qps 10 http://bb:8080
        command:
        - /bin/sh
        image: buoyantio/slow_cooker:1.3.0
        name: slow-cooker

```

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

### Check Gateway API installation

Source: https://linkerd.io/2.18/features/gateway-api/index.html

Verify if the Gateway API is installed on your cluster and retrieve its bundle version.

```bash
kubectl get crds/httproutes.gateway.networking.k8s.io -o "jsonpath={.metadata.annotations.gateway\.networking\.k8s\.io/bundle-version}"
```
Tokens:
Raw