docker-development-youtube-series Documentation

node('jenkins-slave') {
    
     stage('unit-tests') {
        sh(script: """
            docker run --rm alpine /bin/sh -c "echo hello world"
        """)
    }
}

+------------+
| videos-web |
|            |
+------------+

+------------+     +---------------+
| videos-web +---->+ playlists-api |
|            |     |               |
+------------+     +---------------+

+------------+     +---------------+    +--------------+
| videos-web +---->+ playlists-api +--->+ playlists-db |
|            |     |               |    |              |
+------------+     +---------------+    +--------------+

{
  "id" : "playlist-01",
  "title": "Cool playlist",
  "videos" : [ "video-1", "video-x" , "video-b"]
}

+------------+       +-----------+
| videos-api +------>+ videos-db |
|            |       |           |
+------------+       +-----------+

+------------+     +---------------+    +--------------+
| videos-web +---->+ playlists-api +--->+ playlists-db |
|            |     |               |    |    [redis]   |
+------------+     +-----+---------+    +--------------+
                         |
                         v
                   +-----+------+       +-----------+
                   | videos-api +------>+ videos-db |
                   |            |       |  [redis]  |
                   +------------+       +-----------+

cd tracing

docker-compose build

docker-compose up

---
name: k8s_expert
description: A specialized kubernetes agent specialised in local cluster development and troubleshooting.
---

You help engineers provision, inspect, and debug Kubernetes clusters running on their local machine.

## Persona & Behaviour

- Speak like a senior platform engineer: direct, precise, no hand-holding
- Always confirm tool availability before running commands
- Prefer `kind` for local clusters unless the user specifies otherwise
- When creating clusters, always confirm the cluster name and Kubernetes version first
- When troubleshooting, always check events before logs

## Available Skills

* Provision test k8s infrastructure for testing technical guides using provided available skill

docker run -it --rm \
  -p 8080:8080 \
  ubuntu:latest bash

# install some tools we'll use:
apt-get update && apt-get install -y curl tree git jq tar

#install nodejs and python as a requirement for many MCP servers
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.4/install.sh | bash
# in lieu of restarting the shell
\. "$HOME/.nvm/nvm.sh"
nvm install 24
node -v

apt-get install -y python3 python3-pip python3-venv# Create the environment
python3 -m venv /opt/venv
source /opt/venv/bin/activate

mkdir -p /workspace && cd /workspace
echo "# Hello MCP" > README.md
echo "console.log('hello')" > app.js
mkdir src && echo "export default {}" > src/index.js
tree

git init
git config user.email "[email protected]"
git config user.name "MCP Demo"
git add .
git commit -m "initial commit"

# leave an uncommitted change for the diff demo
echo "## Updated" >> README.md

(
  echo '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}},"id":1}'
  echo '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"list_directory","arguments":{"path":"/workspace"}},"id":2}'
  echo '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"read_text_file","arguments":{"path":"/workspace/README.md"}},"id":3}'
  sleep 2
) | npx -y @modelcontextprotocol/server-filesystem /workspace 2>/dev/null | jq -c .

pip3 install mcp-server-git

(
  echo '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}},"id":1}'
  echo '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"git_log","arguments":{"repo_path":"/workspace","max_count":3}},"id":2}'
  echo '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"git_diff_unstaged","arguments":{"repo_path":"/workspace"}},"id":3}'
  sleep 2
) | python3 -u -m mcp_server_git --repository /workspace 2>/dev/null | jq -c .

curl -fsSL https://github.com/github/github-mcp-server/releases/download/v1.0.5/github-mcp-server_Linux_x86_64.tar.gz \
  | tar -xz -C /usr/local/bin github-mcp-server
github-mcp-server --help

github-mcp-server http --port 8080

export GITHUB_PERSONAL_ACCESS_TOKEN=''

# step-1: initialise
curl -s -i http://localhost:8080/mcp \
       -H "Content-Type: application/json" \
       -H "Accept: application/json, text/event-stream" \
       -H "Authorization: Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}" \
       -d '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}},"id":1}'

MCP_SESSION_ID=''

# step-2: list tools
curl -s http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}" \
  -H "Mcp-Session-Id: ${MCP_SESSION_ID}" \
  -d '{"jsonrpc":"2.0","method":"tools/list","id":2}'

# step-3: tool call
curl -s http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}" \
  -H "Mcp-Session-Id: ${MCP_SESSION_ID}" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"search_repositories","arguments":{"query":"kubernetes gateway-api","sort":"stars","perPage":5}},"id":3}'

kind create cluster --name mcp --image kindest/node:v1.34.0

kubectl apply -f kubernetes/gateway-api/agentgateway/mcp/kubernetes/02-mcp.yaml

# check mcp server
kubectl get pods
kubectl get sa
kubectl get service

# forward ports
kubectl port-forward svc/mcp-k8s 8080

# step-1: initialise
curl -s -i http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}},"id":1}'

MCP_SESSION_ID=''

# step-2: list tools
curl -s http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Mcp-Session-Id: ${MCP_SESSION_ID}" \
  -d '{"jsonrpc":"2.0","method":"tools/list","id":2}'

# step-3: tool call
curl -s http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Mcp-Session-Id: ${MCP_SESSION_ID}" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"namespaces_list","arguments":{}},"id":3}'

go version

cd golang\introduction

docker build --target dev . -t go
docker run -it -v ${PWD}:/work go sh
go version

mkdir app

# change directory to your application source code

cd app

# create a go module file

go mod init github.com/docker-development-youtube-series/golang/introdouction/app

package main

import "fmt"

func main() {
	fmt.Println("Hello, world.")
}

go run app.go

go build

./app

go install github.com/docker-development-youtube-series/golang/introdouction/app

// This function returns some data 
// The data could be coming from a database, or a file.
// The person calling the function should not care
// Since the function does not leak its Data provider

func getData(inputs)(outputs){
}

// functions can take multiple inputs, and return multiple outputs

// lets say we have 1) customers and 2) the cities they are from
// we may want to 1) get a list of customers and 2) get a list of cities
// therefore we have 2 types of data, 1) customers 2) cities
// let's improve our function so its gets data based on the type

func getData(customerId int) (customer string) {
}

func getData(customerId int) (customer string) {
  var firstName = "Marcel"
  lastName := "Dempers"
  
  fullName := firstName + " " + lastName
  return fullName

  //or we can return the computation instead of adding another variable!
  return firstName + " " + lastName

  //or we dont even need to declare variables :)
  return "Marcel Dempers"

}

func getData(customerId int) (customer string) {

  if customerId == 1 {
    return "Marcel Dempers"
  } else if customerId == 2 {
    return "Bob Smith"
  } else {
    return ""
  }
  
}

//in the main() function

//get our customer
customer := getData(1)
fmt.Println(customer)

//get the wrong customer
customer := getData(3)
fmt.Println(customer)

func getData() (customers [2]string) {
  //create 1 record
  customer := "Marcel Dempers"

  //assign our customer to the array
  customers[0] = customer

  //OR we can assign it like this
  customers[1] = "Bob Smith"

  //send it back to the caller
  return customers
  
}

customers := getData()

fmt.Println(customers)

func getData() (customers []string) {
  
  //initialise our slice of type string
  customers = []string{ "Marcel Dempers", "Bob Smith", "John Smith"}
  
  //add more legendary customers dynamically 
  customers = append(customers, "Ben Spain")
  customers = append(customers, "Aleem Janmohamed")
  customers = append(customers, "Jamie le Notre")
  customers = append(customers, "Victor Savkov")
  customers = append(customers, "P The Admin")
  customers = append(customers, "Adrian Oprea")
  customers = append(customers, "Jonathan D")

  //send it back to the caller
  return customers
  
}

//loop forever
for {
  //any code in here will run forever!
  
  fmt.Println("Infinite Loop 1")
	time.Sleep(time.Second)

  //unless we break out the loop like this
  break
}

//loop for x number of loops
for x := 0; x < 10; x++ {

  //any code in here will run 10 times! (unless we break!)
  fmt.Println(customers[x])

}

//loop for ALL our customer

for x, customer := range customers {

  //we can access the "customer" variable in this approach
  customer = customers[x]
  fmt.Println(customer)

  //OR
  //we can use the supplied customer from the loop
  // and silence the x variable, replace it with a _ character
  fmt.Println(customer)
}

package main

Customer struct {
  FirstName string
  LastName string
  FullName string
}

func GetCustomers()(customers []Customer) {

  //we can declare customers like this:
  marcel := 	Customer{ FirstName: "Marcel", LastName: "Dempers" }

	customers = append(customers,
		Customer{ FirstName: "Marcel", LastName: "Dempers" },
		Customer{ FirstName: "Ben", LastName: "Spain" },
		Customer{ FirstName: "Aleem", LastName: "Janmohamed" },
		Customer{ FirstName: "Jamie", LastName: "le Notre" },
		Customer{ FirstName: "Victor", LastName: "Savkov" },
		Customer{ FirstName: "P", LastName: "The Admin" },
		Customer{ FirstName: "Adrian", LastName: "Oprea" },
		Customer{ FirstName: "Jonathan", LastName: "D" },
	)

	return customers

}

customers := GetCustomers()

for _, customer := range customers {
  //we can access the "customer" variable in this approach
  fmt.Println(customer)
}

FROM golang:1.15 as dev

WORKDIR /work

FROM golang:1.15 as build

WORKDIR /app
COPY ./app/* /app/
RUN go build -o app

FROM alpine as runtime 
COPY --from=build /app/app /
CMD ./app

docker build . -t customer-app

docker run customer-app

cd hashicorp/vault-2022

kind create cluster --name vault --image kindest/node:v1.21.1 --config kind.yaml

docker run -it --rm --net host -v ${HOME}/.kube/:/root/.kube/ -v ${PWD}:/work -w /work alpine sh

apk add --no-cache curl
curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
chmod +x ./kubectl
mv ./kubectl /usr/local/bin/kubectl

curl -LO https://get.helm.sh/helm-v3.7.2-linux-amd64.tar.gz
tar -C /tmp/ -zxvf helm-v3.7.2-linux-amd64.tar.gz
rm helm-v3.7.2-linux-amd64.tar.gz
mv /tmp/linux-amd64/helm /usr/local/bin/helm
chmod +x /usr/local/bin/helm

kubectl get nodes
NAME                  STATUS   ROLES                  AGE   VERSION
vault-control-plane   Ready    control-plane,master   37s   v1.21.1

helm repo add hashicorp https://helm.releases.hashicorp.com

helm search repo hashicorp/consul --versions

mkdir manifests

helm template consul hashicorp/consul \
  --namespace vault \
  --version 0.39.0 \
  -f consul-values.yaml \
  > ./manifests/consul.yaml

kubectl create ns vault
kubectl -n vault apply -f ./manifests/consul.yaml
kubectl -n vault get pods

kubectl -n vault create secret tls tls-ca \
 --cert ./tls/ca.pem  \
 --key ./tls/ca-key.pem

kubectl -n vault create secret tls tls-server \
  --cert ./tls/vault.pem \
  --key ./tls/vault-key.pem

helm search repo hashicorp/vault --versions

helm template vault hashicorp/vault \
  --namespace vault \
  --version 0.19.0 \
  -f vault-values.yaml \
  > ./manifests/vault.yaml

kubectl -n vault apply -f ./manifests/vault.yaml
kubectl -n vault get pods

kubectl -n vault exec -it vault-0 -- sh
kubectl -n vault exec -it vault-1 -- sh
kubectl -n vault exec -it vault-2 -- sh

vault operator init
vault operator unseal

kubectl -n vault exec -it vault-0 -- vault status
kubectl -n vault exec -it vault-1 -- vault status
kubectl -n vault exec -it vault-2 -- vault status

kubectl -n vault get svc
kubectl -n vault port-forward svc/vault-ui 443:8200

kubectl -n vault exec -it vault-0 -- sh 

vault login
vault auth enable kubernetes

vault write auth/kubernetes/config \
token_reviewer_jwt="$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)" \
kubernetes_host=https://${KUBERNETES_PORT_443_TCP_ADDR}:443 \
kubernetes_ca_cert=@/var/run/secrets/kubernetes.io/serviceaccount/ca.crt \
issuer="https://kubernetes.default.svc.cluster.local"
exit

#Windows
kind create cluster --name vault --image kindest/node:v1.17.0@sha256:9512edae126da271b66b990b6fff768fbb7cd786c7d39e86bdf55906352fdf62

#Linux
kind create cluster --name vault --kubeconfig ~/.kube/kind-vault --image kindest/node:v1.17.0@sha256:9512edae126da271b66b990b6fff768fbb7cd786c7d39e86bdf55906352fdf62

kubectl create ns vault-example
kubectl -n vault-example apply -f ./hashicorp/vault/server/
kubectl -n vault-example get pods

kubectl -n vault-example get pvc

kubectl -n vault-example exec -it vault-example-0 vault operator init
# unseal 3 times
kubectl -n vault-example exec -it vault-example-0 vault operator unseal
kubectl -n vault-example get pods

kubectl -n vault-example apply -f ./hashicorp/vault/injector/
kubectl -n vault-example get pods

kubectl -n vault-example exec -it vault-example-0 vault login
kubectl -n vault-example exec -it vault-example-0 vault auth enable kubernetes

kubectl -n vault-example exec -it vault-example-0 sh
vault write auth/kubernetes/config \
token_reviewer_jwt="$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)" \
kubernetes_host=https://${KUBERNETES_PORT_443_TCP_ADDR}:443 \
kubernetes_ca_cert=@/var/run/secrets/kubernetes.io/serviceaccount/ca.crt
exit

kubectl -n vault-example get pods

# deploy EFS storage driver
kubectl apply -k "github.com/kubernetes-sigs/aws-efs-csi-driver/deploy/kubernetes/overlays/stable/?ref=master"

# get VPC ID
aws eks describe-cluster --name getting-started-eks --query "cluster.resourcesVpcConfig.vpcId" --output text
# Get CIDR range
aws ec2 describe-vpcs --vpc-ids vpc-id --query "Vpcs[].CidrBlock" --output text

# security for our instances to access file storage
aws ec2 create-security-group --description efs-test-sg --group-name efs-sg --vpc-id VPC_ID
aws ec2 authorize-security-group-ingress --group-id sg-xxx  --protocol tcp --port 2049 --cidr VPC_CIDR

# create storage
aws efs create-file-system --creation-token eks-efs

# create mount point 
aws efs create-mount-target --file-system-id FileSystemId --subnet-id SubnetID --security-group GroupID

# grab our volume handle to update our PV YAML
aws efs describe-file-systems --query "FileSystems[*].FileSystemId" --output text

kubectl create ns jenkins

kubectl get storageclass

# create volume
kubectl apply -f ./jenkins/amazon-eks/jenkins.pv.yaml 
kubectl get pv

# create volume claim
kubectl apply -n jenkins -f ./jenkins/amazon-eks/jenkins.pvc.yaml
kubectl -n jenkins get pvc

# rbac
kubectl apply -n jenkins -f ./jenkins/jenkins.rbac.yaml 

kubectl apply -n jenkins -f ./jenkins/jenkins.deployment.yaml

kubectl -n jenkins get pods

kubectl apply -n jenkins -f ./jenkins/jenkins.service.yaml

kubectl -n jenkins exec -it <podname> cat /var/jenkins_home/secrets/initialAdminPassword
kubectl port-forward -n jenkins <podname> 8080

# setup user and recommended basic plugins
# let it continue while we move on!

eval $(ssh-agent)
ssh-add ~/.ssh/id_rsa
ssh -i ~/.ssh/id_rsa [email protected]
id -u docker
cat /etc/group
# Get user ID for docker
# Get group ID for docker

# you can build it

cd ./jenkins/dockerfiles/
docker build . -t aimvector/jenkins-slave

/* Detailed source-code truncated for AI context efficiency. */

cd kubernetes/affinity
kind create cluster --name demo --image kindest/node:v1.28.0 --config kind.yaml

kubectl get nodes
NAME                 STATUS   ROLES           AGE   VERSION
demo-control-plane   Ready    control-plane   59s   v1.28.0
demo-worker          Ready    <none>          36s   v1.28.0
demo-worker2         Ready    <none>          35s   v1.28.0
demo-worker3         Ready    <none>          35s   v1.28.0

kubectl apply -f node-affinity.yaml

kubectl get pods -owide 

#introduce more pods
kubectl scale deploy app-disk --replicas 10

#observe all pods on demo-worker

kubectl taint nodes demo-worker type=ssd:NoSchedule-
kubectl taint nodes demo-worker3 type=ssd:NoSchedule-

kubectl scale deploy app-disk --replicas 0
kubectl scale deploy app-disk --replicas 1

# pod should go back to demo-worker , node 1
kubectl get pods -owide

kubectl apply -f pod-affinity.yaml

# observe where pods get deployed
kubectl get pods -owide

kubectl scale deploy app-disk --replicas 3
kubectl scale deploy web-disk --replicas 3

podAntiAffinity:
  requiredDuringSchedulingIgnoredDuringExecution:
  - labelSelector:
      matchExpressions:
      - key: app
        operator: In
        values:
        - app-disk
    topologyKey: "kubernetes.io/hostname"

kubectl scale deploy app-disk --replicas 0
kubectl scale deploy web-disk --replicas 0
kubectl apply -f node-affinity.yaml
kubectl get pods -owide

kubectl scale deploy app-disk --replicas 2 #notice pending pods when scaling to 3
kubectl get pods -owide
kubectl scale deploy web-disk --replicas 2
kubectl get pods -owide

# azure example

NAME=aks-getting-started
RESOURCEGROUP=aks-getting-started
SERVICE_PRINCIPAL=
SERVICE_PRINCIPAL_SECRET=

az aks create -n $NAME \
--resource-group $RESOURCEGROUP \
--location australiaeast \
--kubernetes-version 1.16.10 \
--nodepool-name default \
--node-count 1 \
--node-vm-size Standard_F4s_v2  \
--node-osdisk-size 250 \
--service-principal $SERVICE_PRINCIPAL \
--client-secret $SERVICE_PRINCIPAL_SECRET \
--output none \
--enable-cluster-autoscaler \
--min-count 1 \
--max-count 5

kind create cluster --name hpa --image kindest/node:v1.18.4

- --kubelet-insecure-tls
- --kubelet-preferred-address-types="InternalIP"

cd kubernetes\autoscaling
kubectl -n kube-system apply -f .\components\metric-server\metricserver-0.3.7.yaml

#test 
kubectl -n kube-system get pods

#note: wait for metrics to populate!
kubectl top nodes

# build

cd kubernetes\autoscaling\components\application
docker build . -t aimvector/application-cpu:v1.0.0

# push
docker push aimvector/application-cpu:v1.0.0

# resource requirements
resources:
  requests:
    memory: "50Mi"
    cpu: "500m"
  limits:
    memory: "500Mi"
    cpu: "2000m"

# deploy 
kubectl apply -f deployment.yaml

# metrics
kubectl top pods

cd kubernetes\autoscaling\components\application
kubectl apply -f .\traffic-generator.yaml

# get a terminal to the traffic-generator
kubectl exec -it traffic-generator sh

# install wrk
apk add --no-cache wrk

# simulate some load
wrk -c 5 -t 5 -d 99999 -H "Connection: Close" http://application-cpu

#you can scale to pods manually and see roughly 6-7 pods will satisfy resource requests.
kubectl scale deploy/application-cpu --replicas 2

# scale the deployment back down to 2
kubectl scale deploy/application-cpu --replicas 2

# deploy the autoscaler
kubectl autoscale deploy/application-cpu --cpu-percent=95 --min=1 --max=10

# pods should scale to roughly 6-7 to match criteria of 95% of resource requests

kubectl get pods
kubectl top pods
kubectl get hpa/application-cpu  -owide

kubectl describe hpa/application-cpu

kind create cluster --name certmanager --image kindest/node:v1.34.0

#test cluster access:
kubectl get nodes
NAME                        STATUS   ROLES           AGE     VERSION
certmanager-control-plane   Ready    control-plane   4m25s   v1.34.0

# note: in the legacy video, we used kubectl to install cert-manager.
#       this is now upgraded to use helm instead using the new OCI repo

# install cert-manager 
CHART_VERSION="v1.19.2"

# checkout the values
helm show values oci://quay.io/jetstack/charts/cert-manager > kubernetes/cert-manager/default-values.yaml

helm install \
  cert-manager oci://quay.io/jetstack/charts/cert-manager \
  --version ${CHART_VERSION} \
  --namespace cert-manager \
  --create-namespace \
  --set crds.enabled=true \
  --set config.enableGatewayAPI=true

kubectl -n cert-manager get all
NAME                                           READY   STATUS    RESTARTS   AGE
pod/cert-manager-75bb65b7b9-qmjt5              1/1     Running   0          6m57s
pod/cert-manager-cainjector-5cd89979d6-bs6m8   1/1     Running   0          6m57s
pod/cert-manager-webhook-8fc5dcf5f-xn5pq       1/1     Running   0          6m57s

NAME                              TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)            AGE
service/cert-manager              ClusterIP   10.96.50.192    <none>        9402/TCP           6m57s
service/cert-manager-cainjector   ClusterIP   10.96.144.242   <none>        9402/TCP           6m57s
service/cert-manager-webhook      ClusterIP   10.96.223.22    <none>        443/TCP,9402/TCP   6m57s

NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/cert-manager              1/1     1            1           6m57s
deployment.apps/cert-manager-cainjector   1/1     1            1           6m57s
deployment.apps/cert-manager-webhook      1/1     1           1           6m57s

NAME                                                 DESIRED   CURRENT   READY   AGE
replicaset.apps/cert-manager-75bb65b7b9              1         1         1       6m57s
replicaset.apps/cert-manager-cainjector-5cd89979d6   1         1         1       6m57s
replicaset.apps/cert-manager-webhook-8fc5dcf5f       1         1         1       6m57s

kubectl create ns cert-manager-test

# create a self signed certificate
kubectl apply -f kubernetes/cert-manager/selfsigned/issuer.yaml
kubectl apply -f kubernetes/cert-manager/selfsigned/certificate.yaml

# see progress
kubectl describe certificate -n cert-manager-test
kubectl get secrets -n cert-manager-test

# cleanup
kubectl delete ns cert-manager-test

curl ifconfig.co

kubectl apply -f kubernetes/deployments/
kubectl apply -f kubernetes/services/

kubectl get pods

CHART_VERSION="37.3.0"
helm repo add traefik https://helm.traefik.io/traefik
helm repo update

helm show values traefik/traefik > kubernetes/cert-manager/traefik-default-values.yaml

helm install traefik traefik/traefik \
  --version $CHART_VERSION \
  --namespace traefik \
  --set service.type=NodePort \
  --set ports.web.exposedPort=30911 \
  --set ports.websecure.exposedPort=30787 \
  --create-namespace

# check install 
kubectl -n traefik get pods

# get our service IP
kubectl -n traefik get svc

# deploy an ingress route that needs TLS for our example app
kubectl apply -f kubernetes/cert-manager/ingress.yaml

# curl over HTTP 
curl http://test.marceldempers.dev

kubectl apply -f kubernetes/cert-manager/issuer-ingress.yaml

# check the issuer
kubectl describe clusterissuer letsencrypt-issuer

kubectl apply -f kubernetes/cert-manager/certificate.yaml

# check the cert issue status
kubectl describe certificate example-app

# you can track and diagnose the ordering request process
kubectl get CertificateRequest
#note:  you can use kubectl describe on the resource too

# TLS created as a secret
kubectl get secrets
NAME                  TYPE                                  DATA   AGE
secret-tls       kubernetes.io/tls                     2      1m

# test TLS 
curl https://test.marceldempers.dev
Hello World!

# cleanup
kubectl delete certificate example-app
kubectl delete clusterissuer letsencrypt-issuer
kubectl delete secret secret-tls

kubectl apply -f kubernetes/gateway-api/traefik/01-gatewayclass.yaml

kubectl apply -f kubernetes/gateway-api/traefik/02-gateway.yaml

kubectl apply -f kubernetes/cert-manager/issuer-gatewayapi.yaml

# check the issuer
kubectl describe clusterissuer letsencrypt-issuer

kubectl apply -f kubernetes/cert-manager/certificate.yaml

# check the cert issue status
kubectl describe certificate example-app

# you can track and diagnose the ordering request process
kubectl get CertificateRequest
#note:  you can use kubectl describe on the resource too

# TLS created as a secret
kubectl get secrets
NAME                  TYPE                                  DATA   AGE
secret-tls       kubernetes.io/tls                     2      1m

# test TLS 
kubectl apply -f kubernetes/cert-manager/httproute.yaml
curl https://test.marceldempers.dev
Hello World!

# cleanup
kubectl delete certificate example-app
kubectl delete clusterissuer letsencrypt-issuer
kubectl delete secret secret-tls

kind create cluster --name demo --image kindest/node:v1.33.1

kubectl get nodes
NAME                 STATUS   ROLES           AGE   VERSION
demo-control-plane   Ready    control-plane   19m   v1.33.1

kubectl apply -f kubernetes/configmaps/configmap.yaml

kubectl apply -f kubernetes/configmaps/deployment.yaml

kubectl describe deploy example-deploy

kubectl exec -it <pod-name> -- bash

kind create cluster --name crossplane --image kindest/node:v1.33.0

helm repo add crossplane-stable https://charts.crossplane.io/stable
helm repo update

helm search repo crossplane-stable --versions

VERSION=1.19.1

helm install crossplane \
crossplane-stable/crossplane \
--namespace crossplane-system \
--version $VERSION \
--create-namespace

kubectl get pods -n crossplane-system
kubectl get deployments -n crossplane-system

kubectl api-versions  | grep crossplane

kubectl api-resources | grep crossplane

kubectl apply -f kubernetes/crossplane/provider-azure.yaml

kubectl get provider
kubectl describe provider provider-family-azure

SUBSCRIPTION_ID=<subscription-id>
RESOURCE_GROUP=marcel-test

az account set -s $SUBSCRIPTION_ID
az group create -n $RESOURCE_GROUP -l australiaeast
az ad sp create-for-rbac --sdk-auth  \
-n marcel-test \
--role Contributor \
--scopes "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP" > azure-credentials.json

kubectl create secret \
generic azure-secret \
-n crossplane-system \
--from-file=creds=./azure-credentials.json

kubectl apply -f kubernetes/crossplane/providerconfig-azure.yaml

kubectl apply -f kubernetes/crossplane/resources/azure/resource-vnet.yaml

error: resource mapping not found for name: "marcel-test-vnet" namespace: "" from "kubernetes/crossplane/resources/azure/resource-vnet.yaml": no matches for kind "VirtualNetwork" in version "network.azure.upbound.io/v1beta1"
ensure CRDs are installed first

kubectl apply -f kubernetes/crossplane/provider-azure-network.yaml

kubectl apply -f kubernetes/crossplane/resources/azure/resource-vnet.yaml
kubectl get virtualnetwork

kubectl apply -f kubernetes/crossplane/resources/azure/resource-subnet.yaml
kubectl get subnet

kubectl apply -f kubernetes/crossplane/resources/azure/resource-networkcard.yaml
kubectl get networkinterface

kubectl apply -f kubernetes/crossplane/provider-azure-compute.yaml

kubectl apply -f kubernetes/crossplane/resources/azure/resource-virtualmachine.yaml

kubectl delete linuxvirtualmachine marcel-test
kubectl delete networkinterface marcel-test
kubectl delete subnet marcel-test
kubectl delete virtualnetwork marcel-test

cd kubernetes/daemonsets
kind create cluster --name daemonsets --image kindest/node:v1.20.2 --config kind.yaml

kubectl get nodes
NAME                       STATUS     ROLES                  AGE   VERSION
daemonsets-control-plane   Ready      control-plane,master   65s   v1.20.2
daemonsets-worker          Ready      <none>                 31s   v1.20.2
daemonsets-worker2         Ready      <none>                 31s   v1.20.2
daemonsets-worker3         NotReady   <none>                 31s   v1.20.2

kubectl apply -f daemonset.yaml

kubectl get pods -o wide
NAME                      READY   STATUS    RESTARTS   AGE     IP           NODE                       NOMINATED NODE   READINESS GATES
example-daemonset-8lcr5   1/1     Running   0          3m21s   10.244.2.4   daemonsets-worker          <none>           <none>
example-daemonset-9jhgx   1/1     Running   0          81s     10.244.3.4   daemonsets-worker2         <none>           <none>
example-daemonset-lvvsd   1/1     Running   0          2m41s   10.244.1.4   daemonsets-worker3         <none>           <none>
example-daemonset-xxcv9   1/1     Running   0          119s    10.244.0.7   daemonsets-control-plane   <none>           <none>

kubectl logs <example-daemonset-xxxx>

kubectl delete ds example-daemonset

kubectl apply -f daemonset-communication.yaml
kubectl get pods

kubectl apply -f pod.yaml

kubectl exec -it pod -- bash

kubectl apply -f ./services/clusterip-service.yaml

while true; do curl http://daemonset-svc-clusterip; sleep 1s; done
Hello from daemonsets-worker2
Hello from daemonsets-control-plane
Hello from daemonsets-worker2
Hello from daemonsets-worker3
Hello from daemonsets-worker
Hello from daemonsets-worker

ports:
- containerPort: 80
  hostPort: 80
  name: "http"

# get the node ips
kubectl get nodes -owide

NAME                       STATUS   ROLES                  AGE    VERSION   INTERNAL-IP   EXTERNAL-IP       KERNEL-VERSION                CONTAINER-RUNTIME
daemonsets-control-plane   Ready    control-plane,master   112m   v1.20.2   172.18.0.4    <none>
daemonsets-worker          Ready    <none>                 111m   v1.20.2   172.18.0.3    <none>
daemonsets-worker2         Ready    <none>                 111m   v1.20.2   172.18.0.2    <none>
daemonsets-worker3         Ready    <none>                 111m   v1.20.2   172.18.0.6    <none>

#example:

bash-5.1# curl http://172.18.0.4:80
Hello from daemonsets-control-plane
bash-5.1# curl http://172.18.0.2:80
Hello from daemonsets-worker2

kubectl apply -f ./services/headless-service.yaml

apk add --no-cache bind-tools
dig daemonset-svc-headless.default.svc.cluster.local

;; ANSWER SECTION:
daemonset-svc-headless.default.svc.cluster.local. 30 IN A 10.244.0.5
daemonset-svc-headless.default.svc.cluster.local. 30 IN A 10.244.2.2
daemonset-svc-headless.default.svc.cluster.local. 30 IN A 10.244.3.2
daemonset-svc-headless.default.svc.cluster.local. 30 IN A 10.244.1.2

kubectl describe endpoints daemonset-svc-headless

Addresses:          10.244.0.5,10.244.1.2,10.244.2.2,10.244.3.2

#examples:

10-244-0-5.default.pod.cluster.local
10-244-1-2.default.pod.cluster.local
10-244-2-2.default.pod.cluster.local
10-244-3-2.default.pod.cluster.local

curl http://10-244-0-5.default.pod.cluster.local
Hello from daemonsets-control-plane

git clone https://github.com/prometheus-operator/kube-prometheus.git

git checkout v0.8.0

cd .\manifests\
kubectl create -f .\setup\

kubectl create -f .

# wait for pods to be up
kubectl get pods -n monitoring

#access prometheus in the browser
kubectl -n monitoring port-forward svc/prometheus-k8s 9090

docker run -it -v ${PWD}:/work -v ${HOME}/.kube/:/root/.kube/ -w /work --net host alpine sh

apk add curl unzip bash sudo

curl https://get.datree.io | /bin/bash

curl -L https://github.com/datreeio/datree/releases/download/1.5.20/datree-cli_1.5.20_Linux_x86_64.zip -o /tmp/datree.zip

unzip /tmp/datree.zip -d /tmp && \
chmod +x /tmp/datree && \
mv /tmp/datree /usr/local/bin/datree

datree
Datree is a static code analysis tool for kubernetes files. Full code can be found at https://github.com/datreeio/datree

Usage:
  datree [command]

Available Commands:
  completion       Generate completion script for bash,zsh,fish,powershell
  config           Configuration management
  help             Help about any command
  kustomize        Render resources defined in a kustomization.yaml file and run a policy check against them
  publish          Publish policies configuration for given <fileName>.
  test             Execute static analysis for given <pattern>
  version          Print the version number

Flags:
  -h, --help   help for datree

Use "datree [command] --help" for more information about a command.

datree test ./kubernetes/datree/example/deployment.yaml

datree test ./kubernetes/datree/example/deployment.yaml

datree test ./kubernetes/services/service.yaml
datree test ./kubernetes/configmaps/configmap.yaml
datree test ./kubernetes/statefulsets/statefulset.yaml
datree test ./kubernetes/ingress/ingress.yaml

datree test --schema-version 1.14.0 ./kubernetes/ingress/ingress-nginx-example.yaml
datree test --schema-version 1.19.0 ./kubernetes/ingress/ingress-nginx-example.yaml

datree test kubernetes/tutorials/basics/yaml/*.y*ml

(Summary)

- Passing YAML validation: 4/4

- Passing Kubernetes (1.20.0) schema validation: 4/4

- Passing policy check: 2/4

+-----------------------------------+------------------------------------------------------+
| Enabled rules in policy "Default" | 21                                                   |
| Configs tested against policy     | 5                                                    |
| Total rules evaluated             | 84                                                   |
| Total rules skipped               | 0                                                    |
| Total rules failed                | 14                                                   |
| Total rules passed                | 70                                                   |
| See all rules in policy           | https://app.datree.io/login?t=xxxxxxxxxxxxxxxxxxxxxx |
+-----------------------------------+------------------------------------------------------+

datree test kubernetes/datree/example/deployment.yaml -p production

apk add tar git
curl -L https://get.helm.sh/helm-v3.5.4-linux-amd64.tar.gz -o /tmp/helm.tar.gz && \
tar -xzf /tmp/helm.tar.gz -C /tmp && \
chmod +x /tmp/linux-amd64/helm && \
mv /tmp/linux-amd64/helm /usr/local/bin/helm

helm plugin install https://github.com/datreeio/helm-datree

cd kubernetes/helm

helm datree test example-app \
-- --values ./example-app/example-app-01.values.yaml

datree kustomize test .\kubernetes\kustomize\application\

kind create cluster --name datree --image kindest/node:v1.23.6

curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.23.6/bin/linux/amd64/kubectl
chmod +x ./kubectl
mv ./kubectl /usr/local/bin/kubectl

export DATREE_TOKEN=[your-token]

apk add openssl

curl -L https://get.datree.io/admission-webhook -o datree.sh
chmod +x datree.sh
bash datree.sh

kubectl apply -f kubernetes/datree/example/deployment.yaml

/* Detailed source-code truncated for AI context efficiency. */

kubectl create ns examples

kubectl apply -n examples -f kubernetes/datree/example/deployment.yaml
deployment.apps/example-deploy created

curl -L https://github.com/datreeio/kubectl-datree/releases/download/v0.1.1/manual_install.sh -o /tmp/kubectl-plugin.sh
chmod +x /tmp/kubectl-plugin.sh
bash /tmp/kubectl-plugin.sh

kubectl datree test -- --namespace examples
Fetching resources, this may take some time depending on the amount of resources in your cluster...

(Summary)

- Passing YAML validation: 1/1

- Passing Kubernetes (1.24.2) schema validation: 1/1

- Passing policy check: 1/1

+-----------------------------------+------------------------------------------------------+
| Enabled rules in policy "Default" | 21                                                   |
| Configs tested against policy     | 1                                                    |
| Total rules evaluated             | 21                                                   |
| Total rules skipped               | 0                                                    |
| Total rules failed                | 0                                                    |
| Total rules passed                | 21                                                   |
| See all rules in policy           | https://app.datree.io/login?t=xxxxxxxxxxxxxxxxxxxxxx |
+-----------------------------------+------------------------------------------------------+

The following cluster resources in namespace 'examples' were checked:

deployment.apps/example-deploy

#   Important!
#   make sure you are at root of the repository
#   in your terminal

#   you can choose which app you want to build!


#   aimvector/golang:1.0.0
docker-compose build golang


#   aimvector/csharp:1.0.0
docker-compose build csharp

#   aimvector/nodejs:1.0.0
docker-compose build nodejs

#   aimvector/python:1.0.0
docker-compose build python

kind create cluster --name fluxcd --image kindest/node:v1.26.3

docker run -it --rm -v ${HOME}:/root/ -v ${PWD}:/work -w /work --net host alpine sh

# install curl 
apk add --no-cache curl

# install kubectl 
curl -sLO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
chmod +x ./kubectl
mv ./kubectl /usr/local/bin/kubectl

/work # kubectl get nodes
NAME                    STATUS   ROLES    AGE   VERSION
fluxcd-control-plane   Ready    control-plane   54s   v1.26.3

curl -o /tmp/flux.tar.gz -sLO https://github.com/fluxcd/flux2/releases/download/v2.1.1/flux_2.1.1_linux_amd64.tar.gz
tar -C /tmp/ -zxvf /tmp/flux.tar.gz
mv /tmp/flux /usr/local/bin/flux
chmod +x /usr/local/bin/flux

flux check --pre

export GITHUB_TOKEN=<your-token>

flux bootstrap github \
  --token-auth \
  --owner=marcel-dempers \
  --repository=docker-development-youtube-series \
  --path=kubernetes/fluxcd/repositories/infra-repo/clusters/dev-cluster \
  --personal \
  --branch fluxcd-2022

flux check

# flux manages itself using GitOps objects:
kubectl -n flux-system get GitRepository
kubectl -n flux-system get Kustomization

git pull origin <branch-name>

developer    +-----------+     +----------+           
              |           |     | CI       |           
  ----------> | REPO(code)|---> | PIPELINE |           
              +-----------+     +----------+           
                                         |  commit     
                                         v             
           +----------+ sync    +----------+           
           |  INFRA   |-------> |INFRA     |           
           |  (k8s)   |         |REPO(yaml)|           
           +----------+         +----------+

- repositories
  - infra-repo
  - example-app-1
  - example-app-2

# go to our "git repo"
cd kubernetes/fluxcd/repositories/example-app-1
# check the files
ls

cd src
docker build . -t example-app-1:0.0.1

#load the image to our test cluster so we dont need to push to a registry
kind load docker-image example-app-1:0.0.1 --name fluxcd

cd kubernetes/fluxcd

# tell flux where our Git repo is and where the YAML is
# this is once off
# flux will monitor the example-app-1 Git repo for when any infrastructure changes, it will sync
kubectl -n default apply -f repositories/infra-repo/apps/example-app-1/gitrepository.yaml
kubectl -n default apply -f repositories/infra-repo/apps/example-app-1/kustomization.yaml

# check our flux resources 
kubectl -n default describe gitrepository example-app-1
kubectl -n default describe kustomization example-app-1

# check deployed resources
kubectl get all

kubectl port-forward svc/example-app-1 80:80

docker build . -t example-app-1:0.0.2

#load the image to our test cluster so we dont need to push to a registry
kind load docker-image example-app-1:0.0.2 --name fluxcd 

# update our kubernetes deployment YAML image tag
# git commit with [skip ci] as the prefix of commit message & git push to branch!

docker push                   
                                                                            
        developer    +-----------+     +----------+       +-------------+   
                     |           |     | CI       |       |IMAGE        |   
         ----------> | REPO(code)|---> | PIPELINE | ----->|REGISTRY     |   
                     +-----------+     +----------+       +-------------+   
                                                           ^                
                                                           |sync            
                                                           |                
                                   +----------+  commit   +----------+      
                                   |INFRA     | <-------- |  INFRA   |      
                                   |REPO(yaml)|           |  (k8s)   |      
                                   +----------+           +----------+

flux bootstrap github \
  --token-auth \
  --owner=marcel-dempers \
  --repository=docker-development-youtube-series \
  --path=kubernetes/fluxcd/repositories/infra-repo/clusters/dev-cluster \
  --components-extra=image-reflector-controller,image-automation-controller \
  --personal \
  --branch fluxcd-2022

kubectl -n default create secret docker-registry dockerhub-credential --docker-username '' --docker-password '' --docker-email '[email protected]'

cd kubernetes\fluxcd\repositories\example-app-2\
ls
cd src
ls
docker build . -t aimvector/example-app-2:0.0.1
docker push aimvector/example-app-2:0.0.1

kubectl -n default apply -f kubernetes/fluxcd/repositories/infra-repo/apps/example-app-2/gitrepository.yaml
kubectl -n default apply -f kubernetes/fluxcd/repositories/infra-repo/apps/example-app-2/kustomization.yaml

# see our application 
kubectl get deploy
kubectl get pods

# tell flux about our image update policy
kubectl -n default apply -f kubernetes/fluxcd/repositories/infra-repo/apps/example-app-2/imagerepository.yaml
kubectl -n default apply -f kubernetes/fluxcd/repositories/infra-repo/apps/example-app-2/imagepolicy.yaml
kubectl -n default apply -f kubernetes/fluxcd/repositories/infra-repo/apps/example-app-2/imageupdateautomation.yaml

# we will also need to provide authentication for our git repo
flux create secret git example-app-2-github --url https://github.com/marcel-dempers/docker-development-youtube-series --username '' --password '' --namespace default

kubectl describe imagepolicy example-app-2
kubectl describe  imagerepository example-app-2
kubectl describe imageupdateautomation example-app-2

#make application changes and rebuild + push

docker build . -t aimvector/example-app-2:0.0.2
docker push aimvector/example-app-2:0.0.2


#see changes new tags
kubectl describe imagerepository

#see image being updated
kubectl describe imagepolicy example-app-2

# see flux commiting back to the repo
kubectl describe imageupdateautomation example-app-2

fluxctl

kubectl config current-context
kubectl get nodes

kubectl create ns flux

$GHUSER = "marcel-dempers"
fluxctl install `
--git-user=${GHUSER} `
--git-email=${GHUSER}@users.noreply.github.com `
[email protected]:${GHUSER}/docker-development-youtube-series `
--git-path=kubernetes/configmaps,kubernetes/secrets,kubernetes/deployments `
--git-branch=flux-test `
--namespace=flux | kubectl apply -f -

kubectl -n flux rollout status deployment/flux

$env:FLUX_FORWARD_NAMESPACE = "flux"
fluxctl list-workloads
fluxctl identity


https://github.com/marcel-dempers/docker-development-youtube-series/settings/keys/new

fluxctl sync

  annotations:
    fluxcd.io/tag.example-app: semver:~1.0
    fluxcd.io/automated: 'true'

fluxctl policy -w default:deployment/example-deploy --tag "example-app=1.0.*"

kind create cluster --name gatewayapi --image kindest/node:v1.34.0

kubectl get nodes
NAME                       STATUS   ROLES           AGE   VERSION
gatewayapi-control-plane   Ready    control-plane   40s   v1.34.0

kubectl apply --server-side -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.4.1/standard-install.yaml

# deploy example apps
kubectl apply -f python/deployment.yaml 
kubectl apply -f golang/deployment.yaml
kubectl apply -f kubernetes/gateway-api/web-app.yaml

# check example apps
kubectl get pods
NAME                             READY   STATUS    RESTARTS
go-deploy-b9c69978d-529qb        1/1     Running   0
go-deploy-b9c69978d-jfb2b        1/1     Running   0
python-deploy-54cbfc948b-5ch7w   1/1     Running   0
python-deploy-54cbfc948b-qh22f   1/1     Running   0
web-app-67fbb5d844-68wq4         1/1     Running   0

kubectl get service
NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)
go-svc       ClusterIP   10.96.173.22   <none>        5000/TCP
python-svc   ClusterIP   10.96.113.49   <none>        5000/TCP
web-app      ClusterIP   10.96.44.18    <none>        80/TCP

127.0.0.1  example-app.com
127.0.0.1  example-app-go.com
127.0.0.1  example-app-python.com

CHART_VERSION="37.3.0" # traefik version v3.6.0
helm repo add traefik https://helm.traefik.io/traefik
helm repo update
helm search repo traefik --versions


helm install traefik traefik/traefik \
  --version $CHART_VERSION \
  --values kubernetes/gateway-api/values.yaml \
  --namespace traefik \
  --create-namespace

# check the pods
kubectl -n traefik get pods 

# check the logs 
kubectl -n traefik logs -l app.kubernetes.io/instance=traefik-traefik

# port forward for access
kubectl -n traefik port-forward svc/traefik 80

kubectl apply -f kubernetes/gateway-api/traefik/01-gatewayclass.yaml

# check
kubectl get gatewayclass

# describe
kubectl describe gatewayclass

kubectl apply -f kubernetes/gateway-api/traefik/02-gateway.yaml

kubectl apply -f kubernetes/gateway-api/03-httproute-by-hostname.yaml

kubectl apply -f kubernetes/gateway-api/04-httproute-by-path-exact.yaml

kubectl apply -f kubernetes/gateway-api/05-httproute-by-path-rewrite.yaml

kubectl port-forward svc/web-app 8000:80

kubectl apply -f kubernetes/gateway-api/06-httproute-header-modify.yaml

curl -L https://github.com/FiloSottile/mkcert/releases/download/v1.4.4/mkcert-v1.4.4-linux-amd64 -o mkcert && chmod +x mkcert && mv mkcert /usr/local/bin/

#linux
export CAROOT=${PWD}/kubernetes/gateway-api/tls
#windows
$env:CAROOT = "${PWD}" + "\kubernetes\gateway-api\tls"

mkcert -key-file kubernetes/gateway-api/tls/key.pem -cert-file kubernetes/gateway-api/tls/cert.pem example-app.com

mkcert -install

kubectl create secret tls secret-tls -n default --cert kubernetes/gateway-api/tls/cert.pem --key kubernetes/gateway-api/tls/key.pem

kubectl apply -f kubernetes/gateway-api/07-httproute-tls.yaml

kubectl -n traefik port-forward svc/traefik 443

kind create cluster --name helm --image kindest/node:v1.31.1

docker run -it --rm -v ${HOME}:/root/ -v ${PWD}:/work -w /work --net host alpine sh

# install curl & kubectl
apk add --no-cache curl nano
curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
chmod +x ./kubectl
mv ./kubectl /usr/local/bin/kubectl
export KUBE_EDITOR="nano"

# test cluster access:
/work # kubectl get nodes
NAME                    STATUS   ROLES    AGE   VERSION
helm-control-plane   Ready    control-plane   26m   v1.31.1

curl -LO https://get.helm.sh/helm-v3.17.2-linux-amd64.tar.gz
tar -C /tmp/ -zxvf helm-v3.17.2-linux-amd64.tar.gz
rm helm-v3.17.2-linux-amd64.tar.gz
mv /tmp/linux-amd64/helm /usr/local/bin/helm
chmod +x /usr/local/bin/helm

cd kubernetes/helm

mkdir temp && cd temp
helm create example-app

helm template example-app example-app

helm install example-app example-app

# list our releases

helm list

# see our deployed components

kubectl get all
kubectl get cm
kubectl get secret

# values.yaml

deployment:
  image: "aimvector/python"
  tag: "1.0.4"

# deployment.yaml

image: {{ .Values.deployment.image }}:{{ .Values.deployment.tag }}

# upgrade our release

helm upgrade example-app example-app --values ./example-app/values.yaml

# see revision increased

helm list

helm install example-app-02 example-app --values ./example-app/example-app-02.values.yaml

# deployment.yaml

kind: Deployment
spec:
  template:
    metadata:
      annotations:
        checksum/config: {{ include (print $.Template.BasePath "/configmap.yaml") . | sha256sum }}

# rollout the change

helm upgrade example-app example-app --values ./example-app/example-app-01.values.yaml

{{- if .Values.deployment.resources }}
  resources:
    {{- if .Values.deployment.resources.requests }}
    requests:
      memory: {{ .Values.deployment.resources.requests.memory | default "50Mi" | quote }}
      cpu: {{ .Values.deployment.resources.requests.cpu | default "10m" | quote }}
    {{- else}}
    requests:
      memory: "50Mi"
      cpu: "10m"
    {{- end}}
    {{- if .Values.deployment.resources.limits }}
    limits:
      memory: {{ .Values.deployment.resources.limits.memory | default "1024Mi" | quote }}
      cpu: {{ .Values.deployment.resources.limits.cpu | default "1" | quote }}
    {{- else}}  
    limits:
      memory: "1024Mi"
      cpu: "1"
    {{- end }}
  {{- else }}
  resources:
    requests:
      memory: "50Mi"
      cpu: "10m"
    limits:
      memory: "1024Mi"
      cpu: "1"
  {{- end}} 


# rollout the change

helm upgrade example-app example-app --values ./example-app/example-app-01.values.yaml

kind create cluster --name dev --image kindest/node:v1.23.5
kind create cluster --name prod --image kindest/node:v1.23.5

kubectl get nodes
NAME                  STATUS   ROLES                  AGE     VERSION
prod-control-plane   Ready    control-plane,master   2m12s   v1.23.5

kind: Config
apiVersion: v1
clusters:
 - list of clusters (addresses \ endpoints) 
users:
 - list of users (thing that identifies us when accessing a cluster [certificate]) 
contexts:
 - list of contexts ( which user and cluster to use when running commands)

kubectl config current-context
kubectl config get-contexts
kubectl config use-context <name>

#linux
export KUBECONFIG=<path>

#windows 
$ENV:KUBECONFIG="C:\Users\aimve\.kube\config"

kind --name dev export kubeconfig --kubeconfig C:\Users\aimve\.kube\dev-config 

kind --name prod export kubeconfig --kubeconfig C:\Users\aimve\.kube\prod-config 

#switch to prod
$ENV:KUBECONFIG="C:\Users\aimve\.kube\prod-config"
kubectl get nodes

kubectl get namespaces

kubectl get <resource>

kubectl get pods
kubectl get deployments
kubectl get services
kubectl get configmaps
kubectl get secrets
kubectl get ingress

kubectl create ns example-apps

kubectl -n example-apps create deployment webserver --image=nginx --port=80
kubectl -n example-apps get deploy
kubectl -n example-apps get pods

kubectl -n example-apps create service clusterip webserver --tcp 80:80
kubectl -n example-apps get service
kubectl -n example-apps port-forward svc/webserver 80
# we can access http://localhost/

kubectl -n example-apps create configmap webserver-config --from-file config.json=./kubernetes/kubectl/config.json
kubectl -n example-apps get cm

kubectl -n example-apps create secret generic webserver-secret --from-file secret.json=./kubernetes/kubectl/secret.json
kubectl -n example-apps get secret

kubectl -n example-apps get cm webserver-config -o yaml > .\kubernetes\kubectl\yaml\config.yaml
kubectl -n example-apps get secret webserver-secret -o yaml > .\kubernetes\kubectl\yaml\secret.yaml
kubectl -n example-apps get deploy webserver -o yaml > .\kubernetes\kubectl\yaml\deployment.yaml
kubectl -n example-apps get svc webserver -o yaml > .\kubernetes\kubectl\yaml\service.yaml

kubectl create ns wordpress-site
kubectl -n wordpress-site apply -f ./kubernetes/tutorials/basics/yaml/

kubectl -n wordpress-site get svc

NAME        TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)    AGE
mysql       ClusterIP   10.96.146.75   <none>        3306/TCP   17s
wordpress   ClusterIP   10.96.157.6    <none>        80/TCP     17s

kubectl -n wordpress-site port-forward svc/wordpress 80

kind delete cluster --name dev
kind delete cluster --name prod

kubectl apply -f kubernetes/kustomize/application/namespace.yaml
kubectl apply -f kubernetes/kustomize/application/configmap.yaml
kubectl apply -f kubernetes/kustomize/application/deployment.yaml
kubectl apply -f kubernetes/kustomize/application/service.yaml

# OR 

kubectl apply -f kubernetes/kustomize/application/

kubectl delete ns example

kubectl kustomize .\kubernetes\kustomize\ | kubectl apply -f -
# OR
kubectl apply -k .\kubernetes\kustomize\

kubectl delete ns example

kubectl kustomize .\kubernetes\kustomize\environments\production | kubectl apply -f -
# OR
kubectl apply -k .\kubernetes\kustomize\environments\production

kubectl delete ns example

# run postgres
docker run -d --rm -e POSTGRES_DB=postgresdb -e POSTGRES_USER=admin -e POSTGRES_PASSWORD=admin123 postgres:10.4

# enter the container 
docker exec -it <container-id> bash

# login to postgres
psql --username=admin postgresdb

#create a table
CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

#show table
\dt

# quit 
\q

cd .\kubernetes\persistentvolume\

kubectl create ns postgres
kubectl apply -n postgres -f ./postgres-no-pv.yaml
kubectl -n postgres get pods 
kubectl -n postgres exec -it postgres-0 bash

# run the same above mentioned commands to create and list the database table

kubectl delete po -n postgres postgres-0

# exec back in and confirm table does not exist.

docker volume create postges
docker run -d --rm -v postges:/var/lib/postgresql/data -e POSTGRES_DB=postgresdb -e POSTGRES_USER=admin -e POSTGRES_PASSWORD=admin123 postgres:10.4

# run the same tests as above and notice

kubectl apply -f persistentvolume.yaml
kubectl apply -n postgres -f persistentvolumeclaim.yaml

kubectl apply -n postgres -f postgres-with-pv.yaml

kubectl -n postgres get pods

cd kubernetes\portainer
mkdir volume-ce 

docker run -d -p 9443:9443 -p 8000:8000 --name portainer-ce `
--restart=always `
-v /var/run/docker.sock:/var/run/docker.sock `
-v ${PWD}/volume-ce:/data `
portainer/portainer-ce:2.11.1

kind create cluster --name local --config kind.yaml

kubectl apply -f portainer-agent-ce211-k8s-nodeport.yaml

kubectl -n portainer get pods

kubectl -n portainer get svc

kubectl -n portainer get pods

https://kubernetes.github.io/ingress-nginx

https://github.com/marcel-dempers/docker-development-youtube-series

cd kubernetes/probes
kind create cluster --name demo --image kindest/node:v1.28.0

kubectl get nodes
NAME                 STATUS   ROLES           AGE   VERSION
demo-control-plane   Ready    control-plane   59s   v1.28.0

kubectl apply -f client.yaml

kubectl apply -f server.yaml

while true; do curl http://server; sleep 1s; done

readinessProbe:
  httpGet:
    path: /
    port: 5000
  initialDelaySeconds: 3
  periodSeconds: 3
  failureThreshold: 3

kubectl exec -it podname -- sh -c "rm /data.txt"

kubectl scale deploy server --replicas 2

kubectl exec -it podname -- sh -c "rm /data.txt"

livenessProbe:
  httpGet:
    path: /
    port: 5000
  initialDelaySeconds: 3
  periodSeconds: 4
  failureThreshold: 8

# get our network adapter where all virtual machines will run on
# grab the name we want to use
Get-NetAdapter

Import-Module Hyper-V
$ethernet = Get-NetAdapter -Name "Ethernet 2"
New-VMSwitch -Name "virtual-network" -NetAdapterName $ethernet.Name -AllowManagementOS $true -Notes "shared virtual network interface"

mkdir c:\temp\vms\linux-0\
mkdir c:\temp\vms\linux-1\
mkdir c:\temp\vms\linux-2\

New-VHD -Path c:\temp\vms\linux-0\linux-0.vhdx -SizeBytes 20GB
New-VHD -Path c:\temp\vms\linux-1\linux-1.vhdx -SizeBytes 20GB
New-VHD -Path c:\temp\vms\linux-2\linux-2.vhdx -SizeBytes 20GB

New-VM `
-Name "linux-0" `
-Generation 1 `
-MemoryStartupBytes 2048MB `
-SwitchName "virtual-network" `
-VHDPath "c:\temp\vms\linux-0\linux-0.vhdx" `
-Path "c:\temp\vms\linux-0\"

New-VM `
-Name "linux-1" `
-Generation 1 `
-MemoryStartupBytes 2048MB `
-SwitchName "virtual-network" `
-VHDPath "c:\temp\vms\linux-1\linux-1.vhdx" `
-Path "c:\temp\vms\linux-1\"

New-VM `
-Name "linux-2" `
-Generation 1 `
-MemoryStartupBytes 2048MB `
-SwitchName "virtual-network" `
-VHDPath "c:\temp\vms\linux-2\linux-2.vhdx" `
-Path "c:\temp\vms\linux-2\"

Set-VMDvdDrive -VMName "linux-0" -ControllerNumber 1 -Path "C:\temp\ubuntu-20.04.3-live-server-amd64.iso"
Set-VMDvdDrive -VMName "linux-1" -ControllerNumber 1 -Path "C:\temp\ubuntu-20.04.3-live-server-amd64.iso"
Set-VMDvdDrive -VMName "linux-2" -ControllerNumber 1 -Path "C:\temp\ubuntu-20.04.3-live-server-amd64.iso"

Start-VM -Name "linux-0"
Start-VM -Name "linux-1"
Start-VM -Name "linux-2"

sudo apt update
sudo apt install -y nano net-tools openssh-server
sudo systemctl enable ssh
sudo ufw allow ssh
sudo systemctl start ssh

sudo ifconfig
# record eth0
linux-0 IP=192.168.0.16
linux-1 IP=192.168.0.17
linux-2 IP=192.168.0.18

ssh [email protected]
ssh [email protected]
ssh [email protected]

curl -sSL https://get.docker.com/ | sh
sudo usermod -aG docker $(whoami)
sudo service docker start

cd kubernetes/rancher
mkdir volume

docker run -d --name rancher-server  -v ${PWD}/volume:/var/lib/rancher --restart=unless-stopped -p 80:80 -p 443:443 --privileged rancher/rancher

docker logs rancher-server > rancher.log

ipconfig

$ENV:KUBECONFIG="<path-to-kubeconfig>"

kubectl create ns marcel
kubectl -n marcel apply -f .\kubernetes\configmaps\configmap.yaml
kubectl -n marcel apply -f .\kubernetes\secrets\secret.yaml
kubectl -n marcel apply -f .\kubernetes\deployments\deployment.yaml
kubectl -n marcel apply -f .\kubernetes\services\service.yaml

kubectl -n marcel get svc 
NAME              TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
example-service   LoadBalancer   10.43.235.240   <pending>     80:31310/TCP   13s

kubectl -n marcel port-forward svc/example-service 81:80

kind create cluster --name rbac --image kindest/node:v1.20.2

docker exec -it rbac-control-plane bash

ls -l /etc/kubernetes/pki
total 60
-rw-r--r-- 1 root root 1135 Sep 10 01:38 apiserver-etcd-client.crt
-rw------- 1 root root 1675 Sep 10 01:38 apiserver-etcd-client.key
-rw-r--r-- 1 root root 1143 Sep 10 01:38 apiserver-kubelet-client.crt
-rw------- 1 root root 1679 Sep 10 01:38 apiserver-kubelet-client.key
-rw-r--r-- 1 root root 1306 Sep 10 01:38 apiserver.crt
-rw------- 1 root root 1675 Sep 10 01:38 apiserver.key
-rw-r--r-- 1 root root 1066 Sep 10 01:38 ca.crt
-rw------- 1 root root 1675 Sep 10 01:38 ca.key
drwxr-xr-x 2 root root 4096 Sep 10 01:38 etcd
-rw-r--r-- 1 root root 1078 Sep 10 01:38 front-proxy-ca.crt
-rw------- 1 root root 1679 Sep 10 01:38 front-proxy-ca.key
-rw-r--r-- 1 root root 1103 Sep 10 01:38 front-proxy-client.crt
-rw------- 1 root root 1675 Sep 10 01:38 front-proxy-client.key
-rw------- 1 root root 1679 Sep 10 01:38 sa.key
-rw------- 1 root root  451 Sep 10 01:38 sa.pub

exit the container

cd kubernetes/rbac
docker cp rbac-control-plane:/etc/kubernetes/pki/ca.crt ca.crt
docker cp rbac-control-plane:/etc/kubernetes/pki/ca.key ca.key

docker run -it -v ${PWD}:/work -w /work -v ${HOME}:/root/ --net host alpine sh

apk add openssl

#start with a private key
openssl genrsa -out bob.key 2048

openssl req -new -key bob.key -out bob.csr -subj "/CN=Bob Smith/O=Shopping"

openssl x509 -req -in bob.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out bob.crt -days 1

apk add curl nano
curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
chmod +x ./kubectl
mv ./kubectl /usr/local/bin/kubectl

export KUBECONFIG=~/.kube/new-config

kubectl config set-cluster dev-cluster --server=https://127.0.0.1:52807 \
--certificate-authority=ca.crt \
--embed-certs=true

#see changes 
nano ~/.kube/new-config

cd kubernetes/rbac
kubectl create ns shopping

kubectl -n shopping apply -f .\role.yaml
kubectl -n shopping apply -f .\rolebinding.yaml

kubectl -n shopping apply -f serviceaccount.yaml

kubectl -n shopping apply -f pod.yaml

kubectl -n shopping exec -it shopping-api -- bash

# Point to the internal API server hostname
APISERVER=https://kubernetes.default.svc

# Path to ServiceAccount token
SERVICEACCOUNT=/var/run/secrets/kubernetes.io/serviceaccount

# Read this Pod's namespace
NAMESPACE=$(cat ${SERVICEACCOUNT}/namespace)

# Read the ServiceAccount bearer token
TOKEN=$(cat ${SERVICEACCOUNT}/token)

# Reference the internal certificate authority (CA)
CACERT=${SERVICEACCOUNT}/ca.crt

# List pods through the API
curl --cacert ${CACERT} --header "Authorization: Bearer $TOKEN" -s ${APISERVER}/api/v1/namespaces/shopping/pods/ 

# we should see an error not having access

kubectl -n shopping apply -f serviceaccount-role.yaml
kubectl -n shopping apply -f serviceaccount-rolebinding.yaml

kind create cluster --name demo --image kindest/node:v1.33.1

kubectl get nodes
NAME                 STATUS   ROLES           AGE   VERSION
demo-control-plane   Ready    control-plane   19m   v1.33.1

kubectl apply -f kubernetes/configmaps/configmap.yaml

kubectl apply -f kubernetes/secrets/secret.yaml

helm repo add stakater https://stakater.github.io/stakater-charts
helm repo update

# see versions
helm search repo stakater/reloader -l

#pick a version
CHART_VERSION="2.1.5"


helm install reloader stakater/reloader \
--create-namespace \
--namespace reloader \
--version $CHART_VERSION \
--values kubernetes/reloader/values.yaml

kubectl apply -f kubernetes/reloader/deployment.yaml

kind create cluster --name secrets --image kindest/node:v1.31.1

cat kubernetes/secrets/secret.json

docker run -it -v $PWD/kubernetes/secrets/secret.json:/secrets/secret.json ubuntu:latest bash

cat /secrets/secret.json

api_key="somesecretgoeshere"
docker run -it -e API_KEY=$api_key ubuntu:latest bash

echo $API_KEY

kubectl create secret generic mysecret --from-file kubernetes/secrets/secret.json

kubectl apply -f kubernetes/secrets/secret.yaml

kubectl apply -f kubernetes/secrets/pod.yaml

# create cluster
kind create cluster --name monitoring --image kindest/node:v1.23.5

# see cluster up and running
kubectl get nodes
NAME                  STATUS   ROLES                  AGE     VERSION
monitoring-control-plane   Ready    control-plane,master   2m12s   v1.23.5

kubectl create -f ./monitoring/prometheus/kubernetes/1.23/manifests/setup/
kubectl create -f ./monitoring/prometheus/kubernetes/1.23/manifests/

kubectl -n monitoring get pods

kubectl -n monitoring get pods
NAME                                   READY   STATUS    RESTARTS   AGE
alertmanager-main-0                    2/2     Running   0          3m10s
alertmanager-main-1                    2/2     Running   0          3m10s
alertmanager-main-2                    2/2     Running   0          3m10s
blackbox-exporter-6b79c4588b-t4czf     3/3     Running   0          4m7s
grafana-7fd69887fb-zm2d2               1/1     Running   0          4m7s
kube-state-metrics-55f67795cd-f7frb    3/3     Running   0          4m6s
node-exporter-xjdtn                    2/2     Running   0          4m6s
prometheus-adapter-85664b6b74-bvmnj    1/1     Running   0          4m6s
prometheus-adapter-85664b6b74-mcgbz    1/1     Running   0          4m6s
prometheus-k8s-0                       2/2     Running   0          3m9s
prometheus-k8s-1                       2/2     Running   0          3m9s
prometheus-operator-6dc9f66cb7-z98nj   2/2     Running   0          4m6s

kubectl -n monitoring port-forward svc/grafana 3000

kubectl -n monitoring port-forward svc/prometheus-operated 9090

kubectl apply -n monitoring -f ./kubernetes/servicemonitors/prometheus.yaml

kubectl -n monitoring get pods

kubectl -n monitoring port-forward prometheus-applications-0 9090

kubectl -n default apply -f ./kubernetes/servicemonitors/servicemonitor.yaml

kubectl -n default apply -f ./kubernetes/servicemonitors/example-app/

kind create cluster --name services --image kindest/node:v1.31.1

kubectl get nodes
NAME                     STATUS   ROLES           AGE     VERSION
services-control-plane   Ready    control-plane   5m48s   v1.31.1

kubectl apply -f kubernetes/deployments/deployment.yaml

kubectl apply -f kubernetes/services/service.yaml

# start up a cluster

minikube start --kubernetes-version='v1.18.2' --memory='5gb' --disk-size='20gb' --driver=hyperv

# check our cluster

kubectl get nodes
NAME       STATUS   ROLES    AGE   VERSION
minikube   Ready    master   45s   v1.18.2

# add a route for accessing Shipa API
route add 10.100.10.10/32 MASK 255.255.255.255  $(minikube ip)

# add a route for accessing our Applications
route add 10.100.10.20/32 MASK 255.255.255.255  $(minikube ip)

docker run -it --rm  -v ${PWD}:/work -w /work alpine sh
apk add --no-cache curl unzip

cd kubernetes/shipa/
mkdir installs && cd installs

curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.19.4/bin/windows/amd64/kubectl.exe

curl -LO https://get.helm.sh/helm-v3.4.1-windows-amd64.zip && \
unzip helm-v3.4.1-windows-amd64.zip && \
mv windows-amd64/helm.exe . && \
rm -rf windows-amd64 && \
rm helm-v3.4.1-windows-amd64.zip

curl -LO  https://storage.googleapis.com/shipa-client/v1.1/shipa_windows_amd64.exe
mv shipa_windows_amd64.exe shipa.exe

curl  -L -s -o shipa1.1.1.zip https://github.com/shipa-corp/helm-chart/archive/v1.1.1.zip && \
unzip shipa1.1.1.zip && rm shipa1.1.1.zip && \
mv helm-chart-1.1.1 shipa-helm-chart-1.1.1 && \

# we can abandon this container
exit

/* Detailed source-code truncated for AI context efficiency. */

shipa target-add dev 10.100.10.10
shipa target-list
shipa target-set dev
shipa login

#username: [email protected]
#password: shipa2020

shipa pool-add dev --public --kube-namespace dev-team --provisioner kubernetes
shipa pool-list

shipa team-create dev-team
shipa pool-constraint-set theonepool team dev-team --append

shipa cluster-list
+------------+-------------+---------------+-------------+---------+------------+-------+-------+
| Name       | Provisioner | Addresses     | Custom Data | Default | Pools      | Teams | Error |
+------------+-------------+---------------+-------------+---------+------------+-------+-------+
| shipa-core | kubernetes  | 10.96.0.1:443 |             | false   | theonepool |       |       |
+------------+-------------+---------------+-------------+---------+------------+-------+-------+

cd kubernetes\shipa\developers\docker\golang

docker build . -t aimvector/shipa-golang:v1
docker push aimvector/shipa-golang:v1

# create an app: Golang
shipa app-create go-helloworld static -t dev-team -o theonepool

# deploy the app: Golang
shipa app-deploy -i aimvector/shipa-golang:v1 -a go-helloworld
shipa app-list

cd .\kubernetes\shipa\developers\docker\python\

docker build . -t aimvector/shipa-python:v1
docker push aimvector/shipa-python:v1

# create an app: Python
shipa app-create python-helloworld static -t dev-team -o theonepool
shipa env set FLASK_APP=/app/server.py -a python-helloworld

# deploy the app: Python
shipa app-deploy -i aimvector/shipa-python:v1 -a python-helloworld
shipa app-list

# ensure we are pointing to AKS Or the
kubectl get nodes

# deploy Shipa to AKS

cd kubernetes/shipa

# create username + password override
cat > ops/values.override.yaml << EOF
auth:
  adminUser: [email protected]
  adminPassword: shipa-prod-aks2020
EOF

kubectl create ns shipa-system

kubectl apply -n shipa-system -f limits.yaml

helm install shipa ./installs/shipa-helm-chart-1.1.1 --timeout=1000s --namespace=shipa-system -f ops/values.override.yaml

#wait until the dashboard pod is up!
kubectl --namespace=shipa-system get pods

# get the ingress IP for the Shipa API
kubectl --namespace=shipa-system get svc shipa-ingress-nginx  -o jsonpath="{.status.loadBalancer.ingress[0].ip}"

# add the ingress IP as our Shipa target for AKS dev
shipa target-add dev-aks 20.53.128.244 -s
shipa target-set dev-aks
shipa target-list

# lets login, view the node, and dashboard app URL
shipa login [email protected]
shipa node-list
shipa app-list

#add a host file entry for the dashboard, I.E:
20.193.20.106 dashboard.20.193.20.106.shipa.cloud

# create a team for developers
shipa team-create dev-team

#allow dev-team to deploy to AKS pool
shipa pool-constraint-set theonepool team dev-team --append

# add service account to EKS cluster to allow Shipa to connect
kubectl apply -f ops/shipa-admin-service-account.yaml 

#add a pool allow people to deploy to Amazon
shipa pool-add amazon --public --kube-namespace dev-team --provisioner kubernetes

# allow dev-team to deploy to Amazon
shipa pool-constraint-set amazon  team dev-team --append

# We will need the EKS token of the service account to allow connection
kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | grep shipa-admin | awk '{print $1}')

# We will also need the CA cert of Kubernetes
kubectl get secret $(kubectl get secret | grep default-token | awk '{print $1}') -o jsonpath='{.data.ca\.crt}' | base64 -d

# create an app: Golang
shipa app-create go-helloworld static -t dev-team -o theonepool

# deploy the app: Golang
shipa app-deploy -i aimvector/shipa-golang:v1 -a go-helloworld
shipa app-list

# create an app: Python
shipa app-create python-helloworld static -t dev-team -o amazon
shipa env set FLASK_APP=/app/server.py -a python-helloworld

# deploy the app: Python
shipa app-deploy -i aimvector/shipa-python:v1 -a python-helloworld
shipa app-list

https://collabnix.com/the-rise-of-shipa-a-continuous-operation-platform/

1. Configured default user:

Username: [email protected]
Password: adminadmin123

2. If this is a production cluster, please configure persistent volumes.
   The default reclaimPolicy for dynamically provisioned persistent volumes is "Delete" and
   users are advised to change it for production

   The code snippet below can be used to set reclaimPolicy to "Retain" for all volumes:

PVCs=$(kubectl --namespace=shipa-system get pvc -l release=shipa -o name)

for pvc in $PVCs; do
    volumeName=$(kubectl -n shipa-system get $pvc -o template --template=\{\{.spec.volumeName\}\})
    kubectl -n shipa-system patch pv $volumeName -p '{"spec":{"persistentVolumeReclaimPolicy":"Retain"}}'
done

3. Set default target for shipa-client:
export SHIPA_HOST=$(kubectl --namespace=shipa-system get svc shipa-ingress-nginx  -o jsonpath="{.status.loadBalancer.ingress[0].ip}")

shipa target-add shipa $SHIPA_HOST -s

shipa login [email protected]
shipa node-list
shipa app-list

kind create cluster --name velero --image kindest/node:v1.19.1

docker run -it --rm -v ${HOME}:/root/ -v ${PWD}:/work -w /work --net host alpine sh

# install curl & kubectl
apk add --no-cache curl nano
curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
chmod +x ./kubectl
mv ./kubectl /usr/local/bin/kubectl
export KUBE_EDITOR="nano"

#test cluster access:
/work # kubectl get nodes
NAME                    STATUS   ROLES    AGE   VERSION
velero-control-plane   Ready    master   26m   v1.18.4

curl -L -o /tmp/velero.tar.gz https://github.com/vmware-tanzu/velero/releases/download/v1.5.1/velero-v1.5.1-linux-amd64.tar.gz 
tar -C /tmp -xvf /tmp/velero.tar.gz
mv /tmp/velero-v1.5.1-linux-amd64/velero /usr/local/bin/velero
chmod +x /usr/local/bin/velero

velero --help

kubectl apply -f kubernetes/configmaps/configmap.yaml
kubectl apply -f kubernetes/secrets/secret.yaml
kubectl apply -f kubernetes/deployments/deployment.yaml
kubectl apply -f kubernetes/services/service.yaml

kubectl get all

# Azure credential file
cat << EOF  > /tmp/credentials-velero
AZURE_STORAGE_ACCOUNT_ACCESS_KEY=${AZURE_STORAGE_ACCOUNT_ACCESS_KEY}
AZURE_CLOUD_NAME=AzurePublicCloud
EOF

velero install \
    --provider azure \
    --plugins velero/velero-plugin-for-microsoft-azure:v1.1.0 \
    --bucket $BLOB_CONTAINER \
    --secret-file /tmp/credentials-velero \
    --backup-location-config resourceGroup=$AZURE_BACKUP_RESOURCE_GROUP,storageAccount=$AZURE_STORAGE_ACCOUNT_NAME,storageAccountKeyEnvVar=AZURE_STORAGE_ACCOUNT_ACCESS_KEY,subscriptionId=$AZURE_BACKUP_SUBSCRIPTION_ID \
    --use-volume-snapshots=false


kubectl -n velero get pods
kubectl logs deployment/velero -n velero

cat > /tmp/credentials-velero <<EOF
[default]
aws_access_key_id=$AWS_ACCESS_ID
aws_secret_access_key=$AWS_ACCESS_KEY
EOF

velero install \
    --provider aws \
    --plugins velero/velero-plugin-for-aws:v1.1.0 \
    --bucket $BUCKET \
    --backup-location-config region=$REGION \
    --snapshot-location-config region=$REGION \
    --secret-file /tmp/credentials-velero

kubectl -n velero get pods
kubectl logs deployment/velero -n velero

velero backup create default-namespace-backup --include-namespaces default

# describe
velero backup describe default-namespace-backup

# logs
velero backup logs default-namespace-backup

# delete all resources

kubectl delete -f kubernetes/configmaps/configmap.yaml
kubectl delete -f kubernetes/secrets/secret.yaml
kubectl delete -f kubernetes/deployments/deployment.yaml
kubectl delete -f kubernetes/services/service.yaml

velero restore create default-namespace-backup --from-backup default-namespace-backup

# describe
velero restore describe default-namespace-backup

#logs 
velero restore logs default-namespace-backup

# see items restored

kubectl get all

cd .\messaging\kafka\
docker build . -t aimvector/kafka:2.7.0

docker run --rm --name kafka -it aimvector/kafka:2.7.0 bash

ls -l /kafka/bin/
cat /kafka/config/server.properties

docker cp kafka:/kafka/config/server.properties ./server.properties
docker cp kafka:/kafka/config/zookeeper.properties ./zookeeper.properties

cd ./zookeeper
docker build . -t aimvector/zookeeper:2.7.0
cd ..

docker network create kafka
docker run -d `
--rm `
--name zookeeper-1 `
--net kafka `
-v ${PWD}/config/zookeeper-1/zookeeper.properties:/kafka/config/zookeeper.properties `
aimvector/zookeeper:2.7.0

docker logs zookeeper-1

docker run -d `
--rm `
--name kafka-1 `
--net kafka `
-v ${PWD}/config/kafka-1/server.properties:/kafka/config/server.properties `
aimvector/kafka:2.7.0

docker logs kafka-1

docker run -d `
--rm `
--name kafka-2 `
--net kafka `
-v ${PWD}/config/kafka-2/server.properties:/kafka/config/server.properties `
aimvector/kafka:2.7.0

docker run -d `
--rm `
--name kafka-3 `
--net kafka `
-v ${PWD}/config/kafka-3/server.properties:/kafka/config/server.properties `
aimvector/kafka:2.7.0

docker exec -it zookeeper-1 bash

/kafka/bin/kafka-topics.sh \
--create \
--zookeeper zookeeper-1:2181 \
--replication-factor 1 \
--partitions 3 \
--topic Orders

/kafka/bin/kafka-topics.sh \
--describe \
--topic Orders \
--zookeeper zookeeper-1:2181

docker exec -it zookeeper-1 bash

/kafka/bin/kafka-console-consumer.sh \
--bootstrap-server kafka-1:9092,kafka-2:9092,kafka-3:9092 \
--topic Orders --from-beginning

docker exec -it zookeeper-1 bash

echo "New Order: 1" | \
/kafka/bin/kafka-console-producer.sh \
--broker-list kafka-1:9092,kafka-2:9092,kafka-3:9092 \
--topic Orders > /dev/null

docker exec -it kafka-1 bash

apt install -y tree
tree /tmp/kafka-logs/


ls -lh /tmp/kafka-logs/Orders-*

/tmp/kafka-logs/Orders-0:
total 4.0K
-rw-r--r-- 1 root root 10M May  4 06:54 00000000000000000000.index    
-rw-r--r-- 1 root root   0 May  4 06:54 00000000000000000000.log      
-rw-r--r-- 1 root root 10M May  4 06:54 00000000000000000000.timeindex
-rw-r--r-- 1 root root   8 May  4 06:54 leader-epoch-checkpoint       

/tmp/kafka-logs/Orders-1:
total 4.0K
-rw-r--r-- 1 root root 10M May  4 06:54 00000000000000000000.index    
-rw-r--r-- 1 root root   0 May  4 06:54 00000000000000000000.log      
-rw-r--r-- 1 root root 10M May  4 06:54 00000000000000000000.timeindex
-rw-r--r-- 1 root root   8 May  4 06:54 leader-epoch-checkpoint       

/tmp/kafka-logs/Orders-2:
total 8.0K
-rw-r--r-- 1 root root 10M May  4 06:54 00000000000000000000.index    
-rw-r--r-- 1 root root  80 May  4 06:57 00000000000000000000.log      
-rw-r--r-- 1 root root 10M May  4 06:54 00000000000000000000.timeindex
-rw-r--r-- 1 root root   8 May  4 06:54 leader-epoch-checkpoint

cat /tmp/kafka-logs/Orders-2/*.log

version: "3.8"
services:

zookeeper-1:
  container_name: zookeeper-1
  image: aimvector/zookeeper:2.7.0
  build:
    context: ./zookeeper
  volumes:
  - ./config/zookeeper-1/zookeeper.properties:/kafka/config/zookeeper.properties

kafka-1:
  container_name: kafka-1
  image: aimvector/kafka:2.7.0
  build: 
    context: .
  volumes:
  - ./config/kafka-1/server.properties:/kafka/config/server.properties
  - ./data/kafka-1/:/tmp/kafka-logs/

kafka-producer:
    container_name: kafka-producer
    image: aimvector/kafka:2.7.0
    build: 
      context: .
    working_dir: /kafka
    entrypoint: /bin/bash
    stdin_open: true
    tty: true

kafka-consumer:
    container_name: kafka-consumer
    image: aimvector/kafka:2.7.0
    build: 
      context: .
    working_dir: /kafka
    entrypoint: /bin/bash
    stdin_open: true
    tty: true

cd messaging\kafka

docker compose build
docker compose up

# run a standalone instance
docker network create rabbits
docker run -d --rm --net rabbits --hostname rabbit-1 --name rabbit-1 rabbitmq:3.8 

# how to grab existing erlang cookie
docker exec -it rabbit-1 cat /var/lib/rabbitmq/.erlang.cookie

# clean up
docker rm -f rabbit-1

docker run -d --rm --net rabbits -p 8080:15672 -e RABBITMQ_ERLANG_COOKIE=DSHEVCXBBETJJVJWTOWT --hostname rabbit-manager --name rabbit-manager rabbitmq:3.8-management

#join the manager

docker exec -it rabbit-manager rabbitmqctl stop_app
docker exec -it rabbit-manager rabbitmqctl reset
docker exec -it rabbit-manager rabbitmqctl join_cluster rabbit@rabbit-1
docker exec -it rabbit-manager rabbitmqctl start_app
docker exec -it rabbit-manager rabbitmqctl cluster_status

docker exec -it rabbit-1 rabbitmq-plugins enable rabbitmq_management
docker exec -it rabbit-2 rabbitmq-plugins enable rabbitmq_management
docker exec -it rabbit-3 rabbitmq-plugins enable rabbitmq_management

cd messaging\rabbitmq\applications\publisher
docker build . -t aimvector/rabbitmq-publisher:v1.0.0

docker run -it --rm --net rabbits -e RABBIT_HOST=rabbit-1 -e RABBIT_PORT=5672 -e RABBIT_USERNAME=guest -e RABBIT_PASSWORD=guest -p 80:80 aimvector/rabbitmq-publisher:v1.0.0

docker build . -t aimvector/rabbitmq-consumer:v1.0.0
docker run -it --rm --net rabbits -e RABBIT_HOST=rabbit-1 -e RABBIT_PORT=5672 -e RABBIT_USERNAME=guest -e RABBIT_PASSWORD=guest aimvector/rabbitmq-consumer:v1.0.0

docker exec -it rabbit-1 rabbitmqctl cluster_status

#join node 2

docker exec -it rabbit-2 rabbitmqctl stop_app
docker exec -it rabbit-2 rabbitmqctl reset
docker exec -it rabbit-2 rabbitmqctl join_cluster rabbit@rabbit-1
docker exec -it rabbit-2 rabbitmqctl start_app
docker exec -it rabbit-2 rabbitmqctl cluster_status

#join node 3
docker exec -it rabbit-3 rabbitmqctl stop_app
docker exec -it rabbit-3 rabbitmqctl reset
docker exec -it rabbit-3 rabbitmqctl join_cluster rabbit@rabbit-1
docker exec -it rabbit-3 rabbitmqctl start_app
docker exec -it rabbit-3 rabbitmqctl cluster_status

docker run -d --rm --net rabbits `
-v ${PWD}/config/rabbit-1/:/config/ `
-e RABBITMQ_CONFIG_FILE=/config/rabbitmq `
-e RABBITMQ_ERLANG_COOKIE=WIWVHCDTCIUAWANLMQAW `
--hostname rabbit-1 `
--name rabbit-1 `
-p 8081:15672 `
rabbitmq:3.8-management

docker run -d --rm --net rabbits `
-v ${PWD}/config/rabbit-2/:/config/ `
-e RABBITMQ_CONFIG_FILE=/config/rabbitmq `
-e RABBITMQ_ERLANG_COOKIE=WIWVHCDTCIUAWANLMQAW `
--hostname rabbit-2 `
--name rabbit-2 `
-p 8082:15672 `
rabbitmq:3.8-management

docker run -d --rm --net rabbits `
-v ${PWD}/config/rabbit-3/:/config/ `
-e RABBITMQ_CONFIG_FILE=/config/rabbitmq `
-e RABBITMQ_ERLANG_COOKIE=WIWVHCDTCIUAWANLMQAW `
--hostname rabbit-3 `
--name rabbit-3 `
-p 8083:15672 `
rabbitmq:3.8-management

#NODE 1 : MANAGEMENT http://localhost:8081
#NODE 2 : MANAGEMENT http://localhost:8082
#NODE 3 : MANAGEMENT http://localhost:8083

# enable federation plugin
docker exec -it rabbit-1 rabbitmq-plugins enable rabbitmq_federation 
docker exec -it rabbit-2 rabbitmq-plugins enable rabbitmq_federation
docker exec -it rabbit-3 rabbitmq-plugins enable rabbitmq_federation

docker exec -it rabbit-1 bash

# https://www.rabbitmq.com/ha.html#mirroring-arguments

rabbitmqctl set_policy ha-fed \
    ".*" '{"federation-upstream-set":"all", "ha-mode":"nodes", "ha-params":["rabbit@rabbit-1","rabbit@rabbit-2","rabbit@rabbit-3"]}' \
    --priority 1 \
    --apply-to queues

rabbitmqctl set_policy ha-fed \
    ".*" '{"federation-upstream-set":"all", "ha-sync-mode":"automatic", "ha-mode":"nodes", "ha-params":["rabbit@rabbit-1","rabbit@rabbit-2","rabbit@rabbit-3"]}' \
    --priority 1 \
    --apply-to queues

docker rm -f rabbit-1
docker rm -f rabbit-2
docker rm -f rabbit-3

# starts fluentbit with default config
docker run -it cr.fluentbit.io/fluent/fluent-bit:4.0

# see HELP text 
docker run -it cr.fluentbit.io/fluent/fluent-bit:4.0 -h

docker run -it -p 2020:2020 \
-v ./monitoring/fluentbit/fluent-bit.yaml:/fluent-bit/etc/fluent-bit.yaml \
cr.fluentbit.io/fluent/fluent-bit:4.0 --config=/fluent-bit/etc/fluent-bit.yaml

pipeline:
  inputs:
  - name: tail
    path: /var/lib/docker/containers/*/*.log
    multiline.parser: docker

  - name: http
    listen: 0.0.0.0
    port: 8888

docker run -it \
-p 2020:2020 \
-p 8888:8888 \
-v ./monitoring/fluentbit/fluent-bit.yaml:/fluent-bit/etc/fluent-bit.yaml \
-v /var/lib/docker:/var/lib/docker \
cr.fluentbit.io/fluent/fluent-bit:4.0 --config=/fluent-bit/etc/fluent-bit.yaml

curl -d '{"namespace":"product","message":"hello from product"}' -X POST -H "content-type: application/json" http://localhost:8888/product.log

- name: file
  match: '*'
  template: '{log}'
  path: /fluent-bit/.data

docker run -it \
-p 2020:2020 \
-p 8888:8888 \
-v ./monitoring/fluentbit/fluent-bit.yaml:/fluent-bit/etc/fluent-bit.yaml \
-v /var/lib/docker:/var/lib/docker \
-v ./monitoring/fluentbit/.data:/fluent-bit/.data \
cr.fluentbit.io/fluent/fluent-bit:4.0 --config=/fluent-bit/etc/fluent-bit.yaml

filters:
- name: grep
  match: '*'
  regex: namespace product

filters:
- name: grep
  match: '*'
  exclude: namespace search

#request allowed
curl -d '{"namespace":"product","message":"hello from product"}' -X POST -H "content-type: application/json" http://localhost:8888/product.log

# request dropped\filtered
curl -d '{"namespace":"search","message":"hello from search"}' -X POST -H "content-type: application/json" http://localhost:8888/search.log

docker compose up -d prometheus
docker compose up -d grafana
docker compose up -d grafana-dashboards

docker compose up -d --build go-application
docker compose up -d --build python-application
docker compose up -d --build dotnet-application
docker compose up -d --build nodejs-application

http://localhost:80 #Golang
http://localhost:81 #Python
http://localhost:82 #Dotnet
http://localhost:83 #NodeJS

http://localhost:3000

irate(go_request_operations_total[2m])

rate(go_request_duration_seconds_sum[2m]) / rate(go_request_duration_seconds_total[2m])

cd python\introduction

docker build --target dev . -t python
docker run -it -v ${PWD}:/work python sh

/work # python --version
Python 3.9.

mkdir src

def main():
	print("Hello, world.")

main()

/work # python src/app.py
Hello, world.

# This function returns some data 
# The data could be coming from a database, or a file.
# The person calling the function should not care
# how the data is retrieved.
# Since the function does not leak its Data provider

def getCustomer():
  return "Marcel Dempers"

print(getCustomer())

def getCustomer(customerID):
  return "CustomerID: " + customerID + ", Name: Marcel Dempers"

print(getCustomer("abc"))

def getCustomer(customerID):
  firstName = "Marcel"
  lastName = "Dempers"
  fullName = firstName + " " + lastName

  return fullName

  #or we can return the computation instead of adding another variable!
  return firstName + " " + lastName

  #or we don't even need to declare variables :)
  return "Marcel Dempers"

customer = getCustomer("abc")
print(customer)

def getCustomer(customerID):
  if customerID == "abc":
    return "Marcel Dempers"
  elif customerID == "def":
    return "Bob Smith"
  else:
    return ""

customer = getCustomer("abc")
print(customer)

marcel = getCustomer("abc")
print(marcel)

bob = getCustomer("def")
print(bob)

def getCustomers():
  customers = [ "Marcel Dempers", "Bob Smith" ]
  return customers

customers = getCustomers()
print(customers)

customers = getCustomers()

marcel = customers[0]
bob = customers[1]

print(marcel + "\n" + bob)

customers[2] = "John Smith"
IndexError: list assignment index out of range

def getCustomers():
  customers = [ "Marcel Dempers", "Bob Smith" ]
  customers.append("James Baker")
  customers.append("Jonathan D")
  customers.append("Aleem Janmohamed")
  customers.append("Ivo Galic")
  customers.append("Joel Griffiths")
  customers.append("Michael Spinks")
  customers.append("Victor Savkov")
  return customers

customers.remove("Bob Smith")

customers = {
    "a": "James Baker",
    "b": "Jonathan D",
    "c": "Aleem Janmohamed",
    "d": "Ivo Galic",
    "e": "Joel Griffiths",
    "f": "Michael Spinks",
    "g": "Victor Savkov"
  }

#update or create item
customers["h"] = "Marcel Dempers"

#get an item
marcel = customers["h"]
print(marcel)

def getCustomer(customerID):
  customer = getCustomers()
  return customer[customerID]

def getCustomers():
  customers = {
    "a": "James Baker",
    "b": "Jonathan D",
    "c": "Aleem Janmohamed",
    "d": "Ivo Galic",
    "e": "Joel Griffiths",
    "f": "Michael Spinks",
    "g": "Victor Savkov",
    "h" : "Marcel Dempers"
  }
  
  return customers

customers = getCustomers()
customer = getCustomer("h")

print(customer)
print(customers)

i = 0
while i < 7:
  print(customers[i])
  i += 1

customers = [ "Marcel Dempers", "Bob Smith" ]
customers.append("James Baker")
customers.append("Jonathan D")
customers.append("Aleem Janmohamed")
customers.append("Ivo Galic")
customers.append("Joel Griffiths")
customers.append("Michael Spinks")
customers.append("Victor Savkov")
i = 0
while i <= 8:
  print(customers[i])
  i += 1

customers = getCustomers()

for customerID in customers:
  print(customers[customerID])

class Customer:
  customerID = ""
  firstName  = ""
  lastName   = ""
  def fullName(self):
    return self.firstName + " " + self.lastName

marcel = Customer()
marcel.firstName = "Marcel"
marcel.lastName = "Dempers"
marcel.customerID = "h"

print(marcel.fullName())

class Customer:
  def __init__(self, c="", f="", l=""):
    self.customerID = c
    self.firstName  = f
    self.lastName   = l
  def fullName(self):
    return self.firstName + " " + self.lastName

marcel = Customer("h", "Marcel", "Dempers")

print(marcel.fullName())

def getCustomers():
  customers = {
    "a": Customer("a","James", "Baker"),
    "b": Customer("b", "Jonathan", "D"),
    "c": Customer("c", "Aleem", "Janmohamed"),
    "d": Customer("d", "Ivo", "Galic"),
    "e": Customer("e", "Joel", "Griffiths"),
    "f": Customer("f", "Michael", "Spinks"),
    "g": Customer("g", "Victor", "Savkov"),
    "h" : Customer("h", "Marcel", "Dempers")
  }
  
  return customers

customers = getCustomers()
for customerID in customers:
  print(customers[customerID].fullName())

FROM python:3.9.6-alpine3.13 as dev

WORKDIR /work

FROM python:3.9.6-alpine3.13 as debugging

# add a debugger

FROM dev as runtime
COPY ./src/ /app 

ENTRYPOINT [ "python", "/app/app.py" ]

docker build . -t customer-app

docker run customer-app

docker network create redis
docker run -it --rm --name redis --net redis -p 6379:6379 redis:6.0-alpine

cd .\storage\redis\
docker run -it --rm --name redis --net redis -v ${PWD}/config:/etc/redis/ redis:6.0-alpine redis-server /etc/redis/redis.conf

requirepass SuperSecretSecureStrongPass

docker volume create redis
cd .\storage\redis\
docker run -it --rm --name redis --net redis -v ${PWD}/config:/etc/redis/ -v redis:/data/  redis:6.0-alpine redis-server /etc/redis/redis.conf

cd .\storage\redis\applications\client\

# start go dev environment
docker run -it -v ${PWD}:/go/src -w /go/src --net redis -p 80:80 golang:1.14-alpine

go build client.go
# start the app
./client

# build the container
docker build . -t aimvector/redis-client:v1.0.0

cd .\storage\redis\applications\client\
docker build . -t aimvector/redis-client:v1.0.0

docker run -it --net redis `
-e REDIS_HOST=redis `
-e REDIS_PORT=6379 `
-e REDIS_PASSWORD="SuperSecretSecureStrongPass" `
-p 80:80 `
aimvector/redis-client:v1.0.0

git clone --depth 1 https://github.com/openclaw/openclaw.git /tmp/openclaw

tree /tmp/openclaw/scripts/docker/
/tmp/openclaw/scripts/docker/
├── cleanup-smoke
│   ├── Dockerfile
│   └── run.sh
├── install-sh-common
│   ├── cli-verify.sh
│   └── version-parse.sh
├── install-sh-e2e
│   ├── Dockerfile
│   └── run.sh
├── install-sh-nonroot
│   ├── Dockerfile
│   └── run.sh
├── install-sh-smoke
│   ├── Dockerfile
│   └── run.sh
├── sandbox
│   ├── Dockerfile
│   ├── Dockerfile.browser
│   └── Dockerfile.common
├── setup.sh
└── shared-image-artifact.sh

export OPENCLAW_IMAGE="ghcr.io/openclaw/openclaw:latest"
./scripts/docker/setup.sh

docker build . -t aimvector/openclaw

export OPENCLAW_GATEWAY_TOKEN="$(openssl rand -hex 32)"
export GEMINI_API_KEY="xxxxxxx"
export DISCORD_BOT_TOKEN="xxxxxxx"
export GITHUB_TOKEN="xxxxxxx"

mkdir ~/.openclaw
cp ai/agents/openclaw/openclaw.json  ~/.openclaw/
docker run -it --rm \
  --name openclaw \
  -e OPENCLAW_GATEWAY_TOKEN=${OPENCLAW_GATEWAY_TOKEN} \
  -e GEMINI_API_KEY=${GEMINI_API_KEY} \
  -e DISCORD_BOT_TOKEN=${DISCORD_BOT_TOKEN} \
  -e GITHUB_TOKEN=${GITHUB_TOKEN} \
  --cap-drop ALL \
  -v $PWD:/work \
  -v ~/.openclaw:/home/openclaw/.openclaw \
  -w /work \
  --net host \
  -v /var/run/docker.sock:/var/run/docker.sock \
  aimvector/openclaw

openclaw onboard --classic

tree /tmp/openclaw/scripts/k8s/
/tmp/openclaw/scripts/k8s/
├── create-kind.sh
├── deploy.sh
└── manifests
    ├── configmap.yaml
    ├── deployment.yaml
    ├── kustomization.yaml
    ├── pvc.yaml
    └── service.yaml

1 directories, 7 files

kind create cluster --name openclaw --image kindest/node:v1.36.1

kubectl get nodes
NAME                     STATUS   ROLES           AGE     VERSION
openclaw-control-plane   Ready    control-plane   2m30s   v1.36.1

tree /tmp/openclaw/scripts/k8s/

/tmp/openclaw/scripts/k8s/
├── create-kind.sh
├── deploy.sh
└── manifests
    ├── configmap.yaml
    ├── deployment.yaml
    ├── kustomization.yaml
    ├── pvc.yaml
    └── service.yaml

2 directories, 7 files

cp /tmp/openclaw/scripts/k8s/manifests/* ai/agents/openclaw/kubernetes/

export OPENCLAW_GATEWAY_TOKEN="$(openssl rand -hex 32)"
export GEMINI_API_KEY="xxxxxxx"
export DISCORD_BOT_TOKEN="xxxxxxx"

- name: DISCORD_BOT_TOKEN
  valueFrom:
    secretKeyRef:
      name: openclaw-secrets
      key: DISCORD_BOT_TOKEN
      optional: false

kubectl create ns openclaw
kubectl create secret generic openclaw-secrets -n openclaw \
  --from-literal OPENCLAW_GATEWAY_TOKEN=${OPENCLAW_GATEWAY_TOKEN} \
  --from-literal GEMINI_API_KEY=${GEMINI_API_KEY} \
  --from-literal DISCORD_BOT_TOKEN=${DISCORD_BOT_TOKEN}

kubectl -n openclaw apply -f ai/agents/openclaw/kubernetes/

export NPM_CONFIG_CACHE=~/.openclaw/.npm
openclaw plugins install @openclaw/discord
kubectl -n openclaw delete pods --all

kind create cluster --name llmkube --image kindest/node:v1.34.3

kubectl get nodes
NAME                       STATUS   ROLES           AGE   VERSION
llmkube-control-plane   Ready    control-plane   40s   v1.34.3

helm repo add llmkube https://defilantech.github.io/LLMKube
helm repo update

helm search repo llmkube --versions
CHART_VERSION="0.7.5"

helm install llmkube llmkube/llmkube \
  --namespace llmkube-system \
  --version ${CHART_VERSION} \
  --create-namespace

kubectl get pods -n llmkube-system

kubectl get crds | grep llmkube
inferenceservices.inference.llmkube.dev
models.inference.llmkube.dev

# Deploy the Model
kubectl apply -f ai/kubernetes/llm-kube/model.yaml

# Check the Model
kubectl get model
kubectl describe model

# Deploy the InferenceService
kubectl apply -f ai/kubernetes/llm-kube/inference.yaml

# Check the InferenceService
kubectl get inferenceservices
kubectl describe inferenceservices

kubectl port-forward svc/gemma-e2b-service 8080:8080

curl -X POST http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma-e2b",
    "messages": [
      {"role": "user", "content": "What is Kubernetes in one sentence?"}
    ],
    "max_tokens": 80
  }'

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llmkube": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LLMKube (local)",
      "options": {
        "baseURL": "http://localhost:8080/v1"
      },
      "models": {
        "gemma-e2b": {
          "name": "Gemma 4 E2B (kind)",
          "limit": {
            "context": 32768,
            "output": 4096
          }
        }
      }
    }
  }
}

docker run -it \
  -v ~/models:/models \
  --device /dev/dri \
  -p 8080:8080 \
  --entrypoint bash ghcr.io/ggml-org/llama.cpp:full-intel

docker run -it \
  -v ~/models:/models \
  --gpus all \
  -p 8080:8080 \
  --entrypoint bash ghcr.io/ggml-org/llama.cpp:full-cuda

./llama-cli -hf ggml-org/gemma-4-E4B-it-GGUF:Q4_K_M

./llama-cli -m /models/gemma-4-E4B-it-Q4_K_M.gguf -ngl 99

./llama-cli -m /models/gemma-4-E4B-it-Q4_K_M.gguf -ngl 0

export LLAMA_ARG_HOST=0.0.0.0
./llama-server -m /models/gemma-4-E4B-it-Q4_K_M.gguf \
  --port 8080 \
  -ngl 0 \
  --jinja \
  -c 8192 \
  --parallel 1 \
  --temperature 1.0 \
  --top-p 0.95 \
  --top-k 64

export LLAMA_ARG_HOST=0.0.0.0

# gemma-4-31B-it-Q4_K_M.gguf
# gemma-4-26B-A4B-it-Q4_K_M.gguf
# gemma-4-E2B-it-Q8_0.gguf
# gemma-4-E4B-it-Q4_K_M.gguf

./llama-server -m /models/gemma-4-E2B-it-Q8_0.gguf \
  --port 8080 \
  -ngl 99 \
  --jinja \
  -c 131072 \
  --parallel 1 \
  --temperature 1.0 \
  --top-p  0.95 \
  --top-k 64

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "llama-server (local)",
      "options": {
        "baseURL": "http://localhost:8080/v1"
      },
      "models": {
        "gemma-4-26B-A4B-it-Q4_K_M.gguf": {
          "name": "gemma-4-26B-A4B-it-Q4_K_M (local)",
          "limit": {
            "context": 65536,
            "output": 16384
          }
        }
      }
    }
  }
}

import sys

message = sys.argv[0]

responseMessage = response.choices[0].message.content

cd ai\openai\introduction
docker build . -t ai-app

$ENV:OPENAI_API_KEY=""

docker run -it -e OPENAI_API_KEY=$ENV:OPENAI_API_KEY ai-app

import sys
import os
import json
import openai

openai.api_key = os.getenv("OPENAI_API_KEY")

#read the incoming message
message = sys.argv[1]
user_message = {
  "role" : "user",
  "content" : message
}

systemMessage = {
  "role": "system",
  "content": "You are a kubernetes exper that can assist developers with troubleshooting deployments\n\nTo help the developer you will need to know the namespaces as well as the pod name. Ask for missing information\n\nGenerate a command to help the developer surface logs or information\n"
}

# read the cached user messages if there are any
userMessages = []
if os.path.isfile("messages.json"):
  with open('messages.json', newline='') as messagesFile:
    data = messagesFile.read()
    userMessages = json.loads(data)

# add the new message to it and update the cached messages
userMessages.append(user_message)
with open('messages.json', 'w', newline='') as messagesFile:
  msgJSON = json.dumps(userMessages)
  messagesFile.write(msgJSON)
  print(msgJSON)

messages = []
messages.append(systemMessage)
messages.extend(userMessages)

response = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=messages,
  temperature=1,
  max_tokens=256,
  top_p=1,
  frequency_penalty=0,
  presence_penalty=0
)

responseMessage = response.choices[0].message.content
print(responseMessage)

docker run -it -e OPENAI_API_KEY=$ENV:OPENAI_API_KEY -v ${PWD}:/app ai-app "can you help me with my deployment?"
Of course! I'd be happy to help with your deployment. Could you please provide me with the namespace and the name of the pod you're encountering issues with?

docker run -it -e OPENAI_API_KEY=$ENV:OPENAI_API_KEY -v ${PWD}:/app ai-app "my pod is pod-123" 
Sure, I can help you with your deployment. Can you please provide me with the namespace in which the pod is running?

docker run -it -e OPENAI_API_KEY=$ENV:OPENAI_API_KEY -v ${PWD}:/app ai-app "its in the products namespace"
Great! To surface the logs for the pod "pod-123" in the "products" namespace, you can use the following command:

```shell
kubectl logs -n products pod-123

---

### Overview (`automation/cicd/octopus-deploy/README.md`)

# Introduction to Octopus Deploy

[](https://youtu.be/xxxxx) 

Start here 👉🏽[https://octopus.com/](https://octopus.com/) 
Documentation 👉🏽[https://octopus.com/docs](https://octopus.com/docs)

In this video, I sign up with the Free version of Octopus deploy to get my license key. 

## Create Kubernetes clusters

In my video I use `kind` to act as my DEV and PROD environment where I run microservices 
Let's create that:
```shell
kind create cluster --name dev --image kindest/node:v1.34.0
kind create cluster --name prod --image kindest/node:v1.34.0

cd automation/cicd/octopus-deploy

export MASTER_KEY=$(openssl rand -base64 32)
export OCTOPUS_SERVER_BASE64_LICENSE=xxxxx
export ADMIN_USERNAME="octo-admin"
export ADMIN_PASSWORD="octo-admin123"
export ADMIN_EMAIL="[email protected]"

docker run -d --name octopus-database \
--net kind \
-u root \
-e ACCEPT_EULA="Y" \
-e MSSQL_SA_PASSWORD="OurStrongPassword123" \
-v ${PWD}/.data/mssql/:/var/opt/mssql/data \
mcr.microsoft.com/mssql/server:2022-latest

docker run -d \
--name octopus \
--net kind \
-p 8080:8080 \
-p 8443:8443 \
-p 10943:10943 \
-e ACCEPT_EULA="Y" \
-e ADMIN_USERNAME=$ADMIN_USERNAME \
-e ADMIN_PASSWORD=$ADMIN_PASSWORD \
-e ADMIN_EMAIL=$ADMIN_EMAIL \
-e OCTOPUS_SERVER_BASE64_LICENSE=$OCTOPUS_SERVER_BASE64_LICENSE \
-e MASTER_KEY=$MASTER_KEY \
-e DB_CONNECTION_STRING="Server=octopus-database,1433;Database=OctopusDeploy;User=sa;Password=OurStrongPassword123" \
-v ${PWD}/.data/octopus/repository/:/repository \
-v ${PWD}/.data/octopus/artifacts/:/artifacts \
-v ${PWD}/.data/octopus/taskLogs/:/taskLogs \
-v ${PWD}/.data/octopus/cache/:/cache \
-v ${PWD}/.data/octopus/import/:/import \
-v ${PWD}/.data/octopus/eventExports/:/eventExports \
octopusdeploy/octopusdeploy:2025.3

ifconfig eth0 | grep 'inet' | awk '{print $2}' | cut -d: -f2

create_namespace() {
NAMESPACE_NAME=$1

# Check if the namespace exists.
# The 'get namespace' command will fail if the namespace is not found.
# The '>/dev/null 2>&1' part suppresses all output (success or failure) 
# so the script remains silent unless a new namespace is created.

kubectl get namespace $NAMESPACE_NAME >/dev/null 2>&1

# $? is the exit status of the last command (0 for success, non-zero for failure)
if [ $? -ne 0 ]; then
    echo "Namespace '$NAMESPACE_NAME' not found. Creating it now..."
    kubectl create namespace $NAMESPACE_NAME
    echo "Namespace '$NAMESPACE_NAME' created successfully."
else
    echo "Namespace '$NAMESPACE_NAME' already exists. Skipping creation."
fi
}

source create_namespace.sh
create_namespace $(get_octopusvariable "NAMESPACE")

https://github.com/marcel-dempers/docker-development-youtube-series.git

automation/cicd/octopus-deploy/example-application/deployment.yaml
automation/cicd/octopus-deploy/example-application/service.yaml
automation/cicd/octopus-deploy/example-application/ingress.yaml

spec:
  ingressClassName: nginx
  rules:
  - host: marcel.local

NAMESPACE=$(get_octopusvariable "config_namespace")
CONFIGMAP_NAME=$(get_octopusvariable "config_name")
BODY_JSON=$(get_octopusvariable "config_body")

CONFIG_KEY=config.json
# Check if arguments are provided
if [ -z "$NAMESPACE" ] || [ -z "$CONFIGMAP_NAME" ] || [ -z "$BODY_JSON" ]; then
    echo "Error: Missing one or more required arguments."
    usage
fi

kubectl create configmap "${CONFIGMAP_NAME}" --namespace "${NAMESPACE}" \
  --from-literal="${CONFIG_KEY}=${BODY_JSON}" \
  --dry-run=client -o yaml | kubectl apply -f -

NAMESPACE=$(get_octopusvariable "secret_namespace")
SECRET_NAME=$(get_octopusvariable "secret_name")
BODY_JSON=$(get_octopusvariable "secret_body")

SECRET_KEY="secret.json"

# Check if arguments are provided
if [ -z "$NAMESPACE" ] || [ -z "$SECRET_NAME" ] || [ -z "$BODY_JSON" ]; then
    echo "Error: Missing one or more required arguments."
    usage
fi

ENCODED_BODY=$(echo -n "$BODY_JSON" | base64)

kubectl create secret generic "${SECRET_NAME}" --namespace "${NAMESPACE}" \
  --from-literal="${SECRET_KEY}=${ENCODED_BODY}" \
  --dry-run=client -o yaml | kubectl apply -f -

<li> user management  </li>
<li> permission management  </li>
<li> hardware management & devices </li>
<li> resource management </li>
  
    <li> CPU</li>
    <li> Memory</li>
    <li> Disk</li>