Install Knative using quickstart¶

This topic describes how to install a local deployment of Knative Serving and Eventing using the Knative quickstart plugin.

The plugin installs a preconfigured Knative deployment on a local Kubernetes cluster.

Warning

Knative quickstart environments are for experimentation use only. For a production ready installation, see the YAML-based installation or the Knative Operator installation.

Before you begin¶

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) v0.25 or later. For instructions, see the next section.

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:
```
brew install kn
```
To upgrade an existing kn install to the latest version, run the command:
```
brew upgrade kn
```
Having issues upgrading kn using Homebrew?

If you are having issues upgrading using Homebrew, it might be due to a change to a CLI repository where the master branch was renamed to main. Resolve this issue by running the command:
```
brew tap --repair
brew update
brew upgrade kn
```

You can install kn by downloading the executable binary for your system and placing it in the system path. Note that you will need kn v0.25 or later.

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 binary file to a directory on your PATH by running the command:
```
mv kn /usr/local/bin
```
Verify that the plugin is working by running the command:
```
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 kn into your system path, and 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:
```
brew install knative-sandbox/kn-plugins/quickstart
```
To upgrade an existing quickstart install to the latest version, run the command:
```
brew upgrade knative-sandbox/kn-plugins/quickstart
```

Download the executable binary for your system from the quickstart release page.
Move the executable binary file to a directory on your PATH, for example, in /usr/local/bin.
Verify that the plugin is working, for example:
```
kn quickstart --help
```

Check out the kn-plugin-quickstart repository:

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

Build an executable binary:
```
hack/build.sh
```
Move the executable binary file to a directory on your PATH:
```
mv kn-quickstart /usr/local/bin
```
Verify that the plugin is working, for example:
```
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 on a local Docker daemon by running:
```
kn quickstart kind
```
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:
```
kn quickstart minikube
```
After the plugin is finished, verify you have a cluster called knative:
```
minikube profile list
```
To finish setting up networking for minikube, start the minikube tunnel process in a separate terminal window:
```
minikube tunnel --profile knative
```
The tunnel must continue to run in a terminal window while you are using your Knative quickstart environment.

Note

To terminate the process and clean up network routes, enter Ctrl-C. For more information about the minikube tunnel command, see the minikube documentation.

Next steps¶

Now you've installed Knative, learn how to deploy your first Service in the next topic in this tutorial.