Skip to content
This repository has been archived by the owner on May 15, 2024. It is now read-only.

Latest commit

 

History

History
990 lines (715 loc) · 31.8 KB

README.md

File metadata and controls

990 lines (715 loc) · 31.8 KB
Raw

kubernetes-demo-helm-rabbitmq-mysql

Synopsis

Bring up a reference implementation Senzing stack on Kubernetes using minikube, kubectl, and helm. A containerized RabbitMQ and a MySQL database are deployed as backing services for demonstration purposes.

Overview

These instructions illustrate a reference implementation of Senzing using MySQL as the underlying database.

The instructions show how to set up a system that:

  1. Reads JSON lines from a file on the internet and sends each JSON line to a message queue using the Senzing stream-producer.
    1. In this implementation, the queue is RabbitMQ.
  2. Reads messages from the queue and inserts into Senzing using the Senzing stream-loader.
    1. In this implementation, Senzing keeps its data in a MySQL database.
  3. Reads information from Senzing using the Senzing API Server server.
  4. Views resolved entities in a web app.

The following diagram shows the relationship of the Helm charts, docker containers, and code in this Kubernetes demonstration.

Image of architecture

Contents

  1. Prerequisites
    1. Prerequisite software
    2. Clone repository
    3. Create demo directory
    4. Start minikube cluster
    5. View minikube cluster
    6. Set environment variables
    7. Identify Docker registry
    8. Create custom helm values files
    9. Create custom Kubernetes configuration files
    10. Save environment variables
    11. Create namespace
    12. Create persistent volume
    13. Add helm repositories
    14. Install MySQL Helm chart
    15. Install phpMyAdmin Helm chart
    16. Initialize database
    17. Install RabbitMQ Helm chart
  2. Demonstrate
    1. Install stream-producer Helm chart
    2. Install stream-loader Helm chart
    3. Install senzing-api-server Helm chart
    4. Install senzing-entity-search-web-app Helm chart
    5. Install senzing-console Helm chart
    6. Install senzing-redoer Helm chart
    7. Optional charts
      1. Install SwaggerUI Helm chart
    8. View data
      1. View RabbitMQ
      2. View MySQL
      3. View Senzing API Server
      4. View Senzing Entity Search WebApp
      5. View Senzing Console pod
      6. View SwaggerUI
  3. Cleanup
    1. Delete everything in Kubernetes
    2. Delete minikube cluster
  4. Errors
  5. References

Preamble

At Senzing, we strive to create GitHub documentation in a "don't make me think" style. For the most part, instructions are copy and paste. Whenever thinking is needed, it's marked with a "thinking" icon 🤔. Whenever customization is needed, it's marked with a "pencil" icon ✏️. If the instructions are not clear, please let us know by opening a new Documentation issue describing where we can improve. Now on with the show...

Legend

  1. 🤔 - A "thinker" icon means that a little extra thinking may be required. Perhaps you'll need to make some choices. Perhaps it's an optional step.
  2. ✏️ - A "pencil" icon means that the instructions may need modification before performing.
  3. ⚠️ - A "warning" icon means that something tricky is happening, so pay attention.

Expectations

  • Space: This repository and demonstration require 20 GB free disk space.
  • Time: Budget 4 hours to get the demonstration up-and-running, depending on CPU and network speeds.
  • Background knowledge: This repository assumes a working knowledge of:

Related artifacts

  1. DockerHub
  2. Helm Charts

Prerequisites

Prerequisite software

  1. minikube
  2. kubectl
  3. Helm 3
  4. Create MySQL compatible Docker images.

Clone repository

The Git repository has files that will be used in the helm install --values parameter.

  1. Using these environment variable values:

    export GIT_ACCOUNT=senzing
export GIT_REPOSITORY=kubernetes-demo
export GIT_ACCOUNT_DIR=~/${GIT_ACCOUNT}.git
export GIT_REPOSITORY_DIR="${GIT_ACCOUNT_DIR}/${GIT_REPOSITORY}"

  2. Follow steps in clone-repository to install the Git repository.

Create demo directory

  1. ✏️ Create a unique prefix. This will be used in a local directory name as well as a prefix to Kubernetes object.

    ⚠️ Because it's used in Kubernetes resource names, it must be all lowercase.

    Example:

    export DEMO_PREFIX=my

  2. Make a directory for the demo. Example:

    export SENZING_DEMO_DIR=~/senzing-rabbitmq-mysql-demo-${DEMO_PREFIX}
mkdir -p ${SENZING_DEMO_DIR}

Start minikube cluster

Using Get Started with Bitnami Charts using Minikube as a guide, start a minikube cluster.

  1. Start cluster using minikube start. Example:

    minikube start --cpus 4 --memory 8192 --disk-size=50g

View minikube cluster

🤔 Optional: View the minikube cluster using the dashboard.

  1. Run command in a separate terminal using minikube dashboard. Example:

    minikube dashboard

Set environment variables

  1. Set environment variables listed in "Clone repository".

  2. Synthesize environment variables. Example:

    export DEMO_NAMESPACE=${DEMO_PREFIX}-namespace

  3. Retrieve docker image version numbers and set their environment variables. Example:

    curl -X GET \
    --output ${SENZING_DEMO_DIR}/docker-versions-stable.sh \
    https://raw.githubusercontent.com/Senzing/knowledge-base/main/lists/docker-versions-stable.sh
source ${SENZING_DEMO_DIR}/docker-versions-stable.sh

  4. Retrieve Helm Chart version numbers and set their environment variables. Example:

    curl -X GET \
    --output ${SENZING_DEMO_DIR}/helm-versions-stable.sh \
    https://raw.githubusercontent.com/Senzing/knowledge-base/main/lists/helm-versions-stable.sh
source ${SENZING_DEMO_DIR}/helm-versions-stable.sh

  5. 🤔 Optional: To use a license other than the Senzing complimentary 100K record license, the SENZING_LICENSE_BASE64_ENCODED environment variable needs to be set. Note: Modify the path to a file containing the Senzing license in Base64 format. Example:

    export SENZING_LICENSE_BASE64_ENCODED=$(cat /etc/opt/senzing/g2lic_base64.txt)

echo ${SENZING_LICENSE_BASE64_ENCODED}

Identify Docker registry

🤔 There are 2 options when it comes to using a docker registry. Choose one:

  1. Use private registry
  2. Use minikube registry

Use private registry

Method #1: Pulls docker images from a private registry.

  1. ✏️ Specify a private registry. Example:

    export DOCKER_REGISTRY_URL=my.example.com:5000
export DOCKER_REGISTRY_SECRET=${DOCKER_REGISTRY_URL}-secret
export SENZING_SUDO=sudo
${GIT_REPOSITORY_DIR}/bin/docker-pull-tag-and-push.sh docker-images-for-helm-rabbitmq-mysql

Use minikube registry

Method #2: Pulls docker images from minikube's registry.

  1. Use minikube's docker registry using minkube addons enable and minikube image load. Example:

    minikube addons enable registry
export DOCKER_REGISTRY_URL=docker.io
export DOCKER_REGISTRY_SECRET=${DOCKER_REGISTRY_URL}-secret
${GIT_REPOSITORY_DIR}/bin/populate-minikube-registry-without-pull.sh docker-images-for-helm-rabbitmq-mysql

Create custom helm values files

For final customization of the Helm Charts, various files need to be created for use in the --values parameter of helm install.

🤔 In this step, Helm template files are populated with actual values. There are two methods of accomplishing this. Only one method needs to be performed.

  1. Method #1: Helm template files are instantiated with actual values into ${HELM_VALUES_DIR} directory by using make-helm-values-files.sh.

    export HELM_VALUES_DIR=${SENZING_DEMO_DIR}/helm-values
${GIT_REPOSITORY_DIR}/bin/make-helm-values-files.sh

  2. Method #2: Copy and manually modify files method. Example:

    export HELM_VALUES_DIR=${SENZING_DEMO_DIR}/helm-values
mkdir -p ${HELM_VALUES_DIR}

cp ${GIT_REPOSITORY_DIR}/helm-values-templates/* ${HELM_VALUES_DIR}

    ✏️ Edit files in ${HELM_VALUES_DIR} replacing the following variables with actual values.

    1. ${DEMO_PREFIX}
    2. ${DOCKER_REGISTRY_SECRET}
    3. ${DOCKER_REGISTRY_URL}
    4. ${SENZING_ACCEPT_EULA}

  3. 🤔 Optional: List newly generated files. Example:

    ls ${HELM_VALUES_DIR}

Create custom kubernetes configuration files

Create Kubernetes manifest files for use with kubectl create.

🤔 In this step, Kubernetes template files are populated with actual values. There are two methods of accomplishing this. Only one method needs to be performed.

  1. Method #1: Kubernetes manifest files are instantiated with actual values into {KUBERNETES_DIR} directory by using make-kubernetes-manifest-files.sh. Example:

    export KUBERNETES_DIR=${SENZING_DEMO_DIR}/kubernetes
${GIT_REPOSITORY_DIR}/bin/make-kubernetes-manifest-files.sh

  2. Method #2: Copy and manually modify files method. Example:

    export KUBERNETES_DIR=${SENZING_DEMO_DIR}/kubernetes
mkdir -p ${KUBERNETES_DIR}

cp ${GIT_REPOSITORY_DIR}/kubernetes-templates/* ${KUBERNETES_DIR}

    ✏️ Edit files in ${KUBERNETES_DIR} replacing the following variables with actual values.

    1. ${DEMO_NAMESPACE}

Save environment variables

Environment variables will be needed in new terminal windows using save-environment-variables.sh.

  1. Save environment variables into a file that can be sourced. Example:

    ${GIT_REPOSITORY_DIR}/bin/save-environment-variables.sh

Create namespace

A new Kubernetes namespace is created to isolate this demonstration from other applications running on Kubernetes.

  1. Create Kubernetes namespace using kubectl create. Example:

    kubectl create -f ${KUBERNETES_DIR}/namespace.yaml

  2. 🤔 Optional: Review namespaces using kubectl get. Example:

    kubectl get namespaces

Create persistent volume

🤔 Optional: These steps for creating Persistent Volumes (PV) and Persistent Volume Claims (PVC) are for a demonstration environment. They are not sufficient for a production environment. If PVs and PVCs already exist, this step may be skipped.

Note: Senzing does not require Persistent Volumes. The volumes being created are for the MySQL and RabbitMQ backing services.

  1. Create persistent volumes using kubectl create. Example:

    kubectl create -f ${KUBERNETES_DIR}/persistent-volume-mysql.yaml
kubectl create -f ${KUBERNETES_DIR}/persistent-volume-rabbitmq.yaml

  2. Create persistent volume claims using kubectl create. Example:

    kubectl create -f ${KUBERNETES_DIR}/persistent-volume-claim-mysql.yaml
kubectl create -f ${KUBERNETES_DIR}/persistent-volume-claim-rabbitmq.yaml

  3. 🤔 Optional: Review persistent volumes and claims using kubectl get. Example:

    kubectl get persistentvolumes \
  --namespace ${DEMO_NAMESPACE}

kubectl get persistentvolumeClaims \
  --namespace ${DEMO_NAMESPACE}

Add Helm repositories

  1. Add Helm repositories using helm repo add. Example:

    helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo add runix   https://helm.runix.net
helm repo add senzing https://hub.senzing.com/charts/

  2. Update repositories using helm repo update. Example:

    helm repo update

  3. 🤔 Optional: Review repositories using helm repo list. Example:

    helm repo list

Install MySQL Helm chart

🤔 This step installs a MySQL database container. It is not a production-ready database and is only used for demonstration purposes. The choice of database is a limiting factor in the speed at which Senzing can operate. This database choice is at least an order of magnitude slower than a well-tuned production database.

In a production environment, a separate MySQL database would be provisioned and maintained. The ${SENZING_DEMO_DIR}/helm-values/*.yaml files would then be updated to have the SENZING_DATABASE_URL point to the production database.

For this demonstration, the bitnami/mysql Helm Chart provisions an instance of the bitnami/mysql Docker image.

  1. Install bitnami/mysql chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-bitnami-mysql \
  bitnami/mysql \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/bitnami-mysql.yaml \
  --version ${SENZING_HELM_VERSION_BITNAMI_MYSQL:-""}

  2. Wait for pod to run using kubectl get. Example:

    kubectl get pods \
  --namespace ${DEMO_NAMESPACE} \
  --watch

  3. Example of pod running:

    NAME                              READY   STATUS      RESTARTS   AGE
my-bitnami-mysql-6bf64cbbdf-25gtb  1/1     Running     0          10m

Install phpMyAdmin Helm Chart

phpMyAdmin is a web-based user interface for viewing the MySQL database.

  1. Install bitnami/phpmyadmin chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-bitnami-phpmyadmin \
  bitnami/phpmyadmin \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/bitnami-phpmyadmin.yaml \
  --version ${SENZING_HELM_VERSION_BITNAMI_PHPMYADMIN:-""}

  2. To view MySQL via phpMyAdmin, see View MySQL.

Initialize database

senzing/init-mysql is used to create Senzing tables in the database (i.e. the schema) and insert initial Senzing configuration.

  1. Install senzing/senzing-init-mysql chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-senzing-init-mysql \
  senzing/senzing-init-mysql \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/senzing-init-mysql.yaml \
  --version ${SENZING_HELM_VERSION_SENZING_INIT_MYSQL:-""}

Install RabbitMQ Helm chart

The binami/rabbitmq Helm Chart provisions an instance of the bitnami/rabbitmq Docker image.

  1. Install bitnami/rabbitmq chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-bitnami-rabbitmq \
  bitnami/rabbitmq \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/bitnami-rabbitmq.yaml \
  --version ${SENZING_HELM_VERSION_BITNAMI_RABBITMQ:-""}

  2. Wait for pods to run using kubectl get. Example:

    kubectl get pods \
  --namespace ${DEMO_NAMESPACE} \
  --watch

  3. To view RabbitMQ, see View RabbitMQ.

Demonstrate

Now that all of the pre-requisites are in place, it's time to bring up a system that uses Senzing.

Install senzing-api-server Helm chart

The Senzing API server receives HTTP requests to read and modify Senzing data.

  1. Install senzing/senzing-api-server chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-senzing-api-server \
  senzing/senzing-api-server \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/senzing-api-server-mysql.yaml \
  --version ${SENZING_HELM_VERSION_SENZING_API_SERVER:-""}

  2. To view Senzing API server, see View Senzing API Server.

Install stream-producer Helm chart

The stream producer pulls JSON lines from a file and pushes them to a message queue.

  1. Install senzing/senzing-stream-producer chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-senzing-stream-producer \
  senzing/senzing-stream-producer \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/senzing-stream-producer-rabbitmq.yaml \
  --version ${SENZING_HELM_VERSION_SENZING_STREAM_PRODUCER:-""}

Install stream-loader Helm chart

The stream loader pulls messages from a message queue and sends them to Senzing.

  1. Install senzing/senzing-stream-loader chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-senzing-stream-loader \
  senzing/senzing-stream-loader \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/senzing-stream-loader-rabbitmq-mysql.yaml \
  --version ${SENZING_HELM_VERSION_SENZING_STREAM_LOADER:-""}

Install senzing-console Helm chart

The senzing-console will be used later to inspect mounted volumes, debug issues, or run command-line tools.

  1. Install senzing/senzing-console chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-senzing-console \
  senzing/senzing-console \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/senzing-console-mysql.yaml \
  --version ${SENZING_HELM_VERSION_SENZING_CONSOLE:-""}

  2. To use senzing-console pod, see View Senzing Console pod.

Install senzing-redoer Helm chart

The redoer pulls Senzing redo records from the Senzing database and re-processes.

  1. Install senzing/senzing-redoer chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-senzing-redoer \
  senzing/senzing-redoer \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/senzing-redoer-mysql.yaml \
  --version ${SENZING_HELM_VERSION_SENZING_REDOER:-""}

Install senzing-entity-search-web-app Helm chart

The Senzing Entity Search WebApp is a light-weight WebApp demonstrating Senzing search capabilities.

  1. Install senzing/senzing-entity-search-web-app chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-senzing-entity-search-web-app \
  senzing/senzing-entity-search-web-app \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/senzing-entity-search-web-app.yaml \
  --version ${SENZING_HELM_VERSION_SENZING_ENTITY_SEARCH_WEB_APP:-""}

  2. Wait for pods to run using kubectl get. Example:

    kubectl get pods \
  --namespace ${DEMO_NAMESPACE} \
  --watch

  3. To view Senzing Entity Search WebApp, see View Senzing Entity Search WebApp.

Optional charts

These charts are not necessary for the demonstration, but may be valuable in a production environment.

Install SwaggerUI Helm chart

The SwaggerUI is a micro-service for viewing the Senzing REST OpenAPI specification in a web browser.

  1. Install senzing/swaggerapi-swagger-ui chart using helm install. Example:

    helm install \
  ${DEMO_PREFIX}-swaggerapi-swagger-ui \
  senzing/swaggerapi-swagger-ui \
  --namespace ${DEMO_NAMESPACE} \
  --values ${HELM_VALUES_DIR}/swaggerapi-swagger-ui.yaml \
  --version ${SENZING_HELM_VERSION_SENZING_SWAGGERAPI_SWAGGER_UI:-""}

  2. To view SwaggerUI, see View SwaggerUI.

View data

  1. Because some of the Kubernetes Services use LoadBalancer, a minikube tunnel is needed for LoadBalancer access. Example:

    minikube tunnel

  2. ✏️ When using a separate terminal window in each of the examples below, set environment variables. Note: Replace ${DEMO_PREFIX} with the actual DEMO_PREFIX value. Example:

    source ~/senzing-rabbitmq-mysql-demo-${DEMO_PREFIX}/environment.sh

  3. Username and password for the following sites are the values seen in the corresponding "values" YAML file located in the helm-values-templates directory.

View RabbitMQ

The RabbitMQ Management UI is used to view the state of the queues.

  1. In a separate terminal window, port forward to local machine using kubectl port-forward. Example:

    kubectl port-forward \
  --address 0.0.0.0 \
  --namespace ${DEMO_NAMESPACE} \
  svc/${DEMO_PREFIX}-bitnami-rabbitmq 15672:15672

  2. RabbitMQ will be viewable at localhost:15672.

    1. Login
      1. See ${SENZING_DEMO_DIR}/helm-values/bitnami-rabbitmq.yaml for Username and password.

View MySQL

phpMyAdmin is a web-based user interface for viewing the MySQL database.

  1. In a separate terminal window, port forward to local machine using kubectl port-forward. Example:

    kubectl port-forward \
  --address 0.0.0.0 \
  --namespace ${DEMO_NAMESPACE} \
  svc/${DEMO_PREFIX}-bitnami-phpmyadmin 9173:80

  2. MySQL will be viewable at localhost:9173.

    1. Login
      1. See helm-values/bitnami-mysql.yaml for mysqlUser and mysqlPassword.
      2. Default: username: g2 password: g2
    2. On left-hand navigation, select "G2" database to explore.
    3. The records received from the queue can be viewed in the following Senzing tables:
      1. G2 > DSRC_RECORD
      2. G2 > OBS_ENT

View Senzing API Server

The Senzing API server receives HTTP requests to read and modify Senzing data.

  1. In a separate terminal window, port forward to local machine using kubectl port-forward. Example:

    kubectl port-forward \
  --address 0.0.0.0 \
  --namespace ${DEMO_NAMESPACE} \
  svc/${DEMO_PREFIX}-senzing-api-server 8250:80

  2. Make HTTP calls using curl. Example:

    export SENZING_API_SERVICE=http://localhost:8250

curl -X GET ${SENZING_API_SERVICE}/heartbeat
curl -X GET ${SENZING_API_SERVICE}/license
curl -X GET ${SENZING_API_SERVICE}/entities/1

View Senzing Entity Search WebApp

The Senzing Entity Search WebApp is a light-weight WebApp demonstrating Senzing search capabilities.

  1. In a separate terminal window, port forward to local machine using kubectl port-forward. Example:

    kubectl port-forward \
  --address 0.0.0.0 \
  --namespace ${DEMO_NAMESPACE} \
  svc/${DEMO_PREFIX}-senzing-entity-search-web-app 8251:80

  2. Senzing Entity Search WebApp will be viewable at localhost:8251. The demonstration instructions will give a tour of the Senzing web app.

View Senzing Console pod

The senzing-console is used to inspect mounted volumes, debug issues, or run command-line tools.

  1. In a separate terminal window, log into Senzing Console pod using kubectl exec. Example:

    export CONSOLE_POD_NAME=$(kubectl get pods \
  --namespace ${DEMO_NAMESPACE} \
  --output jsonpath="{.items[0].metadata.name}" \
  --selector "app.kubernetes.io/name=senzing-console, \
              app.kubernetes.io/instance=${DEMO_PREFIX}-senzing-console" \
  )

kubectl exec -it --namespace ${DEMO_NAMESPACE} ${CONSOLE_POD_NAME} -- /bin/bash

View SwaggerUI

The SwaggerUI is a micro-service for viewing the Senzing REST OpenAPI specification in a web browser.

  1. In a separate terminal window, port forward to local machine using kubectl port-forward. Example:

    kubectl port-forward \
  --address 0.0.0.0 \
  --namespace ${DEMO_NAMESPACE} \
  svc/${DEMO_PREFIX}-swaggerapi-swagger-ui 9180:80

    Then visit http://localhost:9180.

Cleanup

The following commands remove the Senzing Demo application from Kubernetes.

Delete everything in Kubernetes

Delete Kubernetes artifacts using helm uninstall, helm repo remove, and kubectl delete.

  1. Example:

    helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-swaggerapi-swagger-ui
helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-senzing-redoer
helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-senzing-entity-search-web-app
helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-senzing-api-server
helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-senzing-stream-loader
helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-senzing-init-mysql
helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-senzing-stream-producer
helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-bitnami-rabbitmq
helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-bitnami-phpmyadmin
helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-bitnami-mysql
helm uninstall --namespace ${DEMO_NAMESPACE} ${DEMO_PREFIX}-senzing-console
helm repo remove senzing
helm repo remove bitnami
kubectl delete -f ${KUBERNETES_DIR}/persistent-volume-claim-mysql.yaml
kubectl delete -f ${KUBERNETES_DIR}/persistent-volume-claim-rabbitmq.yaml
kubectl delete -f ${KUBERNETES_DIR}/persistent-volume-mysql.yaml
kubectl delete -f ${KUBERNETES_DIR}/persistent-volume-rabbitmq.yaml
kubectl delete -f ${KUBERNETES_DIR}/namespace.yaml

Delete minikube cluster

Delete minikube artifacts using minikube stop and minikube delete

  1. Example:

    minikube stop
minikube delete

Errors

  1. See docs/errors.md.

References