Installing Knative using quickstart¶

This lesson creates the local environment used by all the Quickstart lessons.

Chosen route for Knative v1.24: Start Docker, install kind and kubectl, then use the Using a binary instructions below to install the kn v1.24 release and quickstart v1.24 release for your operating system and architecture. Do not assume an existing v1.23 binary matches this lesson. Homebrew and source-build instructions remain as alternatives, not additional steps.

The selected Quickstart source recommends kind 0.30 or newer and kubectl 1.35 or newer, and defaults to kindest/node:v1.35.0. For this route, use a kubectl 1.35.x client to match that default cluster version. The plugin warns and offers a not-recommended continuation with an older client; this tutorial does not choose that override. These are the selected plugin's source-checked prerequisites, not a general Knative compatibility matrix. See the version checks and kind defaults.

When you reach Run the Knative quickstart plugin, use Using kind (kn quickstart kind). Do not run both cluster options. Port 80 must be available, and the plugin needs access to your Docker daemon as described below. Use a disposable environment; this is not an installation procedure for an existing shared cluster.

Before you begin¶

Warning

Knative quickstart environments are for experimentation only. To administer Knative on an existing cluster, start with Installing Knative. Installing components alone does not establish production readiness; review your security, availability, observability, and upgrade requirements.

Before you can get started with a Knative quickstart deployment you must install:

kind (Kubernetes in Docker) or minikube to enable you to run a local Kubernetes cluster with Docker container nodes.
The Kubernetes CLI (kubectl) to run commands against Kubernetes clusters. You can use kubectl to deploy applications, inspect and manage cluster resources, and view logs.
The Knative CLI (kn). For instructions, see the next section.
You need to have a minimum of 3 CPUs and 3 GB of RAM available for the cluster to be created.

Install the Knative CLI¶

The Knative CLI (kn) provides a quick and easy interface for creating Knative resources, such as Knative Services and Event Sources, without the need to create or modify YAML files directly.

The kn CLI also simplifies completion of otherwise complex procedures such as autoscaling and traffic splitting.

Using HomebrewUsing a binaryUsing GoUsing a container image

Do one of the following:

To install kn by using Homebrew, run the command (Use brew upgrade instead if you are upgrading from a previous version):
```
brew install knative/client/kn
```

You can install kn by downloading the executable binary for your system and placing it in the system path.

Download the binary for your system from the kn release page.
Rename the binary to kn and make it executable by running the commands:
```
mv <path-to-binary-file> kn
chmod +x kn
```
Where <path-to-binary-file> is the path to the binary file you downloaded in the previous step, for example, kn-darwin-amd64 or kn-linux-amd64.
Move the executable to a writable directory on your PATH. For example:
```
mkdir -p "$HOME/.local/bin"
mv kn "$HOME/.local/bin/kn"
export PATH="$HOME/.local/bin:$PATH"
```
If this directory is not already on your PATH, add the same export to your shell's startup configuration for future terminals.
Verify that kn commands are working properly. For example:
```
kn version
```

Check out the kn client repository:

git clone https://github.com/knative/client.git
cd client/

Build an executable binary:
```
hack/build.sh -f
```
Move the executable to a writable directory on your PATH, as described in the binary installation option above.
Verify that kn commands are working properly. For example:
```
kn version
```

Links to images are available here:

Latest release

You can run kn from a container image. For example:

docker run --rm -v "$HOME/.kube/config:/root/.kube/config" gcr.io/knative-releases/knative.dev/client/cmd/kn:latest service list

Note

Running kn from a container image does not place the binary on a permanent path. This procedure must be repeated each time you want to use kn.

Install the Knative quickstart plugin¶

To get started, install the Knative quickstart plugin:

Using HomebrewUsing a binaryUsing Go

Do one of the following:

To install the quickstart plugin by using Homebrew, run the command (Use brew upgrade instead if you are upgrading from a previous version):
```
brew install knative-extensions/kn-plugins/quickstart
```

Download the binary for your system from the quickstart release page.
Rename the file to remove the OS and architecture information. For example, rename kn-quickstart-amd64 to kn-quickstart.
Make the plugin executable. For example, chmod +x kn-quickstart.
Move the executable to a writable directory on your PATH. For example:
```
mkdir -p "$HOME/.local/bin"
mv kn-quickstart "$HOME/.local/bin/kn-quickstart"
export PATH="$HOME/.local/bin:$PATH"
```
If this directory is not already on your PATH, add the same export to your shell's startup configuration for future terminals.
Verify that the plugin is working by running the command:
```
kn quickstart --help
```

Check out the kn-plugin-quickstart repository:

git clone https://github.com/knative-extensions/kn-plugin-quickstart.git
cd kn-plugin-quickstart/

Build an executable binary:
```
hack/build.sh
```
Move the executable to a writable directory on your PATH, as described in the binary installation option above.
Verify that the plugin is working by running the command:
```
kn quickstart --help
```

Run the Knative quickstart plugin¶

The quickstart plugin completes the following functions:

Checks if you have the selected Kubernetes instance installed
Creates a cluster called knative
Installs Knative Serving with Kourier as the default networking layer, and sslip.io as the DNS
Installs Knative Eventing and creates an in-memory Broker and Channel implementation

To get a local deployment of Knative, run the quickstart plugin:

Using kindUsing minikube

Install Knative and Kubernetes using kind by running:
```
kn quickstart kind
```
Note

Quickstart uses Port 80, and it will fail to install if any other services are bound on that port. If you have a service using Port 80, you'll need to stop it before using Quickstart. To check if another service is using Port 80:
```
netstat -tnlp | grep 80
```
Note

Quickstart connects to the Docker daemon at /var/run/docker.sock and does not honor the socket selected by your current docker context (for example, when using Colima, Rancher Desktop, or Lima). If you see an error like Cannot connect to the Docker daemon at unix:///var/run/docker.sock, set the DOCKER_HOST environment variable to your active socket before running the command. For example:
```
export DOCKER_HOST=unix://$HOME/.lima/docker/sock/docker.sock
```
You can find the endpoint for your active context by running docker context ls.
After the plugin is finished, verify you have a cluster called knative:
```
kind get clusters
```

Install Knative and Kubernetes in a minikube instance by running:

Note

The minikube cluster will be created with 3 GB of RAM. You can change to a different value not lower than 3 GB by setting a memory config in minikube. For example, minikube config set memory 4096 will use 4 GB of RAM.
```
kn quickstart minikube
```
The output of the previous command asked you to run minikube tunnel. Run the following command to start the process in a secondary terminal window, then return to the primary window and press enter to continue:
```
minikube tunnel --profile knative
```
The tunnel must continue to run in a terminal window any time you are using your Knative quickstart environment.

The tunnel command is required because it allows your cluster to access Knative ingress service as a LoadBalancer from your host computer.

Note

To terminate the tunnel process and clean up network routes, enter Ctrl-C. For more information about the minikube tunnel command, see the minikube documentation.
After the plugin is finished, verify you have a cluster called knative:
```
minikube profile list
```

Next steps¶

Check the versions of the tools used for this installation:

kn version
kn quickstart version
kubectl version --client -o json
kind version

The selected kn and Quickstart release versions are 1.24.0; check the kubectl client's gitVersion for v1.35.x and the kind version against the prerequisites above. Also check the installer's reported Serving, Kourier, and Eventing versions: a plugin's version label alone is not proof of which components were installed. Historical v1.23 runtime results do not validate this new installation.

Next, inspect the selected Kubernetes context. This block does not change it:

kubectl config current-context
kubectl config get-contexts

Confirm that the selected context is the newly created disposable Quickstart cluster, normally kind-knative, and that it is the cluster you intend to use for the lessons. If another context is selected, stop before running the next block. After identifying the correct context from your installation output, select it with kubectl config use-context <quickstart-context> and repeat the inspection. Do not select a shared or production cluster. See CLI cluster-access guidance if you cannot identify the intended context.

Only after approving the context, set its default namespace and inspect the installed components:

kubectl config set-context --current --namespace=default
kubectl get pods -n knative-serving
kubectl get pods -n knative-eventing

Wait for the Serving and Eventing pods to become Ready before continuing; pod names vary by release.

Previous: Quickstart route · Next: Deploy your first Service