### Kerberos Vault Ingress Configuration Example

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

An example of an Ingress resource configuration for Kerberos Vault. This snippet shows how to define routing rules, specify the backend service, and configure annotations for Ingress controllers like Nginx, including TLS settings.

```yaml
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: vault
  annotations:
    kubernetes.io/ingress.class: nginx
    kubernetes.io/tls-acme: "true"
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  rules:
-->   - host: vault.domain.com
    http:
      paths:
      - path: /
        backend:
          serviceName: vault
          servicePort: 80
```

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

### Start Docker Compose Services

Source: https://github.com/kerberos-io/vault/blob/master/docker/README.md

Starts all the services defined in the docker-compose.yaml file. This command brings up Kerberos Vault, Minio, MongoDB, and Traefik.

```bash
docker compose up
```

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

### Install Minio Operator using Krew

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/minio/README.md

Installs the Minio operator using kubectl krew, a plugin manager for kubectl. Ensure krew is installed by following the official documentation.

```bash
kubectl krew update
kubectl krew install minio
```

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

### Install Kubernetes Components (Shell)

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Installs necessary packages for Kubernetes, adds the Kubernetes APT repository, and installs specific versions of kubelet, kubeadm, and kubectl. It also includes commands to disable swap memory for Kubernetes.

```shell
apt update -y
apt install apt-transport-https curl -y
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add
apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"
apt update -y && apt install kubelet=1.25.0-00 kubeadm=1.25.0-00 kubectl=1.25.0-00 -y

swapoff -a
sudo sed -i.bak '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
```

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

### Install Ingress-Nginx Controller using Helm

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Installs the Ingress-Nginx controller in a Kubernetes cluster using Helm. This includes adding the Helm repository, updating repositories, creating a namespace, and performing the Helm installation.

```bash
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
kubectl create namespace ingress-nginx
helm install ingress-nginx -n ingress-nginx ingress-nginx/ingress-nginx
```

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

### Install MetalLB Components

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Applies the necessary Kubernetes manifests to install MetalLB, including its namespace and core components. It also creates a secret required for the memberlist communication.

```bash
kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.10.1/manifests/namespace.yaml
kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.10.1/manifests/metallb.yaml
kubectl create secret generic -n metallb-system memberlist --from-literal=secretkey=$(openssl rand -base64 128)
```

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

### Apply MetalLB Configuration

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Applies the MetalLB configuration defined in a local `configmap.yaml` file to the Kubernetes cluster. This step ensures that MetalLB can start assigning IP addresses to services.

```bash
kubectl apply -f ./metallb/configmap.yaml
```

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

### Install Docker and Configure cgroup Driver (Shell)

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Installs the docker.io package and configures the Docker daemon to use systemd for cgroup driver, which is necessary for Kubernetes compatibility. It also enables and restarts the Docker service.

```shell
apt install docker.io -y

sudo mkdir /etc/docker
cat <<EOF | sudo tee /etc/docker/daemon.json
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF

sudo systemctl enable docker
sudo systemctl daemon-reload
sudo systemctl restart docker
```

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

### Clone Kerberos Vault Kubernetes Configurations

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

This command clones the official Kerberos Vault repository from GitHub, which contains all necessary Kubernetes configuration files. You will then navigate into the `kubernetes` directory to proceed with the installation.

```bash
git clone https://github.com/kerberos-io/vault
```

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

### Create Docker Compose Services

Source: https://github.com/kerberos-io/vault/blob/master/docker/README.md

Creates the services defined in the docker-compose.yaml file without starting them. This step prepares the containers, networks, and volumes.

```bash
docker compose create
```

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

### Install Helm Package Manager

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Installs the Helm package manager, a crucial dependency for deploying applications on Kubernetes. This can be done using various OS package managers.

```bash
brew install helm
choco install kubernetes-helm
scoop install helm
gofish install helm
```

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

### Install MongoDB using Helm

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Deploys MongoDB into the Kubernetes cluster using the Helm package manager. It utilizes a local values.yaml file for configuration and is deployed in the 'mongodb' namespace.

```bash
helm install mongodb -n mongodb bitnami/mongodb --values ./mongodb/values.yaml
```

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

### Initialize Kubernetes Cluster and Configure Kubeconfig (Shell)

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Resets any existing Kubernetes installation, removes the local kubeconfig, initializes a new Kubernetes cluster using kubeadm, and configures the user's kubeconfig to interact with the new cluster.

```shell
kubeadm reset
rm -rf $HOME/.kube

# For a specific pod network CIDR, use:
# kubeadm init --pod-network-cidr=10.244.0.0/16
kubeadm init

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
```

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

### Download Docker Compose Configuration

Source: https://github.com/kerberos-io/vault/blob/master/docker/README.md

Downloads the docker-compose.yml file from the Kerberos Vault GitHub repository. This file defines the services, networks, and volumes for the Kerberos Vault setup.

```bash
wget https://raw.githubusercontent.com/kerberos-io/vault/master/docker/docker-compose.yml -O docker-compose.yaml
```

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

### Download OpenEBS Operator

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Downloads the OpenEBS operator manifest using `wget`. This file is required to install the OpenEBS control plane, which enables automatic provisioning of persistent volumes.

```bash
wget https://openebs.github.io/charts/openebs-operator.yaml
```

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

### Initialize and Verify Minio Operator

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/minio/README.md

Initializes the Minio operator and verifies its version. This step ensures the operator is ready to manage Minio instances.

```bash
kubectl minio version
kubectl minio init
```

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

### Add MongoDB Helm Repository and Create Namespace

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Adds the Bitnami MongoDB Helm chart repository and creates a Kubernetes namespace for MongoDB. This is a prerequisite for installing MongoDB using Helm.

```bash
helm repo add bitnami https://charts.bitnami.com/bitnami
kubectl create namespace mongodb
```

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

### List All Pods Across Namespaces

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

This command retrieves a list of all pods running in your Kubernetes cluster, regardless of their namespace. It's useful for a comprehensive overview of running processes and debugging.

```bash
kubectl get pods --all-namespaces
```

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

### Run Python Kafka Handler

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

Instructions for setting up a Python virtual environment, installing dependencies, and running the Kafka handler script. Assumes Python 3 and a requirements.txt file are available.

```shell
python3 -m venv kafka-handler
./kafka-handler/bin/pip install -r requirements.txt
./kafka-handler/bin/python index.py
```

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

### Update Ubuntu Operating System

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Updates the package list and upgrades installed packages on an Ubuntu system. This is a common prerequisite step for setting up software or services on a Linux-based environment.

```bash
apt-get update -y && apt-get upgrade -y
```

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

### Install Calico Network Plugin (Shell)

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Downloads the Calico manifest file and applies it to the Kubernetes cluster to set up the network layer. Calico is a popular choice for container networking and network security.

```shell
curl https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/calico.yaml -O
kubectl apply -f calico.yaml
```

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

### Install Kafka using Helm

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

Commands to add the Bitnami Helm repository and install a Kafka broker using the Kafka helm chart. Requires Helm to be installed and configured.

```shell
helm repo add bitnami https://charts.bitnami.com/bitnami
helm install --name kafka bitnami/kafka  -f ./kafka/values.yaml
```

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

### Clone Vault and Apply Minio Tenant Manifests

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/minio/README.md

Clones the Kerberos-io vault repository, navigates to the Minio Kubernetes configuration directory, and applies the necessary manifests to create a Minio tenant. This includes credentials, configuration, and the tenant definition itself.

```bash
git clone https://github.com/kerberos-io/vault && cd vault/kubernetes/minio
kubectl create namespace minio-tenant
kubectl apply -f minio.cred.yaml
kubectl apply -f minio.config.tenant.yaml
kubectl apply -f minio.tenant.yaml
```

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

### Apply MongoDB Config Map to Kubernetes

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Applies the MongoDB configuration defined in a ConfigMap file to the 'kerberos-vault' namespace in Kubernetes.

```bash
kubectl apply -f ./mongodb/mongodb.config.yaml -n kerberos-vault
```

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

### List Docker Networks

Source: https://github.com/kerberos-io/vault/blob/master/docker/README.md

Lists all available Docker networks on the host. This command is used to verify that the 'cluster-net' network was successfully created.

```bash
docker network ls
```

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

### Deploy Kerberos Vault using kubectl

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Applies the Kerberos Vault deployment configuration to the cluster. This command creates the necessary deployment and exposes the service, typically via a LoadBalancer. It assumes the deployment YAML file is present in the specified path.

```bash
kubectl apply -f ./kerberos-vault/deployment.yaml -n kerberos-vault
```

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

### Clone Kerberos Vault Repository (Shell)

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Clones the Kerberos Vault configuration repository from GitHub and changes the current directory to the 'kubernetes' subfolder, preparing for further configuration steps.

```shell
git clone https://github.com/kerberos-io/vault
cd kubernetes
```

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

### Retrieve MongoDB Root Password

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Retrieves the MongoDB root password from a Kubernetes secret and exports it as an environment variable. This is useful for verifying the installation and for subsequent configurations.

```bash
export MONGODB_ROOT_PASSWORD=$(kubectl get secret -n mongodb mongodb -o jsonpath="{.data.mongodb-root-password}" | base64 --decode)
echo $MONGODB_ROOT_PASSWORD
```

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

### Create Proxy to MinIO Operator Console

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/minio/README.md

Establishes a local proxy to the MinIO Operator Console, allowing access to manage MinIO tenants. This is typically used for accessing the management interface.

```bash
kubectl minio proxy -n minio-operator
```

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

### Navigate to Kerberos Vault Kubernetes Directory

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

After cloning the repository, this command changes your current directory to the `kubernetes` folder within the cloned repository. This is where all the deployment manifests and configuration files are located.

```bash
cd kubernetes
```

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

### Apply OpenEBS Operator

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Applies the OpenEBS operator manifest to the Kubernetes cluster using `kubectl`. This action initiates the deployment of OpenEBS resources, including the necessary components for storage provisioning.

```bash
kubectl apply -f openebs-operator.yaml
```

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

### Create Kerberos Vault Namespace

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

This command creates a dedicated Kubernetes namespace named `kerberos-vault`. Using namespaces is a best practice for isolating applications and their resources within a cluster, improving organization and access control.

```bash
kubectl create namespace kerberos-vault
```

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

### Port-forward to MinIO Tenant Console

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/minio/README.md

Forwards traffic from a local port to the MinIO Tenant console service, enabling access to the tenant's management interface. This is done after the MinIO tenant has been successfully created.

```bash
kubectl get svc -n minio-tenant
kubectl port-forward svc/minio-console 9090 -n minio-tenant
```

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

### Verify Kubernetes Cluster Access

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

This command checks if you can connect to your Kubernetes cluster's API server and lists the available nodes. It's a fundamental step to ensure your `kubectl` is configured correctly.

```bash
kubectl get nodes
```

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

### Verify Ingress-Nginx Pod Status

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Checks the status of the Ingress-Nginx controller pods within the 'ingress-nginx' namespace. This command verifies that the Ingress controller, responsible for handling external traffic, is operational.

```bash
kubectl get pods -n ingress-nginx
```

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

### Install Dependencies for Color Detection

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

Installs the 'opencv-python' and 'sklearn' libraries, which are required for video processing and color histogram calculation.

```bash
pip3 install opencv-python
pip3 install sklearn
```

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

### Create Host Volumes for Data Persistence

Source: https://github.com/kerberos-io/vault/blob/master/docker/README.md

Creates directories on the host machine to persist data for Docker containers. These directories ('vault' and 'mongodb') are bind-mounted into the respective containers.

```bash
mkdir vault
mkdir mongodb
```

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

### Verify MongoDB Pod Status

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Checks the status of the MongoDB pods within the 'mongodb' namespace. This is useful for ensuring that the database dependency for Kerberos Vault is running correctly.

```bash
kubectl get pods -n mongodb
```

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

### Configure MongoDB Connection in Kubernetes

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Creates a Kubernetes ConfigMap to configure the MongoDB connection for Kerberos Vault. This can be done using a MONGODB_URI or individual connection parameters.

```yaml
- name: MONGODB_URI
  value: "mongodb+srv://xx:xx@kerberos-hub.xxx.mongodb.net/?retryWrites=true&w=majority&appName=xxx"

- name: MONGODB_USERNAME
  value: "root"
- name: MONGODB_PASSWORD
  value: "yourmongodbpassword"
```

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

### Apply Kerberos Vault Ingress Configuration

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Applies the Ingress configuration file to the Kubernetes cluster. This command enables external access to Kerberos Vault via a specified hostname and port, assuming the Ingress resource is correctly defined.

```bash
kubectl apply -f ./kerberos-vault/ingress.yaml -n kerberos-vault
```

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

### Check Minio Operator Pod Status

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/minio/README.md

Verifies the status of the Minio operator pods running in the `minio-operator` namespace. This helps confirm the operator is running correctly.

```bash
kubectl get pods -n minio-operator
```

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

### Configure OpenEBS BasePath

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Illustrates how to modify the `BasePath` value within the OpenEBS operator's `StorageClass` section. This path specifies the directory on the host where Persistent Volume data will be stored.

```yaml
#Specify the location (directory) where
# where PV(volume) data will be saved.
# A sub-directory with pv-name will be
# created. When the volume is deleted,
# the PV sub-directory will be deleted.
#Default value is /var/openebs/local
- name: BasePath
  value: "/var/openebs/local/"
```

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

### Kafka JAAS Configuration Example

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

Example of a JAAS configuration string for connecting to a Kafka broker with username and password authentication. Used for client-side authentication.

```properties
org.apache.kafka.common.security.plain.PlainLoginModule required username="aaa" password="xxx";
```

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

### Verify Kerberos Vault Pod Status

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Checks the status of the Kerberos Vault pods within the 'kerberos-vault' namespace. This command helps to confirm that the application pods are running and healthy after deployment.

```bash
kubectl get pods -n kerberos-vault
```

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

### Create Docker Network

Source: https://github.com/kerberos-io/vault/blob/master/docker/README.md

Creates a new Docker virtual network named 'cluster-net'. This network is used to isolate the containers and manage communication between them.

```bash
docker network create cluster-net
```

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

### Configure MetalLB Address Pool

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Defines a MetalLB configuration using a ConfigMap. This configuration specifies an address pool named 'default' using the 'layer2' protocol and a range of IP addresses to be assigned to LoadBalancers.

```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    address-pools:
    - name: default
      protocol: layer2
      addresses:
      - 192.168.1.200-192.168.1.210
```

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

### Untaint Master Node for Workloads (Shell)

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Removes the control-plane taint from a node, allowing pods to be scheduled on master nodes. This is particularly useful in single-node clusters or for specific testing scenarios.

```shell
kubectl taint nodes <your_node_name> node-role.kubernetes.io/control-plane-
```

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

### Verify Kerberos Vault Service IP

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/README.md

Retrieves the service details for Kerberos Vault to confirm it has been assigned an internal or external IP address. This is crucial for accessing the application after deployment, especially when using a LoadBalancer.

```bash
kubectl get svc -n kerberos-vault
```

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

### Verify Kafka Deployment Status

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/kafka/README.md

Checks the status of Kafka and Zookeeper pods deployed within the 'kafka' namespace. This command helps confirm that the Kafka broker has been successfully installed and is running.

```bash
kubectl get po -n kafka
```

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

### Python: Create and Consume Kafka Messages

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

This snippet demonstrates how to create a Kafka consumer client using the confluent_kafka library and continuously receive messages from a specified topic. It handles potential exceptions during message retrieval and prints each message. The code requires the confluent_kafka library to be installed.

```python
from mqueue import CreateQueue

kafkaQueue = CreateQueue(queueName='kerberos-storage-example-queue',
                         broker='broker1.kerberos.io:9094,broker2.kerberos.io:9094,broker3.kerberos.io:9094',
                         mechanism='PLAIN',
                         security='SASL_PLAINTEXT',
                         username= 'aaa',
                         password='xxx')
while True:
    try:
        messages = kafkaQueue.ReceiveMessages()
        for message in messages:
            print message
            print("next..")
        print("reading..")

    except Exception as e:
        print("error..")
        print(e)
        pass
```

```python
import json
from confluent_kafka import Producer, Consumer

def CreateQueue(queueName='', broker='', mechanism='', security='', username= '', password=''):
    return Kafka(queueName=queueName, broker=broker, mechanism=mechanism, security=security, username=username, password=password)

class Kafka:
    def __init__(self, queueName='', broker='', mechanism='', security='', username= '', password=''):
        self.queueName = queueName
        kafkaC_settings = {
            'bootstrap.servers': broker,
            "group.id":             "mygroup",
            "session.timeout.ms":   10000,
            "queued.max.messages.kbytes": 10000, #10MB
        	"auto.offset.reset":    "earliest",
            "sasl.mechanisms":   mechanism, #"PLAIN",
            "security.protocol": security, #"SASL_PLAINTEXT",
            "sasl.username":     username,
            "sasl.password":     password,
        }
        self.kafka_consumer = Consumer(kafkaC_settings)
        self.kafka_consumer.subscribe([self.queueName])

    def ReceiveMessages(self):
        msg = self.kafka_consumer.poll(timeout=1.0)
        if msg is None:
            return []
        return [json.loads(msg.value())]

    def Close(self):
        self.kafka_consumer.close()
        return True
```

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

### Install OpenEBS Storage Class for Kafka

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/kafka/README.md

Applies the OpenEBS operator manifest to set up a storage class, which is a prerequisite for deploying Kafka within Kubernetes. This ensures persistent storage is available for the Kafka broker.

```bash
kubectl apply -f https://openebs.github.io/charts/openebs-operator.yaml
```

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

### Modify Host File for DNS Resolution

Source: https://github.com/kerberos-io/vault/blob/master/docker/README.md

Adds entries to the host's /etc/hosts file to map DNS names to IP addresses. This allows accessing services like Kerberos Vault and Minio using custom domain names instead of IP addresses.

```bash
x.x.x.x kerberos-vault-api.domain.tld kerberos-vault.domain.tld minio-console.domain.tld
```

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

### Deploy Kafka Broker using Helm

Source: https://github.com/kerberos-io/vault/blob/master/kubernetes/kafka/README.md

Clones the Kerberos Vault Kubernetes Kafka configuration, creates a dedicated namespace, and deploys the Kafka broker using Helm. This command assumes you have Helm and kubectl configured.

```bash
git clone https://github.com/kerberos-io/vault && cd vault/kubernetes/kafka
kubectl create namespace kafka
helm install kafka bitnami/kafka -f values.yaml -n kafka
```

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

### Create MongoDB Index for Media Collection

Source: https://github.com/kerberos-io/vault/blob/master/README.md

This MongoDB command creates an index on the 'timestamp' field in the 'media' collection, sorted in descending order. This index is crucial for improving the performance of future queries on the media collection.

```javascript
db.getCollection("media").createIndex({timestamp:-1})
```

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

### Build Docker Image for Kafka Handler

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

Command to build a Docker image for the Kafka handler application. Requires a Dockerfile in the current directory.

```shell
docker build -t kafka-handler .
```

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

### Fetch Recording from Kerberos Vault API

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

This endpoint allows you to retrieve binary files (recordings) from your defined Kerberos Vault provider (AWS, GCP, Azure, or Minio). It requires specific headers containing file identification and access credentials.

```APIDOC
## GET /api/storage/blob

### Description
Retrieves a binary file (recording) from a specified Kerberos Vault provider using provided file name and access credentials.

### Method
GET

### Endpoint
`http(s)://your-kerberos-vault-domain.com/api/storage/blob`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Headers
- **X-Kerberos-Storage-FileName** (string) - Required - The filename of the recording to retrieve.
- **X-Kerberos-Storage-Provider** (string) - Required - The provider where the file was stored (e.g., AWS, GCP, Azure, Minio).
- **X-Kerberos-Storage-AccessKey** (string) - Required - The AccessKey for the Kerberos Vault account.
- **X-Kerberos-Storage-SecretAccessKey** (string) - Required - The SecretAccessKey for the Kerberos Vault account.

### Request Example
```python
import requests

fileName = message['payload']['key']
provider = message['source']

response = requests.get(
  'http(s)://yourkerberostoragedomain.com/api/storage/blob',
  headers={
    'X-Kerberos-Storage-FileName': fileName,
    'X-Kerberos-Storage-Provider': provider,
    'X-Kerberos-Storage-AccessKey': 'YOUR_ACCESS_KEY',
    'X-Kerberos-Storage-SecretAccessKey': 'YOUR_SECRET_ACCESS_KEY',
  },
)

if response.status_code == 200:
    fileContent = response.content
    with open('video.mp4', 'wb') as file:
        file.write(fileContent)
else:
    print(f"Error retrieving file: {response.status_code} - {response.text}")
```

### Response
#### Success Response (200)
- **fileContent** (binary) - The content of the requested recording file.

#### Response Example
(Binary content of the video file, saved to `video.mp4` in the example)
```

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

### Fetch Recording from Kerberos Vault API (Python)

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

This snippet demonstrates how to retrieve a recording from the Kerberos Vault API using the 'requests' library in Python. It extracts the filename and provider from a message, constructs the API request with necessary headers including access keys, and handles the response. If the request is successful (status code 200), the recording content is saved to a local 'video.mp4' file. Otherwise, an error message is printed.

```python
import requests

# Assuming 'message' is a dictionary containing 'payload' and 'source'
# Example: message = {'payload': {'key': 'recording.mp4'}, 'source': 'aws'}

fileName = message['payload']['key']
provider = message['source']

response = requests.get(
  'http(s)://yourkerberostoragedomain.com/api/storage/blob',
  headers={
    'X-Kerberos-Storage-FileName': fileName,
    'X-Kerberos-Storage-Provider': provider,
    'X-Kerberos-Storage-AccessKey': 'xxx',
    'X-Kerberos-Storage-SecretAccessKey': 'xxx',
  },
)

if response.status_code != 200:
    print("Something went wrong: " + response.content)
else:
    fileContent = response.content
    with open('video.mp4', 'wb') as file:
        file.write(fileContent)
    print("Recording saved to video.mp4")
```

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

### Python: Process Video Frame and Calculate Histogram

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

This script snippet demonstrates how to capture the first frame from a video file named 'video.mp4', pass it to the `calculateHistogram` function, and print the resulting dominant RGB colors. It includes error handling for frame capture.

```python
import cv2

# Assume calculateHistogram function is defined elsewhere or above
# def calculateHistogram(img):
#     ...

vidcap = cv2.VideoCapture('video.mp4')
success, img = vidcap.read()

histogram = []
if success:
    histogram = calculateHistogram(img)
else:
    print("Something went wrong while capturing a frame from video.mp4")
print(histogram)
```

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

### Deploy Kafka Handler to Kubernetes

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

Command to deploy the Kafka handler to a Kubernetes cluster using a provided YAML configuration file. Assumes Docker image is already built and accessible.

```shell
kubectl apply -f kubernetes.yaml
```

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

### Bash: Execute Python Script for Color Detection

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

This command executes the Python script ('index.py' or similar) that performs video frame capture and color histogram calculation.

```bash
python3 index.py
```

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

### Python: Calculate Color Histogram using OpenCV and Scikit-learn

Source: https://github.com/kerberos-io/vault/blob/master/examples/kafka-handler/README.md

This Python function, `calculateHistogram`, takes an image frame as input, converts it to RGB format, reshapes it for clustering, and uses scikit-learn's KMeans to find the dominant colors. It returns a list of the top 3 most common RGB color values.

```python
import cv2
import numpy as np
from sklearn.cluster import KMeans

def calculateHistogram(img):

    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    img = img.reshape((img.shape[0] * img.shape[1],3)) #represent as row*column,channel number
    clt = KMeans(n_clusters=3)
    clt.fit(img)

    numLabels = np.arange(0, len(np.unique(clt.labels_)) + 1)
    (hist, _) = np.histogram(clt.labels_, bins=numLabels)

    hist = hist.astype("float")
    hist /= hist.sum()

    rgbs = []
    for cluster in clt.cluster_centers_:
        rgbs.append(list(map(int,cluster)))
    return rgbs
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.