Preparations

To install the Axual Streaming and Governance Helm charts, we need to go through some preparation steps.

The current helm charts support only a single cluster platform with no distribution in place. Be sure to have Use gRPC FUSE for file sharing disabled.

Docker Engine v20.10.12 or newer (use docker -v to check your version)
Kubernetes v1.24.0 or newer (use kubectl version to check your version). We recommend Docker Desktop for managing Kubernetes locally.
Helm Charts v3.x.x or newer (use helm version to check your version)

Make sure to allocate enough resources for Docker. The Recommended minimum values are 4 CPUs and 8 GB of RAM. Please note that these values may change based on the combination of the components that are running.

Setup loopback alias (Local only)

Create a script to add a loopback interface on the ip 192.168.99.100

#!/bin/bash

ITF=lo0
ADDRESS=192.168.99.100

ifconfig "$ITF" | grep inet | grep "$ADDRESS" >/dev/null
if [ "$?" = "0" ]; then
	echo "Removing alias $ADDRESS from interface $ITF"
	sudo ifconfig "$ITF" -alias "$ADDRESS"
	echo "Adding alias $ADDRESS to interface $ITF"
	sudo ifconfig "$ITF" alias "$ADDRESS/32" up
else
	echo "Adding alias $ADDRESS to interface $ITF"
	sudo ifconfig "$ITF" alias "$ADDRESS/32" up
fi

Execute the script at every restart of your local machine

You can check if the loopback interface got successfully added by executing:
```
ifconfig | grep 192.168.99.100
```
It should be something like this:
```
	inet 192.168.99.100 netmask 0xffffffff
```
Add the following entry to your /etc/hosts file:
```
192.168.99.100 platform.local
```

Create a namespace and Docker Registry Secret

Creating a namespace is optional but recommended. A namespace provides an isolation layer within a Kubernetes cluster.

Create a namespace.
```
kubectl create namespace kafka
```

Create a secret for the Axual Docker registry.

kubectl -n kafka                                    \
    create secret docker-registry axualdockercred   \
    --docker-server=docker.axual.io               \
    --docker-username=[your-username]               \
    --docker-password=[your-password]

Make sure to replace the username and password with your credentials for Axual Harbor.

Install nginx

We need to start nginx in order to make the Self-Service pod accessible from outside the kubernetes clusters.

Create a namespace for nginx.
```
kubectl create namespace nginx
```
Depending on your kubectl client version, execute one command.
Add the kubernetes-charts repository to your helm, assuming kubernetes version 1.22.0-0 or greater.

Add the ingress-nginx repo.

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

Start the ingress-nginx.

helm upgrade --install nginx ingress-nginx/ingress-nginx -n nginx --set controller.ingressClassResource.default=true

Install Strimzi Operator with custom Axual Kafka image

Installing the Strimzi Operator using Helm simplifies the deployment of Kafka and its associated Custom Resource Definitions (CRDs) on a Kubernetes cluster.

To be able to install Strimzi, we need to:

Add the Strimzi repository to helm:

helm repo add strimzi https://strimzi.io/charts/

Update the repo:
```
helm repo update
```
If you are aiming to deploy an environment which supports multi-tenant installations (as described in Strimzi Operator), you can install the Strimzi Operator using custom Axual Kafka image:
```
helm install strimzi strimzi/strimzi-kafka-operator \
--version=0.34.0 \
--namespace kafka \
--set kafka.image.registry=docker.axual.io \
--set kafka.image.repository=axual/streaming/strimzi \
--set image.imagePullSecrets='axualdockercred'
```
If you are not interested in multi-tenancy support, you can install the Strimzi Operator with standard images:
```
helm install strimzi strimzi/strimzi-kafka-operator \
--namespace kafka
```
In the first case, you can install the latest version of Strimzi that supports released Axual Kafka images, in the second case, you can install the latest version of Strimzi available.