Kanister

https://docs.kanister.io
Admin
Kanister is a data protection workflow management tool that provides APIs for defining and curating...
Tokens:34,543
Snippets:316
Trust Score:7.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Kanister Tools

Source: https://docs.kanister.io/tooling.html

Installs kanctl and kando using the provided installation script.

```bash
# The script installs both kanctl and kando
$ curl https://raw.githubusercontent.com/kanisterio/kanister/master/scripts/get.sh | bash
```

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

### WaitV2 Function Example

Source: https://docs.kanister.io/functions.html

Example usage of the WaitV2 function to wait for a deployment to become ready.

```yaml
- func: WaitV2
  name: waitForDeploymentReady
  args:
    timeout: 5m
    conditions:
      anyOf:
      - condition: '{{ $available := false }}{{ range $condition := $.status.conditions }}{{ if and (eq .type "Available") (eq .status "True") }}{{ $available = true }}{{ end }}{{ end }}{{ $available }}'
        objectReference:
          apiVersion: "v1"
          group: "apps"
          name: "{{ .Object.metadata.name }}"
          namespace: "{{ .Object.metadata.namespace }}"
          resource: "deployments"
```

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

### Install Loki via Helm

Source: https://docs.kanister.io/tasks/logs.html

Adds the Grafana Helm repository and installs a single-instance Loki deployment.

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

helm repo update

helm -n loki install --create-namespace loki grafana/loki \
  --set image.tag=2.5.0
```

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

### Backup and Restore Workflow Example

Source: https://docs.kanister.io/functions.html

A complete workflow demonstrating how to use CopyVolumeData to backup data and RestoreData to restore it to the same mount path.

```yaml
actions:
  backup:
    outputArtifacts:
      backupInfo:
        keyValue:
          backupID: "{{ .Phases.backupData.Output.backupID }}"
          backupRoot: "{{ .Phases.backupData.Output.backupRoot }}"
          backupTag: "{{ .Phases.backupData.Output.backupTag }}"
    phases:
    - func: CopyVolumeData
      name: backupData
      args:
        namespace: "{{ .PVC.Namespace }}"
        volume: "{{ .PVC.Name }}"
        dataArtifactPrefix: s3-bucket-name/backup-path

  restore:
    inputArtifactNames:
    - backupInfo
    phases:
    - func: RestoreData
      name: restoreData
      args:
        namespace: "{{ .PVC.Namespace }}"
        image: ghcr.io/kanisterio/kanister-tools:0.110.0
        backupArtifactPrefix: s3-bucket-name/backup-path
        backupTag: "{{ .ArtifactsIn.backupInfo.KeyValue.backupTag }}"
        volumes:
          "{{ .PVC.Name }}": "/mnt/vol_data/{{ .PVC.Name }}"
```

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

### Install Promtail via Helm

Source: https://docs.kanister.io/tasks/logs.html

Installs Promtail to discover log targets and stream them to the Loki API endpoint.

```bash
svc_url=$(kubectl -n loki get svc loki -ojsonpath='{.metadata.name}.{.metadata.namespace}:{.spec.ports[?(@.name=="http-metrics")].port}')

helm -n loki upgrade --install --create-namespace promtail grafana/promtail \
  --set image.tag=2.5.0 \
  --set "config.clients[0].url=http://${svc_url}/loki/api/v1/push"
```

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

### Example Profile and Secret YAML

Source: https://docs.kanister.io/architecture.html

A complete example of a Profile CR and the corresponding Kubernetes Secret required for authentication.

```yaml
apiVersion: cr.kanister.io/v1alpha1
kind: Profile
metadata:
  name: example-profile
  namespace: example-namespace
location:
  type: s3Compliant
  bucket: example-bucket
  endpoint: <endpoint URL>:<port>
  prefix: ""
  region: ""
credential:
  type: keyPair
  keyPair:
    idField: example_key_id
    secretField: example_secret_access_key
    secret:
      apiVersion: v1
      kind: Secret
      name: example-secret
      namespace: example-namespace
skipSSLVerify: true
---
apiVersion: v1
kind: Secret
type: Opaque
metadata:
  name: example-secret
  namespace: example-namespace
data:
  example_key_id: <access key>
  example_secret_access_key: <access secret>
```

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

### KubeExecAll Blueprint Phase Example

Source: https://docs.kanister.io/functions.html

Configuration for using the KubeExecAll function to execute commands in parallel across multiple containers.

```yaml
- func: KubeExecAll
  name: examplePhase
  args:
    namespace: "{{ .Deployment.Namespace }}"
    pods: "{{ index .Deployment.Pods 0 }} {{ index .Deployment.Pods 1 }}"
    containers: "container1 container2"
    command:
      - sh
      - -c
      - |
        echo "Example"
```

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

### KubeExec Blueprint Phase Example

Source: https://docs.kanister.io/functions.html

Configuration for using the KubeExec function within a Blueprint phase.

```yaml
- func: KubeExec
  name: examplePhase
  args:
    namespace: "{{ .Deployment.Namespace }}"
    pod: "{{ index .Deployment.Pods 0 }}"
    container: kanister-sidecar
    command:
      - sh
      - -c
      - |
        echo "Example"
```

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

### RestoreDataAll Workflow Example

Source: https://docs.kanister.io/functions.html

Demonstrates a full workflow including scaling down an application, restoring data using RestoreDataAll, and scaling the application back up.

```yaml
- func: ScaleWorkload
  name: ShutdownApplication
  args:
    namespace: "{{ .Deployment.Namespace }}"
    name: "{{ .Deployment.Name }}"
    kind: Deployment
    replicas: 0
- func: RestoreDataAll
  name: RestoreFromObjectStore
  args:
    namespace: "{{ .Deployment.Namespace }}"
    image: ghcr.io/kanisterio/kanister-tools:0.110.0
    backupArtifactPrefix: s3-bucket/path/artifactPrefix
    backupInfo: "{{ .ArtifactsIn.params.KeyValue.backupInfo }}"
    podAnnotations:
      annKey: annValue
    podLabels:
      labelKey: labelValue
- func: ScaleWorkload
  name: StartupApplication
  args:
    namespace: "{{ .Deployment.Namespace }}"
    name: "{{ .Deployment.Name }}"
    kind: Deployment
    replicas: 2
```

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

### Example Pod Status Output

Source: https://docs.kanister.io/install.html

Expected output showing the operator pod in the Running state.

```text
NAME READY STATUS RESTARTS AGE
kanister-kanister-operator-85c747bfb8-dmqnj 1/1 Running 0 15s
```

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

### Sample Workflow Output

Source: https://docs.kanister.io/tasks/argo.html

Example output showing the status of cron workflow creation, listing, and the resulting ActionSet.

```bash
$ argo cron create mysql-cron-wf.yaml -n argo
> Name:                   mysql-cron-wf
  Namespace:              argo
  Created:                Fri Jul 22 10:23:09 -0400 (now)
  Schedule:               */5 * * * *
  Suspended:              false
  ConcurrencyPolicy:      Replace
  NextScheduledTime:      Fri Jul 22 10:25:00 -0400 (1 minute from now) (assumes workflow-controller is in UTC)

$ argo cron list -n argo
> NAME            AGE    LAST RUN    NEXT RUN      SCHEDULE      TIMEZONE        SUSPENDED
  mysql-cron-wf   12s    N/A         1m            */5 * * * *                   false

$ argo cron list -n argo
> NAME            AGE    LAST RUN    NEXT RUN      SCHEDULE      TIMEZONE        SUSPENDED
  mysql-cron-wf   4m     2m          2m            */5 * * * *                   false

$ kubectl get actionsets.cr.kanister.io -n kanister
> NAME            AGE
  backup-478lk    2m28s
```

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

### KubeExec Command Usage

Source: https://docs.kanister.io/functions.html

Example of the equivalent kubectl command for KubeExec.

```bash
kubectl exec -it --namespace <NAMESPACE> <POD> -c <CONTAINER> [CMD LIST...]
```

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

### Install Kanister Operator

Source: https://docs.kanister.io/install.html

Deploy the Kanister operator into the kanister namespace.

```bash
helm -n kanister upgrade \
--install kanister \
--create-namespace kanister/kanister-operator
```

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

### Verify Kanister Installation

Source: https://docs.kanister.io/install.html

Check the status of the Kanister operator pod.

```bash
kubectl -n kanister get po
```

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

### ScaleWorkload Blueprint Example

Source: https://docs.kanister.io/tasks/scaleworkload.html

Demonstrates scaling a StatefulSet to zero replicas during backup and restoring the original replica count during restore using output artifacts.

```yaml
apiVersion: cr.kanister.io/v1alpha1
kind: Blueprint
metadata:
  name: my-blueprint
actions:
  backup:
    outputArtifacts:
      backupOutput:
        keyValue:
          origReplicas: "{{ .Phases.shutdownPod.Output.originalReplicaCount }}"
    phases:
    # before scaling replicas 0, ScaleWorkload will get the original replica count
    # to set that as output artifact (originalReplicaCount)
    - func: ScaleWorkload
      name: shutdownPod
      args:
        namespace: "{{ .StatefulSet.Namespace }}"
        name: "{{ .StatefulSet.Name }}"
        kind: StatefulSet
        replicas: 0 # this is the replica count, the STS will scaled to
  restore:
    inputArtifactNames:
      - backupOutput
    phases:
    - func: ScaleWorkload
      name: bringUpPod
      args:
        namespace: "{{ .StatefulSet.Namespace }}"
        name: "{{ .StatefulSet.Name }}"
        kind: StatefulSet
        replicas: "{{ .ArtifactsIn.backupOutput.KeyValue.origReplicas }}"
```

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

### Wait Function Example

Source: https://docs.kanister.io/functions.html

Example usage of the deprecated Wait function to monitor namespace status.

```yaml
- func: Wait
  name: waitNsReady
  args:
    timeout: 60s
    conditions:
      allOf:
        - condition: '{{ if (eq "{ $.status.phase }" "Invalid")}}true{{ else }}false{{ end }}'
          objectReference:
            apiVersion: v1
            resource: namespaces
            name: "{{ .Namespace.Name }}"
        - condition: '{{ if (eq "{ $.status.phase }" "Active")}}true{{ else }}false{{ end }}'
          objectReference:
            apiVersion: v1
            resource: namespaces
            name: "{{ .Namespace.Name }}"
```

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

### CreateCSISnapshot Function Example

Source: https://docs.kanister.io/functions.html

Example usage of the CreateCSISnapshot function within a Kanister action.

```yaml
actions:
  backup:
    outputArtifacts:
      snapshotInfo:
        keyValue:
          name: "{{ .Phases.createCSISnapshot.Output.name }}"
          pvc: "{{ .Phases.createCSISnapshot.Output.pvc }}"
          namespace: "{{ .Phases.createCSISnapshot.Output.namespace }}"
          restoreSize: "{{ .Phases.createCSISnapshot.Output.restoreSize }}"
          snapshotContent: "{{ .Phases.createCSISnapshot.Output.snapshotContent }}"
    phases:
    - func: CreateCSISnapshot
      name: createCSISnapshot
      args:
        pvc: "{{ .PVC.Name }}"
        namespace: "{{ .PVC.Namespace }}"
        snapshotClass: do-block-storage
```

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

### Scale a Kubernetes Workload

Source: https://docs.kanister.io/functions.html

Examples demonstrating how to scale a deployment to zero or one replica using the ScaleWorkload function.

```bash
kubectl scale deployment <DEPLOYMENT-NAME> --replicas=<NUMBER OF REPLICAS> --namespace <NAMESPACE>
```

```yaml
- func: ScaleWorkload
  name: examplePhase
  args:
    namespace: "{{ .Deployment.Namespace }}"
    name: "{{ .Deployment.Name }}"
    kind: deployment
    replicas: 0
```

```yaml
- func: ScaleWorkload
  name: examplePhase
  args:
    namespace: "{{ .Deployment.Namespace }}"
    name: "{{ .Deployment.Name }}"
    kind: deployment
    replicas: 1
    waitForReady: false
```

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

### Using Kando in a Blueprint

Source: https://docs.kanister.io/tooling.html

Example usage of kando commands within a Kanister Blueprint phase.

```bash
kando location push \--profile '{{ toJson .Profile }}' \--path '/backup/path' -

kando location delete \--profile '{{ toJson .Profile }}' \--path '/backup/path'

kando output version
```

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

### Define ActionSet Options

Source: https://docs.kanister.io/templates.html

Example of specifying a podName in an ActionSet to be used within a Blueprint.

```yaml
apiVersion: cr.kanister.io/v1alpha1
kind: ActionSet
metadata:
  generateName: s3backup-
  namespace: kanister
spec:
  actions:
  - name: backup
    blueprint: my-blueprint
    object:
      kind: deployment
      name: my-deployment
      namespace: default
    options:
      podName: some-pod
```

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

### Format Time with Sprig Functions

Source: https://docs.kanister.io/templates.html

Template string example for formatting the .Time parameter into a specific time format.

```go
"{{ toDate \"2006-01-02T15:04:05.999999999Z07:00\" .Time  | date \"3:04PM\" }}"
```

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

### Configure Blueprint with Artifacts

Source: https://docs.kanister.io/templates.html

Example of defining input and output artifacts within a Kanister Blueprint.

```yaml
apiVersion: cr.kanister.io/v1alpha1
kind: Blueprint
metadata:
  name: time-log-bp
  namespace: kanister
actions:
  backup:
    configMapNames:
    - location
    secretNames:
    - aws
    outputArtifacts:
      timeLog:
        keyValue:
          path: 's3://{{ .ConfigMaps.location.Data.path }}/time-log/{{ toDate "2006-01-02T15:04:05.999999999Z07:00" .Time  | date "2006-01-02" }}'

    ...
  restore:
    inputArtifactNames:
      - exampleArtifact
    ...
```

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

### Define ActionSet for Restore

Source: https://docs.kanister.io/templates.html

Example of an ActionSet configuration that provides the necessary artifacts for a restore action.

```yaml
apiVersion: cr.kanister.io/v1alpha1
kind: ActionSet
metadata:
  generateName: time-log-restore-
  namespace: kanister
spec:
  actions:
  - name: restore
    blueprint: time-log-bp
    object:
      kind: Deployment
      name: time-logger
      namespace: default
    secrets:
      aws:
        name: aws-creds
        namespace: kanister
    artifacts:
      timeLog:
        keyValue:
          path: s3://time-log-test-bucket/tutorial/time-log/time.log
```

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

### RestoreDataUsingKopiaServer YAML Configuration

Source: https://docs.kanister.io/functions.html

Example workflow demonstrating scaling down a workload, restoring data with RestoreDataUsingKopiaServer, and scaling the workload back up.

```yaml
- func: ScaleWorkload
  name: shutdownPod
  args:
    namespace: "{{.Deployment.Namespace }}"
    name: "{{ .Deployment.Name }}"
    kind: Deployment
    replicas: 0
- func: RestoreDataUsingKopiaServer
  name: restoreFromS3
  args:
    namespace: "{{ .Deployment.Namespace }}"
    pod: "{{ index.Deployment.Pods 0 }}"
    backupIdentifier: "{{.ArtifactsIn.backupIdentifier.KeyValue.id }}"
    restorePath: /mnt/data
    podAnnotations:
      annKey: annValue
    podLabels:
      labelKey: labelValue
- func: ScaleWorkload
  name: bringupPod
  args:
    namespace: "{{.Deployment.Namespace }}"
    name: "{{ .Deployment.Name }}"
    kind: Deployment
    replicas: 1
```

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

### Prepare Data with Temporary Pods

Source: https://docs.kanister.io/functions.html

Example of using PrepareData to mount PVCs and execute a command for data manipulation after scaling down an application.

```yaml
- func: ScaleWorkload
  name: ShutdownApplication
  args:
    namespace: "{{ .Deployment.Namespace }}"
    name: "{{ .Deployment.Name }}"
    kind: deployment
    replicas: 0
- func: PrepareData
  name: ManipulateData
  args:
    namespace: "{{ .Deployment.Namespace }}"
    image: busybox
    volumes:
      application-pvc-1: "/data"
      application-pvc-2: "/restore-data"
    podAnnotations:
      annKey: annValue
    podLabels:
      labelKey: labelValue
    command:
      - sh
      - -c
      - |
        cp /restore-data/file_to_replace.data /data/file.data
    failOnError: true
```

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

### BackupDataUsingKopiaServer YAML Configuration

Source: https://docs.kanister.io/functions.html

Example configuration for the BackupDataUsingKopiaServer function within a Kanister action set.

```yaml
actions:
backup:
  outputArtifacts:
    backupIdentifier:
      keyValue:
        id: "{{ .Phases.backupToS3.Output.backupID }}"
  phases:
  - func: BackupDataUsingKopiaServer
    name: backupToS3
    args:
      namespace: "{{ .Deployment.Namespace }}"
      pod: "{{ index .Deployment.Pods 0 }}"
      container: kanister-tools
      includePath: /mnt/data
```

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

### RestoreData Workflow Example

Source: https://docs.kanister.io/functions.html

Demonstrates a complete workflow involving scaling down an application, performing a data restore using RestoreData, and scaling the application back up.

```yaml
- func: ScaleWorkload
  name: ShutdownApplication
  args:
    namespace: "{{.Deployment.Namespace }}"
    name: "{{ .Deployment.Name }}"
    kind: Deployment
    replicas: 0
- func: RestoreData
  name: RestoreFromObjectStore
  args:
    namespace: "{{.Deployment.Namespace }}"
    pod: "{{ index .Deployment.Pods 0 }}"
    image: ghcr.io/kanisterio/kanister-tools:0.110.0
    backupArtifactPrefix: s3-bucket/path/artifactPrefix
    backupTag: "{{.ArtifactsIn.backupInfo.KeyValue.backupIdentifier }}"
    podAnnotations:
      annKey: annValue
    podLabels:
      labelKey: labelValue
- func: ScaleWorkload
  name: StartupApplication
  args:
    namespace: "{{.Deployment.Namespace }}"
    name: "{{ .Deployment.Name }}"
    kind: Deployment
    replicas: 1
```

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

### Install with Custom CRD Management

Source: https://docs.kanister.io/install.html

Install Kanister while disabling automatic CRD updates by the operator.

```bash
helm -n kanister upgrade \
--install kanister \
--create-namespace kanister/kanister-operator \
--set controller.updateCRDs=false
```

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

### Install Grafana with Loki Data Source

Source: https://docs.kanister.io/tasks/logs.html

Deploys Grafana using Helm with a pre-configured Loki data source pointing to the internal service URL.

```bash
svc_url=$(kubectl -n loki get svc loki -ojsonpath='{.metadata.name}.{.metadata.namespace}:{.spec.ports[?(@.name=="http-metrics")].port}')

cat <<EOF | helm -n grafana install --create-namespace grafana grafana/grafana -f -
datasources:
  datasources.yaml:
    apiVersion: 1
    datasources:
    - name: Loki
      type: loki
      url: http://$svc_url
      access: proxy
      isDefault: true
EOF
```

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

### BackupDataStats YAML Configuration

Source: https://docs.kanister.io/functions.html

Example configuration for the BackupDataStats function, requiring a kanister-tools sidecar container.

```yaml
actions:
  backupStats:
    outputArtifacts:
      backupStats:
        keyValue:
          mode: "{{ .Phases.BackupDataStatsFromObjectStore.Output.mode }}"
          fileCount: "{{ .Phases.BackupDataStatsFromObjectStore.Output.fileCount }}"
          size: "{{ .Phases.BackupDataStatsFromObjectStore.Output.size }}"
    phases:
      - func: BackupDataStats
        name: BackupDataStatsFromObjectStore
        args:
          namespace: "{{ .Deployment.Namespace }}"
          backupArtifactPrefix: s3-bucket/path/artifactPrefix
          mode: restore-size
          backupID: "{{ .ArtifactsIn.snapshot.KeyValue.backupIdentifier }}"
          podAnnotations:
            annKey: annValue
          podLabels:
            labelKey: labelValue
```

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

### KubeOps Function Operations

Source: https://docs.kanister.io/functions.html

Examples of using KubeOps to create, patch, and delete Kubernetes resources.

```yaml
- func: KubeOps
  name: createDeploy
  args:
    operation: create
    namespace: "{{ .Deployment.Namespace }}"
    spec: |-
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: "{{ .Deployment.Name }}"
      spec:
        replicas: 1
        selector:
          matchLabels:
            app: example
        template:
          metadata:
            labels:
              app: example
          spec:
            containers:
            - image: busybox
              imagePullPolicy: IfNotPresent
              name: container
              ports:
              - containerPort: 80
                name: http
                protocol: TCP
- func: KubeOps
  name: patchDeploy
  args:
    operation: patch
    objectReference:
      apiVersion: "{{ .Phases.createDeploy.Output.apiVersion }}"
      group: "{{ .Phases.createDeploy.Output.group }}"
      resource: "{{ .Phases.createDeploy.Output.resource }}"
      name: "{{ .Phases.createDeploy.Output.name }}"
      namespace: "{{ .Phases.createDeploy.Output.namespace }}"
    spec: |-
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: "{{ .Deployment.Name }}"
        labels:
          "dummy-label-key": "dummy-label-annotation"
        annotations:
          "dummy-annotations-key": "dummy-annotations-annotation"
      spec:
        replicas: 5
- func: KubeOps
  name: deleteDeploy
  args:
    operation: delete
    objectReference:
      apiVersion: "{{ .Phases.createDeploy.Output.apiVersion }}"
      group: "{{ .Phases.createDeploy.Output.group }}"
      resource: "{{ .Phases.createDeploy.Output.resource }}"
      name: "{{ .Phases.createDeploy.Output.name }}"
      namespace: "{{ .Phases.createDeploy.Output.namespace }}"
```

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

### Install with Custom TLS Certificates

Source: https://docs.kanister.io/install.html

Deploy Kanister configured to use custom TLS certificates for the validating webhook.

```bash
helm upgrade --install kanister kanister/kanister-operator --namespace kanister --create-namespace \
--set bpValidatingWebhook.tls.mode=custom \
--set bpValidatingWebhook.tls.caBundle=$(cat /path/to/ca.pem | base64 -w 0) \
--set bpValidatingWebhook.tls.secretName=tls-secret
```

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

### Define a BlueprintAction

Source: https://docs.kanister.io/architecture.html

Example of a BlueprintAction configuration using the KubeExec function to run a command inside a container.

```yaml
actions:
  example-action:
    phases:
    - func: KubeExec
      name: examplePhase
      args:
        namespace: "{{ .Deployment.Namespace }}"
        pod: "{{ index .Deployment.Pods 0 }}"
        container: kanister-sidecar
        command:
          - bash
          - -c
          - |
            echo "Example Action"
```

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

### CreateRDSSnapshot YAML Configuration

Source: https://docs.kanister.io/functions.html

Example configuration for creating an RDS snapshot, supporting various credential sources.

```yaml
actions:
  backup:
    outputArtifacts:
      backupInfo:
        keyValue:
          snapshotID: "{{ .Phases.createSnapshot.Output.snapshotID }}"
          instanceID: "{{ .Phases.createSnapshot.Output.instanceID }}"
          securityGroupID: "{{ .Phases.createSnapshot.Output.securityGroupID }}"
          allocatedStorage: "{{ .Phases.createSnapshot.Output.allocatedStorage }}"
          dbSubnetGroup: "{{ .Phases.createSnapshot.Output.dbSubnetGroup }}"
    configMapNames:
    - dbconfig
    phases:
    - func: CreateRDSSnapshot
      name: createSnapshot
      args:
        instanceID: '{{ index .ConfigMaps.dbconfig.Data "postgres.instanceid" }}'
```

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

### Define an ActionSet Spec

Source: https://docs.kanister.io/architecture.html

Example YAML configuration for an ActionSet specification referencing a blueprint and target object.

```yaml
spec:
  actions:
  - name: example-action
    blueprint: example-blueprint
    object:
      kind: Deployment
      name: example-deployment
      namespace: example-namespace
    profile:
      apiVersion: v1alpha1
      kind: profile
      name: example-profile
      namespace: example-namespace
```

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

### RestoreRDSSnapshot YAML Configuration

Source: https://docs.kanister.io/functions.html

Example configuration for the RestoreRDSSnapshot function within a Kanister blueprint phase.

```yaml
restore:
  inputArtifactNames:
  - backupInfo
  kind: Namespace
  phases:
  - func: RestoreRDSSnapshot
    name: restoreSnapshots
    objects:
      dbsecret:
        kind: Secret
        name: '{{ index .ConfigMaps.dbconfig.Data "postgres.secret" }}'
        namespace: "{{ .Namespace.Name }}"
    args:
      namespace: "{{ .Namespace.Name }}"
      backupArtifactPrefix: test-postgresql-instance/postgres
      instanceID:  "{{ .ArtifactsIn.backupInfo.KeyValue.instanceID }}"
      backupID:  "{{ .ArtifactsIn.backupInfo.KeyValue.backupID }}"
      securityGroupID:  "{{ .ArtifactsIn.backupInfo.KeyValue.securityGroupID }}"
      username: '{{ index .Phases.restoreSnapshots.Secrets.dbsecret.Data "username" | toString }}'
      password: '{{ index .Phases.restoreSnapshots.Secrets.dbsecret.Data "password" | toString }}'
      dbEngine: "PostgreSQL"
      dbSubnetGroup: "{{ .ArtifactsIn.backupInfo.KeyValue.dbSubnetGroup }}"
      podAnnotations:
        annKey: annValue
      podLabels:
        labelKey: labelValue
```

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

### ExportRDSSnapshotToLocation YAML Configuration

Source: https://docs.kanister.io/functions.html

Example usage of the ExportRDSSnapshotToLocation function within a Kanister blueprint action.

```yaml
actions:
  backup:
    outputArtifacts:
      backupInfo:
        keyValue:
          snapshotID: "{{ .Phases.createSnapshot.Output.snapshotID }}"
          instanceID: "{{ .Phases.createSnapshot.Output.instanceID }}"
          securityGroupID: "{{ .Phases.createSnapshot.Output.securityGroupID }}"
          backupID: "{{ .Phases.exportSnapshot.Output.backupID }}"
          dbSubnetGroup: "{{ .Phases.createSnapshot.Output.dbSubnetGroup }}"
    configMapNames:
    - dbconfig
    phases:

    - func: CreateRDSSnapshot
      name: createSnapshot
      args:
        instanceID: '{{ index .ConfigMaps.dbconfig.Data "postgres.instanceid" }}'

    - func: ExportRDSSnapshotToLocation
      name: exportSnapshot
      objects:
        dbsecret:
          kind: Secret
          name: '{{ index .ConfigMaps.dbconfig.Data "postgres.secret" }}'
          namespace: "{{ .Namespace.Name }}"
      args:
        namespace: "{{ .Namespace.Name }}"
        instanceID: "{{ .Phases.createSnapshot.Output.instanceID }}"
        securityGroupID: "{{ .Phases.createSnapshot.Output.securityGroupID }}"
        username: '{{ index .Phases.exportSnapshot.Secrets.dbsecret.Data "username" | toString }}'
        password: '{{ index .Phases.exportSnapshot.Secrets.dbsecret.Data "password" | toString }}'
        dbEngine: "PostgreSQL"
        databases: '{{ index .ConfigMaps.dbconfig.Data "postgres.databases" }}'
        snapshotID: "{{ .Phases.createSnapshot.Output.snapshotID }}"
        backupArtifactPrefix: test-postgresql-instance/postgres
        dbSubnetGroup: "{{ .Phases.createSnapshot.Output.dbSubnetGroup }}"
        podAnnotations:
          annKey: annValue
        podLabels:
          labelKey: labelValue"
```

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

### View RepositoryServer creation help

Source: https://docs.kanister.io/tooling.html

Displays help information for the kanctl create repository-server command.

```bash
$ kanctl create repository-server --help
Create a new RepositoryServer

Usage:
  kanctl create repository-server [flags]

Flags:
  -a, --admin-user-access-secret string           name of the secret having admin credentials to connect to connect to kopia repository server
  -r, --kopia-repository-password-secret string   name of the secret containing password for the kopia repository
  -k, --kopia-repository-user string              name of the user for accessing the kopia repository
  -c, --location-creds-secret string              name of the secret containing kopia repository storage credentials
  -l, --location-secret string                    name of the secret containing kopia repository storage location details
  -p, --prefix string                             prefix to be set in kopia repository
  -t, --tls-secret string                         name of the tls secret needed for secure kopia client and kopia repository server communication
  -u, --user string                               name of the user to be created for the kopia repository server
  -s, --user-access-secret string                 name of the secret having access credentials of the users that can connect to kopia repository server
  -w, --wait                                      wait for the kopia repository server to be in ready state after creation
  -h, --help                                      help for repository-server
```

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

### View Profile creation help

Source: https://docs.kanister.io/tooling.html

Displays help information for the kanctl create profile command.

```bash
$ kanctl create profile --help
Create a new profile

Usage:
  kanctl create profile [command]

Available Commands:
  s3compliant Create new S3 compliant profile

Flags:
  -h, --help                    help for profile
      --skip-SSL-verification   if set, SSL verification is disabled for the profile

Global Flags:
      --dry-run            if set, resource YAML will be printed but not created
  -n, --namespace string   Override namespace obtained from kubectl context
      --skip-validation    if set, resource is not validated before creation

Use "kanctl create profile [command] --help" for more information about a command.
```

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

### Delete RDS Snapshot Function

Source: https://docs.kanister.io/functions.html

Example usage of the DeleteRDSSnapshot function within a blueprint phase to remove a snapshot.

```yaml
actions:
  delete:
  kind: Namespace
  inputArtifactNames:
  - backupInfo
  phases:
  - func: DeleteRDSSnapshot
    name: deleteSnapshot
    args:
      snapshotID: "{{ .ArtifactsIn.backupInfo.KeyValue.snapshotID }}"
```

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

### Create and monitor a backup ActionSet

Source: https://docs.kanister.io/tooling.html

Initiates a backup action using a specified blueprint and profile, then describes the resulting ActionSet to track progress.

```bash
$ kanctl create actionset --action backup --namespace kanister --blueprint time-log-bp \
                          --deployment kanister/time-logger                            \
                          --profile s3-profile
actionset backup-9gtmp created

# View the progress of the ActionSet
$ kubectl --namespace kanister describe actionset backup-9gtmp
```

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

### View kanctl create actionset help

Source: https://docs.kanister.io/tooling.html

Displays the help menu for creating or overriding ActionSets using kanctl.

```bash
$ kanctl create actionset --help
Create a new ActionSet or override a <parent> ActionSet

Usage:
  kanctl create actionset [flags]

Flags:
  -a, --action string               action for the action set (required if creating a new action set)
  -b, --blueprint string            blueprint for the action set (required if creating a new action set)
  -c, --config-maps strings         config maps for the action set, comma separated ref=namespace/name pairs (eg: --config-maps ref1=namespace1/name1,ref2=namespace2/name2)
  -d, --deployment strings          deployment for the action set, comma separated namespace/name pairs (eg: --deployment namespace1/name1,namespace2/name2)
  -f, --from string                 specify name of the action set
  -h, --help                        help for actionset
  -k, --kind string                 resource kind to apply selector on. Used along with the selector specified using --selector/-l (default "all")
  -T, --namespacetargets strings    namespaces for the action set, comma separated list of namespaces (eg: --namespacetargets namespace1,namespace2)
  -O, --objects strings             objects for the action set, comma separated list of object references (eg: --objects group/version/resource/namespace1/name1,group/version/resource/namespace2/name2)
  -o, --options strings             specify options for the action set, comma separated key=value pairs (eg: --options key1=value1,key2=value2)
  -p, --profile string              profile for the action set
  -v, --pvc strings                 pvc for the action set, comma separated namespace/name pairs (eg: --pvc namespace1/name1,namespace2/name2)
  -s, --secrets strings             secrets for the action set, comma separated ref=namespace/name pairs (eg: --secrets ref1=namespace1/name1,ref2=namespace2/name2)
  -l, --selector string             k8s selector for objects
      --selector-namespace string   namespace to apply selector on. Used along with the selector specified using --selector/-l
  -t, --statefulset strings         statefulset for the action set, comma separated namespace/name pairs (eg: --statefulset namespace1/name1,namespace2/name2)

Global Flags:
      --dry-run            if set, resource YAML will be printed but not created
  -n, --namespace string   Override namespace obtained from kubectl context
      --skip-validation    if set, resource is not validated before creation
```

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

### Deployment Parameters

Source: https://docs.kanister.io/templates.html

Structure and access pattern for Deployment parameters.

```go
// DeploymentParams are params for deployments
type DeploymentParams struct {
  Name                   string
  Namespace              string
  Pods                   []string
  Containers             [][]string
  PersistentVolumeClaims [][]string
}
```

```go
"{{ index .Deployment.Name }}"
```

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

### View kanctl create help

Source: https://docs.kanister.io/tooling.html

Displays the help menu for the kanctl create command to see available subcommands and flags.

```bash
$ kanctl create --help
Create a custom kanister resource

Usage:
  kanctl create [command]

Available Commands:
  actionset   Create a new ActionSet or override a <parent> ActionSet
  profile     Create a new profile
  repository-server   Create a new kopia repository server

Flags:
      --dry-run           if set, resource YAML will be printed but not created
  -h, --help              help for create
      --skip-validation   if set, resource is not validated before creation

Global Flags:
  -n, --namespace string   Override namespace obtained from kubectl context

Use "kanctl create [command] --help" for more information about a command.
```

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

### Create the first ActionSet

Source: https://docs.kanister.io/tutorial.html

Triggers the backup action defined in the Blueprint for the time-logger deployment.

```yaml
$ cat <<EOF | kubectl create -f -
apiVersion: cr.kanister.io/v1alpha1
kind: ActionSet
metadata:
  generateName: s3backup-
  namespace: kanister
spec:
  actions:
  - name: backup
    blueprint: time-log-bp
    object:
      kind: Deployment
      name: time-logger
      namespace: default
EOF
```

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

### Backup and Restore with Different Mount Paths

Source: https://docs.kanister.io/functions.html

Demonstrates migrating data between environments by specifying different source and target mount paths. Both backupPath and restorePath are required in the RestoreData phase.

```yaml
actions:
  backup:
    outputArtifacts:
      backupInfo:
        keyValue:
          backupID: "{{ .Phases.backupData.Output.backupID }}"
          backupRoot: "{{ .Phases.backupData.Output.backupRoot }}"
          backupTag: "{{ .Phases.backupData.Output.backupTag }}"
    phases:
    - func: CopyVolumeData
      name: backupData
      args:
        namespace: "{{ .PVC.Namespace }}"
        volume: "{{ .PVC.Name }}"
        dataArtifactPrefix: s3-bucket-name/backup-path
        mountPath: "/mnt/source_data"

  restore:
    inputArtifactNames:
    - backupInfo
    phases:
    - func: RestoreData
      name: restoreData
      args:
        namespace: "{{ .PVC.Namespace }}"
        image: ghcr.io/kanisterio/kanister-tools:0.110.0
        backupArtifactPrefix: s3-bucket-name/backup-path
        backupTag: "{{ .ArtifactsIn.backupInfo.KeyValue.backupTag }}"
        backupPath: "{{ .ArtifactsIn.backupInfo.KeyValue.backupRoot }}"
        restorePath: "/mnt/target_data"
        volumes:
          "{{ .PVC.Name }}": "/mnt/target_data"
```

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

### Create the first Blueprint

Source: https://docs.kanister.io/tutorial.html

Defines a Kanister Blueprint with a backup action that uses KubeExec to echo the log file path.

```yaml
$ cat <<EOF | kubectl create -f -
apiVersion: cr.kanister.io/v1alpha1
kind: Blueprint
metadata:
  name: time-log-bp
  namespace: kanister
actions:
  backup:
    phases:
    - func: KubeExec
      name: backupToS3
      args:
        namespace: "{{ .Deployment.Namespace }}"
        pod: "{{ index .Deployment.Pods 0 }}"
        container: test-container
        command:
          - sh
          - -c
          - echo /var/log/time.log
EOF
```

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

### Deploy the time-logger application

Source: https://docs.kanister.io/tutorial.html

Deploys a sample Kubernetes deployment that logs the current time to a file every second.

```yaml
$ cat <<EOF | kubectl create -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: time-logger
spec:
  replicas: 1  
  selector:
    matchLabels:
      app: time-logger
  template:
    metadata:
      labels:
        app: time-logger
    spec:
      containers:
      - name: test-container
        image: containerlabs/aws-sdk
        command: ["sh", "-c"]
        args: ["while true; do for x in $(seq 1200); do date >> /var/log/time.log; sleep 1; done; truncate /var/log/time.log --size 0; done"]
EOF
```

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

### KubeTask

Source: https://docs.kanister.io/functions.html

KubeTask spins up a new container and executes a command via a Pod. This allows you to run a new Pod from a Blueprint.

```APIDOC
## KubeTask

### Description
Spins up a new container and executes a command via a Pod.

### Arguments
- **namespace** (string) - Optional - namespace in which to execute (the pod will be created in controller's namespace if not specified)
- **image** (string) - Required - image to be used for executing the task
- **command** ([]string) - Required - command list to execute
- **podOverride** (map[string]interface{}) - Optional - specs to override default pod specs with
- **podAnnotations** (map[string]string) - Optional - custom annotations for the temporary pod that gets created
- **podLabels** (map[string]string) - Optional - custom labels for the temporary pod that gets created

### Example
```yaml
- func: KubeTask
  name: examplePhase
  args:
    namespace: "{{ .Deployment.Namespace }}"
    image: busybox
    podOverride:
      serviceAccountName: <sa-name>
      containers:
      - name: container
        imagePullPolicy: IfNotPresent
    podAnnotations:
      annKey: annValue
    podLabels:
      labelKey: labelValue
    command:
      - sh
      - -c
      - |
        echo "Example"
```
```

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

### Namespace Parameters

Source: https://docs.kanister.io/templates.html

Structure and access pattern for Namespace parameters.

```go
// NamespaceParams are params for a Namespace
type NamespaceParams struct {
  Name              string
}
```

```go
"{{ .Namespace.Name }}"
```

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

### Launch and List Cron Workflows

Source: https://docs.kanister.io/tasks/argo.html

Commands to create a cron workflow from a YAML file and list existing cron workflows in the argo namespace.

```bash
argo cron create mysql-cron-wf.yaml -n argo
```

```bash
argo cron list -n argo
```

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

### List Configurable Helm Values

Source: https://docs.kanister.io/install.html

View available configuration options for the Kanister operator chart.

```bash
helm show values kanister/kanister-operator
```

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

### View S3Compliant profile help

Source: https://docs.kanister.io/tooling.html

Displays help information for the s3compliant subcommand.

```bash
$ kanctl create profile s3compliant --help
Create new S3 compliant profile

Usage:
  kanctl create profile s3compliant [flags]

Flags:
  -a, --access-key string   access key of the s3 compliant bucket
  -b, --bucket string       s3 bucket name
  -e, --endpoint string     endpoint URL of the s3 bucket
  -h, --help                help for s3compliant
  -p, --prefix string       prefix URL of the s3 bucket
  -r, --region string       region of the s3 bucket
  -s, --secret-key string   secret key of the s3 compliant bucket

Global Flags:
      --dry-run                 if set, resource YAML will be printed but not created
  -n, --namespace string        Override namespace obtained from kubectl context
      --skip-SSL-verification   if set, SSL verification is disabled for the profile
      --skip-validation         if set, resource is not validated before creation
```

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

### BackupDataAll YAML Configuration

Source: https://docs.kanister.io/functions.html

Configures a concurrent backup action for multiple pods using the BackupDataAll function.

```yaml
actions:
  backup:
    outputArtifacts:
      params:
        keyValue:
          backupInfo: "{{ .Phases.backupToObjectStore.Output.BackupAllInfo }}"
    phases:
      - func: BackupDataAll
        name: BackupToObjectStore
        args:
          namespace: "{{ .Deployment.Namespace }}"
          container: kanister-tools
          includePath: /mnt/data
          backupArtifactPrefix: s3-bucket/path/artifactPrefix
```

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

### Validate GKE webhook connectivity error

Source: https://docs.kanister.io/troubleshooting.html

Example of an error message indicating that the Kubernetes API server cannot reach the Kanister operator webhook on port 9443.

```console
$ kubectl apply -f blueprint.yaml
Error from server (InternalError): error when creating "blueprint.yaml": Internal error occurred: failed calling webhook "blueprints.cr.kanister.io": failed to call webhook: Post "https://kanister-kanister-operator.kanister.svc:443/validate/v1alpha1/blueprint?timeout=5s": context deadline exceeded
```

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

### Kando Command Help

Source: https://docs.kanister.io/tooling.html

Displays help information for kando commands.

```bash
$ kando location pull --help
```

```bash
$ kando location push --help
```

```bash
$ kando location delete --help
```

```bash
$ kando output --help
```

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

### Access Options in Blueprint

Source: https://docs.kanister.io/templates.html

Template syntax to access options defined in the ActionSet.

```go
"{{ .Options.podName }}"
```

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

### DeploymentConfig Parameters

Source: https://docs.kanister.io/templates.html

Structure and access pattern for OpenShift DeploymentConfig parameters.

```go
// DeploymentConfigParams are params for DeploymentConfig
type DeploymentConfigParams struct {
  Name                   string
  Namespace              string
  Pods                   []string
  Containers             [][]string
  PersistentVolumeClaims map[string]map[string]string
}
```

```go
"{{ index .DeploymentConfig.Name }}"
```

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

### Create ActionSet for Restore

Source: https://docs.kanister.io/tutorial.html

Initiates a restore action by providing the full S3 path as an artifact.

```yaml
cat <<EOF | kubectl create -f -
apiVersion: cr.kanister.io/v1alpha1
kind: ActionSet
metadata:
  generateName: s3restore
  namespace: kanister
spec:
  actions:
    - name: restore
      blueprint: time-log-bp
      object:
        kind: Deployment
        name: time-logger
        namespace: default
      secrets:
        aws:
          name: aws-creds
          namespace: kanister
      artifacts:
        timeLog:
          keyValue:
            path: s3://time-log-test-bucket/tutorial/time-log/time.log
EOF
```

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

### Create ActionSet with dry-run

Source: https://docs.kanister.io/tooling.html

Executes a dry-run creation of an ActionSet to preview the generated YAML configuration.

```bash
$ kanctl create actionset --action backup --namespace kanister --blueprint time-log-bp \
                          --selector app=time-logger                                   \
                          --kind deployment                                            \
                          --selector-namespace kanister                                \
                          --profile s3-profile                                         \
                          --dry-run
apiVersion: cr.kanister.io/v1alpha1
kind: ActionSet
metadata:
  creationTimestamp: null
  generateName: backup-
spec:
  actions:
  - blueprint: time-log-bp
    configMaps: {}
    name: backup
    object:
      apiVersion: ""
      kind: deployment
      name: time-logger
      namespace: kanister
    options: {}
    profile:
      apiVersion: ""
      kind: ""
      name: s3-profile
      namespace: kanister
    secrets: {}
```

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

### Configure KubeTask for Pod Execution

Source: https://docs.kanister.io/functions.html

Use this configuration to execute a command in a temporary pod with custom service account, annotations, and labels.

```yaml
- func: KubeTask
  name: examplePhase
  args:
    namespace: "{{ .Deployment.Namespace }}"
    image: busybox
    podOverride:
      serviceAccountName: <sa-name>
      containers:
      - name: container
        imagePullPolicy: IfNotPresent
    podAnnotations:
      annKey: annValue
    podLabels:
      labelKey: labelValue
    command:
      - sh
      - -c
      - |
        echo "Example"
```

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

### Create S3Compliant profile

Source: https://docs.kanister.io/tooling.html

Creates a new S3 compliant profile using specified bucket and credential details.

```bash
$ kanctl create profile s3compliant --bucket <bucket> --access-key ${AWS_ACCESS_KEY_ID} \
                                    --secret-key ${AWS_SECRET_ACCESS_KEY}               \
                                    --region us-west-1                                  \
                                    --namespace kanister
secret 's3-secret-chst2' created
profile 's3-profile-5mmkj' created
```

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

### StatefulSet Parameters

Source: https://docs.kanister.io/templates.html

Structure and access pattern for StatefulSet parameters.

```go
// StatefulSetParams are params for stateful sets.
type StatefulSetParams struct {
  Name                   string
  Namespace              string
  Pods                   []string
  Containers             [][]string
  PersistentVolumeClaims [][]string
}
```

```go
"{{ index .StatefulSet.Pods 0 }}"
```

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

### Backup resources using K8s labels

Source: https://docs.kanister.io/tooling.html

Targets specific resources for backup by applying Kubernetes labels and selectors.

```bash
# backup deployment time-logger in namespace kanister using selectors
# if --kind deployment is not specified, all deployments, statefulsets and pvc matching the
# selector will be chosen for the action. You can also narrow down the search by setting the
# --selector-namespace flag
$ kanctl create actionset --action backup --namespace kanister --blueprint time-log-bp \
                          --selector app=time-logger                                   \
                          --kind deployment                                            \
                          --selector-namespace kanister --profile s3-profile
actionset backup-8f827 created
```

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

### Add Kanister Helm Repository

Source: https://docs.kanister.io/install.html

Add the official Kanister repository to your local Helm configuration.

```bash
helm repo add kanister https://charts.kanister.io/
```
Tokens:
Raw