### Install dependencies

Source: https://www.windmill.dev/docs/apps/react_components

Install the necessary project dependencies before starting development.

```bash
npm install
```

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

### Verify Nushell Installation

Source: https://www.windmill.dev/docs/misc/windows_workers

Start Nushell to verify installation.

```powershell
nu  
```

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

### Install service with NSSM

Source: https://www.windmill.dev/docs/misc/windows_workers

Use the NSSM GUI to install the service.

```powershell
nssm install WindmillWorker
```

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

### Flow preview example

Source: https://www.windmill.dev/docs/advanced/cli/dev-preview

Example of previewing a local flow with specific input data.

```bash
wmill flow preview f/my_flows/etl__flow --data '{"date":"2026-01-01"}'
```

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

### Worker Setup (Go)

Source: https://www.windmill.dev/docs/misc/benchmarks/competitors/hatchet

This Go program sets up a Hatchet worker named 'fibo-workflow-worker'. It registers the 'FibonacciWorkflow' and 'BulkFibonacciWorkflow' and starts the worker in a blocking manner, listening for tasks until an interrupt signal is received.

```go
package main

import (
    hatchet_client "hatchet-go-quickstart/hatchet_client"
    workflows "hatchet-go-quickstart/workflows"

    "github.com/hatchet-dev/hatchet/pkg/cmdutils"
    "github.com/hatchet-dev/hatchet/pkg/v1/worker"
    "github.com/hatchet-dev/hatchet/pkg/v1/workflow"
)

func main() {

    hatchet, err := hatchet_client.HatchetClient()

    if err != nil {
        panic(err)
    }

    worker, err := hatchet.Worker(
        worker.WorkerOpts{
            Name: "fibo-workflow-worker",
            Workflows: []workflow.WorkflowBase{
                workflows.FibonacciWorkflow(hatchet),
                workflows.BulkFibonacciWorkflow(hatchet),
            },
            Slots: 1,
        },
    )

    if err != nil {
        panic(err)
    }

    interruptCtx, cancel := cmdutils.NewInterruptContext()

    defer cancel()

    err = worker.StartBlocking(interruptCtx)

    if err != nil {
        panic(err)
    }
}
```

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

### Script preview examples

Source: https://www.windmill.dev/docs/advanced/cli/dev-preview

Examples showing how to preview regular scripts, codebase scripts, and using silent mode for piping.

```bash
# Regular script
wmill script preview u/admin/my_script.ts --data '{"x": 5}'

# Codebase script (bundled before preview)
wmill script preview f/codebase_test/my_script.ts --data '{"x": 7}'

# Silent mode for piping
wmill script preview f/scripts/hello.ts -d '{"n":3}' --silent | jq
```

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

### Install App Dependencies

Source: https://www.windmill.dev/docs/full_code_apps/cli_workflow

After scaffolding a new app, navigate to its directory and run this command to install necessary project dependencies.

```bash
cd f/folder/my_app.raw_app   # or my_app__raw_app  
npm install  
```

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

### Installing NuGet Packages in Windmill

Source: https://www.windmill.dev/docs/getting_started/scripts_quickstart/csharp

Demonstrates how to install NuGet packages at the top of a Windmill script file. Only lines at the very top are considered for package installation.

```csharp
#r "nuget: Humanizer, 2.14.1"
#r "nuget: AutoMapper, 6.1.0"

```

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

### Create a new Windmill app using CLI

Source: https://www.windmill.dev/docs/getting_started/full_code_apps_quickstart

Use the Windmill CLI to scaffold a new full-code application. Follow the prompts to choose a framework and data configuration, then install dependencies and start the development server.

```bash
wmill app new  

```

```bash
cd f/folder/my_app.raw_app  
npm install  
wmill app dev  

```

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

### Start Development Server

Source: https://www.windmill.dev/docs/advanced/cli/app

Starts a local development server with hot reload and WebSocket backend from within the app directory. Options include `--port`, `--host`, `--entry`, and `--no-open`.

```bash
wmill app dev  

```

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

### Install uv for Python Executor

Source: https://www.windmill.dev/docs/misc/windows_workers

Install the uv package manager using PowerShell.

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"  
```

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

### Install Playwright via uv

Source: https://www.windmill.dev/docs/advanced/preinstall_binaries

Install the Playwright tool and its required browser binaries and dependencies.

```bash
uv tool install playwright
playwright install
playwright install-deps
```

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

### Install Global Site-Packages

Source: https://www.windmill.dev/docs/advanced/dependencies_in_python

Use uv to install packages into the global site-packages directory to make them available across all scripts on a worker.

```bash
uv pip install --system pandas --target /tmp/windmill/cache/python_3_11/global-site-packages  
```

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

### List .NET SDKs

Source: https://www.windmill.dev/docs/misc/windows_workers

Verify the installation of .NET SDKs.

```powershell
dotnet --list-sdks  
```

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

### Start service with NSSM

Source: https://www.windmill.dev/docs/misc/windows_workers

Start the service using the NSSM manager.

```powershell
nssm start WindmillWorker
```

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

### Kubernetes example with CloudNativePG

Source: https://www.windmill.dev/docs/advanced/high_availability

This example demonstrates setting up Windmill on Kubernetes when using CloudNativePG for PostgreSQL management. No specific code is provided, but it indicates a configuration context.

```yaml
```
```

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

### Install Pandas to global-site-packages

Source: https://www.windmill.dev/docs/advanced/preinstall_binaries

Use uv to install a package into a specific target directory for use as a local dependency.

```bash
uv pip install --system pandas --target /tmp/windmill/cache/python_3_11/global-site-packages
```

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

### PHP Dependency File Example

Source: https://www.windmill.dev/docs/core_concepts/workspace_dependencies

Example of a PHP dependency file (`web.composer.json`) for managing PHP package requirements.

```json
{
  "require": {
    "guzzlehttp/guzzle": "^7.4",
    "monolog/monolog": "^2.8"
  }
}

```

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

### Install Windmill Chart

Source: https://www.windmill.dev/docs/advanced/self_host

Install the Windmill Helm chart with default values. Specify the namespace and create it if it doesn't exist.

```bash
# install chart with default values
helm install windmill-chart windmill/windmill \
      --namespace=windmill \
      --create-namespace
```

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

### Start a flow development loop

Source: https://www.windmill.dev/docs/advanced/cli/dev-preview

Command syntax to start a local dev loop that watches files and pushes changes for interactive testing.

```bash
wmill flow dev <path>
```

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

### Delegate Environment Setup to Git Repository

Source: https://www.windmill.dev/docs/getting_started/scripts_quickstart/ansible

Delegate environment setup to a Git repository by specifying a resource. This feature is available in Enterprise Edition and requires instance-wide blob storage. You can also specify a playbook to execute within the repository.

```yaml
delegate_to_git_repo:
  resource: u/user/git_repo_resource
```

```yaml
delegate_to_git_repo:
  resource: u/user/git_repo_resource
  playbook: playbooks/your_playbook.yml
```

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

### Basic Setup Compute Units Calculation

Source: https://www.windmill.dev/docs/misc/plans_details

This configuration demonstrates a basic setup resulting in 3 Compute Units. It includes two workers with 2GB memory each (1 CU each) and one native worker configured for 8 subworkers (1 CU).

```yaml
services:
  # Other services (db, server, caddy, etc.) don't count towards CUs
    
  windmill_worker_custom_name:
    deploy:
      replicas: 2  # 2 workers × 1 CU each = 2 CUs
      resources:
        limits:
          memory: 2048M  # 2GB = 1 CU per worker
    
  windmill_worker_native:
    deploy:
      replicas: 1  # 1 worker with subworkers NUM_WORKERS=8 = 1 CU
      resources:
        limits:
          memory: 2048M
    environment:
      - WORKER_GROUP=native
      - NATIVE_MODE=true

```

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

### Locate .NET Installation

Source: https://www.windmill.dev/docs/misc/windows_workers

Find the path to the .NET executable.

```powershell
where.exe dotnet  
```

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

### Start development server

Source: https://www.windmill.dev/docs/apps/react_components

Launch the local development server to preview changes.

```bash
npm run dev
```

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

### Start the development server

Source: https://www.windmill.dev/docs/full_code_apps

Navigate to the app directory and launch the local development environment with hot reloading.

```bash
cd f/folder/my_app.raw_app   # or my_app__raw_app  
wmill app dev .
```

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

### Trigger Synchronous GET Request with cURL

Source: https://www.windmill.dev/docs/core_concepts/webhooks

Example of a synchronous GET request using an Authorization header.

```bash
## Request with Header".  
curl -X GET \
    -H "Content-Type: application/json"    \
    -H "Authorization: Bearer supersecret" \
    ".../w/demo/jobs/run_wait_result/p/u/bot/hello_world_deno?payload=<URL_SAFE_BASE64_ENCODED_JSON>"  
```

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

### Starter Main Implementation

Source: https://www.windmill.dev/docs/misc/benchmarks/competitors/temporal

Initializes multiple worker processes, waits for their readiness, and triggers the benchmark workflow.

```go
package main  
  
import (  
    "context"  
    "flag"  
    "fmt"  
    "log"  
    "os"  
    "os/exec"  
    "path/filepath"  
    "strconv"  
    "sync"  
    "time"  
  
    "go.temporal.io/sdk/client"  
)  
  
func main() {  
    // Parse command line arguments  
    iter := flag.Int("iter", 10, "Number of iterations")  
    fiboN := flag.Int("fibo-n", 33, "Fibonacci number to calculate")  
    workers := flag.Int("workers", 1, "Number of worker processes")  
    parallel := flag.Bool("parallel", false, "Run in parallel mode")  
    flag.Parse()  
  
    log.Printf("Starting benchmark with %d workers, %d iterations, fibo(%d), parallel=%v", *workers, *iter, *fiboN, *parallel)  
  
    // Keep track of worker processes  
    var workerProcesses []*os.Process  
    var wg sync.WaitGroup  
  
    // Start worker processes  
    for i := 0; i < *workers; i++ {  
        cmd := exec.Command("go", "run", "./cmd/worker/main.go",  
            "-iter", strconv.Itoa(*iter),  
            "-fibo-n", strconv.Itoa(*fiboN),  
            fmt.Sprintf("-parallel=%v", *parallel))  
        cmd.Stdout = os.Stdout  
        cmd.Stderr = os.Stderr  
        log.Printf("Starting worker %d with command: %v", i, cmd.Args)  
        if err := cmd.Start(); err != nil {  
            log.Fatalf("Failed to start worker %d: %v", i, err)  
        }  
        workerProcesses = append(workerProcesses, cmd.Process)  
        log.Printf("Started worker %d with PID %d", i, cmd.Process.Pid)  
  
        // Set up wait group for worker  
        wg.Add(1)  
        go func(cmd *exec.Cmd) {  
            defer wg.Done()  
            cmd.Wait()  
        }(cmd)  
    }  
  
    // Wait for all workers to signal ready  
    log.Printf("Waiting for %d workers to initialize...", *workers)  
    readyCount := 0  
    deadline := time.Now().Add(10 * time.Second)  
    for readyCount < *workers && time.Now().Before(deadline) {  
        files, err := filepath.Glob(fmt.Sprintf("/tmp/worker_%d_*.ready", *iter))  
        if err != nil {  
            log.Fatalf("Failed to check for ready files: %v", err)  
        }  
        if len(files) > readyCount {  
            readyCount = len(files)  
            log.Printf("%d/%d workers ready...", readyCount, *workers)  
        }  
        if readyCount < *workers {  
            time.Sleep(100 * time.Millisecond)  
        }  
    }  
  
    if readyCount < *workers {  
        log.Fatalf("Timed out waiting for workers to initialize. Only %d/%d workers ready", readyCount, *workers)  
    }  
  
    log.Printf("All %d workers ready! Starting workflow...", *workers)  
  
    // Create a client to talk to the Temporal server  
    c, err := client.Dial(client.Options{})  
    if err != nil {  
        log.Fatalln("Unable to create client", err)  
    }  
    defer c.Close()  
  
    // Define workflow options  
    workflowID := fmt.Sprintf("bench_%d_%d", *iter, *fiboN)  
    workflowOptions := client.StartWorkflowOptions{  
        ID:        workflowID,  
        TaskQueue: fmt.Sprintf("bench-%d-task-queue", *iter),  
    }  
  
    log.Printf("Starting workflow with ID %s on task queue %s", workflowOptions.ID, workflowOptions.TaskQueue)  
  
    // Start the workflow with parameters  
```

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

### Install Puppeteer via npm in Windmill EE

Source: https://www.windmill.dev/docs/advanced/preinstall_binaries

Install Puppeteer using npm within the Windmill Enterprise Edition base image. This example demonstrates updating apt, installing Node.js, and then globally installing the Puppeteer package.

```dockerfile
FROM ghcr.io/windmill-labs/windmill-ee:main  
  
RUN apt update  
RUN apt install npm -y  
RUN mkdir -p /etc/apt/keyrings  
RUN curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key |  gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg  
RUN echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list  
RUN apt-get update -y  
RUN apt install nodejs libnss3-dev  libatk1.0-0 libatk-bridge2.0-0 libcups2-dev  libdrm-dev libxkbcommon-dev libxcomposite-dev libxdamage-dev libxrandr-dev\  
  libgbm-dev libpango-1.0 libcairo-dev libasound-dev -y  
RUN npm install -g puppeteer -y  
  
CMD ["windmill"]  

```

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

### Set and Get Flow User State in Python

Source: https://www.windmill.dev/docs/core_concepts/resources_and_types

Utilize `set_flow_user_state` for storing and `get_flow_user_state` for retrieving data across flow steps. Ensure `wmill` is installed.

```python
import wmill  
#extra_requirements:  
#wmill==1.297.0  
  
def main(x: str):  
    # Set flow user state  
    wmill.set_flow_user_state("foobar", 43)  
  
    # Get flow user state  
    return wmill.get_flow_user_state("foobar")  


```

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

### JavaScript Temporal Worker Setup

Source: https://www.windmill.dev/docs/misc/benchmarks/competitors/temporal

Configures and runs a Temporal worker in JavaScript. It connects to Temporal, registers activities and workflows, and starts a benchmarking workflow. Ensure Temporal is running and accessible.

```typescript
// ------------------------------------------------------  
// worker.ts  
import { Worker } from '@temporalio/worker';  
import { fiboActivity } from './activities';  
import { bench10Workflow } from './workflows';  
import { Client } from '@temporalio/client';  
  
const ITER = 10; // respectively 40  
  
async function run() {  
    const worker = await Worker.create({  
        workflowsPath: require.resolve('./workflows'),  
        activities: { fiboActivity },  
        taskQueue: `bench-${ITER}`,  
    });  
  
    const client = new Client();  
  
    // Launch the workflow  
    await client.workflow.start(bench10Workflow, {  
        workflowId: `bench-${ITER}`,  
        taskQueue: `bench-${ITER}`,  
    });  
  
    await worker.run();  
    process.exit(0);  
}  
  
run().catch((err) => {  
    console.error(err);  
    process.exit(1);  
});  
```

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

### Initialize Windmill with Docker

Source: https://www.windmill.dev/docs/advanced/self_host

Download the required configuration files and start the Windmill services.

```bash
curl https://raw.githubusercontent.com/windmill-labs/windmill/main/docker-compose.yml -o docker-compose.yml  
curl https://raw.githubusercontent.com/windmill-labs/windmill/main/Caddyfile -o Caddyfile  
curl https://raw.githubusercontent.com/windmill-labs/windmill/main/.env -o .env  
  
docker compose up -d  
```

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

### Extend Windmill Base Image

Source: https://www.windmill.dev/docs/advanced/preinstall_binaries

Extend the base Windmill image to include custom binaries or software. This involves using a Dockerfile that starts from the Windmill base image and adds installation commands.

```dockerfile
FROM ghcr.io/windmill-labs/windmill:main  
# or FROM ghcr.io/windmill-labs/windmill-ee:main for extending the enterprise edition  
  
RUN apt-get update && apt install [...]  
  
CMD ["windmill"]  

```

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

### Basic Go Script Example

Source: https://www.windmill.dev/docs/getting_started/scripts_quickstart/go

This Go script sends an HTTP GET request to a given URL and checks if the status code indicates success (2xx). Ensure the URL is valid. The response body is closed using defer.

```go
package inner  
  
import (  
	"net/http"  
)  
  
func main(url string) (bool, error) {  
	resp, err := http.Get(url) // send a GET request to the provided URL  
	if err != nil {  
		return false, err // if there is an error, return false and the error  
	}
	defer resp.Body.Close() // make sure to close the response body when the function returns  
  
	// if the status code is between 200 and 299, the page exists  
	if resp.StatusCode >= 200 && resp.StatusCode <= 299 {  
		return true, nil  
	}
  
	// if the status code is not between 200 and 299, the page does not exist  
	return false, nil  
}

```

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

### Switch Workspace and Sync Example

Source: https://www.windmill.dev/docs/advanced/cli/sync

This sequence demonstrates how to switch between remote workspaces and perform bidirectional synchronization. It's crucial to ensure you are in the correct workspace before pulling or pushing to avoid data loss.

```bash
wmill workspace switch <source_workspace_id>
wmill sync pull
wmill workspace switch <target_workspace_id>
wmill sync push

```

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

### Implement a basic Hello World script

Source: https://www.windmill.dev/docs/getting_started/scripts_quickstart/typescript

A simplified script example that accepts a name argument and returns it in an object.

```typescript
export async function main(name: string) {  
	console.log("Hello world! Oh, it's you %s? Greetings!", name);  
	return { name };  
}  

```

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

### Install the Windmill Python package

Source: https://www.windmill.dev/docs/advanced/clients/python_client

Use pip to install the wmill package.

```bash
pip install wmill
```

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

### Install Windmill Client

Source: https://www.windmill.dev/docs/advanced/clients/ts_client

Import the Windmill client module for Deno or Bun environments.

```TypeScript (Deno)
import * as wmill from 'npm:windmill-client@1.318.0';
```

```TypeScript (Bun)
import * as wmill from 'windmill-client';
```

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

### Linting Examples

Source: https://www.windmill.dev/docs/advanced/cli/lint

Common patterns for running lint on directories or with specific output formats.

```bash
wmill lint  
```

```bash
wmill lint f/my_project --json  
```

```bash
wmill lint --locks-required  
```

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

### Initialize local workspace directory

Source: https://www.windmill.dev/docs/advanced/local_development

Create a new directory to serve as the local workspace root.

```bash
mkdir myworkspace  
cd myworkspace  
```

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

### Main Function Example

Source: https://www.windmill.dev/docs/core_concepts/gcp_triggers

Example of a main function that receives processed data from the preprocessor.

```APIDOC
## Main Function

### Description
This main function demonstrates how to use the data passed from the preprocessor.

### Method
`export async function main(messageAsDecodedString: string, contentType?: string, parsedMessage?: any, attributes?: Record<string, string>)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
(This function receives arguments from the preprocessor, not a direct request body)

### Response
(This function primarily logs output and does not return a structured response in this example)

#### Response Example
```
Decoded String: { \"content-type\": \"application/json\" }
Content-Type: application/json
Parsed Message: { \"content-type\": \"application/json\" }
Attributes: { \"content-type\": \"application/json\" }
```
```

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

### Install Playwright via uv in Windmill EE

Source: https://www.windmill.dev/docs/advanced/preinstall_binaries

Install Playwright and its dependencies using uv within the Windmill Enterprise Edition base image. This approach leverages uv for managing Python tools and their installations.

```dockerfile
FROM ghcr.io/windmill-labs/windmill-ee:main  
  
RUN uv tool install playwright  
RUN playwright install  
RUN playwright install-deps  
  
CMD ["windmill"]  

```

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

### PHP Script with Dependencies

Source: https://www.windmill.dev/docs/getting_started/scripts_quickstart/php

This PHP script demonstrates how to define a main function and optionally specify dependencies using Composer comments. Uncomment 'require' lines to install packages.

```php
<?php  
  
// remove the first // of the following lines to specify packages to install using composer  
// // require:  
// // monolog/monolog@3.6.0  
// // stripe/stripe-php  
  
function main(  
	// Postgresql $a,  
  // array $b,  
  // object $c,  
	int $d = 123,  
	string $e = "default value",  
	float $f = 3.5,  
  bool $g = true,  
) {  
	return $d;  
}  

```

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

### Verify Windmill CLI Installation

Source: https://www.windmill.dev/docs/advanced/cli/installation

Checks if the Windmill CLI was installed successfully by displaying its version.

```bash
wmill --version
```

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

### Create PostgreSQL Flexible Server

Source: https://www.windmill.dev/docs/advanced/self_host/azure_entra_id

Provisions a PostgreSQL Flexible Server instance with the specified configuration.

```bash
az postgres flexible-server create \
  --name <pg-server> \
  --resource-group <rg> \
  --tier GeneralPurpose \
  --sku-name Standard_D4s_v3 \
  --storage-size 256 \
  --admin-user windmill \
  --admin-password '<strong-password>' \
  --version 16
```

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

### TypeScript Dependency File Example

Source: https://www.windmill.dev/docs/core_concepts/workspace_dependencies

Example of a TypeScript dependency file (`api.package.json`) listing dependencies.

```json
{
  "dependencies": {
    "axios": "^0.27.2",
    "lodash": "^4.17.21",
    "windmill-client": "^1.147.3"
  }
}

```

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

### Preprocessor Function Example

Source: https://www.windmill.dev/docs/core_concepts/gcp_triggers

Example of a preprocessor function to decode and parse the Pub/Sub message payload.

```APIDOC
## Preprocessor Function

### Description
This preprocessor decodes a base64 encoded Pub/Sub message payload and attempts to parse it as JSON if the content type indicates so.

### Method
`export async function preprocessor(event: { kind: 'gcp', payload: string, message_id: string, subscription: string, ordering_key?: string, attributes?: Record<string, string>, delivery_type: "push" | "pull", headers?: Record<string, string>, publish_time?: string })

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```typescript
{
  "kind": "gcp",
  "payload": "eyAiY29udGVudC10eXBlIjogImFwcGxpY2F0aW9uL2pzb24iIH0=", // base64 encoded string
  "message_id": "1234567890",
  "subscription": "my-subscription",
  "attributes": {
    "content-type": "application/json"
  },
  "delivery_type": "push"
}
```

### Response
#### Success Response (200)
- **messageAsDecodedString** (string) - The decoded payload string.
- **contentType** (string) - The detected content type of the message.
- **parsedMessage** (any) - The parsed message payload (JSON object if applicable, otherwise the decoded string).
- **attributes** (object) - The message attributes.

#### Response Example
```json
{
  "messageAsDecodedString": "{ \"content-type\": \"application/json\" }",
  "contentType": "application/json",
  "parsedMessage": {
    "content-type": "application/json"
  },
  "attributes": {
    "content-type": "application/json"
  }
}
```

### Error Handling
- Throws an error if the `event.kind` is not 'gcp'.
- Throws an error if the payload is invalid JSON when `content-type` is `application/json`.
```

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

### Install and Use Windmill CLI

Source: https://www.windmill.dev/docs/core_concepts/infrastructure_as_code

Install the Windmill CLI globally using npm. Add a workspace by providing its URL and an authentication token. Pull workspace content to local files and push local changes back to the workspace. Use the `--yes` flag to bypass confirmation prompts.

```bash
# Install the CLI  
npm install -g windmill-cli  
  
# Add a workspace  
wmill workspace add my-workspace https://windmill.example.com/ --token <your-token>  
  
# Pull workspace content to local files  
wmill sync pull  
  
# Edit scripts/flows locally, then push changes back  
wmill sync push --yes  

```

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

### Python Dependency File Example

Source: https://www.windmill.dev/docs/core_concepts/workspace_dependencies

Example of a Python dependency file (`ml.requirements.in`) specifying package versions.

```python
pandas>=1.5.0  
numpy>=1.21.0  
scikit-learn==1.1.2  
matplotlib>=3.5.0  

```

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

### Define Kerberos Configuration File

Source: https://www.windmill.dev/docs/core_concepts/kafka_triggers

Example krb5.conf file for configuring Kerberos realms and domain mappings in containerized environments.

```ini
[libdefaults]  
    default_realm = EXAMPLE.COM  
    dns_lookup_realm = false  
    dns_lookup_kdc = false  
    # Recommended for containerized environments - see troubleshooting below  
    dns_canonicalize_hostname = false  
  
[realms]  
    EXAMPLE.COM = {  
        kdc = kdc.example.com  
        admin_server = kdc.example.com  
    }  
  
[domain_realm]  
    .example.com = EXAMPLE.COM  
    example.com = EXAMPLE.COM  
```

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

### Secret Masking Example

Source: https://www.windmill.dev/docs/core_concepts/variables_and_secrets

Example of how secret values appear in job logs when automatically masked by Windmill.

```text
my_*****  
[windmill] secret value was masked for security reasons, use string transformations to display partial values  
```

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

### Create Database for Non-Superuser

Source: https://www.windmill.dev/docs/advanced/self_host

Initializes the database with a specific owner before applying role privileges.

```sql
CREATE DATABASE windmill OWNER nonsuperuser  
```

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

### Verify Rscript Installation

Source: https://www.windmill.dev/docs/misc/windows_workers

Confirm that Rscript is installed and accessible in your system's PATH by running this command in PowerShell.

```powershell
Rscript --version  

```

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

### Scaffold a new full-code app

Source: https://www.windmill.dev/docs/full_code_apps

Initialize a new project structure using the Windmill CLI.

```bash
wmill app new
```

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

### Verify Java Installation

Source: https://www.windmill.dev/docs/misc/windows_workers

Use this command in PowerShell to check if Java is installed and accessible in your system's PATH.

```powershell
java --version && javac --version  

```

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

### Add a new user with email and password

Source: https://www.windmill.dev/docs/advanced/cli/user

Add a new user by specifying their email and a desired password. This allows for immediate access with known credentials.

```bash
wmill user add example@example.com mypassword123
```

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

### Setting up DuckDB for S3 Access (IDE)

Source: https://www.windmill.dev/docs/core_concepts/data_pipelines

In a typical IDE, you need to manually configure DuckDB with S3 credentials and settings. This includes installing and loading the httpfs extension and setting various S3 parameters.

```python
conn = duckdb.connect()
conn.execute(
    """
    SET home_directory='./';
    INSTALL 'httpfs';
    LOAD 'httpfs';
    SET s3_url_style='path';
    SET s3_region='us-east-1';
    SET s3_endpoint='http://minio:9000'; # using MinIo in Docker works perfectly fine if you don't have access to an AWS S3 bucket! 
    SET s3_use_ssl=0;
    SET s3_access_key_id='<ACCESS_KEY>';
    SET s3_secret_access_key='<SECRET_KEY>';
"""
)
# then you can start using your connection to pull CSVs/Parquet/JSON/... files from S3 
conn.sql("SELECT * FROM read_parquet(s3:// windmill_bucket/file.parquet)")
```

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

### Apply ConfigMap via kubectl

Source: https://www.windmill.dev/docs/core_concepts/infrastructure_as_code

Apply the manually created instance configuration file.

```bash
kubectl apply -f windmill-instance.yaml
```

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

### Install Windmill CLI

Source: https://www.windmill.dev/docs/advanced/cli/installation

Installs the Windmill CLI globally using npm. Requires Node.js version greater than v20.

```bash
npm install -g windmill-cli
```

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

### Start the service

Source: https://www.windmill.dev/docs/misc/windows_workers

Initiate the service using the Windows Service Control Manager.

```powershell
# Replace WindmillWorker with WindmillServer or WindmillAgent as appropriate  
sc.exe start WindmillWorker
```

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

### AgGrid Table Static Input Example

Source: https://www.windmill.dev/docs/apps/app_configuration_settings/aggrid_table

Example of providing static data as an array of objects to the AgGrid table component.

```json
[
	{
		"id": 1,
		"name": "John Doe",
		"age": 25
	},
	{
		"id": 2,
		"name": "Jane Doe",
		"age": 30
	}
]
```