### PolyHub Quickstart Command Example

Source: https://docs.ayedo.de/polycrate/polyhub_q=

This example demonstrates the PolyHub quickstart command for pulling blocks from a registry. It shows how to use `polycrate blocks pull` and highlights the `--blocks-auto-pull` option for deployment.

```bash
polycrate blocks pull
--blocks-auto-pull
```

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

### ArgoCD CLI Commands for Application Management

Source: https://docs.ayedo.de/delivery/application-deployment_q=

Example ArgoCD CLI commands to log in, list available clusters and repositories, and create a new application deployment. These commands facilitate automation and verification of ArgoCD setup.

```bash
# ArgoCD Login via OIDC
argocd login argocd.example.com --sso

# Verfügbare Cluster auflisten
argocd cluster list

# Verfügbare Repositories prüfen
argocd repo list

# ArgoCD Application erstellen
argocd app create my-application-production \
  --project my-team \
  --repo oci://harbor.example.com/my-team \
  --helm-chart my-application \
  --revision 1.0.0 \
  --dest-server https://production-cluster-api.example.com \
  --dest-namespace my-team-production \
  --sync-policy automated \
  --auto-prune \
  --self-heal \
  --helm-set ohmyhelm.chart.container.image=1.0.0
```

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

### Multi-Cloud Setup with Dockerfile.poly

Source: https://docs.ayedo.de/polycrate/der-polycrate-container

This example demonstrates setting up a multi-cloud environment by installing CLIs for Oracle Cloud (oci-cli), DigitalOcean (doctl), and Linode. This allows managing resources across different cloud providers from within the container.

```dockerfile
FROM cargo.ayedo.cloud/library/polycrate:latest

# Oracle Cloud CLI
RUN pip install oci-cli

# DigitalOcean CLI
RUN wget -O /usr/local/bin/doctl https://github.com/digitalocean/doctl/releases/download/v1.100.0/doctl-1.100.0-linux-amd64 && \
    chmod +x /usr/local/bin/doctl

# Linode CLI
RUN pip install linode-cli

```

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

### Base Dockerfile.poly Example

Source: https://docs.ayedo.de/polycrate/der-polycrate-container

A basic Dockerfile.poly example that starts from the official Polycrate image and installs a Python package. This serves as a template for custom builds.

```dockerfile
FROM cargo.ayedo.cloud/library/polycrate:latest

RUN pip install hcloud==1.16.0

```

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

### Install Local Development Tools

Source: https://docs.ayedo.de/delivery/application-deployment_q=

Installs essential command-line tools for local development and deployment, including Docker, Helm, kubectl, ArgoCD CLI, and optionally ohMyHelm.

```shell
# Docker (für Image-Builds)
docker --version

# Helm (für Chart-Management)
helm version

# kubectl (für Cluster-Zugriff)
kubectl version --client

# argocd CLI (für ArgoCD-Interaktion)
argocd version --client

# Optional: ohMyHelm CLI
npm install -g @ayedo/ohmyhelm

```

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

### Add Node.js Tools with Dockerfile.poly

Source: https://docs.ayedo.de/polycrate/der-polycrate-container

This example shows how to install Node.js and npm, and then globally install npm packages like cdktf-cli and serverless. This is beneficial for projects requiring Node.js tooling.

```dockerfile
FROM cargo.ayedo.cloud/library/polycrate:latest

# Node.js und NPM installieren
RUN apk add --no-cache nodejs npm

# Global NPM Packages
RUN npm install -g \
    cdktf-cli \
    serverless

```

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

### Install Polycrate CLI using Automatic Installer

Source: https://docs.ayedo.de/polycrate/installation

Automatically installs the Polycrate CLI by downloading and moving the executable to your system's PATH. This script detects your OS and architecture. Verify the installation with `polycrate version`.

```shell
curl https://raw.githubusercontent.com/polycrate/polycrate/main/get-polycrate.sh | bash

```

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

### Helm Chart Definition for Infrastructure Setup (`Chart.yaml`)

Source: https://docs.ayedo.de/ohmyhelm/examples

Defines the metadata for an infrastructure setup Helm chart. It includes the API version, chart name, version, and specifies a dependency on the `ohmyhelm` chart.

```yaml
# Chart.yaml
apiVersion: v2
name: infrastructure-setup
version: 1.0.0

dependencies:
  - name: ohmyhelm
    alias: infra
    repository: https://gitlab.com/ayedocloudsolutions/ohmyhelm
    version: 1.13.0


```

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

### Add Custom CLIs and Tools with Dockerfile.poly

Source: https://docs.ayedo.de/polycrate/der-polycrate-container

This Dockerfile.poly example illustrates installing custom command-line interfaces and tools such as Tailscale CLI and Velero. It uses wget to download and install binaries, making them available within the container.

```dockerfile
FROM cargo.ayedo.cloud/library/polycrate:latest

# Tailscale CLI
RUN wget https://pkgs.tailscale.com/stable/tailscale_1.56.1_amd64.tgz && \
    tar xzf tailscale_1.56.1_amd64.tgz && \
    mv tailscale_1.56.1_amd64/tailscale /usr/local/bin/ && \
    rm -rf tailscale_*

# Velero (Kubernetes Backup Tool)
RUN wget https://github.com/vmware-tanzu/velero/releases/download/v1.12.0/velero-v1.12.0-linux-amd64.tar.gz && \
    tar xzf velero-v1.12.0-linux-amd64.tar.gz && \
    mv velero-v1.12.0-linux-amd64/velero /usr/local/bin/ && \
    rm -rf velero-*

```

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

### Helm Chart Versioning Example

Source: https://docs.ayedo.de/delivery/application-deployment_q=

This snippet demonstrates how to properly version a Helm chart using Semantic Versioning. It shows the `version` and `appVersion` fields in the `Chart.yaml` file, which are crucial for managing releases and dependencies.

```yaml
# Chart.yaml
version: 1.2.3  # MAJOR.MINOR.PATCH
appVersion: "1.2.3"

```

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

### Manually Download and Install Polycrate CLI (Linux arm64)

Source: https://docs.ayedo.de/polycrate/installation

Manually installs the Polycrate CLI on Linux arm64 systems by downloading a tarball, extracting it, making it executable, and placing it in the current directory. Verify with `./polycrate version`.

```shell
export VERSION="0.22.1"

curl -fsSLo polycrate.tar.gz https://hub.polycrate.io/get/polycrate/${VERSION}/linux_arm64/polycrate_${VERSION}_linux_arm64.tar.gz

tar xvzf polycrate.tar.gz

chmod +x polycrate
./polycrate version

```

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

### Example 2: Multi-Registry Setup in workspace.poly

Source: https://docs.ayedo.de/polycrate/registry

Shows how to configure multiple block sources within the `workspace.poly` file. This allows blocks to be pulled from different registries, including public hubs, private company registries, and Docker Hub.

```yaml
name: my-workspace

blocks:
  # Von öffentlichem Hub
  - name: postgres-base
    from: hub.polycrate.io/ayedo/postgres-base:1.0.0

  # Von privater Company Registry
  - name: company-base
    from: registry.mycompany.com/infra/base:2.0.0

  # Von Docker Hub
  - name: some-tool
    from: index.docker.io/someuser/tool:1.0.0
```

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

### Workflow: Project Setup with Dependencies

Source: https://docs.ayedo.de/polycrate/dependencies_q=

This workflow outlines the steps to set up a project by first cloning the workspace and then automatically pulling all dependencies using 'polycrate run my-app install --blocks-auto-pull'. Alternatively, dependencies can be pulled manually before installation.

```bash
# 1. Workspace klonen
git clone https://github.com/myorg/my-workspace.git
cd my-workspace

# 2. Alle Dependencies automatisch pullen
polycrate run my-app install --blocks-auto-pull

# Oder manuell:
# polycrate blocks pull postgres-base
# polycrate blocks pull redis-base
# polycrate run my-app install

```

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

### Helm Chart Liveness and Readiness Probes Configuration

Source: https://docs.ayedo.de/delivery/application-deployment_q=

This example shows how to configure liveness and readiness probes within a Helm chart's `values.yaml` file. These probes are essential for Kubernetes to monitor the health of your application pods and ensure proper rollout and recovery.

```yaml
# values.yaml
ohmyhelm:
  deployment:
    livenessProbe:
      httpGet:
        path: /health
        port: 8080
    readinessProbe:
      httpGet:
        path: /ready
        port: 8080

```

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

### Example 3: CI/CD Pipeline for Publishing Blocks

Source: https://docs.ayedo.de/polycrate/registry

Provides a GitHub Actions workflow (`.github/workflows/publish-block.yml`) that automatically checks out code, installs Polycrate, logs into a container registry, and pushes a block when a new tag is pushed to the repository.

```yaml
# .github/workflows/publish-block.yml
name: Publish Block

on:
  push:
    tags:
      - 'v*'

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      - name: Install Polycrate
        run: curl -sSL https://get.polycrate.io | bash

      - name: Docker Login
        run: echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login registry.mycompany.com -u "${{ secrets.REGISTRY_USERNAME }}" --password-stdin

      - name: Push Block
        run: polycrate blocks push registry.mycompany.com/infra/my-block
```

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

### Example: PostgreSQL Deployment

Source: https://docs.ayedo.de/polycrate/polyhub

A practical example demonstrating the deployment of a PostgreSQL instance. It involves pulling the 'postgres-base' block, defining a custom configuration in 'workspace.poly' inheriting from it, and then deploying using 'polycrate run'.

```bash
# 1. Block vom Hub pullen
polycrate blocks pull postgres-base:1.2.0

# 2. Eigenen Block erstellen der davon erbt
cat > workspace.poly <<EOF
name: my-workspace

blocks:
  - name: prod-postgres
    from: postgres-base:1.2.0
    config:
      namespace: production
      app:
        replicas: 3
        persistence:
          size: 100Gi
          storageClass: fast-ssd
        backup:
          enabled: true
          schedule: "0 2 * * *"
EOF

# 3. Deployen
polycrate run prod-postgres install --blocks-auto-pull

```

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

### Dockerfile: Base Polycrate Image with Python Package

Source: https://docs.ayedo.de/polycrate/der-polycrate-container_q=

This Dockerfile example shows how to start from the official Polycrate image and install a specific Python package. It's useful for adding dependencies required by custom Ansible modules or other Python-based tools within the Polycrate container.

```dockerfile
FROM cargo.ayedo.cloud/library/polycrate:latest

RUN pip install hcloud==1.16.0


```

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

### Example 1: Building a Team Library with Polycrate

Source: https://docs.ayedo.de/polycrate/registry

A step-by-step example demonstrating how to create a base block, push it to a team registry, and then have team members pull it. This showcases the workflow for establishing a shared block library.

```bash
# 1. Basis-Block erstellen
cd my-workspace/blocks/postgres-base
cat > block.poly <<EOF
name: postgres-base
version: 1.0.0
kind: k8sapp
actions:
  - name: install
    playbook: playbooks/install.yml
EOF

# 2. Zur Team-Registry pushen
polycrate blocks push registry.mycompany.com/infra/postgres-base

# 3. Team-Mitglieder können pullen
polycrate blocks pull registry.mycompany.com/infra/postgres-base:1.0.0
```

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

### Example: Complete Monitoring Stack Deployment

Source: https://docs.ayedo.de/polycrate/polyhub

This example showcases the deployment of a comprehensive monitoring stack including Prometheus, Grafana, and Alertmanager. It defines Blocks for each component and orchestrates their deployment using workflows in 'workspace.poly'.

```yaml
name: monitoring-workspace

blocks:
  - name: prometheus
    from: prometheus-base:2.0.0
    config:
      namespace: monitoring
      retention: 30d
      storage: 50Gi

  - name: grafana
    from: grafana-base:1.5.0
    config:
      namespace: monitoring
      datasources:
        - name: Prometheus
          type: prometheus
          url: http://prometheus:9090

  - name: alertmanager
    from: alertmanager-base:1.0.0
    config:
      namespace: monitoring
      slack:
        webhook_url: https://hooks.slack.com/services/xxx

workflows:
  - name: deploy-monitoring
    steps:
      - name: deploy-prometheus
        block: prometheus
        action: install

      - name: deploy-grafana
        block: grafana
        action: install

      - name: deploy-alertmanager
        block: alertmanager
        action: install


```

```bash
polycrate workflows run deploy-monitoring --blocks-auto-pull

```

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

### Platform Admin Workflow: Deploying a New App with Polycrate (YAML & Bash)

Source: https://docs.ayedo.de/platform_q=

Illustrates how a platform administrator deploys a new application using Polycrate. This involves defining the application's configuration in a workspace.poly file and then using the 'polycrate install' command to deploy it.

```yaml
# workspace.poly
blocks:
  - name: myapp
    from: cargo.ayedo.cloud/ayedo/k8s/generic-app:1.0.0
    config:
      image: myapp:1.0.0
      replicas: 3

```

```bash
polycrate install myapp

```

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

### Install Polycrate CLI via Docker (Linux arm64)

Source: https://docs.ayedo.de/polycrate/installation

Installs the Polycrate CLI on Linux arm64 systems using Docker. It requires Docker and downloads the CLI executable to the current directory. Verify the installation with `./polycrate version`.

```shell
export VERSION="0.22.1"
export BIN_DIR="${PWD}"
export PLATFORM="linux/arm64"

docker run --platform "${PLATFORM}" --rm -v "${BIN_DIR}":/bin_dir --entrypoint "/bin/sh" cargo.ayedo.cloud/library/polycrate:${VERSION} -c "cp /usr/local/bin/polycrate /bin_dir/."

```

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

### Install Polycrate CLI via Docker (Linux amd64)

Source: https://docs.ayedo.de/polycrate/installation

Installs the Polycrate CLI on Linux amd64 systems using Docker. It requires Docker and downloads the CLI executable to the current directory. Verify the installation with `./polycrate version`.

```shell
export VERSION="0.22.1"
export BIN_DIR="${PWD}"
export PLATFORM="linux/amd64"

docker run --platform "${PLATFORM}" --rm -v "${BIN_DIR}":/bin_dir --entrypoint "/bin/sh" cargo.ayedo.cloud/library/polycrate:${VERSION} -c "cp /usr/local/bin/polycrate /bin_dir/."

```

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

### Polycrate Block Configuration Example

Source: https://docs.ayedo.de/polycrate/konventionen

Example of a Polycrate block definition file (block.poly), including its name, kind, config, and actions for installation and uninstallation.

```yaml
# block.poly
name: my-block
kind: k8sapp
config: {}

actions:
  - name: install
    playbook: install.yml
  - name: uninstall
    playbook: uninstall.yml
```

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

### Install Polycrate and Initialize Workspace

Source: https://docs.ayedo.de/polycrate/production-beispiel

This snippet demonstrates how to install Polycrate using a curl command and then initialize a new Polycrate workspace for a production environment. Ensure you have bash and curl installed.

```bash
# Polycrate installieren
curl -sSL https://get.polycrate.io | bash

# Workspace erstellen
mkdir -p ~/polycrate-workspaces/production
cd ~/polycrate-workspaces/production
polycrate workspace init --with-name production

```

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

### Manually Download and Install Polycrate CLI (macOS Intel)

Source: https://docs.ayedo.de/polycrate/installation

Manually installs the Polycrate CLI on macOS Intel systems by downloading a tarball, extracting it, making it executable, and placing it in the current directory. Verify with `./polycrate version`.

```shell
export VERSION="0.22.1"

curl -fsSLo polycrate.tar.gz https://hub.polycrate.io/get/polycrate/${VERSION}/darwin_amd64/polycrate_${VERSION}_darwin_amd64.tar.gz

tar xvzf polycrate.tar.gz

chmod +x polycrate
./polycrate version

```

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

### Multi-Environment Deployment Example

Source: https://docs.ayedo.de/polycrate/workflows_q=

Demonstrates how to define workflows for deploying to different environments like staging and production, including steps for backups and health checks.

```APIDOC
## Multi-Environment Deployment

### Description
Define separate workflows for deploying to staging and production environments. Production deployments can include prompts for confirmation and critical steps like database backups and health checks.

### Method
N/A (Configuration)

### Endpoint
N/A (Configuration)

### Parameters
N/A

### Request Example
```yaml
workflows:
  - name: deploy-to-staging
    steps:
      - name: deploy-staging
        block: application
        action: deploy
        # Block uses staging kubeconfig

  - name: deploy-to-production
    prompt:
      message: "Deploy to PRODUCTION?"
    steps:
      - name: backup-prod-db
        block: prod-database
        action: backup

      - name: deploy-prod-app
        block: production-application
        action: deploy

      - name: verify-prod
        block: production-application
        action: healthcheck
```

### Response
N/A
```

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

### Run Polycrate Install Action

Source: https://docs.ayedo.de/polycrate/cli-referenz

Specifically executes the `install` action of a block. This is a common command for setting up or deploying a block's resources.

```bash
polycrate install <block-name> [options]

# Example:
polycrate install ayedo/k8s/cluster
```

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

### Manually Download and Install Polycrate CLI (Linux amd64)

Source: https://docs.ayedo.de/polycrate/installation

Manually installs the Polycrate CLI on Linux amd64 systems by downloading a tarball, extracting it, making it executable, and placing it in the current directory. Verify with `./polycrate version`.

```shell
export VERSION="0.22.1"

curl -fsSLo polycrate.tar.gz https://hub.polycrate.io/get/polycrate/${VERSION}/linux_amd64/polycrate_${VERSION}_linux_amd64.tar.gz

tar xvzf polycrate.tar.gz

chmod +x polycrate
./polycrate version

```

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

### Deploy PostgreSQL with Helm

Source: https://docs.ayedo.de/kubernetes_q=

This snippet illustrates the direct installation of a PostgreSQL instance using Helm, a package manager for Kubernetes. It first adds the Bitnami Helm repository and then proceeds with the installation of the PostgreSQL chart. This method is straightforward for manual or scripted deployments.

```shell
helm repo add bitnami https://charts.bitnami.com/bitnami
helm install postgresql bitnami/postgresql

```

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

### Slack Integration Example

Source: https://docs.ayedo.de/polycrate/events_q=

Example configuration to send Polycrate events to a Slack channel using a webhook handler. This setup is useful for real-time notifications of deployment events.

```yaml
# workspace.poly
name: production-workspace

events:
  handler: webhook
  endpoint: https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK

workflows:
  - name: deploy-production
    steps:
      - name: deploy-app
        block: production-app
        action: deploy


```

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

### Set up PostgreSQL Database with StatefulSet using ohMyHelm

Source: https://docs.ayedo.de/ohmyhelm/examples

This example shows how to deploy a PostgreSQL database with persistent storage using ohMyHelm and a StatefulSet. It configures secrets for credentials, container image and ports, persistent volume claims, and service settings. The ohmyhelm chart must be accessible from the specified repository.

```yaml
# Chart.yaml
apiVersion: v2
name: database
version: 1.0.0

dependencies:
  - name: ohmyhelm
    alias: postgres
    repository: https://gitlab.com/ayedocloudsolutions/ohmyhelm
    version: 1.13.0

```

```yaml
# values.yaml
postgres:
  secrets:
    - name: postgres-credentials
      namespace: default
      values:
        POSTGRES_USER: "admin"
        POSTGRES_PASSWORD: ""  # Auto-generiert

  chart:
    enabled: true
    statefulset: true
    fullnameOverride: "postgres"

    container:
      image: postgres:14-alpine
      ports:
        - name: postgres
          containerPort: 5432
          protocol: TCP

      env:
        - name: POSTGRES_USER
          valueFrom:
            secretKeyRef:
              name: postgres-credentials
              key: POSTGRES_USER
        - name: POSTGRES_PASSWORD
          valueFrom:
            secretKeyRef:
              name: postgres-credentials
              key: POSTGRES_PASSWORD
        - name: PGDATA
          value: /var/lib/postgresql/data/pgdata

    statefulsetVolume:
      volumeMounts:
        - name: data
          mountPath: /var/lib/postgresql/data

      volumeClaimTemplates:
        - metadata:
            name: data
          spec:
            accessModes:
              - ReadWriteOnce
            resources:
              requests:
                storage: 20Gi

    service:
      type: ClusterIP
      ports:
        - port: 5432
          targetPort: postgres
          name: postgres

    resources:
      limits:
        cpu: 2000m
        memory: 2Gi
      requests:
        cpu: 500m
        memory: 512Mi

```

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

### Manually Download and Install Polycrate CLI (macOS Apple Silicon)

Source: https://docs.ayedo.de/polycrate/installation

Manually installs the Polycrate CLI on macOS Apple Silicon systems by downloading a tarball, extracting it, making it executable, and placing it in the current directory. Verify with `./polycrate version`.

```shell
export VERSION="0.22.1"

curl -fsSLo polycrate.tar.gz https://hub.polycrate.io/get/polycrate/${VERSION}/darwin_arm64/polycrate_${VERSION}_darwin_arm64.tar.gz

tar xvzf polycrate.tar.gz

chmod +x polycrate
./polycrate version

```

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

### Deploy PostgreSQL with Flux GitOps

Source: https://docs.ayedo.de/kubernetes_q=

This example shows how to deploy a PostgreSQL application using HelmRelease, a custom resource for FluxCD, enabling GitOps-style deployments. It defines the Helm chart to be used and specifies the Helm repository. This approach is suitable for automated, declarative application management within a Kubernetes cluster.

```yaml
# HelmRelease für Flux
apiVersion: helm.toolkit.fluxcd.io/v2beta1
kind: HelmRelease
metadata:
  name: postgresql
spec:
  chart:
    spec:
      chart: postgresql
      sourceRef:
        kind: HelmRepository
        name: bitnami

```

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

### Initialize Local Git Repository and Push to GitLab

Source: https://docs.ayedo.de/delivery/application-deployment_q=

Initializes a new local Git repository, creates an initial commit with a README file, adds a remote origin pointing to a GitLab repository, and pushes the main branch to GitLab.

```shell
# Lokales Repository initialisieren
git init my-application
cd my-application

# README erstellen
echo "# My Application" > README.md
git add README.md
git commit -m "Initial commit"

# Remote hinzufügen
git remote add origin https://gitlab.example.com/my-team/my-application.git

# Pushen
git push -u origin main

```

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

### Install Python Packages with Dockerfile.poly

Source: https://docs.ayedo.de/polycrate/der-polycrate-container

This Dockerfile.poly example demonstrates how to install multiple Python packages using pip. It's useful for setting up Python-based environments and dependencies within the Polycrate container.

```dockerfile
FROM cargo.ayedo.cloud/library/polycrate:latest

# Python Packages für Custom Ansible Modules
RUN pip install \
    hcloud==1.16.0 \
    proxmoxer==2.0.1 \
    requests==2.31.0

```

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

### Install Vault CLI on macOS and Linux

Source: https://docs.ayedo.de/delivery/application-deployment_q=

Instructions for installing the Vault command-line interface. For macOS, it uses Homebrew. For Linux, it involves downloading a zip file and moving the executable to the system's PATH.

```bash
# macOS
brew install hashicorp/tap/vault

# Linux
wget https://releases.hashicorp.com/vault/1.18.0/vault_1.18.0_linux_amd64.zip
unzip vault_1.18.0_linux_amd64.zip
sudo mv vault /usr/local/bin/
```

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

### Add Ansible Collections with Dockerfile.poly

Source: https://docs.ayedo.de/polycrate/der-polycrate-container

This Dockerfile.poly example shows how to install custom Ansible collections using `ansible-galaxy collection install`. This is useful for extending Ansible's capabilities within the Polycrate environment.

```dockerfile
FROM cargo.ayedo.cloud/library/polycrate:latest

# Custom Ansible Collections
RUN ansible-galaxy collection install \
    community.hashi_vault:4.0.0 \
    community.vmware:3.9.0 \
    netbox.netbox:3.13.0

```

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

### Full ohMyHelm Chart Mode Example (Helm)

Source: https://docs.ayedo.de/ohmyhelm/chart

This snippet provides a complete example of Chart.yaml for a production application using ohMyHelm. It includes the ohmyhelm dependency, ready for further configuration in values.yaml.

```yaml
# Chart.yaml
apiVersion: v2
name: production-app
version: 1.0.0

dependencies:
  - name: ohmyhelm
    alias: app
    repository: https://gitlab.com/ayedocloudsolutions/ohmyhelm
    version: 1.13.0


```

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

### Example Polycrate Snapshot Output

Source: https://docs.ayedo.de/polycrate/snapshot_q=

This is an example of the output generated when running 'polycrate run my-postgres install --snapshot'. It shows the structure of a workspace, block, action, and transaction, including configuration details and timestamps.

```yaml
$ polycrate run my-postgres install --snapshot

workspace:
  name: my-workspace
  config:
    blocks_root: blocks
    artifacts_root: artifacts
    # ...

block:
  name: my-postgres
  kind: k8sapp
  config:
    namespace: production
    # ...

action:
  name: install
  playbook: playbooks/install.yml

transaction:
  id: 550e8400-e29b-41d4-a716-446655440000
  timestamp: "2025-01-30T10:30:00Z"

```

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

### Valid Block Naming Convention

Source: https://docs.ayedo.de/polycrate/blocke

Examples of valid block names that adhere to the Polycrate naming convention. Names must start with a letter and can contain alphanumeric characters, hyphens, and forward slashes, but not underscores or start with numbers.

```text
✅ postgres-base
✅ my-app
✅ infra/postgres-base
✅ team/apps/webapp
```

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

### Example .gitignore for Secrets

Source: https://docs.ayedo.de/polycrate/production-beispiel_q=

An example `.gitignore` file demonstrating how to exclude sensitive files like secrets, private keys, and certificates from version control. This is a crucial part of secure development practices.

```gitignore
secrets.poly
*.key
*.pem
id_rsa*
```

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

### Get Polycrate Version

Source: https://docs.ayedo.de/polycrate/cli-referenz_q=

Displays the current version of Polycrate. This is a fundamental command for checking the installed Polycrate version.

```bash
polycrate version
```

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

### Configure Multi-App Deployment Components (values.yaml)

Source: https://docs.ayedo.de/ohmyhelm/examples

This values.yaml file configures the frontend, backend, and database components for a multi-app deployment. It includes image details, ports, service types, ingress settings, and statefulset configurations for the database.

```yaml
frontend:
  chart:
    enabled: true
    fullnameOverride: "frontend"
    container:
      image: nginx:alpine
      ports:
        - name: http
          containerPort: 80
    service:
      type: ClusterIP
      ports:
        - port: 80
          targetPort: http
    ingressSimple:
      enabled: true
      host: app.example.com
      path: /

backend:
  chart:
    enabled: true
    fullnameOverride: "backend"
    container:
      image: node:18-alpine
      command: ["node"]
      args: ["server.js"]
      ports:
        - name: http
          containerPort: 3000
    service:
      type: ClusterIP
      ports:
        - port: 80
          targetPort: http

database:
  chart:
    enabled: true
    statefulset: true
    fullnameOverride: "database"
    container:
      image: postgres:14-alpine
      ports:
        - name: postgres
          containerPort: 5432
      env:
        - name: POSTGRES_PASSWORD
          value: "changeme"
    statefulsetVolume:
      volumeMounts:
        - name: data
          mountPath: /var/lib/postgresql/data
      volumeClaimTemplates:
        - metadata:
            name: data
          spec:
            accessModes:
              - ReadWriteOnce
            resources:
              requests:
                storage: 10Gi

```

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

### ohMyHelm Chart Configuration Example (YAML)

Source: https://docs.ayedo.de/platform_q=

Demonstrates how to include ohMyHelm as a dependency in a Chart.yaml file and configure its settings in values.yaml for enabling features like ingress, autoscaling, and defining image repositories and tags.

```yaml
# Chart.yaml
dependencies:
  - name: ohmyhelm
    alias: myapp
    repository: https://gitlab.com/ayedocloudsolutions/ohmyhelm
    version: 1.13.0

# values.yaml
myapp:
  chart:
    enabled: true
    image:
      repository: myapp
      tag: 1.0.0
    ingress:
      enabled: true
      host: myapp.example.com
      tls: true
    autoscaling:
      enabled: true
      minReplicas: 3
      maxReplicas: 10

```

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

### Build, Package, and Deploy Docker Image and Helm Chart

Source: https://docs.ayedo.de/delivery/application-deployment_q=

This CI/CD pipeline automates the building and pushing of Docker images to Harbor, packaging and pushing Helm charts, and deploying applications to staging and production environments using ArgoCD. It utilizes GitLab CI with Docker, Helm, and ArgoCD.

```yaml
stages:
  - build
  - package
  - deploy

variables:
  HARBOR_REGISTRY: harbor.example.com
  HARBOR_PROJECT: my-team
  IMAGE_NAME: $HARBOR_REGISTRY/$HARBOR_PROJECT/$CI_PROJECT_NAME
  CHART_NAME: $CI_PROJECT_NAME

build-image:
  stage: build
  image: docker:24
  services:
    - docker:24-dind
  before_script:
    - echo "$HARBOR_PASSWORD" | docker login $HARBOR_REGISTRY -u "$HARBOR_USERNAME" --password-stdin
  script:
    # Build Image mit Git Commit SHA als Tag
    - docker build -t $IMAGE_NAME:$CI_COMMIT_SHORT_SHA .
    - docker tag $IMAGE_NAME:$CI_COMMIT_SHORT_SHA $IMAGE_NAME:latest

    # Push Image
    - docker push $IMAGE_NAME:$CI_COMMIT_SHORT_SHA
    - docker push $IMAGE_NAME:latest

    # Warten auf Harbor Vulnerability Scan
    - sleep 30  # Harbor braucht Zeit für Scan
  only:
    - main
    - develop

package-chart:
  stage: package
  image: alpine/helm:latest
  before_script:
    - helm registry login $HARBOR_REGISTRY -u "$HARBOR_USERNAME" -p "$HARBOR_PASSWORD"
  script:
    # Update Chart Version
    - sed -i "s/^version:.*/version: 0.1.$CI_PIPELINE_ID/" Chart.yaml
    - sed -i "s/^appVersion:.*/appVersion: $CI_COMMIT_SHORT_SHA/" Chart.yaml

    # Package und Push Chart
    - helm package .
    - helm push $CHART_NAME-0.1.$CI_PIPELINE_ID.tgz oci://$HARBOR_REGISTRY/$HARBOR_PROJECT
  only:
    - main
    - develop

deploy-staging:
  stage: deploy
  image: argoproj/argocd:latest
  before_script:
    - argocd login argocd.example.com --auth-token $ARGOCD_TOKEN --insecure
  script:
    # Update ArgoCD Application
    - |
      argocd app set my-application-staging \
        --revision 0.1.$CI_PIPELINE_ID \
        --helm-set ohmyhelm.chart.container.image=$CI_COMMIT_SHORT_SHA

    # Trigger Sync
    - argocd app sync my-application-staging

    # Wait for Healthy
    - argocd app wait my-application-staging --health --timeout 300
  only:
    - develop
  environment:
    name: staging
    url: https://my-app-staging.example.com

deploy-production:
  stage: deploy
  image: argoproj/argocd:latest
  before_script:
    - argocd login argocd.example.com --auth-token $ARGOCD_TOKEN --insecure
  script:
    - |
      argocd app set my-application-production \
        --revision 0.1.$CI_PIPELINE_ID \
        --helm-set ohmyhelm.chart.container.image=$CI_COMMIT_SHORT_SHA
    - argocd app sync my-application-production
    - argocd app wait my-application-production --health --timeout 600
  only:
    - main
  when: manual  # Manuelles Approval für Production
  environment:
    name: production
    url: https://my-app.example.com

```

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

### Troubleshoot Polycrate Container Startup Failures

Source: https://docs.ayedo.de/polycrate/troubleshooting_q=

Guides users on fixing issues where Polycrate containers fail to start or crash immediately. It involves checking container logs, Polycrate logs, increasing the log level, and manually testing the container.

```bash
docker logs <container-id>
```

```bash
ls -la .logs/
cat .logs/<latest-log-file>
```

```bash
polycrate run my-block install --loglevel 2
```

```bash
docker run -it --rm cargo.ayedo.cloud/library/polycrate:latest /bin/sh
```

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

### Package and Deploy Helm Chart for Portability

Source: https://docs.ayedo.de/ohmyhelm/15-factor-apps

This example demonstrates how to package an existing Helm chart into a versioned archive (`.tgz`) and then deploy it to a different Kubernetes cluster using a specified kubeconfig file. This is a key step for achieving application portability and exit capability as required by data sovereignty regulations.

```bash
# Export Helm Chart
helm package myapp/

# Import in anderen Cluster
helm install myapp myapp-1.0.0.tgz --kubeconfig cluster-b.yaml

```

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

### Get Cert-Manager Logs

Source: https://docs.ayedo.de/platform/operations/troubleshooting

Retrieves the last 50 log lines from cert-manager pods. This is essential for diagnosing issues related to certificate issuance and renewal.

```bash
kubectl logs -n cert-manager -l app=cert-manager --tail=50
```

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

### Implement Monitoring and Backups for Application Blocks

Source: https://docs.ayedo.de/polycrate/konventionen

This example shows how to configure monitoring and backup settings for an application block. It includes options for enabling VMServiceScrape, Grafana dashboards, and backup schedules using Velero.

```poly
# block.poly
name: my-block
kind: k8sapp
config:
  monitoring:
    enabled: false
    vmservicescrape:
      enabled: false
    dashboard:
      enabled: false
  backups:
    enabled: false
    schedule: "* * * * *"
```

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

### Troubleshooting Pod Startup Issues

Source: https://docs.ayedo.de/ohmyhelm/getting-started_q=

Guide for troubleshooting pods that are not starting correctly, including checking pod descriptions, logs, and previous logs (useful for CrashLoopBackOff scenarios).

```bash
# Pod-Details anzeigen
kubectl describe pod <pod-name>

# Logs anzeigen
kubectl logs <pod-name>

# Previous logs (bei CrashLoopBackOff)
kubectl logs <pod-name> --previous
```

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

### Get Ingress Controller Logs

Source: https://docs.ayedo.de/platform/operations/troubleshooting

Retrieves the last 50 log lines from the ingress-nginx controller pods. This helps in debugging traffic routing and ingress-related problems.

```bash
kubectl logs -n ingress-nginx -l app.kubernetes.io/name=ingress-nginx --tail=50
```