### Add Nuclio Helm Repository

Source: https://docs.nuclio.io/en/stable/setup/minikube/getting-started-minikube

Adds the official Nuclio Helm chart repository to your local Helm configuration. This allows you to easily install Nuclio using Helm.

```bash
helm repo add nuclio https://nuclio.github.io/nuclio/charts
```

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

### Install Nuclio using Helm

Source: https://docs.nuclio.io/en/stable/setup/minikube/getting-started-minikube

Deploys Nuclio and its essential Kubernetes resources, including RBAC roles, to the 'nuclio' namespace using Helm. This command installs the Nuclio controller and dashboard.

```bash
helm --namespace nuclio install nuclio nuclio/nuclio
```

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

### Install Docker-GCR Helper with gcloud

Source: https://docs.nuclio.io/en/stable/setup/gke/getting-started-gke

Installs the GCR Docker credentials helper using the gcloud CLI. This is a prerequisite for authenticating with Google Container Registry.

```bash
gcloud components install docker-credential-gcr

```

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

### Verify Docker Installation

Source: https://docs.nuclio.io/en/stable/_sources/setup/docker/getting-started-docker

This command verifies that your Docker daemon is running correctly. It's a prerequisite for running Nuclio on Docker and should be executed with the same user that will run Nuclio CLI commands.

```bash
docker version
```

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

### Verify Nuclio Pods Status

Source: https://docs.nuclio.io/en/stable/setup/minikube/getting-started-minikube

Checks the status of pods running within the 'nuclio' namespace, specifically verifying if the Nuclio controller and dashboard pods are running correctly after installation.

```bash
minikube kubectl -- get pods --namespace nuclio
```

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

### Start Minikube Cluster with RBAC

Source: https://docs.nuclio.io/en/stable/setup/minikube/getting-started-minikube

Starts a Minikube cluster with a specified Kubernetes version, using the Docker driver, and enabling Role-Based Access Control (RBAC). This is a foundational step for running Kubernetes locally with Nuclio.

```bash
minikube start --kubernetes-version v1.27.5 --driver docker --extra-config=apiserver.authorization-mode=RBAC
```

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

### Run Docker Registry in Minikube

Source: https://docs.nuclio.io/en/stable/setup/minikube/getting-started-minikube

Starts an insecure Docker registry container within the Minikube environment, accessible on port 5000. This registry is used for pushing Docker container images of Nuclio functions.

```bash
minikube ssh -- docker run -d -p 5000:5000 registry:2
```

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

### Create Nuclio Namespace in Kubernetes

Source: https://docs.nuclio.io/en/stable/setup/minikube/getting-started-minikube

Creates a dedicated Kubernetes namespace named 'nuclio' for all Nuclio-related resources. This helps in organizing and managing Nuclio components within the cluster.

```bash
minikube kubectl -- create namespace nuclio
```

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

### Verify Nuclio Pods are Running with kubectl

Source: https://docs.nuclio.io/en/stable/setup/gke/getting-started-gke

This command lists all pods within the `nuclio` namespace. It is used to verify that the Nuclio controller and dashboard pods have been successfully deployed and are running on the Kubernetes cluster. Successful execution indicates that the Nuclio installation is complete.

```shell
kubectl --namespace nuclio get pods
```

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

### Set up and Run Nuclio Kubernetes Platform Tests

Source: https://docs.nuclio.io/en/stable/_sources/devel/contributing

This sequence installs Nuclio CRDs, starts a local Docker registry, and then runs the Kubernetes platform integration tests using `make test-k8s`. It requires shell access, Docker, and Kubernetes.

```shell
# Installing nuclio CRDs
$ sh test/k8s/ci_assets/install_nuclio_crds.sh

# Running local Docker registry
$ docker run --rm -d -p 5000:5000 registry:2

$ make test-k8s
```

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

### Verify Kubernetes Configuration with kubectl

Source: https://docs.nuclio.io/en/stable/setup/gke/getting-started-gke

Verifies the Kubernetes cluster configuration by listing all pods across all namespaces. This command helps confirm that the cluster is accessible and running.

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

```

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

### Run Nuclio on Docker

Source: https://docs.nuclio.io/en/stable/_sources/setup/docker/getting-started-docker

This command initiates the Nuclio dashboard on Docker. It publishes port 8070, mounts the Docker socket for container management, and names the container 'nuclio-dashboard'. The 'stable' tag points to the latest release from the master branch.

```bash
docker run \
  --rm \
  --detach \
  --publish 8070:8070 \
  --volume /var/run/docker.sock:/var/run/docker.sock \
  --name nuclio-dashboard \
  quay.io/nuclio/dashboard:stable-amd64
```

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

### Add Function Ingress Host to /etc/hosts

Source: https://docs.nuclio.io/en/stable/setup/minikube/getting-started-minikube

Appends an entry to the /etc/hosts file to map a function's domain name to the Minikube IP address. This is necessary when using the `--addons ingress` for function ingresses.

```bash
echo "$(minikube ip) my-function.info" | sudo tee -a /etc/hosts
```

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

### Get GKE Cluster Credentials with gcloud

Source: https://docs.nuclio.io/en/stable/setup/gke/getting-started-gke

Retrieves the credentials for the 'nuclio' GKE cluster and updates the kubeconfig file to enable access. This is necessary to interact with the cluster using kubectl.

```bash
gcloud container clusters get-credentials nuclio

```

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

### Create GKE Kubernetes Cluster with gcloud

Source: https://docs.nuclio.io/en/stable/setup/gke/getting-started-gke

Creates a Kubernetes cluster on Google Kubernetes Engine named 'nuclio'. This command allows customization of machine type, image type, disk size, and node count.

```bash
gcloud container clusters create nuclio --machine-type n1-standard-2 --image-type COS --disk-size 100 --num-nodes 2 --no-enable-legacy-authorization

```

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

### Create GCR Service Account Key with gcloud

Source: https://docs.nuclio.io/en/stable/setup/gke/getting-started-gke

Creates a service-to-service key for GKE to access Google Container Registry (GCR). This key is stored in 'credentials.json' and allows Nuclio functions to push/pull images.

```bash
gcloud iam service-accounts keys create credentials.json --iam-account $(gcloud iam service-accounts list --format "value(email)")

```

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

### Install kubectl CLI using Azure CLI

Source: https://docs.nuclio.io/en/stable/_sources/setup/aks/getting-started-aks

Installs the kubectl command-line tool, used for interacting with Kubernetes clusters. This command is part of the Azure CLI.

```bash
az aks install-cli
```

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

### Run Nuclio UI Development Server (Shell)

Source: https://docs.nuclio.io/en/stable/_sources/devel/local-development

Installs dependencies and starts the Nuclio UI development server using `npm` and `gulp`. This command watches for changes and recompiles the UI assets, facilitating front-end development.

```shell
npm install
gulp watch --dev
```

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

### Install Grafana using Helm (Bash)

Source: https://docs.nuclio.io/en/stable/_sources/setup/aks/setup-aks-appinsights-grafana

Command to install Grafana in a Kubernetes cluster using Helm, applying configurations from a local values.yaml file. Ensure Helm is installed and configured for your cluster.

```bash
helm install stable/grafana --values values.yaml
```

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

### Verify kubectl Connection to AKS Cluster

Source: https://docs.nuclio.io/en/stable/_sources/setup/aks/getting-started-aks

Verifies the connection to the Kubernetes cluster by listing the nodes. Requires kubectl to be installed and configured.

```bash
kubectl get nodes
```

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

### Project JSON Response Example

Source: https://docs.nuclio.io/en/stable/_sources/reference/api/README

Example JSON structure for a Nuclio project, including metadata and specification details. This format is returned when listing or retrieving projects.

```JSON
{
  "my-project-1": {
    "metadata": {
      "name": "my-project-1",
      "namespace": "nuclio"
    },
    "spec": {
      "description": "Some description"
    }
  }
}
```

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

### NATS Trigger Configuration Example (YAML)

Source: https://docs.nuclio.io/en/stable/_sources/reference/triggers/nats

This example demonstrates how to configure a NATS trigger in YAML. It specifies the topic to listen to and a custom queue name using Go template fields for dynamic naming.

```yaml
triggers:
  myNatsTopic:
    kind: "nats"
    url: "nats://10.0.0.3:4222"
    attributes:
      "topic": "my.topic"
      "queueName": "{{ .Namespace }}.{{ .Name }}.{{ .Id }}"
```

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

### GET /api/projects

Source: https://docs.nuclio.io/en/stable/reference/api/README

Lists all available projects. Optionally filters by namespace.

```APIDOC
## GET /api/projects

### Description
Lists all available projects. Optionally filters by namespace.

### Method
GET

### Endpoint
/api/projects

### Headers
- **x-nuclio-project-namespace** (string) - Optional - The namespace to filter projects by.

### Response
#### Success Response (200)
- **body** (object) - An object where keys are project names and values contain project metadata and spec.

### Response Example
```json
{
  "my-project-1": {
    "metadata": {
      "name": "my-project-1",
      "namespace": "nuclio"
    },
    "spec": {
      "description": "Some description"
    }
  },
  "my-project-2": {
    "metadata": {
      "name": "my-project-2",
      "namespace": "nuclio"
    },
    "spec": {
      "description": "Some description"
    }
  }
}
```
```

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

### Deploy Nuclio Go Function using nuctl CLI

Source: https://docs.nuclio.io/en/stable/_sources/setup/minikube/getting-started-minikube

Deploys the example 'helloworld' Go function using the nuclt CLI. It specifies the namespace, trigger type, function code path, and Docker registries for building and running images. The `--verbose` flag can be added for more detailed output.

```shell
nuctl deploy helloworld \
    --namespace nuclio \
    --http-trigger-service-type nodePort \
    --path https://raw.githubusercontent.com/nuclio/nuclio/master/hack/examples/golang/helloworld/helloworld.go \
    --registry $(minikube ip):5000 \
    --run-registry localhost:5000
```

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

### Function Template Example - Nuclio API

Source: https://docs.nuclio.io/en/stable/reference/api/README

This snippet provides examples of function templates for Nuclio. It includes templates for Node.js with npm package installation and Python with pip package installation, showcasing build commands and function source code.

```json
{
  "dates:878fefcf-a5ef-4c9b-8099-09d6c57cb426": {
    "metadata": {
      "name": "dates:878fefcf-a5ef-4c9b-8099-09d6c57cb426"
    },
    "spec": {
      "description": "Uses moment.js (which is installed as part of the build) to add a specified amount of time to \"now\", and returns this amount as a string.\n",
      "handler": "handler",
      "runtime": "nodejs",
      "resources": {},
      "build": {
        "functionSourceCode": "<base64 encoded string>",
        "commands": [
          "npm install --global moment"
        ]
      }
    }
  },
  "encrypt:1ce3c946-056a-4ea2-99f2-fa8491d8647c": {
    "metadata": {
      "name": "encrypt:1ce3c946-056a-4ea2-99f2-fa8491d8647c"
    },
    "spec": {
      "description": "Uses a third-party Python package to encrypt the event body, and showcases build commands for installing both OS-level and Python packages.\n",
      "handler": "encrypt:encrypt",
      "runtime": "python",
      "resources": {},
      "build": {
        "functionSourceCode": "<base64 encoded string>",
        "commands": [
          "apk update",
          "apk add --no-cache gcc g++ make libffi-dev openssl-dev",
          "pip install simple-crypt"
        ]
      }
    }
  }
}
```

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

### Example: Build Directives for Python Requirements

Source: https://docs.nuclio.io/en/stable/reference/function-configuration/function-configuration-reference

Demonstrates how to specify build directives to install Python dependencies using pip during the container image build process. This is useful for functions that rely on external Python libraries.

```yaml
build:
  directives:
    postCopy:
      - kind: RUN
        value: "pip install -r /opt/nuclio/requirements.txt"
```

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

### Python Function Entry Point for Nuclio

Source: https://docs.nuclio.io/en/stable/_sources/tasks/deploying-functions

An example of a Python function entry point for Nuclio. It demonstrates accessing context (logger, environment variables) and event data, handling different trigger types, and returning a response.

```python
import os


def my_entry_point(context, event):

	# use the logger, outputting the event body
	context.logger.info_with('Got invoked',
		trigger_kind=event.trigger.kind,
		event_body=event.body,
		some_env=os.environ.get('MY_ENV_VALUE'))

	# check if the event came from cron
	if event.trigger.kind == 'cron':

		# log something
		context.logger.info('Invoked from cron')

	else:

		# return a response
		return 'A string response'
```

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

### Go Hello World Function Handler (Go)

Source: https://docs.nuclio.io/en/stable/_sources/tasks/deploying-pre-built-functions

A simple Go function handler for Nuclio that logs a message and returns a "Hello, from Nuclio" response.

```go
package main

import (
	"github.com/nuclio/nuclio-sdk-go"
)

func Handler(context *nuclio.Context, event nuclio.Event) (interface{}, error) {
	context.Logger.Info("This is an unstructured %s", "log")

	return nuclio.Response{
		StatusCode:  200,
		ContentType: "application/text",
		Body:        []byte("Hello, from Nuclio :]"),
	}, nil
}

```

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

### Creating a project

Source: https://docs.nuclio.io/en/stable/reference/api/README

Creates a new project.

```APIDOC
## POST /projects

### Description
Creates a new project.

### Method
POST

### Endpoint
/projects

#### Request Body
- **project** (object) - Required - The project object to create.
  - **metadata** (object) - Required - Metadata for the project.
    - **name** (string) - Required - The name of the project.

### Request Example
```json
{
  "project": {
    "metadata": {
      "name": "new-project"
    }
  }
}
```

### Response
#### Success Response (201)
- **project** (object) - The created project object.
  - **metadata** (object) - Metadata about the project.

#### Response Example
```json
{
  "metadata": {
    "name": "new-project"
  }
}
```
```

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

### Deploy Bash Script Function with Nuclio CLI

Source: https://docs.nuclio.io/en/stable/reference/runtimes/shell/shell-reference

Deploys a serverless function using a bash script as the handler. It specifies the runtime as 'shell' and the handler file. This example uses the 'rev' command to reverse the event body.

```shell
#!/bin/sh

# @nuclio.configure
#
# function.yaml:
#   apiVersion: "nuclio.io/v1"
#   kind: "NuclioFunction"
#   spec:
#     runtime: "shell"
#     handler: "reverser.sh"
#

rev /dev/stdin

```

```shell
nuctl deploy -p /tmp/nuclio-shell-script/reverser.sh rev

```

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

### Download Go Handler Example

Source: https://docs.nuclio.io/en/stable/_sources/tasks/deploy-functions-from-dockerfile

Downloads a simple Go handler file from a URL to the current directory. This is a prerequisite for building a Go function with Docker.

```sh
curl -LO https://raw.githubusercontent.com/nuclio/nuclio/master/hack/examples/golang/helloworld/helloworld.go
```

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

### Example: Configuring Readiness Probe

Source: https://docs.nuclio.io/en/stable/reference/function-configuration/function-configuration-reference

Shows how to configure the readiness probe for a Nuclio function, specifying parameters like initial delay, check period, timeout, and failure threshold. This ensures the function is ready to serve traffic before being considered active.

```yaml
readinessProbe:
  initialDelaySeconds: 5
  periodSeconds: 10
  timeoutSeconds: 5
  failureThreshold: 3
```

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

### Create AKS Resource Group using Azure CLI

Source: https://docs.nuclio.io/en/stable/_sources/setup/aks/getting-started-aks

Creates an Azure resource group to host AKS resources. Requires Azure CLI and an Azure account. Takes resource group name and location as input.

```bash
az group create --name <resource-group-name> --location <location>
```

```bash
az group create --name my-nuclio-k8s-rg --location westeurope
```

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

### Deploy Executable Binary Function with Nuclio CLI

Source: https://docs.nuclio.io/en/stable/reference/runtimes/shell/shell-reference

Deploys a serverless function using an executable binary ('convert' from ImageMagick) as the handler. It specifies the runtime, a build command to install ImageMagick, the handler, and runtime attributes for image conversion.

```shell
nuctl deploy -p /dev/null convert \
    --runtime shell \
    --build-command "apk --update --no-cache add imagemagick" \
    --handler convert \
    --runtime-attrs '{"arguments": "- -resize 50% fd:1"}'

```

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

### Build Nuclio Artifacts and Run Tests

Source: https://docs.nuclio.io/en/stable/_sources/devel/contributing

This section covers building Nuclio's `nuctl` and container images using `make build`, and then running unit tests with `make lint test-unit`. It depends on Docker and the Go toolchain.

```shell
make build
make lint test-unit
```

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

### Display Nuclio CLI Help

Source: https://docs.nuclio.io/en/stable/reference/nuctl/nuctl

This command displays the full usage instructions and available options for the Nuclio CLI ('nuctl'). It is the primary way to understand the tool's capabilities after installation.

```bash
nuctl --help

```

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

### Assign Cluster-Admin Permissions with kubectl and gcloud

Source: https://docs.nuclio.io/en/stable/setup/gke/getting-started-gke

Assigns cluster-admin permissions to the current GKE user for managing RBAC roles. It first retrieves the user's email address and then creates a cluster role binding. Requires 'jq'.

```bash
GKE_USER=$(gcloud projects get-iam-policy "$(gcloud config list --format 'value(core.project)')" --format json 
           | jq -r '.bindings[] | select(.role == "roles/owner") | .members[]' 
           | awk -F':' '{print $2}')

kubectl create clusterrolebinding cluster-admin-binding --clusterrole cluster-admin --user $GKE_USER

```

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

### Display Nuclio CLI Help Information

Source: https://docs.nuclio.io/en/stable/_sources/reference/nuctl/nuctl

This command displays the full usage instructions and available options for the Nuclio CLI ('nuctl'). It's a fundamental command for understanding how to interact with the tool. No specific dependencies beyond the `nuctl` binary itself.

```sh
nuctl --help
```

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

### Basic Cron Trigger Configuration (YAML)

Source: https://docs.nuclio.io/en/stable/_sources/reference/triggers/cron

This example demonstrates a basic configuration for a Nuclio Cron trigger using a YAML format. It specifies the trigger kind as 'cron' and sets a fixed interval of 3 seconds for execution. This is a fundamental setup for scheduled function invocations.

```yaml
triggers:
  myCronTrigger:
    kind: cron
    attributes:
      interval: 3s
```

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

### Deploy Nuclio Function with nuctl CLI

Source: https://docs.nuclio.io/en/stable/concepts/k8s/function-ingress

Command to deploy a Nuclio function using the `nuctl` CLI. This command specifies the path to the function's source code (a Golang file in this example), the image registry, the function name, and other deployment-related options. It relies on `nuctl` being installed and configured to interact with a Kubernetes cluster.

```bash
nuctl deploy -p https://raw.githubusercontent.com/nuclio/nuclio/master/hack/examples/golang/ingress/ingress.go --registry $(minikube ip):5000 ingress --run-registry localhost:5000 --verbose

```

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

### Configure NATS JetStream Trigger

Source: https://docs.nuclio.io/en/stable/_sources/reference/triggers/natsjetstream

Example configuration for a NATS JetStream trigger. It specifies the trigger kind, the NATS URL, and essential attributes like the stream and consumer names. This setup allows Nuclio functions to consume messages from a specified NATS JetStream stream and consumer.

```yaml
triggers:
  myNatsJetStream:
    kind: "natsjetstream"
    url: "nats://10.0.0.3:4222"
    attributes:
      stream: "mystream"
      consumer: "myconsumer"
```

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

### Run Nuclio Docker Platform Integration Tests

Source: https://docs.nuclio.io/en/stable/_sources/devel/contributing

This command executes the integration tests for the Docker platform using `make test`. Be aware that this process can take approximately 90 minutes to complete. Docker must be installed.

```shell
make test
```

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

### Run Nuclio Dashboard in Docker (Shell)

Source: https://docs.nuclio.io/en/stable/devel/local-docker-development

This script executes the Nuclio dashboard within a Docker container. It determines the system architecture (arm64 or amd64) to pull the correct image and maps the host port 8070 to the container's port. It requires Docker to be installed and running.

```shell
if [[ $(uname -m) -eq "arm64" ]]; then
  ARCH="arm64"
else
  ARCH="amd64"
fi

COMMAND="docker run \
    --rm -p 8070:8070 \
    -v /var/run/docker.sock:/var/run/docker.sock \
    --name nuclio-dashboard \
    -e NUCLIO_DASHBOARD_NO_PULL_BASE_IMAGES='true' \
    quay.io/nuclio/dashboard:latest-$ARCH"

eval "$COMMAND"

```

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

### Replica Configuration Example

Source: https://docs.nuclio.io/en/stable/reference/triggers/v3iostream

This JSON structure shows the configuration of replicas, including their assigned shards and last heartbeat timestamps, demonstrating how shards are distributed among members of a consumer group.

```json
[
  {
    "member_id": "replica1",
    "shards": "0-3",
    "last_heartbeat": "t0"
  },
  {
    "member_id": "replica2",
    "shards": "4-7",
    "last_heartbeat": "t1"
  },
  {
    "member_id": "replica3",
    "shards": "8-11",
    "last_heartbeat": "t2"
  }
]

```

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

### Create Kubernetes Docker-Registry Secret with kubectl

Source: https://docs.nuclio.io/en/stable/setup/gke/getting-started-gke

This command creates a Kubernetes secret named `registry-credentials` in the `nuclio` namespace. It uses credentials from a local `credentials.json` file to authenticate with a private Docker registry (GCR.io). This is a crucial step for allowing Nuclio to pull container images from a private registry.

```shell
kubectl create secret docker-registry registry-credentials \
    --namespace nuclio \
    --docker-username _json_key \
    --docker-password "$(cat credentials.json)" \
    --docker-server gcr.io \
    --docker-email ignored@nuclio.io

rm credentials.json

```

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

### Get Nuclio Function Information using nuctl CLI

Source: https://docs.nuclio.io/en/stable/_sources/setup/minikube/getting-started-minikube

Retrieves detailed information about a deployed Nuclio function named 'helloworld'. This command helps verify the deployment status, assigned NodePort, and replica count.

```shell
nuctl get function helloworld
```

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

### Create AKS Kubernetes Cluster using Azure CLI

Source: https://docs.nuclio.io/en/stable/_sources/setup/aks/getting-started-aks

Creates a managed Kubernetes cluster on Azure. Requires Azure CLI and a resource group. Takes resource group name, cluster name, and node count as input. Generates SSH keys for secure access.

```bash
az aks create --resource-group <resource-group-name> --name <cluster-name> --node-count <number>
```

```bash
az aks create --resource-group my-nuclio-k8s-rg --name myNuclioCluster --node-count 2 --generate-ssh-keys
```

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

### Install Nuclio CRDs (Bash)

Source: https://docs.nuclio.io/en/stable/_sources/devel/local-development

Installs Nuclio Custom Resource Definitions (CRDs) on a Kubernetes cluster. This script is typically used in a CI environment and requires `kubectl` to be configured.

```bash
test/k8s/ci_assets/install_nuclio_crds.sh
```

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

### MQTT Trigger Configuration

Source: https://docs.nuclio.io/en/stable/_sources/reference/triggers/mqtt

Configuration details for setting up an MQTT trigger, including broker URL, subscriptions, and quality of service levels.

```APIDOC
## MQTT Trigger Configuration

### Description
This section describes the attributes and configuration for the MQTT trigger.

### Method
N/A (Configuration)

### Endpoint
N/A (Configuration)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A (Configuration is typically defined in a configuration file or system settings)

### Request Example
```yaml
triggers:
  myMqttTrigger:
    kind: "mqtt"
    url: "10.0.0.3:1883"
    attributes:
        subscriptions:
        - topic: house/living-room/temperature
          qos: 0
        - topic: weather/humidity
          qos: 0
```

### Response
#### Success Response (200)
N/A (Configuration)

#### Response Example
N/A (Configuration)
```

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

### TimeFilter Structure Example

Source: https://docs.nuclio.io/en/stable/_sources/reference/api/README

An example of the 'timeFilter' object structure used for filtering logs by a specified time range and sort order. Supports ISO 8601 date formats.

```JSON
{
  "since": "2025-05-01T00:00:00Z",
  "until": "2025-05-16T23:59:59Z",
  "sort": "desc"
}
```

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

### Create Kubernetes Cluster with gcloud

Source: https://docs.nuclio.io/en/stable/_sources/setup/gke/getting-started-gke

Creates a Kubernetes cluster named 'nuclio' with specified machine type, image type, disk size, and node count. This command is used as the initial step in setting up the Kubernetes environment.

```shell
gcloud container clusters create nuclio --machine-type n1-standard-2 --image-type COS --disk-size 100 --num-nodes 2 --no-enable-legacy-authorization
```

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

### Dockerfile for Golang Nuclio Functions

Source: https://docs.nuclio.io/en/stable/_sources/reference/runtimes/golang/golang-reference

A multi-stage Dockerfile for building and deploying Golang functions with Nuclio. It utilizes builder images for compilation and includes necessary components like the processor binary and handler plugin.

```dockerfile
ARG NUCLIO_LABEL=0.5.6
ARG NUCLIO_ARCH=amd64
ARG NUCLIO_BASE_IMAGE=alpine:3.20
ARG NUCLIO_ONBUILD_IMAGE=nuclio/handler-builder-golang-onbuild:${NUCLIO_LABEL}-${NUCLIO_ARCH}-alpine

# Supplies processor uhttpc, used for healthcheck
FROM gcr.io/iguazio/uhttpc:0.0.3-amd64 as uhttpc

# Builds source, supplies processor binary and handler plugin
FROM ${NUCLIO_ONBUILD_IMAGE} as builder

# From the base image
FROM ${NUCLIO_BASE_IMAGE}

# Copy required objects from the suppliers
COPY --from=builder /home/nuclio/bin/processor /usr/local/bin/processor
COPY --from=builder /home/nuclio/bin/handler.so /opt/nuclio/handler.so
COPY --from=uhttpc /home/nuclio/bin/uhttpc /usr/local/bin/uhttpc

# Readiness probe
HEALTHCHECK --interval=1s --timeout=3s CMD /usr/local/bin/uhttpc --url http://127.0.0.1:8082/ready || exit 1

# Run processor with configuration and platform configuration
CMD [ "processor" ]
```