From e776eb926a0d6dd60bb2e6428075424d24a51a26 Mon Sep 17 00:00:00 2001 From: Waleed Malik Date: Wed, 8 Jun 2022 13:30:45 +0500 Subject: [PATCH] Synchronize OSM with machine-controller (#170) * Add missing flags for node-registry-credentials-secret and node-containerd-registry-mirrors Signed-off-by: Waleed Malik * Enable DHCPv6 support for RHEL Signed-off-by: Waleed Malik * Upgrade to Go v1.18.3 Signed-off-by: Waleed Malik * Add support for rocky linux Signed-off-by: Waleed Malik * Add support for VMware Cloud Director as cloud provider Signed-off-by: Waleed Malik * Synchronize KubeVirt with machine-controller Signed-off-by: Waleed Malik * Update fixtures Signed-off-by: Waleed Malik * Update CRDs Signed-off-by: Waleed Malik * Bump OSP versions and update compatibility matrix Signed-off-by: Waleed Malik * Rocky linux is supported in KKP Signed-off-by: Waleed Malik --- .prow.yaml | 6 +- Dockerfile | 2 +- Makefile | 2 +- cmd/osm-controller/main.go | 2 + deploy/crd/crd-operating-system-config.yaml | 2 + deploy/crd/crd-operating-system-profile.yaml | 2 + deploy/osps/default/osp-amzn2.yaml | 23 +- deploy/osps/default/osp-centos.yaml | 23 +- deploy/osps/default/osp-centos8.yaml | 23 +- deploy/osps/default/osp-flatcar.yaml | 2 +- deploy/osps/default/osp-rhel.yaml | 33 +- deploy/osps/default/osp-rockylinux.yaml | 758 ++++++++++++++++++ deploy/osps/default/osp-sles.yaml | 28 +- deploy/osps/default/osp-ubuntu.yaml | 24 +- docs/compatibility-matrix.md | 23 +- hack/update-codegen.sh | 4 +- hack/update-crds-openapi.sh | 2 +- pkg/cloudprovider/cloudprovider.go | 4 +- pkg/cloudprovider/kubevirt/provider.go | 43 +- .../kubevirt/types/cloudconfig.go | 3 + .../kubevirt/types/cloudconfig_test.go | 3 + pkg/cloudprovider/kubevirt/types/types.go | 59 +- .../osc/resources/operating_system_config.go | 10 + .../osc-kubelet-configuration-containerd.yaml | 16 +- .../osc-kubelet-configuration-docker.yaml | 16 +- .../osc-rhel-8.x-azure-containerd.yaml | 24 +- .../osc/testdata/osc-rhel-8.x-containerd.yaml | 24 +- .../testdata/osc-ubuntu-aws-containerd.yaml | 16 +- .../osc/testdata/osc-ubuntu-aws-docker.yaml | 16 +- ...cret-kubelet-configuration-containerd.yaml | 2 +- .../secret-kubelet-configuration-docker.yaml | 2 +- .../secret-rhel-8.x-azure-containerd.yaml | 2 +- .../testdata/secret-rhel-8.x-containerd.yaml | 2 +- .../secret-ubuntu-aws-containerd.yaml | 2 +- .../testdata/secret-ubuntu-aws-docker.yaml | 2 +- pkg/crd/osm/v1alpha1/common_types.go | 40 +- pkg/providerconfig/rockylinux/rockylinux.go | 47 ++ 37 files changed, 1132 insertions(+), 160 deletions(-) create mode 100644 deploy/osps/default/osp-rockylinux.yaml create mode 100644 pkg/providerconfig/rockylinux/rockylinux.go diff --git a/.prow.yaml b/.prow.yaml index cc3610e1..53bc5723 100644 --- a/.prow.yaml +++ b/.prow.yaml @@ -39,7 +39,7 @@ presubmits: preset-goproxy: "true" spec: containers: - - image: golang:1.18.1 + - image: golang:1.18.3 command: - make args: @@ -61,7 +61,7 @@ presubmits: preset-goproxy: "true" spec: containers: - - image: golang:1.18.1 + - image: golang:1.18.3 command: - make args: @@ -124,7 +124,7 @@ presubmits: preset-goproxy: "true" spec: containers: - - image: golang:1.18.1 + - image: golang:1.18.3 command: - make args: diff --git a/Dockerfile b/Dockerfile index 8331be2d..8fdf75da 100644 --- a/Dockerfile +++ b/Dockerfile @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -ARG GO_VERSION=1.18.1 +ARG GO_VERSION=1.18.3 FROM golang:${GO_VERSION} AS builder WORKDIR /go/src/k8c.io/operating-system-manager COPY . . diff --git a/Makefile b/Makefile index a102e0d4..0b6a3afd 100644 --- a/Makefile +++ b/Makefile @@ -21,7 +21,7 @@ export GO111MODULE=on export GOFLAGS?=-mod=readonly -trimpath export GIT_TAG ?= $(shell git tag --points-at HEAD) -GO_VERSION = 1.18.1 +GO_VERSION = 1.18.3 CMD = $(notdir $(wildcard ./cmd/*)) BUILD_DEST ?= _build diff --git a/cmd/osm-controller/main.go b/cmd/osm-controller/main.go index f5e0b9d1..a17d8722 100644 --- a/cmd/osm-controller/main.go +++ b/cmd/osm-controller/main.go @@ -105,6 +105,8 @@ func main() { flag.StringVar(&opt.nodeNoProxy, "node-no-proxy", ".svc,.cluster.local,localhost,127.0.0.1", "If set, it configures the 'NO_PROXY' environment variable on the nodes.") flag.StringVar(&opt.nodeInsecureRegistries, "node-insecure-registries", "", "Comma separated list of registries which should be configured as insecure on the container runtime") flag.StringVar(&opt.nodeRegistryMirrors, "node-registry-mirrors", "", "Comma separated list of Docker image mirrors") + flag.Var(&opt.nodeContainerdRegistryMirrors, "node-containerd-registry-mirrors", "Configure registry mirrors endpoints. Can be used multiple times to specify multiple mirrors") + flag.StringVar(&opt.nodeRegistryCredentialsSecret, "node-registry-credentials-secret", "", "A Secret object reference, that contains auth info for image registry in namespace/secret-name form, example: kube-system/registry-credentials. See doc at https://github.com/kubermaric/machine-controller/blob/master/docs/registry-authentication.md") flag.StringVar(&opt.healthProbeAddress, "health-probe-address", "127.0.0.1:8085", "The address on which the liveness check on /healthz and readiness check on /readyz will be available") flag.StringVar(&opt.metricsAddress, "metrics-address", "127.0.0.1:8080", "The address on which Prometheus metrics will be available under /metrics") diff --git a/deploy/crd/crd-operating-system-config.yaml b/deploy/crd/crd-operating-system-config.yaml index bbaa53cf..85043276 100644 --- a/deploy/crd/crd-operating-system-config.yaml +++ b/deploy/crd/crd-operating-system-config.yaml @@ -80,6 +80,7 @@ spec: - scaleway - baremetal - external + - vmware-cloud-director spec: description: Spec represents the os/image reference in the supported cloud provider type: object @@ -146,6 +147,7 @@ spec: - ubuntu - sles - amzn2 + - rockylinux osVersion: description: OSVersion the version of the operating system type: string diff --git a/deploy/crd/crd-operating-system-profile.yaml b/deploy/crd/crd-operating-system-profile.yaml index 2e732de5..d2bf1463 100644 --- a/deploy/crd/crd-operating-system-profile.yaml +++ b/deploy/crd/crd-operating-system-profile.yaml @@ -117,6 +117,7 @@ spec: - ubuntu - sles - amzn2 + - rockylinux osVersion: description: OSVersion the version of the operating system type: string @@ -150,6 +151,7 @@ spec: - scaleway - baremetal - external + - vmware-cloud-director spec: description: Spec represents the os/image reference in the supported cloud provider type: object diff --git a/deploy/osps/default/osp-amzn2.yaml b/deploy/osps/default/osp-amzn2.yaml index 1328fd64..3ce56418 100644 --- a/deploy/osps/default/osp-amzn2.yaml +++ b/deploy/osps/default/osp-amzn2.yaml @@ -20,7 +20,7 @@ metadata: spec: osName: "amzn2" osVersion: "2.0" - version: "v0.1.2" + version: "v0.1.3" supportedCloudProviders: - name: "aws" supportedContainerRuntimes: @@ -414,10 +414,6 @@ spec: systemctl restart systemd-modules-load.service sysctl --system - {{- /* Make sure we always disable swap - Otherwise the kubelet won't start'. */}} - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a - yum install -y \ device-mapper-persistent-data \ lvm2 \ @@ -429,7 +425,7 @@ spec: socat \ wget \ curl \ - {{- if eq .CloudProviderName "vsphere" }} + {{- if or (eq .CloudProviderName "vsphere") (eq .CloudProviderName "vmware-cloud-director") }} open-vm-tools \ {{- end }} ipvsadm @@ -484,6 +480,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -719,3 +716,17 @@ spec: [Install] WantedBy=multi-user.target + + - path: "/opt/disable-swap.sh" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a diff --git a/deploy/osps/default/osp-centos.yaml b/deploy/osps/default/osp-centos.yaml index 4741b47d..1e02eb4d 100644 --- a/deploy/osps/default/osp-centos.yaml +++ b/deploy/osps/default/osp-centos.yaml @@ -20,7 +20,7 @@ metadata: spec: osName: "centos" osVersion: "7.7" - version: "v0.1.2" + version: "v0.1.3" supportedCloudProviders: - name: "aws" - name: "azure" @@ -433,10 +433,6 @@ spec: systemctl restart systemd-modules-load.service sysctl --system - {{- /* Make sure we always disable swap - Otherwise the kubelet won't start'. */}} - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a - yum install -y \ device-mapper-persistent-data \ lvm2 \ @@ -448,7 +444,7 @@ spec: socat \ wget \ curl \ - {{- if eq .CloudProviderName "vsphere" }} + {{- if or (eq .CloudProviderName "vsphere") (eq .CloudProviderName "vmware-cloud-director") }} open-vm-tools \ {{- end }} {{- if eq .CloudProviderName "nutanix" }} @@ -515,6 +511,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -750,3 +747,17 @@ spec: [Install] WantedBy=multi-user.target + + - path: "/opt/disable-swap.sh" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a diff --git a/deploy/osps/default/osp-centos8.yaml b/deploy/osps/default/osp-centos8.yaml index 8049c219..731d5445 100644 --- a/deploy/osps/default/osp-centos8.yaml +++ b/deploy/osps/default/osp-centos8.yaml @@ -20,7 +20,7 @@ metadata: spec: osName: "centos" osVersion: "8" - version: "v0.1.2" + version: "v0.1.3" supportedCloudProviders: - name: "aws" - name: "azure" @@ -433,10 +433,6 @@ spec: systemctl restart systemd-modules-load.service sysctl --system - {{- /* Make sure we always disable swap - Otherwise the kubelet won't start'. */}} - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a - {{- /* CentOS 8 has reached EOL and all packages were moved to vault.centos.org -- https://www.centos.org/centos-linux-eol/ */}} sudo sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-* sudo sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-* @@ -452,7 +448,7 @@ spec: socat \ wget \ curl \ - {{- if eq .CloudProviderName "vsphere" }} + {{- if or (eq .CloudProviderName "vsphere") (eq .CloudProviderName "vmware-cloud-director") }} open-vm-tools \ {{- end }} {{- if eq .CloudProviderName "nutanix" }} @@ -519,6 +515,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -754,3 +751,17 @@ spec: [Install] WantedBy=multi-user.target + + - path: "/opt/disable-swap.sh" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a diff --git a/deploy/osps/default/osp-flatcar.yaml b/deploy/osps/default/osp-flatcar.yaml index 5c3118ba..012e1e6d 100644 --- a/deploy/osps/default/osp-flatcar.yaml +++ b/deploy/osps/default/osp-flatcar.yaml @@ -21,7 +21,7 @@ spec: osName: flatcar ## Flatcar Stable (09/11/2021) osVersion: "2983.2.0" - version: "v0.1.2" + version: "v0.1.3" supportedCloudProviders: - name: aws - name: azure diff --git a/deploy/osps/default/osp-rhel.yaml b/deploy/osps/default/osp-rhel.yaml index 6b75a2ff..75baaa4f 100644 --- a/deploy/osps/default/osp-rhel.yaml +++ b/deploy/osps/default/osp-rhel.yaml @@ -20,7 +20,7 @@ metadata: spec: osName: "rhel" osVersion: "8.5" - version: "v0.1.2" + version: "v0.1.3" supportedCloudProviders: - name: "aws" - name: "azure" @@ -430,10 +430,6 @@ spec: systemctl restart systemd-modules-load.service sysctl --system - {{- /* Make sure we always disable swap - Otherwise the kubelet won't start'. */}} - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a - yum install -y \ device-mapper-persistent-data \ lvm2 \ @@ -445,7 +441,7 @@ spec: socat \ wget \ curl \ - {{- if eq .CloudProviderName "vsphere" }} + {{- if or (eq .CloudProviderName "vsphere") (eq .CloudProviderName "vmware-cloud-director") }} open-vm-tools \ {{- end }} {{- if eq .CloudProviderName "nutanix" }} @@ -466,6 +462,14 @@ spec: {{- template "configureProxyScript" }} + DEFAULT_IFC_NAME=$(ip -o route get 1 | grep -oP "dev \K\S+") + + # enable DHCPv6 on the default interface + echo NETWORKING_IPV6=yes >> /etc/sysconfig/network + echo IPV6INIT=yes >> /etc/sysconfig/network-scripts/ifcfg-$DEFAULT_IFC_NAME + echo DHCPV6C=yes >> /etc/sysconfig/network-scripts/ifcfg-$DEFAULT_IFC_NAME + ifdown $DEFAULT_IFC_NAME && ifup $DEFAULT_IFC_NAME + mkdir -p /etc/systemd/system/kubelet.service.d/ # set kubelet nodeip environment variable /opt/bin/setup_net_env.sh @@ -511,6 +515,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -594,7 +599,7 @@ spec: {{- if eq .CloudProviderName "openstack" }} FULL_HOSTNAME=$(echo $FULL_HOSTNAME | sed -e "s/.novalocal//") {{- end }} - + # write the nodeip_env file # we need the line below because flatcar has the same string "coreos" in that file if grep -q coreos /etc/os-release @@ -749,3 +754,17 @@ spec: [Install] WantedBy=multi-user.target + + - path: "/opt/disable-swap.sh" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a diff --git a/deploy/osps/default/osp-rockylinux.yaml b/deploy/osps/default/osp-rockylinux.yaml new file mode 100644 index 00000000..0373bd33 --- /dev/null +++ b/deploy/osps/default/osp-rockylinux.yaml @@ -0,0 +1,758 @@ +# Copyright 2021 The Operating System Manager contributors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +apiVersion: operatingsystemmanager.k8c.io/v1alpha1 +kind: OperatingSystemProfile +metadata: + name: osp-rockylinux + namespace: kube-system +spec: + osName: "rockylinux" + osVersion: "8.6" + version: "v0.1.0" + supportedCloudProviders: + - name: "aws" + - name: "azure" + - name: "digitalocean" + - name: "hetzner" + - name: "openstack" + - name: "kubevirt" + - name: "vsphere" + supportedContainerRuntimes: + - name: containerd + files: + - path: "/etc/systemd/system/containerd.service.d/environment.conf" + content: + inline: + data: | + [Service] + Restart=always + EnvironmentFile=-/etc/environment + + - path: "/etc/crictl.yaml" + content: + inline: + data: | + runtime-endpoint: unix:///run/containerd/containerd.sock + + - path: "/etc/containerd/config.toml" + permissions: 0600 + content: + inline: + encoding: b64 + data: | + {{ .ContainerRuntimeConfig }} + templates: + containerRuntimeInstallation: |- + yum install -y yum-utils + yum-config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo + {{- /* + Due to DNF modules we have to do this on docker-ce repo + More info at: https://bugzilla.redhat.com/show_bug.cgi?id=1756473 + */}} + yum-config-manager --save --setopt=docker-ce-stable.module_hotfixes=true + + yum install -y containerd.io-1.5* yum-plugin-versionlock + yum versionlock add containerd.io + + systemctl daemon-reload + systemctl enable --now containerd + + - name: docker + files: + - path: "/etc/systemd/system/containerd.service.d/environment.conf" + content: + inline: + data: | + [Service] + Restart=always + EnvironmentFile=-/etc/environment + + - path: "/etc/systemd/system/docker.service.d/environment.conf" + content: + inline: + data: | + [Service] + Restart=always + EnvironmentFile=-/etc/environment + + - path: /etc/docker/daemon.json + permissions: 0644 + content: + inline: + encoding: b64 + data: |- + {{ .ContainerRuntimeConfig }} + + - path: /root/.docker/config.json + permissions: 0600 + content: + inline: + encoding: b64 + data: |- + {{ .ContainerRuntimeAuthConfig }} + + templates: + containerRuntimeInstallation: |- + yum install -y yum-utils + yum-config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo + yum-config-manager --save --setopt=docker-ce-stable.module_hotfixes=true + + yum install -y \ + docker-ce-cli-19.03* \ + containerd.io-1.5* \ + docker-ce-19.03* \ + yum-plugin-versionlock + yum versionlock add docker-ce* containerd.io + + systemctl daemon-reload + systemctl enable --now docker + + templates: + safeDownloadBinariesScript: |- + {{- /* setup some common directories */}} + opt_bin=/opt/bin + usr_local_bin=/usr/local/bin + cni_bin_dir=/opt/cni/bin + + {{- /* create all the necessary dirs */}} + mkdir -p /etc/cni/net.d /etc/kubernetes/dynamic-config-dir /etc/kubernetes/manifests "$opt_bin" "$cni_bin_dir" + + {{- /* HOST_ARCH can be defined outside of machine-controller (in kubeone for example) */}} + arch=${HOST_ARCH-} + if [ -z "$arch" ] + then + case $(uname -m) in + x86_64) + arch="amd64" + ;; + aarch64) + arch="arm64" + ;; + *) + echo "unsupported CPU architecture, exiting" + exit 1 + ;; + esac + fi + + {{- /* # CNI variables */}} + CNI_VERSION="${CNI_VERSION:-v0.8.7}" + cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" + cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" + + {{- /* download CNI */}} + curl -Lfo "$cni_bin_dir/$cni_filename" "$cni_base_url/$cni_filename" + + {{- /* download CNI checksum */}} + cni_sum=$(curl -Lf "$cni_base_url/$cni_filename.sha256") + cd "$cni_bin_dir" + + {{- /* verify CNI checksum */}} + sha256sum -c <<<"$cni_sum" + + {{- /* unpack CNI */}} + tar xvf "$cni_filename" + rm -f "$cni_filename" + cd - + + {{- /* # cri-tools variables */}} + CRI_TOOLS_RELEASE="${CRI_TOOLS_RELEASE:-v1.22.0}" + cri_tools_base_url="https://github.com/kubernetes-sigs/cri-tools/releases/download/${CRI_TOOLS_RELEASE}" + cri_tools_filename="crictl-${CRI_TOOLS_RELEASE}-linux-${arch}.tar.gz" + + {{- /* download cri-tools */}} + curl -Lfo "$opt_bin/$cri_tools_filename" "$cri_tools_base_url/$cri_tools_filename" + + {{- /* download cri-tools checksum */}} + {{- /* the cri-tools checksum file has a filename prefix that breaks sha256sum so we need to drop it with sed */}} + cri_tools_sum=$(curl -Lf "$cri_tools_base_url/$cri_tools_filename.sha256" | sed 's/\*\///') + cd "$opt_bin" + + {{- /* verify cri-tools checksum */}} + sha256sum -c <<<"$cri_tools_sum" + + {{- /* unpack cri-tools and symlink to path so it's available to all users */}} + tar xvf "$cri_tools_filename" + rm -f "$cri_tools_filename" + ln -sf "$opt_bin/crictl" "$usr_local_bin"/crictl || echo "symbolic link is skipped" + cd - + + {{- /* kubelet */}} + KUBE_VERSION="${KUBE_VERSION:-{{ .KubeVersion }}}" + kube_dir="$opt_bin/kubernetes-$KUBE_VERSION" + kube_base_url="https://storage.googleapis.com/kubernetes-release/release/$KUBE_VERSION/bin/linux/$arch" + kube_sum_file="$kube_dir/sha256" + + {{- /* create versioned kube dir */}} + mkdir -p "$kube_dir" + : >"$kube_sum_file" + + for bin in kubelet kubeadm kubectl; do + {{- /* download kube binary */}} + curl -Lfo "$kube_dir/$bin" "$kube_base_url/$bin" + chmod +x "$kube_dir/$bin" + + {{- /* download kube binary checksum */}} + sum=$(curl -Lf "$kube_base_url/$bin.sha256") + + {{- /* save kube binary checksum */}} + echo "$sum $kube_dir/$bin" >>"$kube_sum_file" + done + + {{- /* check kube binaries checksum */}} + sha256sum -c "$kube_sum_file" + + for bin in kubelet kubeadm kubectl; do + {{- /* link kube binaries from verioned dir to $opt_bin */}} + ln -sf "$kube_dir/$bin" "$opt_bin"/$bin + done + + configureProxyScript: |- + {{- if .HTTPProxy }} + cat <.yaml. The env variables come from an env + # file provided by the systemd service. + + # This script is a slightly adjusted version of + # https://github.com/kubernetes/kubernetes/blob/e1a1aa211224fcd9b213420b80b2ae680669683d/cluster/gce/gci/health-monitor.sh + # Adjustments are: + # * Kubelet health port is 10248 not 10255 + # * Removal of all all references to the KUBE_ENV file + + set -o nounset + set -o pipefail + + # We simply kill the process when there is a failure. Another systemd service will + # automatically restart the process. + function container_runtime_monitoring() { + local -r max_attempts=5 + local attempt=1 + local -r container_runtime_name="${CONTAINER_RUNTIME_NAME:-docker}" + # We still need to use 'docker ps' when container runtime is "docker". This is because + # dockershim is still part of kubelet today. When kubelet is down, crictl pods + # will also fail, and docker will be killed. This is undesirable especially when + # docker live restore is disabled. + local healthcheck_command="docker ps" + if [[ "${CONTAINER_RUNTIME:-docker}" != "docker" ]]; then + healthcheck_command="crictl pods" + fi + # Container runtime startup takes time. Make initial attempts before starting + # killing the container runtime. + until timeout 60 ${healthcheck_command} > /dev/null; do + if ((attempt == max_attempts)); then + echo "Max attempt ${max_attempts} reached! Proceeding to monitor container runtime healthiness." + break + fi + echo "$attempt initial attempt \"${healthcheck_command}\"! Trying again in $attempt seconds..." + sleep "$((2 ** attempt++))" + done + while true; do + if ! timeout 60 ${healthcheck_command} > /dev/null; then + echo "Container runtime ${container_runtime_name} failed!" + if [[ "$container_runtime_name" == "docker" ]]; then + # Dump stack of docker daemon for investigation. + # Log file name looks like goroutine-stacks-TIMESTAMP and will be saved to + # the exec root directory, which is /var/run/docker/ on Ubuntu and COS. + pkill -SIGUSR1 dockerd + fi + systemctl kill --kill-who=main "${container_runtime_name}" + # Wait for a while, as we don't want to kill it again before it is really up. + sleep 120 + else + sleep "${SLEEP_SECONDS}" + fi + done + } + + function kubelet_monitoring() { + echo "Wait for 2 minutes for kubelet to be functional" + sleep 120 + local -r max_seconds=10 + local output="" + while true; do + local failed=false + + if journalctl -u kubelet -n 1 | grep -q "use of closed network connection"; then + failed=true + echo "Kubelet stopped posting node status. Restarting" + elif ! output=$(curl -m "${max_seconds}" -f -s -S http://127.0.0.1:10248/healthz 2>&1); then + failed=true + # Print the response and/or errors. + echo "$output" + fi + + if [[ "$failed" == "true" ]]; then + echo "Kubelet is unhealthy!" + systemctl kill kubelet + # Wait for a while, as we don't want to kill it again before it is really up. + sleep 60 + else + sleep "${SLEEP_SECONDS}" + fi + done + } + + ############## Main Function ################ + if [[ "$#" -ne 1 ]]; then + echo "Usage: health-monitor.sh " + exit 1 + fi + + SLEEP_SECONDS=10 + component=$1 + echo "Start kubernetes health monitoring for ${component}" + if [[ "${component}" == "container-runtime" ]]; then + container_runtime_monitoring + elif [[ "${component}" == "kubelet" ]]; then + kubelet_monitoring + else + echo "Health monitoring for component ${component} is not supported!" + fi + + - path: "/etc/systemd/journald.conf.d/max_disk_use.conf" + content: + inline: + encoding: b64 + data: | + [Journal] + SystemMaxUse=5G + + - path: "/opt/load-kernel-modules.sh" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/usr/bin/env bash + set -euo pipefail + + modprobe ip_vs + modprobe ip_vs_rr + modprobe ip_vs_wrr + modprobe ip_vs_sh + + if modinfo nf_conntrack_ipv4 &> /dev/null; then + modprobe nf_conntrack_ipv4 + else + modprobe nf_conntrack + fi + + - path: "/etc/sysctl.d/k8s.conf" + content: + inline: + encoding: b64 + data: | + net.bridge.bridge-nf-call-ip6tables = 1 + net.bridge.bridge-nf-call-iptables = 1 + kernel.panic_on_oops = 1 + kernel.panic = 10 + net.ipv4.ip_forward = 1 + vm.overcommit_memory = 1 + fs.inotify.max_user_watches = 1048576 + fs.inotify.max_user_instances = 8192 + + - path: "/etc/selinux/config" + content: + inline: + encoding: b64 + data: | + # This file controls the state of SELinux on the system. + # SELINUX= can take one of these three values: + # enforcing - SELinux security policy is enforced. + # permissive - SELinux prints warnings instead of enforcing. + # disabled - No SELinux policy is loaded. + SELINUX=permissive + # SELINUXTYPE= can take one of three two values: + # targeted - Targeted processes are protected, + # minimum - Modification of targeted policy. Only selected processes are protected. + # mls - Multi Level Security protection. + SELINUXTYPE=targeted + + - path: "/opt/bin/setup" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/bin/bash + set -xeuo pipefail + + setenforce 0 || true + + {{- /* As we added some modules and don't want to reboot, restart the service */}} + systemctl restart systemd-modules-load.service + sysctl --system + + yum install -y \ + device-mapper-persistent-data \ + lvm2 \ + ebtables \ + ethtool \ + nfs-utils \ + bash-completion \ + sudo \ + socat \ + wget \ + curl \ + tar \ + {{- if or (eq .CloudProviderName "vsphere") (eq .CloudProviderName "vmware-cloud-director") }} + open-vm-tools \ + {{- end }} + {{- if eq .CloudProviderName "nutanix" }} + iscsi-initiator-utils \ + {{- end }} + ipvsadm + + systemctl disable --now firewalld || true + + {{- /* iscsid service is required on Nutanix machines for CSI driver to attach volumes. */}} + {{- if eq .CloudProviderName "nutanix" }} + systemctl enable --now iscsid + {{ end }} + + {{- template "containerRuntimeInstallation" }} + + {{- template "safeDownloadBinariesScript" }} + + {{- template "configureProxyScript" }} + + mkdir -p /etc/systemd/system/kubelet.service.d/ + # set kubelet nodeip environment variable + /opt/bin/setup_net_env.sh + + {{ if eq .CloudProviderName "vsphere" }} + systemctl enable --now vmtoolsd.service + {{ end -}} + + systemctl enable --now kubelet + systemctl enable --now --no-block kubelet-healthcheck.service + + - path: "/opt/bin/supervise.sh" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/bin/bash + set -xeuo pipefail + while ! "$@"; do + sleep 1 + done + + - path: "/etc/systemd/system/kubelet.service" + content: + inline: + encoding: b64 + data: | + [Unit] + After={{ .ContainerRuntime }}.service + Requires={{ .ContainerRuntime }}.service + + Description=kubelet: The Kubernetes Node Agent + Documentation=https://kubernetes.io/docs/home/ + + [Service] + User=root + Restart=always + StartLimitInterval=0 + RestartSec=10 + CPUAccounting=true + MemoryAccounting=true + + Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" + EnvironmentFile=-/etc/environment + + ExecStartPre=/bin/bash /opt/disable-swap.sh + ExecStartPre=/bin/bash /opt/load-kernel-modules.sh + ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh + ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ + --bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf \ + --kubeconfig=/var/lib/kubelet/kubeconfig \ + --config=/etc/kubernetes/kubelet.conf \ + {{- if semverCompare "<1.24" .KubeVersion }} + --network-plugin=cni \ + {{- end }} + --cert-dir=/etc/kubernetes/pki \ + {{- if .ExternalCloudProvider }} + --cloud-provider=external \ + {{- else if .InTreeCCMAvailable }} + --cloud-provider={{- .CloudProviderName }} \ + --cloud-config=/etc/kubernetes/cloud-config \ + {{- end }} + {{- if ne .CloudProviderName "aws" }} + --hostname-override=${KUBELET_HOSTNAME} \ + {{- else if and (eq .CloudProviderName "aws") (.ExternalCloudProvider) }} + --hostname-override=${KUBELET_HOSTNAME} \ + {{- end }} + --dynamic-config-dir=/etc/kubernetes/dynamic-config-dir \ + --feature-gates=DynamicKubeletConfig=true \ + --exit-on-lock-contention \ + --lock-file=/tmp/kubelet.lock \ + {{- if .PauseImage }} + --pod-infra-container-image={{ .PauseImage }} \ + {{- end }} + {{- if .InitialTaints }} + --register-with-taints={{- .InitialTaints }} \ + {{- end }} + {{- if eq .ContainerRuntime "containerd" }} + --container-runtime=remote \ + --container-runtime-endpoint=unix:///run/containerd/containerd.sock \ + {{- end }} + {{- if eq .ContainerRuntime "docker" }} + --container-runtime=docker \ + --container-runtime-endpoint=unix:///var/run/dockershim.sock \ + {{- end }} + --node-ip ${KUBELET_NODE_IP} + + [Install] + WantedBy=multi-user.target + + - path: "/etc/kubernetes/cloud-config" + permissions: 0600 + content: + inline: + encoding: b64 + data: | + {{ .CloudConfig }} + + - path: "/opt/bin/setup_net_env.sh" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/usr/bin/env bash + echodate() { + echo "[$(date -Is)]" "$@" + } + + # get the default interface IP address + DEFAULT_IFC_IP=$(ip -o route get 1 | grep -oP "src \K\S+") + + if [ -z "${DEFAULT_IFC_IP}" ] + then + echodate "Failed to get IP address for the default route interface" + exit 1 + fi + + # get the full hostname + FULL_HOSTNAME=$(hostname -f) + # if /etc/hostname is not empty then use the hostname from there + if [ -s /etc/hostname ]; then + FULL_HOSTNAME=$(cat /etc/hostname) + fi + + # write the nodeip_env file + # we need the line below because flatcar has the same string "coreos" in that file + if grep -q coreos /etc/os-release + then + echo "KUBELET_NODE_IP=${DEFAULT_IFC_IP}\nKUBELET_HOSTNAME=${FULL_HOSTNAME}" > /etc/kubernetes/nodeip.conf + elif [ ! -d /etc/systemd/system/kubelet.service.d ] + then + echodate "Can't find kubelet service extras directory" + exit 1 + else + echo -e "[Service]\nEnvironment=\"KUBELET_NODE_IP=${DEFAULT_IFC_IP}\"\nEnvironment=\"KUBELET_HOSTNAME=${FULL_HOSTNAME}\"" > /etc/systemd/system/kubelet.service.d/nodeip.conf + fi + + - path: "/etc/kubernetes/pki/ca.crt" + content: + inline: + encoding: b64 + data: | + {{ .KubernetesCACert }} + + - path: "/etc/systemd/system/setup.service" + permissions: 0644 + content: + inline: + encoding: b64 + data: | + [Install] + WantedBy=multi-user.target + + [Unit] + Requires=network-online.target + After=network-online.target + + [Service] + Type=oneshot + RemainAfterExit=true + EnvironmentFile=-/etc/environment + ExecStart=/opt/bin/supervise.sh /opt/bin/setup + + - path: "/etc/profile.d/opt-bin-path.sh" + permissions: 0644 + content: + inline: + encoding: b64 + data: | + export PATH="/opt/bin:$PATH" + + - path: "/etc/kubernetes/kubelet.conf" + content: + inline: + encoding: b64 + data: | + apiVersion: kubelet.config.k8s.io/v1beta1 + kind: KubeletConfiguration + authentication: + anonymous: + enabled: false + webhook: + enabled: true + x509: + clientCAFile: /etc/kubernetes/pki/ca.crt + authorization: + mode: Webhook + cgroupDriver: systemd + clusterDNS: + {{- range .ClusterDNSIPs }} + - "{{ . }}" + {{- end }} + clusterDomain: cluster.local + {{- /* containerLogMaxSize and containerLogMaxFiles have no effect for docker */}} + {{- if ne .ContainerRuntime "docker" }} + {{- if .ContainerLogMaxSize }} + containerLogMaxSize: {{ .ContainerLogMaxSize }} + {{- else }} + containerLogMaxSize: 100Mi + {{- end }} + {{- if .ContainerLogMaxFiles }} + containerLogMaxFiles: {{ .ContainerLogMaxFiles }} + {{- else }} + containerLogMaxFiles: 5 + {{- end }} + {{- end }} + featureGates: + {{- if .KubeletFeatureGates -}} + {{ range $key, $val := .KubeletFeatureGates }} + {{ $key }}: {{ $val }} + {{- end -}} + {{- end }} + protectKernelDefaults: true + readOnlyPort: 0 + rotateCertificates: true + serverTLSBootstrap: true + staticPodPath: /etc/kubernetes/manifests + kubeReserved: + {{- if .KubeReserved -}} + {{ range $key, $val := .KubeReserved }} + {{ $key }}: {{ $val }} + {{- end -}} + {{- else }} + cpu: 200m + ephemeral-storage: 1Gi + memory: 200Mi + {{- end }} + systemReserved: + {{- if .SystemReserved -}} + {{ range $key, $val := .SystemReserved }} + {{ $key }}: {{ $val }} + {{- end -}} + {{- else }} + cpu: 200m + ephemeral-storage: 1Gi + memory: 200Mi + {{- end }} + evictionHard: + {{- if .EvictionHard -}} + {{ range $key, $val := .EvictionHard }} + {{ $key }}: {{ $val }} + {{- end -}} + {{- else }} + imagefs.available: 15% + memory.available: 100Mi + nodefs.available: 10% + nodefs.inodesFree: 5% + {{- end }} + {{- if .MaxPods }} + maxPods: {{ .MaxPods }} + {{- end }} + tlsCipherSuites: + - TLS_AES_128_GCM_SHA256 + - TLS_AES_256_GCM_SHA384 + - TLS_CHACHA20_POLY1305_SHA256 + - TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 + - TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 + - TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 + - TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 + - TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 + - TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305 + volumePluginDir: /var/lib/kubelet/volumeplugins + + - path: /etc/systemd/system/kubelet-healthcheck.service + permissions: 0644 + content: + inline: + encoding: b64 + data: | + [Unit] + Requires=kubelet.service + After=kubelet.service + + [Service] + ExecStart=/opt/bin/health-monitor.sh kubelet + + [Install] + WantedBy=multi-user.target + + - path: "/opt/disable-swap.sh" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a diff --git a/deploy/osps/default/osp-sles.yaml b/deploy/osps/default/osp-sles.yaml index f7b9d2d0..8a0da5f8 100644 --- a/deploy/osps/default/osp-sles.yaml +++ b/deploy/osps/default/osp-sles.yaml @@ -20,7 +20,7 @@ metadata: spec: osName: sles osVersion: "15-SP-1" - version: "v0.1.2" + version: "v0.1.3" supportedCloudProviders: - name: aws supportedContainerRuntimes: @@ -350,19 +350,12 @@ spec: systemctl restart systemd-modules-load.service sysctl --system - {{- /* Make sure we always disable swap - Otherwise the kubelet won't start'. */}} - cp /etc/fstab /etc/fstab.orig - cat /etc/fstab.orig | awk '$3 ~ /^swap$/ && $1 !~ /^#/ {$0="# commented out by cloudinit\n#"$0} 1' > /etc/fstab.noswap - mv /etc/fstab.noswap /etc/fstab - swapoff -a - - zypper --non-interactive --quiet --color install ebtables \ ceph-common \ e2fsprogs \ jq \ socat \ - {{- if eq .CloudProviderName "vsphere" }} + {{- if or (eq .CloudProviderName "vsphere") (eq .CloudProviderName "vmware-cloud-director") }} open-vm-tools \ {{- end }} ipvsadm @@ -413,6 +406,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -664,3 +658,19 @@ spec: [Install] WantedBy=multi-user.target + + - path: "/opt/disable-swap.sh" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + cp /etc/fstab /etc/fstab.orig + cat /etc/fstab.orig | awk '$3 ~ /^swap$/ && $1 !~ /^#/ {$0="# commented out by cloudinit\n#"$0} 1' > /etc/fstab.noswap + mv /etc/fstab.noswap /etc/fstab + swapoff -a diff --git a/deploy/osps/default/osp-ubuntu.yaml b/deploy/osps/default/osp-ubuntu.yaml index aad2aedc..58770e5f 100644 --- a/deploy/osps/default/osp-ubuntu.yaml +++ b/deploy/osps/default/osp-ubuntu.yaml @@ -20,7 +20,7 @@ metadata: spec: osName: "ubuntu" osVersion: "20.04" - version: "v0.1.2" + version: "v0.1.3" supportedCloudProviders: - name: "aws" - name: "azure" @@ -31,6 +31,7 @@ spec: - name: "kubevirt" - name: "nutanix" - name: "openstack" + - name: "vmware-cloud-director" - name: "vsphere" supportedContainerRuntimes: - name: containerd @@ -423,10 +424,6 @@ spec: systemctl restart systemd-modules-load.service sysctl --system - {{- /* Make sure we always disable swap - Otherwise the kubelet won't start'. */}} - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a - apt-get update DEBIAN_FRONTEND=noninteractive apt-get -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold" install -y \ @@ -446,7 +443,7 @@ spec: nfs-common \ socat \ util-linux \ - {{- if eq .CloudProviderName "vsphere" }} + {{- if or (eq .CloudProviderName "vsphere") (eq .CloudProviderName "vmware-cloud-director") }} open-vm-tools \ {{- end }} ipvsadm @@ -498,6 +495,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -742,3 +740,17 @@ spec: [Install] WantedBy=multi-user.target + + - path: "/opt/disable-swap.sh" + permissions: 0755 + content: + inline: + encoding: b64 + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a diff --git a/docs/compatibility-matrix.md b/docs/compatibility-matrix.md index f9800356..4dd5290f 100644 --- a/docs/compatibility-matrix.md +++ b/docs/compatibility-matrix.md @@ -11,14 +11,15 @@ Currently supported K8S versions are: ## Operating System -| | Ubuntu | CentOS | Flatcar | Amazon Linux 2 | -|---|---|---|---|---| -| AWS | ✓ | ✓ | ✓ | ✓ | -| Azure | ✓ | ✓ | ✓ | x | -| Digitalocean | ✓ | ✓ | x | x | -| Google Cloud Platform | ✓ | x | x | x | -| Hetzner | ✓ | ✓ | x | x | -| KubeVirt | ✓ | ✓ | ✓ | x | -| Nutanix | ✓ | ✓ | x | x | -| Openstack | ✓ | ✓ | ✓ | x | -| VSphere | ✓ | ✓ | ✓ | x | +| | Ubuntu | CentOS | Flatcar | Amazon Linux 2 | Rocky Linux | +|---|---|---|---|---|---| +| AWS | ✓ | ✓ | ✓ | ✓ | ✓ | +| Azure | ✓ | ✓ | ✓ | x | ✓ | +| Digitalocean | ✓ | ✓ | x | x | ✓ | +| Google Cloud Platform | ✓ | x | x | x | x | +| Hetzner | ✓ | ✓ | x | x | ✓ | +| KubeVirt | ✓ | ✓ | ✓ | x | ✓ | +| Nutanix | ✓ | ✓ | x | x | x | +| Openstack | ✓ | ✓ | ✓ | x | ✓ | +| VMware Cloud Director | ✓ | x | x | x | x | +| VSphere | ✓ | ✓ | ✓ | x | ✓ | diff --git a/hack/update-codegen.sh b/hack/update-codegen.sh index 12029949..ebd2b5a4 100755 --- a/hack/update-codegen.sh +++ b/hack/update-codegen.sh @@ -19,7 +19,7 @@ set -euo pipefail cd $(dirname $0)/.. source hack/lib.sh -CONTAINERIZE_IMAGE=golang:1.18.1 containerize ./hack/update-codegen.sh +CONTAINERIZE_IMAGE=golang:1.18.3 containerize ./hack/update-codegen.sh SCRIPT_ROOT=$(dirname "${BASH_SOURCE}") echodate "Creating vendor directory" @@ -36,4 +36,4 @@ echodate "Generating osm:v1alpha1" --go-header-file ${SCRIPT_ROOT}/header.txt echodate "Generating reconciling functions" -go generate ./pkg/... \ No newline at end of file +go generate ./pkg/... diff --git a/hack/update-crds-openapi.sh b/hack/update-crds-openapi.sh index 640abc8b..17863e57 100755 --- a/hack/update-crds-openapi.sh +++ b/hack/update-crds-openapi.sh @@ -19,7 +19,7 @@ set -euo pipefail cd $(dirname $0)/.. source hack/lib.sh -CONTAINERIZE_IMAGE=golang:1.18.1 containerize ./hack/update-crds-openapi.sh +CONTAINERIZE_IMAGE=golang:1.18.3 containerize ./hack/update-crds-openapi.sh SCRIPT_ROOT=$(dirname "${BASH_SOURCE}") echodate "Creating vendor directory" diff --git a/pkg/cloudprovider/cloudprovider.go b/pkg/cloudprovider/cloudprovider.go index 0c439ce4..299fb24c 100644 --- a/pkg/cloudprovider/cloudprovider.go +++ b/pkg/cloudprovider/cloudprovider.go @@ -51,7 +51,7 @@ func GetCloudConfig(pconfig providerconfigtypes.Config, kubeletVersion string) ( // cloud-config is not required for these cloud providers case osmv1alpha1.CloudProviderAlibaba, osmv1alpha1.CloudProviderAnexia, osmv1alpha1.CloudProviderDigitalocean, osmv1alpha1.CloudProviderHetzner, osmv1alpha1.CloudProviderLinode, osmv1alpha1.CloudProviderEquinixMetal, - osmv1alpha1.CloudProviderScaleway: + osmv1alpha1.CloudProviderScaleway, osmv1alpha1.CloudProviderVMwareCloudDirector: return "", nil } @@ -69,7 +69,7 @@ func KubeletCloudProviderConfig(cloudProvider providerconfigtypes.CloudProvider) case osmv1alpha1.CloudProviderAlibaba, osmv1alpha1.CloudProviderAnexia, osmv1alpha1.CloudProviderDigitalocean, osmv1alpha1.CloudProviderHetzner, osmv1alpha1.CloudProviderLinode, osmv1alpha1.CloudProviderEquinixMetal, - osmv1alpha1.CloudProviderScaleway, osmv1alpha1.CloudProviderNutanix: + osmv1alpha1.CloudProviderScaleway, osmv1alpha1.CloudProviderNutanix, osmv1alpha1.CloudProviderVMwareCloudDirector: return false, false, nil } diff --git a/pkg/cloudprovider/kubevirt/provider.go b/pkg/cloudprovider/kubevirt/provider.go index e253020d..6cea1cfc 100644 --- a/pkg/cloudprovider/kubevirt/provider.go +++ b/pkg/cloudprovider/kubevirt/provider.go @@ -17,14 +17,17 @@ limitations under the License. package kubevirt import ( + "encoding/base64" "encoding/json" "errors" "fmt" + "os" providerconfigtypes "github.com/kubermatic/machine-controller/pkg/providerconfig/types" "k8c.io/operating-system-manager/pkg/cloudprovider/kubevirt/types" "k8c.io/operating-system-manager/pkg/providerconfig/config" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) const ( @@ -59,14 +62,48 @@ func getConfig(pconfig providerconfigtypes.Config) (*types.CloudConfig, error) { err error ) - opts.Kubeconfig, err = config.GetConfigVarResolver().GetConfigVarStringValueOrEnv(rawConfig.Auth.Kubeconfig, envKubevirtKubeconfig) - if err != nil { - return nil, fmt.Errorf(`failed to get value of "kubeconfig" field: %w`, err) + // Kubeconfig was specified directly in the Machine/MachineDeployment CR. In this case we need to ensure that the value is base64 encoded. + if rawConfig.Auth.Kubeconfig.Value != "" { + val, err := base64.StdEncoding.DecodeString(rawConfig.Auth.Kubeconfig.Value) + if err != nil { + // An error here means that this is not a valid base64 string + // We can be more explicit here with the error for visibility. Webhook will return this error if we hit this scenario. + return nil, fmt.Errorf("failed to decode base64 encoded kubeconfig. Expected value is a base64 encoded Kubeconfig in JSON or YAML format: %w", err) + } + opts.Kubeconfig = string(val) + } else { + // Environment variable or secret reference was used for providing the value of kubeconfig + // We have to be lenient in this case and allow unencoded values as well. + opts.Kubeconfig, err = config.GetConfigVarResolver().GetConfigVarStringValueOrEnv(rawConfig.Auth.Kubeconfig, envKubevirtKubeconfig) + if err != nil { + return nil, fmt.Errorf(`failed to get value of "kubeconfig" field: %w`, err) + } + val, err := base64.StdEncoding.DecodeString(opts.Kubeconfig) + // We intentionally ignore errors here with an assumption that an unencoded YAML or JSON must have been passed on + // in this case. + if err == nil { + opts.Kubeconfig = string(val) + } } + opts.Namespace = getNamespace() + cloudConfig := &types.CloudConfig{ Global: opts, } return cloudConfig, nil } + +// getNamespace returns the namespace where the VM is created. +// VM is created in a dedicated namespace +// which is the namespace where the machine-controller pod is running. +// Defaults to `kube-system`. +func getNamespace() string { + ns := os.Getenv("POD_NAMESPACE") + if ns == "" { + // Useful especially for ci tests. + ns = metav1.NamespaceSystem + } + return ns +} diff --git a/pkg/cloudprovider/kubevirt/types/cloudconfig.go b/pkg/cloudprovider/kubevirt/types/cloudconfig.go index fa76746a..37e42028 100644 --- a/pkg/cloudprovider/kubevirt/types/cloudconfig.go +++ b/pkg/cloudprovider/kubevirt/types/cloudconfig.go @@ -27,6 +27,9 @@ type CloudConfig struct { type GlobalOpts struct { // Kubeconfig used to connect to the cluster that runs KubeVirt Kubeconfig string `yaml:"kubeconfig"` + + // Namespace used in KubeVirt cloud-controller-manager as infra cluster namespace. + Namespace string `yaml:"namespace"` } // ToString renders the cloud configuration as string. diff --git a/pkg/cloudprovider/kubevirt/types/cloudconfig_test.go b/pkg/cloudprovider/kubevirt/types/cloudconfig_test.go index ca6b4c67..d19b99b1 100644 --- a/pkg/cloudprovider/kubevirt/types/cloudconfig_test.go +++ b/pkg/cloudprovider/kubevirt/types/cloudconfig_test.go @@ -31,10 +31,12 @@ func TestCloudConfigToString(t *testing.T) { config: &CloudConfig{ Global: GlobalOpts{ Kubeconfig: "redacted", + Namespace: "kube-system", }, }, expected: `global: kubeconfig: redacted + namespace: kube-system `}, } @@ -44,6 +46,7 @@ func TestCloudConfigToString(t *testing.T) { if err != nil { t.Fatalf("failed to convert to string: %v", err) } + if s != test.expected { t.Fatalf("output is not as expected") } diff --git a/pkg/cloudprovider/kubevirt/types/types.go b/pkg/cloudprovider/kubevirt/types/types.go index 135abd7d..ac1dcc0a 100644 --- a/pkg/cloudprovider/kubevirt/types/types.go +++ b/pkg/cloudprovider/kubevirt/types/types.go @@ -18,70 +18,13 @@ package types import ( providerconfigtypes "github.com/kubermatic/machine-controller/pkg/providerconfig/types" - - corev1 "k8s.io/api/core/v1" ) type RawConfig struct { - Auth Auth `json:"auth,omitempty"` - VirtualMachine VirtualMachine `json:"virtualMachine,omitempty"` - Affinity Affinity `json:"affinity,omitempty"` + Auth Auth `json:"auth,omitempty"` } // Auth type Auth struct { Kubeconfig providerconfigtypes.ConfigVarString `json:"kubeconfig,omitempty"` } - -// VirtualMachine -type VirtualMachine struct { - Flavor Flavor `json:"flavor,omitempty"` - Template Template `json:"template,omitempty"` - DNSPolicy providerconfigtypes.ConfigVarString `json:"dnsPolicy,omitempty"` - DNSConfig *corev1.PodDNSConfig `json:"dnsConfig,omitempty"` -} - -// Flavor -type Flavor struct { - Name providerconfigtypes.ConfigVarString `json:"name,omitempty"` - Profile providerconfigtypes.ConfigVarString `json:"profile,omitempty"` -} - -// Template -type Template struct { - CPUs providerconfigtypes.ConfigVarString `json:"cpus,omitempty"` - Memory providerconfigtypes.ConfigVarString `json:"memory,omitempty"` - PrimaryDisk PrimaryDisk `json:"primaryDisk,omitempty"` - SecondaryDisks []SecondaryDisks `json:"secondaryDisks,omitempty"` -} - -// PrimaryDisk -type PrimaryDisk struct { - Disk - OsImage providerconfigtypes.ConfigVarString `json:"osImage,omitempty"` -} - -// SecondaryDisks -type SecondaryDisks struct { - Disk -} - -// Disk -type Disk struct { - Size providerconfigtypes.ConfigVarString `json:"size,omitempty"` - StorageClassName providerconfigtypes.ConfigVarString `json:"storageClassName,omitempty"` -} - -// Affinity -type Affinity struct { - PodAffinityPreset providerconfigtypes.ConfigVarString `json:"podAffinityPreset,omitempty"` - PodAntiAffinityPreset providerconfigtypes.ConfigVarString `json:"podAntiAffinityPreset,omitempty"` - NodeAffinityPreset NodeAffinityPreset `json:"nodeAffinityPreset,omitempty"` -} - -// NodeAffinityPreset -type NodeAffinityPreset struct { - Type providerconfigtypes.ConfigVarString `json:"type,omitempty"` - Key providerconfigtypes.ConfigVarString `json:"key,omitempty"` - Values []providerconfigtypes.ConfigVarString `json:"values,omitempty"` -} diff --git a/pkg/controllers/osc/resources/operating_system_config.go b/pkg/controllers/osc/resources/operating_system_config.go index ae78b03d..70913ff0 100644 --- a/pkg/controllers/osc/resources/operating_system_config.go +++ b/pkg/controllers/osc/resources/operating_system_config.go @@ -38,6 +38,7 @@ import ( "k8c.io/operating-system-manager/pkg/providerconfig/centos" "k8c.io/operating-system-manager/pkg/providerconfig/flatcar" "k8c.io/operating-system-manager/pkg/providerconfig/rhel" + "k8c.io/operating-system-manager/pkg/providerconfig/rockylinux" "k8c.io/operating-system-manager/pkg/providerconfig/sles" "k8c.io/operating-system-manager/pkg/providerconfig/ubuntu" jsonutil "k8c.io/operating-system-manager/pkg/util/json" @@ -250,6 +251,7 @@ type OperatingSystemConfig struct { RhelConfig rhel.Config SlesConfig sles.Config UbuntuConfig ubuntu.Config + RockyLinuxConfig rockylinux.Config } type kubeletConfig struct { @@ -388,7 +390,15 @@ func setOperatingSystemConfig(os providerconfigtypes.OperatingSystem, operatingS } data.UbuntuConfig = *config return nil + case providerconfigtypes.OperatingSystemRockyLinux: + config, err := rockylinux.LoadConfig(operatingSystemSpec) + if err != nil { + return err + } + data.RockyLinuxConfig = *config + return nil } + return errors.New("unknown OperatingSystem") } diff --git a/pkg/controllers/osc/testdata/osc-kubelet-configuration-containerd.yaml b/pkg/controllers/osc/testdata/osc-kubelet-configuration-containerd.yaml index 0002bc81..87a685de 100644 --- a/pkg/controllers/osc/testdata/osc-kubelet-configuration-containerd.yaml +++ b/pkg/controllers/osc/testdata/osc-kubelet-configuration-containerd.yaml @@ -191,8 +191,6 @@ spec: systemctl mask ufw systemctl restart systemd-modules-load.service sysctl --system - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a apt-get update @@ -326,6 +324,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -527,6 +526,19 @@ spec: encoding: b64 path: /etc/systemd/system/kubelet-healthcheck.service permissions: 420 + - content: + inline: + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a + encoding: b64 + path: /opt/disable-swap.sh + permissions: 493 - content: inline: data: | diff --git a/pkg/controllers/osc/testdata/osc-kubelet-configuration-docker.yaml b/pkg/controllers/osc/testdata/osc-kubelet-configuration-docker.yaml index 8fd47c0d..8cdabff1 100644 --- a/pkg/controllers/osc/testdata/osc-kubelet-configuration-docker.yaml +++ b/pkg/controllers/osc/testdata/osc-kubelet-configuration-docker.yaml @@ -191,8 +191,6 @@ spec: systemctl mask ufw systemctl restart systemd-modules-load.service sysctl --system - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a apt-get update @@ -329,6 +327,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -528,6 +527,19 @@ spec: encoding: b64 path: /etc/systemd/system/kubelet-healthcheck.service permissions: 420 + - content: + inline: + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a + encoding: b64 + path: /opt/disable-swap.sh + permissions: 493 - content: inline: data: | diff --git a/pkg/controllers/osc/testdata/osc-rhel-8.x-azure-containerd.yaml b/pkg/controllers/osc/testdata/osc-rhel-8.x-azure-containerd.yaml index d467a002..28a6978a 100644 --- a/pkg/controllers/osc/testdata/osc-rhel-8.x-azure-containerd.yaml +++ b/pkg/controllers/osc/testdata/osc-rhel-8.x-azure-containerd.yaml @@ -198,8 +198,6 @@ spec: setenforce 0 || true systemctl restart systemd-modules-load.service sysctl --system - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a yum install -y \ device-mapper-persistent-data \ @@ -286,6 +284,14 @@ spec: ln -sf "$kube_dir/$bin" "$opt_bin"/$bin done + DEFAULT_IFC_NAME=$(ip -o route get 1 | grep -oP "dev \K\S+") + + # enable DHCPv6 on the default interface + echo NETWORKING_IPV6=yes >> /etc/sysconfig/network + echo IPV6INIT=yes >> /etc/sysconfig/network-scripts/ifcfg-$DEFAULT_IFC_NAME + echo DHCPV6C=yes >> /etc/sysconfig/network-scripts/ifcfg-$DEFAULT_IFC_NAME + ifdown $DEFAULT_IFC_NAME && ifup $DEFAULT_IFC_NAME + mkdir -p /etc/systemd/system/kubelet.service.d/ # set kubelet nodeip environment variable /opt/bin/setup_net_env.sh @@ -327,6 +333,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -521,6 +528,19 @@ spec: encoding: b64 path: /etc/systemd/system/kubelet-healthcheck.service permissions: 420 + - content: + inline: + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a + encoding: b64 + path: /opt/disable-swap.sh + permissions: 493 - content: inline: data: | diff --git a/pkg/controllers/osc/testdata/osc-rhel-8.x-containerd.yaml b/pkg/controllers/osc/testdata/osc-rhel-8.x-containerd.yaml index 08a997bb..311314e9 100644 --- a/pkg/controllers/osc/testdata/osc-rhel-8.x-containerd.yaml +++ b/pkg/controllers/osc/testdata/osc-rhel-8.x-containerd.yaml @@ -200,8 +200,6 @@ spec: setenforce 0 || true systemctl restart systemd-modules-load.service sysctl --system - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a yum install -y \ device-mapper-persistent-data \ @@ -288,6 +286,14 @@ spec: ln -sf "$kube_dir/$bin" "$opt_bin"/$bin done + DEFAULT_IFC_NAME=$(ip -o route get 1 | grep -oP "dev \K\S+") + + # enable DHCPv6 on the default interface + echo NETWORKING_IPV6=yes >> /etc/sysconfig/network + echo IPV6INIT=yes >> /etc/sysconfig/network-scripts/ifcfg-$DEFAULT_IFC_NAME + echo DHCPV6C=yes >> /etc/sysconfig/network-scripts/ifcfg-$DEFAULT_IFC_NAME + ifdown $DEFAULT_IFC_NAME && ifup $DEFAULT_IFC_NAME + mkdir -p /etc/systemd/system/kubelet.service.d/ # set kubelet nodeip environment variable /opt/bin/setup_net_env.sh @@ -329,6 +335,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -526,6 +533,19 @@ spec: encoding: b64 path: /etc/systemd/system/kubelet-healthcheck.service permissions: 420 + - content: + inline: + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a + encoding: b64 + path: /opt/disable-swap.sh + permissions: 493 - content: inline: data: | diff --git a/pkg/controllers/osc/testdata/osc-ubuntu-aws-containerd.yaml b/pkg/controllers/osc/testdata/osc-ubuntu-aws-containerd.yaml index 4465dea9..dabcdcaf 100644 --- a/pkg/controllers/osc/testdata/osc-ubuntu-aws-containerd.yaml +++ b/pkg/controllers/osc/testdata/osc-ubuntu-aws-containerd.yaml @@ -191,8 +191,6 @@ spec: systemctl mask ufw systemctl restart systemd-modules-load.service sysctl --system - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a apt-get update @@ -325,6 +323,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -527,6 +526,19 @@ spec: encoding: b64 path: /etc/systemd/system/kubelet-healthcheck.service permissions: 420 + - content: + inline: + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a + encoding: b64 + path: /opt/disable-swap.sh + permissions: 493 - content: inline: data: | diff --git a/pkg/controllers/osc/testdata/osc-ubuntu-aws-docker.yaml b/pkg/controllers/osc/testdata/osc-ubuntu-aws-docker.yaml index 6b125bd0..b78c3d67 100644 --- a/pkg/controllers/osc/testdata/osc-ubuntu-aws-docker.yaml +++ b/pkg/controllers/osc/testdata/osc-ubuntu-aws-docker.yaml @@ -191,8 +191,6 @@ spec: systemctl mask ufw systemctl restart systemd-modules-load.service sysctl --system - sed -i.orig '/.*swap.*/d' /etc/fstab - swapoff -a apt-get update @@ -329,6 +327,7 @@ spec: Environment="PATH=/opt/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin/" EnvironmentFile=-/etc/environment + ExecStartPre=/bin/bash /opt/disable-swap.sh ExecStartPre=/bin/bash /opt/load-kernel-modules.sh ExecStartPre=/bin/bash /opt/bin/setup_net_env.sh ExecStart=/opt/bin/kubelet $KUBELET_EXTRA_ARGS \ @@ -532,6 +531,19 @@ spec: encoding: b64 path: /etc/systemd/system/kubelet-healthcheck.service permissions: 420 + - content: + inline: + data: | + #!/usr/bin/env bash + set -euo pipefail + + # Make sure we always disable swap - Otherwise the kubelet won't start as for some cloud + # providers swap gets enabled on reboot or after the setup script has finished executing. + sed -i.orig '/.*swap.*/d' /etc/fstab + swapoff -a + encoding: b64 + path: /opt/disable-swap.sh + permissions: 493 - content: inline: data: | diff --git a/pkg/controllers/osc/testdata/secret-kubelet-configuration-containerd.yaml b/pkg/controllers/osc/testdata/secret-kubelet-configuration-containerd.yaml index 7cf2adfc..f0281af7 100644 --- a/pkg/controllers/osc/testdata/secret-kubelet-configuration-containerd.yaml +++ b/pkg/controllers/osc/testdata/secret-kubelet-configuration-containerd.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdnMKbW9kcHJvYmUgaXBfdnNfcnIKbW9kcHJvYmUgaXBfdnNfd3JyCm1vZHByb2JlIGlwX3ZzX3NoCgppZiBtb2RpbmZvIG5mX2Nvbm50cmFja19pcHY0ICY+IC9kZXYvbnVsbDsgdGhlbgogIG1vZHByb2JlIG5mX2Nvbm50cmFja19pcHY0CmVsc2UKICBtb2Rwcm9iZSBuZl9jb25udHJhY2sKZmkK

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/default/grub.d/60-swap-accounting.cfg'
  encoding: 'b64'
  content: |-
    IyBBZGRlZCBieSBrdWJlcm1hdGljIG1hY2hpbmUtY29udHJvbGxlcgojIEVuYWJsZSBjZ3JvdXBzIG1lbW9yeSBhbmQgc3dhcCBhY2NvdW50aW5nCkdSVUJfQ01ETElORV9MSU5VWD0iY2dyb3VwX2VuYWJsZT1tZW1vcnkgc3dhcGFjY291bnQ9MSIK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWNvbnRhaW5lcmQuc2VydmljZQpSZXF1aXJlcz1jb250YWluZXJkLnNlcnZpY2UKCkRlc2NyaXB0aW9uPWt1YmVsZXQ6IFRoZSBLdWJlcm5ldGVzIE5vZGUgQWdlbnQKRG9jdW1lbnRhdGlvbj1odHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy9ob21lLwoKW1NlcnZpY2VdClVzZXI9cm9vdApSZXN0YXJ0PWFsd2F5cwpTdGFydExpbWl0SW50ZXJ2YWw9MApSZXN0YXJ0U2VjPTEwCkNQVUFjY291bnRpbmc9dHJ1ZQpNZW1vcnlBY2NvdW50aW5nPXRydWUKCkVudmlyb25tZW50PSJQQVRIPS9vcHQvYmluOi9iaW46L3Vzci9sb2NhbC9zYmluOi91c3IvbG9jYWwvYmluOi91c3Ivc2JpbjovdXNyL2Jpbjovc2Jpbi8iCkVudmlyb25tZW50RmlsZT0tL2V0Yy9lbnZpcm9ubWVudAoKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2xvYWQta2VybmVsLW1vZHVsZXMuc2gKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Jpbi9zZXR1cF9uZXRfZW52LnNoCkV4ZWNTdGFydD0vb3B0L2Jpbi9rdWJlbGV0ICRLVUJFTEVUX0VYVFJBX0FSR1MgXAogIC0tYm9vdHN0cmFwLWt1YmVjb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Jvb3RzdHJhcC1rdWJlbGV0LmNvbmYgXAogIC0ta3ViZWNvbmZpZz0vdmFyL2xpYi9rdWJlbGV0L2t1YmVjb25maWcgXAogIC0tY29uZmlnPS9ldGMva3ViZXJuZXRlcy9rdWJlbGV0LmNvbmYgXAogIC0tbmV0d29yay1wbHVnaW49Y25pIFwKICAtLWNlcnQtZGlyPS9ldGMva3ViZXJuZXRlcy9wa2kgXAogIC0tY2xvdWQtcHJvdmlkZXI9YXdzIFwKICAtLWNsb3VkLWNvbmZpZz0vZXRjL2t1YmVybmV0ZXMvY2xvdWQtY29uZmlnIFwKICAtLWR5bmFtaWMtY29uZmlnLWRpcj0vZXRjL2t1YmVybmV0ZXMvZHluYW1pYy1jb25maWctZGlyIFwKICAtLWZlYXR1cmUtZ2F0ZXM9RHluYW1pY0t1YmVsZXRDb25maWc9dHJ1ZSBcCiAgLS1leGl0LW9uLWxvY2stY29udGVudGlvbiBcCiAgLS1sb2NrLWZpbGU9L3RtcC9rdWJlbGV0LmxvY2sgXAogIC0tY29udGFpbmVyLXJ1bnRpbWU9cmVtb3RlIFwKICAtLWNvbnRhaW5lci1ydW50aW1lLWVuZHBvaW50PXVuaXg6Ly8vcnVuL2NvbnRhaW5lcmQvY29udGFpbmVyZC5zb2NrIFwKICAtLW5vZGUtaXAgJHtLVUJFTEVUX05PREVfSVB9CgpbSW5zdGFsbF0KV2FudGVkQnk9bXVsdGktdXNlci50YXJnZXQK

- path: '/etc/systemd/system/kubelet.service.d/extras.conf'
  encoding: 'b64'
  content: |-
    W1NlcnZpY2VdCkVudmlyb25tZW50PSJLVUJFTEVUX0VYVFJBX0FSR1M9LS1yZXNvbHYtY29uZj0vcnVuL3N5c3RlbWQvcmVzb2x2ZS9yZXNvbHYuY29uZiIK

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    W2dsb2JhbF0KWm9uZT0iZXUtY2VudHJhbC0xYiIKVlBDPSJlLTEyM2YiClN1Ym5ldElEPSJ0ZXN0LXN1Ym5ldCIKCg==

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKCiMgZ2V0IHRoZSBmdWxsIGhvc3RuYW1lCkZVTExfSE9TVE5BTUU9JChob3N0bmFtZSAtZikKIyBpZiAvZXRjL2hvc3RuYW1lIGlzIG5vdCBlbXB0eSB0aGVuIHVzZSB0aGUgaG9zdG5hbWUgZnJvbSB0aGVyZQppZiBbIC1zIC9ldGMvaG9zdG5hbWUgXTsgdGhlbgogIEZVTExfSE9TVE5BTUU9JChjYXQgL2V0Yy9ob3N0bmFtZSkKZmkKCiMgd3JpdGUgdGhlIG5vZGVpcF9lbnYgZmlsZQojIHdlIG5lZWQgdGhlIGxpbmUgYmVsb3cgYmVjYXVzZSBmbGF0Y2FyIGhhcyB0aGUgc2FtZSBzdHJpbmcgImNvcmVvcyIgaW4gdGhhdCBmaWxlCmlmIGdyZXAgLXEgY29yZW9zIC9ldGMvb3MtcmVsZWFzZQp0aGVuCiAgZWNobyAiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XG5LVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX0iID4gL2V0Yy9rdWJlcm5ldGVzL25vZGVpcC5jb25mCmVsaWYgWyAhIC1kIC9ldGMvc3lzdGVtZC9zeXN0ZW0va3ViZWxldC5zZXJ2aWNlLmQgXQp0aGVuCiAgZWNob2RhdGUgIkNhbid0IGZpbmQga3ViZWxldCBzZXJ2aWNlIGV4dHJhcyBkaXJlY3RvcnkiCiAgZXhpdCAxCmVsc2UKICBlY2hvIC1lICJbU2VydmljZV1cbkVudmlyb25tZW50PVwiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XCJcbkVudmlyb25tZW50PVwiS1VCRUxFVF9IT1NUTkFNRT0ke0ZVTExfSE9TVE5BTUV9XCIiID4gL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZC9ub2RlaXAuY29uZgpmaQo=

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKY29udGFpbmVyTG9nTWF4U2l6ZTogMzAwTWkKY29udGFpbmVyTG9nTWF4RmlsZXM6IDMwCmZlYXR1cmVHYXRlczoKICBHcmFjZWZ1bE5vZGVTaHV0ZG93bjogdHJ1ZQogIElkZW50aWZ5UG9kT1M6IGZhbHNlCnByb3RlY3RLZXJuZWxEZWZhdWx0czogdHJ1ZQpyZWFkT25seVBvcnQ6IDAKcm90YXRlQ2VydGlmaWNhdGVzOiB0cnVlCnNlcnZlclRMU0Jvb3RzdHJhcDogdHJ1ZQpzdGF0aWNQb2RQYXRoOiAvZXRjL2t1YmVybmV0ZXMvbWFuaWZlc3RzCmt1YmVSZXNlcnZlZDoKICBjcHU6IDMwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAzMEdpCnN5c3RlbVJlc2VydmVkOgogIGNwdTogMzBtCiAgZXBoZW1lcmFsLXN0b3JhZ2U6IDMwR2kKZXZpY3Rpb25IYXJkOgogIG1lbW9yeS5hdmFpbGFibGU6IDMwTWkKbWF4UG9kczogMTEwCnRsc0NpcGhlclN1aXRlczoKLSBUTFNfQUVTXzEyOF9HQ01fU0hBMjU2Ci0gVExTX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19DSEFDSEEyMF9QT0xZMTMwNV9TSEEyNTYKLSBUTFNfRUNESEVfRUNEU0FfV0lUSF9BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfRUNESEVfRUNEU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfRUNEU0FfV0lUSF9DSEFDSEEyMF9QT0xZMTMwNQotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfRUNESEVfUlNBX1dJVEhfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0VDREhFX1JTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1CnZvbHVtZVBsdWdpbkRpcjogL3Zhci9saWIva3ViZWxldC92b2x1bWVwbHVnaW5zCg==

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/etc/crictl.yaml'
  content: |-
    runtime-endpoint: unix:///run/containerd/containerd.sock
    

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/containerd/config.toml'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    dmVyc2lvbiA9IDIKClttZXRyaWNzXQphZGRyZXNzID0gIjEyNy4wLjAuMToxMzM4IgoKW3BsdWdpbnNdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIl0Kc2FuZGJveF9pbWFnZSA9ICIxOTIuMTY4LjEwMC4xMDA6NTAwMC9rdWJlcm5ldGVzL3BhdXNlOnYzLjEiCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5jb250YWluZXJkXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIuY29udGFpbmVyZC5ydW50aW1lc10KW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuY10KcnVudGltZV90eXBlID0gImlvLmNvbnRhaW5lcmQucnVuYy52MiIKW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuYy5vcHRpb25zXQpTeXN0ZW1kQ2dyb3VwID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnldCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5taXJyb3JzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkubWlycm9ycy4iZG9ja2VyLmlvIl0KZW5kcG9pbnQgPSBbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTAuMC4wLjE6NTAwMCJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzLiIxMC4wLjAuMTo1MDAwIi50bHNdCmluc2VjdXJlX3NraXBfdmVyaWZ5ID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiLnRsc10KaW5zZWN1cmVfc2tpcF92ZXJpZnkgPSB0cnVlCgo=
 + cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdnMKbW9kcHJvYmUgaXBfdnNfcnIKbW9kcHJvYmUgaXBfdnNfd3JyCm1vZHByb2JlIGlwX3ZzX3NoCgppZiBtb2RpbmZvIG5mX2Nvbm50cmFja19pcHY0ICY+IC9kZXYvbnVsbDsgdGhlbgogIG1vZHByb2JlIG5mX2Nvbm50cmFja19pcHY0CmVsc2UKICBtb2Rwcm9iZSBuZl9jb25udHJhY2sKZmkK

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/default/grub.d/60-swap-accounting.cfg'
  encoding: 'b64'
  content: |-
    IyBBZGRlZCBieSBrdWJlcm1hdGljIG1hY2hpbmUtY29udHJvbGxlcgojIEVuYWJsZSBjZ3JvdXBzIG1lbW9yeSBhbmQgc3dhcCBhY2NvdW50aW5nCkdSVUJfQ01ETElORV9MSU5VWD0iY2dyb3VwX2VuYWJsZT1tZW1vcnkgc3dhcGFjY291bnQ9MSIK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWNvbnRhaW5lcmQuc2VydmljZQpSZXF1aXJlcz1jb250YWluZXJkLnNlcnZpY2UKCkRlc2NyaXB0aW9uPWt1YmVsZXQ6IFRoZSBLdWJlcm5ldGVzIE5vZGUgQWdlbnQKRG9jdW1lbnRhdGlvbj1odHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy9ob21lLwoKW1NlcnZpY2VdClVzZXI9cm9vdApSZXN0YXJ0PWFsd2F5cwpTdGFydExpbWl0SW50ZXJ2YWw9MApSZXN0YXJ0U2VjPTEwCkNQVUFjY291bnRpbmc9dHJ1ZQpNZW1vcnlBY2NvdW50aW5nPXRydWUKCkVudmlyb25tZW50PSJQQVRIPS9vcHQvYmluOi9iaW46L3Vzci9sb2NhbC9zYmluOi91c3IvbG9jYWwvYmluOi91c3Ivc2JpbjovdXNyL2Jpbjovc2Jpbi8iCkVudmlyb25tZW50RmlsZT0tL2V0Yy9lbnZpcm9ubWVudAoKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Rpc2FibGUtc3dhcC5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvbG9hZC1rZXJuZWwtbW9kdWxlcy5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvYmluL3NldHVwX25ldF9lbnYuc2gKRXhlY1N0YXJ0PS9vcHQvYmluL2t1YmVsZXQgJEtVQkVMRVRfRVhUUkFfQVJHUyBcCiAgLS1ib290c3RyYXAta3ViZWNvbmZpZz0vZXRjL2t1YmVybmV0ZXMvYm9vdHN0cmFwLWt1YmVsZXQuY29uZiBcCiAgLS1rdWJlY29uZmlnPS92YXIvbGliL2t1YmVsZXQva3ViZWNvbmZpZyBcCiAgLS1jb25maWc9L2V0Yy9rdWJlcm5ldGVzL2t1YmVsZXQuY29uZiBcCiAgLS1uZXR3b3JrLXBsdWdpbj1jbmkgXAogIC0tY2VydC1kaXI9L2V0Yy9rdWJlcm5ldGVzL3BraSBcCiAgLS1jbG91ZC1wcm92aWRlcj1hd3MgXAogIC0tY2xvdWQtY29uZmlnPS9ldGMva3ViZXJuZXRlcy9jbG91ZC1jb25maWcgXAogIC0tZHluYW1pYy1jb25maWctZGlyPS9ldGMva3ViZXJuZXRlcy9keW5hbWljLWNvbmZpZy1kaXIgXAogIC0tZmVhdHVyZS1nYXRlcz1EeW5hbWljS3ViZWxldENvbmZpZz10cnVlIFwKICAtLWV4aXQtb24tbG9jay1jb250ZW50aW9uIFwKICAtLWxvY2stZmlsZT0vdG1wL2t1YmVsZXQubG9jayBcCiAgLS1jb250YWluZXItcnVudGltZT1yZW1vdGUgXAogIC0tY29udGFpbmVyLXJ1bnRpbWUtZW5kcG9pbnQ9dW5peDovLy9ydW4vY29udGFpbmVyZC9jb250YWluZXJkLnNvY2sgXAogIC0tbm9kZS1pcCAke0tVQkVMRVRfTk9ERV9JUH0KCltJbnN0YWxsXQpXYW50ZWRCeT1tdWx0aS11c2VyLnRhcmdldAo=

- path: '/etc/systemd/system/kubelet.service.d/extras.conf'
  encoding: 'b64'
  content: |-
    W1NlcnZpY2VdCkVudmlyb25tZW50PSJLVUJFTEVUX0VYVFJBX0FSR1M9LS1yZXNvbHYtY29uZj0vcnVuL3N5c3RlbWQvcmVzb2x2ZS9yZXNvbHYuY29uZiIK

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    W2dsb2JhbF0KWm9uZT0iZXUtY2VudHJhbC0xYiIKVlBDPSJlLTEyM2YiClN1Ym5ldElEPSJ0ZXN0LXN1Ym5ldCIKCg==

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKCiMgZ2V0IHRoZSBmdWxsIGhvc3RuYW1lCkZVTExfSE9TVE5BTUU9JChob3N0bmFtZSAtZikKIyBpZiAvZXRjL2hvc3RuYW1lIGlzIG5vdCBlbXB0eSB0aGVuIHVzZSB0aGUgaG9zdG5hbWUgZnJvbSB0aGVyZQppZiBbIC1zIC9ldGMvaG9zdG5hbWUgXTsgdGhlbgogIEZVTExfSE9TVE5BTUU9JChjYXQgL2V0Yy9ob3N0bmFtZSkKZmkKCiMgd3JpdGUgdGhlIG5vZGVpcF9lbnYgZmlsZQojIHdlIG5lZWQgdGhlIGxpbmUgYmVsb3cgYmVjYXVzZSBmbGF0Y2FyIGhhcyB0aGUgc2FtZSBzdHJpbmcgImNvcmVvcyIgaW4gdGhhdCBmaWxlCmlmIGdyZXAgLXEgY29yZW9zIC9ldGMvb3MtcmVsZWFzZQp0aGVuCiAgZWNobyAiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XG5LVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX0iID4gL2V0Yy9rdWJlcm5ldGVzL25vZGVpcC5jb25mCmVsaWYgWyAhIC1kIC9ldGMvc3lzdGVtZC9zeXN0ZW0va3ViZWxldC5zZXJ2aWNlLmQgXQp0aGVuCiAgZWNob2RhdGUgIkNhbid0IGZpbmQga3ViZWxldCBzZXJ2aWNlIGV4dHJhcyBkaXJlY3RvcnkiCiAgZXhpdCAxCmVsc2UKICBlY2hvIC1lICJbU2VydmljZV1cbkVudmlyb25tZW50PVwiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XCJcbkVudmlyb25tZW50PVwiS1VCRUxFVF9IT1NUTkFNRT0ke0ZVTExfSE9TVE5BTUV9XCIiID4gL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZC9ub2RlaXAuY29uZgpmaQo=

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKY29udGFpbmVyTG9nTWF4U2l6ZTogMzAwTWkKY29udGFpbmVyTG9nTWF4RmlsZXM6IDMwCmZlYXR1cmVHYXRlczoKICBHcmFjZWZ1bE5vZGVTaHV0ZG93bjogdHJ1ZQogIElkZW50aWZ5UG9kT1M6IGZhbHNlCnByb3RlY3RLZXJuZWxEZWZhdWx0czogdHJ1ZQpyZWFkT25seVBvcnQ6IDAKcm90YXRlQ2VydGlmaWNhdGVzOiB0cnVlCnNlcnZlclRMU0Jvb3RzdHJhcDogdHJ1ZQpzdGF0aWNQb2RQYXRoOiAvZXRjL2t1YmVybmV0ZXMvbWFuaWZlc3RzCmt1YmVSZXNlcnZlZDoKICBjcHU6IDMwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAzMEdpCnN5c3RlbVJlc2VydmVkOgogIGNwdTogMzBtCiAgZXBoZW1lcmFsLXN0b3JhZ2U6IDMwR2kKZXZpY3Rpb25IYXJkOgogIG1lbW9yeS5hdmFpbGFibGU6IDMwTWkKbWF4UG9kczogMTEwCnRsc0NpcGhlclN1aXRlczoKLSBUTFNfQUVTXzEyOF9HQ01fU0hBMjU2Ci0gVExTX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19DSEFDSEEyMF9QT0xZMTMwNV9TSEEyNTYKLSBUTFNfRUNESEVfRUNEU0FfV0lUSF9BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfRUNESEVfRUNEU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfRUNEU0FfV0lUSF9DSEFDSEEyMF9QT0xZMTMwNQotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfRUNESEVfUlNBX1dJVEhfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0VDREhFX1JTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1CnZvbHVtZVBsdWdpbkRpcjogL3Zhci9saWIva3ViZWxldC92b2x1bWVwbHVnaW5zCg==

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/opt/disable-swap.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKIyBNYWtlIHN1cmUgd2UgYWx3YXlzIGRpc2FibGUgc3dhcCAtIE90aGVyd2lzZSB0aGUga3ViZWxldCB3b24ndCBzdGFydCBhcyBmb3Igc29tZSBjbG91ZAojIHByb3ZpZGVycyBzd2FwIGdldHMgZW5hYmxlZCBvbiByZWJvb3Qgb3IgYWZ0ZXIgdGhlIHNldHVwIHNjcmlwdCBoYXMgZmluaXNoZWQgZXhlY3V0aW5nLgpzZWQgLWkub3JpZyAnLy4qc3dhcC4qL2QnIC9ldGMvZnN0YWIKc3dhcG9mZiAtYQo=

- path: '/etc/crictl.yaml'
  content: |-
    runtime-endpoint: unix:///run/containerd/containerd.sock
    

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/containerd/config.toml'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    dmVyc2lvbiA9IDIKClttZXRyaWNzXQphZGRyZXNzID0gIjEyNy4wLjAuMToxMzM4IgoKW3BsdWdpbnNdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIl0Kc2FuZGJveF9pbWFnZSA9ICIxOTIuMTY4LjEwMC4xMDA6NTAwMC9rdWJlcm5ldGVzL3BhdXNlOnYzLjEiCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5jb250YWluZXJkXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIuY29udGFpbmVyZC5ydW50aW1lc10KW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuY10KcnVudGltZV90eXBlID0gImlvLmNvbnRhaW5lcmQucnVuYy52MiIKW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuYy5vcHRpb25zXQpTeXN0ZW1kQ2dyb3VwID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnldCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5taXJyb3JzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkubWlycm9ycy4iZG9ja2VyLmlvIl0KZW5kcG9pbnQgPSBbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTAuMC4wLjE6NTAwMCJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzLiIxMC4wLjAuMTo1MDAwIi50bHNdCmluc2VjdXJlX3NraXBfdmVyaWZ5ID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiLnRsc10KaW5zZWN1cmVfc2tpcF92ZXJpZnkgPSB0cnVlCgo=
 immutable: true kind: Secret metadata: diff --git a/pkg/controllers/osc/testdata/secret-kubelet-configuration-docker.yaml b/pkg/controllers/osc/testdata/secret-kubelet-configuration-docker.yaml index bdf2ad31..4eb65ab9 100644 --- a/pkg/controllers/osc/testdata/secret-kubelet-configuration-docker.yaml +++ b/pkg/controllers/osc/testdata/secret-kubelet-configuration-docker.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdnMKbW9kcHJvYmUgaXBfdnNfcnIKbW9kcHJvYmUgaXBfdnNfd3JyCm1vZHByb2JlIGlwX3ZzX3NoCgppZiBtb2RpbmZvIG5mX2Nvbm50cmFja19pcHY0ICY+IC9kZXYvbnVsbDsgdGhlbgogIG1vZHByb2JlIG5mX2Nvbm50cmFja19pcHY0CmVsc2UKICBtb2Rwcm9iZSBuZl9jb25udHJhY2sKZmkK

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/default/grub.d/60-swap-accounting.cfg'
  encoding: 'b64'
  content: |-
    IyBBZGRlZCBieSBrdWJlcm1hdGljIG1hY2hpbmUtY29udHJvbGxlcgojIEVuYWJsZSBjZ3JvdXBzIG1lbW9yeSBhbmQgc3dhcCBhY2NvdW50aW5nCkdSVUJfQ01ETElORV9MSU5VWD0iY2dyb3VwX2VuYWJsZT1tZW1vcnkgc3dhcGFjY291bnQ9MSIK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWRvY2tlci5zZXJ2aWNlClJlcXVpcmVzPWRvY2tlci5zZXJ2aWNlCgpEZXNjcmlwdGlvbj1rdWJlbGV0OiBUaGUgS3ViZXJuZXRlcyBOb2RlIEFnZW50CkRvY3VtZW50YXRpb249aHR0cHM6Ly9rdWJlcm5ldGVzLmlvL2RvY3MvaG9tZS8KCltTZXJ2aWNlXQpVc2VyPXJvb3QKUmVzdGFydD1hbHdheXMKU3RhcnRMaW1pdEludGVydmFsPTAKUmVzdGFydFNlYz0xMApDUFVBY2NvdW50aW5nPXRydWUKTWVtb3J5QWNjb3VudGluZz10cnVlCgpFbnZpcm9ubWVudD0iUEFUSD0vb3B0L2JpbjovYmluOi91c3IvbG9jYWwvc2JpbjovdXNyL2xvY2FsL2JpbjovdXNyL3NiaW46L3Vzci9iaW46L3NiaW4vIgpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKCkV4ZWNTdGFydFByZT0vYmluL2Jhc2ggL29wdC9sb2FkLWtlcm5lbC1tb2R1bGVzLnNoCkV4ZWNTdGFydFByZT0vYmluL2Jhc2ggL29wdC9iaW4vc2V0dXBfbmV0X2Vudi5zaApFeGVjU3RhcnQ9L29wdC9iaW4va3ViZWxldCAkS1VCRUxFVF9FWFRSQV9BUkdTIFwKICAtLWJvb3RzdHJhcC1rdWJlY29uZmlnPS9ldGMva3ViZXJuZXRlcy9ib290c3RyYXAta3ViZWxldC5jb25mIFwKICAtLWt1YmVjb25maWc9L3Zhci9saWIva3ViZWxldC9rdWJlY29uZmlnIFwKICAtLWNvbmZpZz0vZXRjL2t1YmVybmV0ZXMva3ViZWxldC5jb25mIFwKICAtLW5ldHdvcmstcGx1Z2luPWNuaSBcCiAgLS1jZXJ0LWRpcj0vZXRjL2t1YmVybmV0ZXMvcGtpIFwKICAtLWNsb3VkLXByb3ZpZGVyPWF3cyBcCiAgLS1jbG91ZC1jb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Nsb3VkLWNvbmZpZyBcCiAgLS1keW5hbWljLWNvbmZpZy1kaXI9L2V0Yy9rdWJlcm5ldGVzL2R5bmFtaWMtY29uZmlnLWRpciBcCiAgLS1mZWF0dXJlLWdhdGVzPUR5bmFtaWNLdWJlbGV0Q29uZmlnPXRydWUgXAogIC0tZXhpdC1vbi1sb2NrLWNvbnRlbnRpb24gXAogIC0tbG9jay1maWxlPS90bXAva3ViZWxldC5sb2NrIFwKICAtLWNvbnRhaW5lci1ydW50aW1lPWRvY2tlciBcCiAgLS1jb250YWluZXItcnVudGltZS1lbmRwb2ludD11bml4Oi8vL3Zhci9ydW4vZG9ja2Vyc2hpbS5zb2NrIFwKICAtLW5vZGUtaXAgJHtLVUJFTEVUX05PREVfSVB9CgpbSW5zdGFsbF0KV2FudGVkQnk9bXVsdGktdXNlci50YXJnZXQK

- path: '/etc/systemd/system/kubelet.service.d/extras.conf'
  encoding: 'b64'
  content: |-
    W1NlcnZpY2VdCkVudmlyb25tZW50PSJLVUJFTEVUX0VYVFJBX0FSR1M9LS1yZXNvbHYtY29uZj0vcnVuL3N5c3RlbWQvcmVzb2x2ZS9yZXNvbHYuY29uZiIK

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    W2dsb2JhbF0KWm9uZT0iZXUtY2VudHJhbC0xYiIKVlBDPSJlLTEyM2YiClN1Ym5ldElEPSJ0ZXN0LXN1Ym5ldCIKCg==

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKCiMgZ2V0IHRoZSBmdWxsIGhvc3RuYW1lCkZVTExfSE9TVE5BTUU9JChob3N0bmFtZSAtZikKIyBpZiAvZXRjL2hvc3RuYW1lIGlzIG5vdCBlbXB0eSB0aGVuIHVzZSB0aGUgaG9zdG5hbWUgZnJvbSB0aGVyZQppZiBbIC1zIC9ldGMvaG9zdG5hbWUgXTsgdGhlbgogIEZVTExfSE9TVE5BTUU9JChjYXQgL2V0Yy9ob3N0bmFtZSkKZmkKCiMgd3JpdGUgdGhlIG5vZGVpcF9lbnYgZmlsZQojIHdlIG5lZWQgdGhlIGxpbmUgYmVsb3cgYmVjYXVzZSBmbGF0Y2FyIGhhcyB0aGUgc2FtZSBzdHJpbmcgImNvcmVvcyIgaW4gdGhhdCBmaWxlCmlmIGdyZXAgLXEgY29yZW9zIC9ldGMvb3MtcmVsZWFzZQp0aGVuCiAgZWNobyAiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XG5LVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX0iID4gL2V0Yy9rdWJlcm5ldGVzL25vZGVpcC5jb25mCmVsaWYgWyAhIC1kIC9ldGMvc3lzdGVtZC9zeXN0ZW0va3ViZWxldC5zZXJ2aWNlLmQgXQp0aGVuCiAgZWNob2RhdGUgIkNhbid0IGZpbmQga3ViZWxldCBzZXJ2aWNlIGV4dHJhcyBkaXJlY3RvcnkiCiAgZXhpdCAxCmVsc2UKICBlY2hvIC1lICJbU2VydmljZV1cbkVudmlyb25tZW50PVwiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XCJcbkVudmlyb25tZW50PVwiS1VCRUxFVF9IT1NUTkFNRT0ke0ZVTExfSE9TVE5BTUV9XCIiID4gL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZC9ub2RlaXAuY29uZgpmaQo=

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKZmVhdHVyZUdhdGVzOgogIEdyYWNlZnVsTm9kZVNodXRkb3duOiB0cnVlCiAgSWRlbnRpZnlQb2RPUzogZmFsc2UKcHJvdGVjdEtlcm5lbERlZmF1bHRzOiB0cnVlCnJlYWRPbmx5UG9ydDogMApyb3RhdGVDZXJ0aWZpY2F0ZXM6IHRydWUKc2VydmVyVExTQm9vdHN0cmFwOiB0cnVlCnN0YXRpY1BvZFBhdGg6IC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMKa3ViZVJlc2VydmVkOgogIGNwdTogMzBtCiAgZXBoZW1lcmFsLXN0b3JhZ2U6IDMwR2kKc3lzdGVtUmVzZXJ2ZWQ6CiAgY3B1OiAzMG0KICBlcGhlbWVyYWwtc3RvcmFnZTogMzBHaQpldmljdGlvbkhhcmQ6CiAgbWVtb3J5LmF2YWlsYWJsZTogMzBNaQptYXhQb2RzOiAxMTAKdGxzQ2lwaGVyU3VpdGVzOgotIFRMU19BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0NIQUNIQTIwX1BPTFkxMzA1X1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1Ci0gVExTX0VDREhFX1JTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfUlNBX1dJVEhfQ0hBQ0hBMjBfUE9MWTEzMDUKdm9sdW1lUGx1Z2luRGlyOiAvdmFyL2xpYi9rdWJlbGV0L3ZvbHVtZXBsdWdpbnMK

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/systemd/system/docker.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/docker/daemon.json'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    eyJleGVjLW9wdHMiOlsibmF0aXZlLmNncm91cGRyaXZlcj1zeXN0ZW1kIl0sInN0b3JhZ2UtZHJpdmVyIjoib3ZlcmxheTIiLCJsb2ctZHJpdmVyIjoianNvbi1maWxlIiwibG9nLW9wdHMiOnsibWF4LWZpbGUiOiIzMCIsIm1heC1zaXplIjoiMzAwbSJ9LCJpbnNlY3VyZS1yZWdpc3RyaWVzIjpbIjE5Mi4xNjguMTAwLjEwMDo1MDAwIiwiMTAuMC4wLjE6NTAwMCJdLCJyZWdpc3RyeS1taXJyb3JzIjpbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdfQ==

- path: '/root/.docker/config.json'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    
 + cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAoKIyBDb3B5cmlnaHQgMjAxNiBUaGUgS3ViZXJuZXRlcyBBdXRob3JzLgojCiMgTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlICJMaWNlbnNlIik7CiMgeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLgojIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdAojCiMgICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMAojCiMgVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZQojIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuICJBUyBJUyIgQkFTSVMsCiMgV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuCiMgU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZAojIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLgoKIyBUaGlzIHNjcmlwdCBpcyBmb3IgbWFzdGVyIGFuZCBub2RlIGluc3RhbmNlIGhlYWx0aCBtb25pdG9yaW5nLCB3aGljaCBpcwojIHBhY2tlZCBpbiBrdWJlLW1hbmlmZXN0IHRhcmJhbGwuIEl0IGlzIGV4ZWN1dGVkIHRocm91Z2ggYSBzeXN0ZW1kIHNlcnZpY2UKIyBpbiBjbHVzdGVyL2djZS9nY2kvPG1hc3Rlci9ub2RlPi55YW1sLiBUaGUgZW52IHZhcmlhYmxlcyBjb21lIGZyb20gYW4gZW52CiMgZmlsZSBwcm92aWRlZCBieSB0aGUgc3lzdGVtZCBzZXJ2aWNlLgoKIyBUaGlzIHNjcmlwdCBpcyBhIHNsaWdodGx5IGFkanVzdGVkIHZlcnNpb24gb2YKIyBodHRwczovL2dpdGh1Yi5jb20va3ViZXJuZXRlcy9rdWJlcm5ldGVzL2Jsb2IvZTFhMWFhMjExMjI0ZmNkOWIyMTM0MjBiODBiMmFlNjgwNjY5NjgzZC9jbHVzdGVyL2djZS9nY2kvaGVhbHRoLW1vbml0b3Iuc2gKIyBBZGp1c3RtZW50cyBhcmU6CiMgKiBLdWJlbGV0IGhlYWx0aCBwb3J0IGlzIDEwMjQ4IG5vdCAxMDI1NQojICogUmVtb3ZhbCBvZiBhbGwgYWxsIHJlZmVyZW5jZXMgdG8gdGhlIEtVQkVfRU5WIGZpbGUKCnNldCAtbyBub3Vuc2V0CnNldCAtbyBwaXBlZmFpbAoKIyBXZSBzaW1wbHkga2lsbCB0aGUgcHJvY2VzcyB3aGVuIHRoZXJlIGlzIGEgZmFpbHVyZS4gQW5vdGhlciBzeXN0ZW1kIHNlcnZpY2Ugd2lsbAojIGF1dG9tYXRpY2FsbHkgcmVzdGFydCB0aGUgcHJvY2Vzcy4KZnVuY3Rpb24gY29udGFpbmVyX3J1bnRpbWVfbW9uaXRvcmluZygpIHsKICBsb2NhbCAtciBtYXhfYXR0ZW1wdHM9NQogIGxvY2FsIGF0dGVtcHQ9MQogIGxvY2FsIC1yIGNvbnRhaW5lcl9ydW50aW1lX25hbWU9IiR7Q09OVEFJTkVSX1JVTlRJTUVfTkFNRTotZG9ja2VyfSIKICAjIFdlIHN0aWxsIG5lZWQgdG8gdXNlICdkb2NrZXIgcHMnIHdoZW4gY29udGFpbmVyIHJ1bnRpbWUgaXMgImRvY2tlciIuIFRoaXMgaXMgYmVjYXVzZQogICMgZG9ja2Vyc2hpbSBpcyBzdGlsbCBwYXJ0IG9mIGt1YmVsZXQgdG9kYXkuIFdoZW4ga3ViZWxldCBpcyBkb3duLCBjcmljdGwgcG9kcwogICMgd2lsbCBhbHNvIGZhaWwsIGFuZCBkb2NrZXIgd2lsbCBiZSBraWxsZWQuIFRoaXMgaXMgdW5kZXNpcmFibGUgZXNwZWNpYWxseSB3aGVuCiAgIyBkb2NrZXIgbGl2ZSByZXN0b3JlIGlzIGRpc2FibGVkLgogIGxvY2FsIGhlYWx0aGNoZWNrX2NvbW1hbmQ9ImRvY2tlciBwcyIKICBpZiBbWyAiJHtDT05UQUlORVJfUlVOVElNRTotZG9ja2VyfSIgIT0gImRvY2tlciIgXV07IHRoZW4KICAgIGhlYWx0aGNoZWNrX2NvbW1hbmQ9ImNyaWN0bCBwb2RzIgogIGZpCiAgIyBDb250YWluZXIgcnVudGltZSBzdGFydHVwIHRha2VzIHRpbWUuIE1ha2UgaW5pdGlhbCBhdHRlbXB0cyBiZWZvcmUgc3RhcnRpbmcKICAjIGtpbGxpbmcgdGhlIGNvbnRhaW5lciBydW50aW1lLgogIHVudGlsIHRpbWVvdXQgNjAgJHtoZWFsdGhjaGVja19jb21tYW5kfSA+IC9kZXYvbnVsbDsgZG8KICAgIGlmICgoYXR0ZW1wdCA9PSBtYXhfYXR0ZW1wdHMpKTsgdGhlbgogICAgICBlY2hvICJNYXggYXR0ZW1wdCAke21heF9hdHRlbXB0c30gcmVhY2hlZCEgUHJvY2VlZGluZyB0byBtb25pdG9yIGNvbnRhaW5lciBydW50aW1lIGhlYWx0aGluZXNzLiIKICAgICAgYnJlYWsKICAgIGZpCiAgICBlY2hvICIkYXR0ZW1wdCBpbml0aWFsIGF0dGVtcHQgXCIke2hlYWx0aGNoZWNrX2NvbW1hbmR9XCIhIFRyeWluZyBhZ2FpbiBpbiAkYXR0ZW1wdCBzZWNvbmRzLi4uIgogICAgc2xlZXAgIiQoKDIgKiogYXR0ZW1wdCsrKSkiCiAgZG9uZQogIHdoaWxlIHRydWU7IGRvCiAgICBpZiAhIHRpbWVvdXQgNjAgJHtoZWFsdGhjaGVja19jb21tYW5kfSA+IC9kZXYvbnVsbDsgdGhlbgogICAgICBlY2hvICJDb250YWluZXIgcnVudGltZSAke2NvbnRhaW5lcl9ydW50aW1lX25hbWV9IGZhaWxlZCEiCiAgICAgIGlmIFtbICIkY29udGFpbmVyX3J1bnRpbWVfbmFtZSIgPT0gImRvY2tlciIgXV07IHRoZW4KICAgICAgICAjIER1bXAgc3RhY2sgb2YgZG9ja2VyIGRhZW1vbiBmb3IgaW52ZXN0aWdhdGlvbi4KICAgICAgICAjIExvZyBmaWxlIG5hbWUgbG9va3MgbGlrZSBnb3JvdXRpbmUtc3RhY2tzLVRJTUVTVEFNUCBhbmQgd2lsbCBiZSBzYXZlZCB0bwogICAgICAgICMgdGhlIGV4ZWMgcm9vdCBkaXJlY3RvcnksIHdoaWNoIGlzIC92YXIvcnVuL2RvY2tlci8gb24gVWJ1bnR1IGFuZCBDT1MuCiAgICAgICAgcGtpbGwgLVNJR1VTUjEgZG9ja2VyZAogICAgICBmaQogICAgICBzeXN0ZW1jdGwga2lsbCAtLWtpbGwtd2hvPW1haW4gIiR7Y29udGFpbmVyX3J1bnRpbWVfbmFtZX0iCiAgICAgICMgV2FpdCBmb3IgYSB3aGlsZSwgYXMgd2UgZG9uJ3Qgd2FudCB0byBraWxsIGl0IGFnYWluIGJlZm9yZSBpdCBpcyByZWFsbHkgdXAuCiAgICAgIHNsZWVwIDEyMAogICAgZWxzZQogICAgICBzbGVlcCAiJHtTTEVFUF9TRUNPTkRTfSIKICAgIGZpCiAgZG9uZQp9CgpmdW5jdGlvbiBrdWJlbGV0X21vbml0b3JpbmcoKSB7CiAgZWNobyAiV2FpdCBmb3IgMiBtaW51dGVzIGZvciBrdWJlbGV0IHRvIGJlIGZ1bmN0aW9uYWwiCiAgc2xlZXAgMTIwCiAgbG9jYWwgLXIgbWF4X3NlY29uZHM9MTAKICBsb2NhbCBvdXRwdXQ9IiIKICB3aGlsZSB0cnVlOyBkbwogICAgbG9jYWwgZmFpbGVkPWZhbHNlCgogICAgaWYgam91cm5hbGN0bCAtdSBrdWJlbGV0IC1uIDEgfCBncmVwIC1xICJ1c2Ugb2YgY2xvc2VkIG5ldHdvcmsgY29ubmVjdGlvbiI7IHRoZW4KICAgICAgZmFpbGVkPXRydWUKICAgICAgZWNobyAiS3ViZWxldCBzdG9wcGVkIHBvc3Rpbmcgbm9kZSBzdGF0dXMuIFJlc3RhcnRpbmciCiAgICBlbGlmICEgb3V0cHV0PSQoY3VybCAtbSAiJHttYXhfc2Vjb25kc30iIC1mIC1zIC1TIGh0dHA6Ly8xMjcuMC4wLjE6MTAyNDgvaGVhbHRoeiAyPiYxKTsgdGhlbgogICAgICBmYWlsZWQ9dHJ1ZQogICAgICAjIFByaW50IHRoZSByZXNwb25zZSBhbmQvb3IgZXJyb3JzLgogICAgICBlY2hvICIkb3V0cHV0IgogICAgZmkKCiAgICBpZiBbWyAiJGZhaWxlZCIgPT0gInRydWUiIF1dOyB0aGVuCiAgICAgIGVjaG8gIkt1YmVsZXQgaXMgdW5oZWFsdGh5ISIKICAgICAgc3lzdGVtY3RsIGtpbGwga3ViZWxldAogICAgICAjIFdhaXQgZm9yIGEgd2hpbGUsIGFzIHdlIGRvbid0IHdhbnQgdG8ga2lsbCBpdCBhZ2FpbiBiZWZvcmUgaXQgaXMgcmVhbGx5IHVwLgogICAgICBzbGVlcCA2MAogICAgZWxzZQogICAgICBzbGVlcCAiJHtTTEVFUF9TRUNPTkRTfSIKICAgIGZpCiAgZG9uZQp9CgojIyMjIyMjIyMjIyMjIyBNYWluIEZ1bmN0aW9uICMjIyMjIyMjIyMjIyMjIyMKaWYgW1sgIiQjIiAtbmUgMSBdXTsgdGhlbgogIGVjaG8gIlVzYWdlOiBoZWFsdGgtbW9uaXRvci5zaCA8Y29udGFpbmVyLXJ1bnRpbWUva3ViZWxldD4iCiAgZXhpdCAxCmZpCgpTTEVFUF9TRUNPTkRTPTEwCmNvbXBvbmVudD0kMQplY2hvICJTdGFydCBrdWJlcm5ldGVzIGhlYWx0aCBtb25pdG9yaW5nIGZvciAke2NvbXBvbmVudH0iCmlmIFtbICIke2NvbXBvbmVudH0iID09ICJjb250YWluZXItcnVudGltZSIgXV07IHRoZW4KICBjb250YWluZXJfcnVudGltZV9tb25pdG9yaW5nCmVsaWYgW1sgIiR7Y29tcG9uZW50fSIgPT0gImt1YmVsZXQiIF1dOyB0aGVuCiAga3ViZWxldF9tb25pdG9yaW5nCmVsc2UKICBlY2hvICJIZWFsdGggbW9uaXRvcmluZyBmb3IgY29tcG9uZW50ICR7Y29tcG9uZW50fSBpcyBub3Qgc3VwcG9ydGVkISIKZmkK

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdnMKbW9kcHJvYmUgaXBfdnNfcnIKbW9kcHJvYmUgaXBfdnNfd3JyCm1vZHByb2JlIGlwX3ZzX3NoCgppZiBtb2RpbmZvIG5mX2Nvbm50cmFja19pcHY0ICY+IC9kZXYvbnVsbDsgdGhlbgogIG1vZHByb2JlIG5mX2Nvbm50cmFja19pcHY0CmVsc2UKICBtb2Rwcm9iZSBuZl9jb25udHJhY2sKZmkK

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/default/grub.d/60-swap-accounting.cfg'
  encoding: 'b64'
  content: |-
    IyBBZGRlZCBieSBrdWJlcm1hdGljIG1hY2hpbmUtY29udHJvbGxlcgojIEVuYWJsZSBjZ3JvdXBzIG1lbW9yeSBhbmQgc3dhcCBhY2NvdW50aW5nCkdSVUJfQ01ETElORV9MSU5VWD0iY2dyb3VwX2VuYWJsZT1tZW1vcnkgc3dhcGFjY291bnQ9MSIK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWRvY2tlci5zZXJ2aWNlClJlcXVpcmVzPWRvY2tlci5zZXJ2aWNlCgpEZXNjcmlwdGlvbj1rdWJlbGV0OiBUaGUgS3ViZXJuZXRlcyBOb2RlIEFnZW50CkRvY3VtZW50YXRpb249aHR0cHM6Ly9rdWJlcm5ldGVzLmlvL2RvY3MvaG9tZS8KCltTZXJ2aWNlXQpVc2VyPXJvb3QKUmVzdGFydD1hbHdheXMKU3RhcnRMaW1pdEludGVydmFsPTAKUmVzdGFydFNlYz0xMApDUFVBY2NvdW50aW5nPXRydWUKTWVtb3J5QWNjb3VudGluZz10cnVlCgpFbnZpcm9ubWVudD0iUEFUSD0vb3B0L2JpbjovYmluOi91c3IvbG9jYWwvc2JpbjovdXNyL2xvY2FsL2JpbjovdXNyL3NiaW46L3Vzci9iaW46L3NiaW4vIgpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKCkV4ZWNTdGFydFByZT0vYmluL2Jhc2ggL29wdC9kaXNhYmxlLXN3YXAuc2gKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2xvYWQta2VybmVsLW1vZHVsZXMuc2gKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Jpbi9zZXR1cF9uZXRfZW52LnNoCkV4ZWNTdGFydD0vb3B0L2Jpbi9rdWJlbGV0ICRLVUJFTEVUX0VYVFJBX0FSR1MgXAogIC0tYm9vdHN0cmFwLWt1YmVjb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Jvb3RzdHJhcC1rdWJlbGV0LmNvbmYgXAogIC0ta3ViZWNvbmZpZz0vdmFyL2xpYi9rdWJlbGV0L2t1YmVjb25maWcgXAogIC0tY29uZmlnPS9ldGMva3ViZXJuZXRlcy9rdWJlbGV0LmNvbmYgXAogIC0tbmV0d29yay1wbHVnaW49Y25pIFwKICAtLWNlcnQtZGlyPS9ldGMva3ViZXJuZXRlcy9wa2kgXAogIC0tY2xvdWQtcHJvdmlkZXI9YXdzIFwKICAtLWNsb3VkLWNvbmZpZz0vZXRjL2t1YmVybmV0ZXMvY2xvdWQtY29uZmlnIFwKICAtLWR5bmFtaWMtY29uZmlnLWRpcj0vZXRjL2t1YmVybmV0ZXMvZHluYW1pYy1jb25maWctZGlyIFwKICAtLWZlYXR1cmUtZ2F0ZXM9RHluYW1pY0t1YmVsZXRDb25maWc9dHJ1ZSBcCiAgLS1leGl0LW9uLWxvY2stY29udGVudGlvbiBcCiAgLS1sb2NrLWZpbGU9L3RtcC9rdWJlbGV0LmxvY2sgXAogIC0tY29udGFpbmVyLXJ1bnRpbWU9ZG9ja2VyIFwKICAtLWNvbnRhaW5lci1ydW50aW1lLWVuZHBvaW50PXVuaXg6Ly8vdmFyL3J1bi9kb2NrZXJzaGltLnNvY2sgXAogIC0tbm9kZS1pcCAke0tVQkVMRVRfTk9ERV9JUH0KCltJbnN0YWxsXQpXYW50ZWRCeT1tdWx0aS11c2VyLnRhcmdldAo=

- path: '/etc/systemd/system/kubelet.service.d/extras.conf'
  encoding: 'b64'
  content: |-
    W1NlcnZpY2VdCkVudmlyb25tZW50PSJLVUJFTEVUX0VYVFJBX0FSR1M9LS1yZXNvbHYtY29uZj0vcnVuL3N5c3RlbWQvcmVzb2x2ZS9yZXNvbHYuY29uZiIK

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    W2dsb2JhbF0KWm9uZT0iZXUtY2VudHJhbC0xYiIKVlBDPSJlLTEyM2YiClN1Ym5ldElEPSJ0ZXN0LXN1Ym5ldCIKCg==

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKCiMgZ2V0IHRoZSBmdWxsIGhvc3RuYW1lCkZVTExfSE9TVE5BTUU9JChob3N0bmFtZSAtZikKIyBpZiAvZXRjL2hvc3RuYW1lIGlzIG5vdCBlbXB0eSB0aGVuIHVzZSB0aGUgaG9zdG5hbWUgZnJvbSB0aGVyZQppZiBbIC1zIC9ldGMvaG9zdG5hbWUgXTsgdGhlbgogIEZVTExfSE9TVE5BTUU9JChjYXQgL2V0Yy9ob3N0bmFtZSkKZmkKCiMgd3JpdGUgdGhlIG5vZGVpcF9lbnYgZmlsZQojIHdlIG5lZWQgdGhlIGxpbmUgYmVsb3cgYmVjYXVzZSBmbGF0Y2FyIGhhcyB0aGUgc2FtZSBzdHJpbmcgImNvcmVvcyIgaW4gdGhhdCBmaWxlCmlmIGdyZXAgLXEgY29yZW9zIC9ldGMvb3MtcmVsZWFzZQp0aGVuCiAgZWNobyAiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XG5LVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX0iID4gL2V0Yy9rdWJlcm5ldGVzL25vZGVpcC5jb25mCmVsaWYgWyAhIC1kIC9ldGMvc3lzdGVtZC9zeXN0ZW0va3ViZWxldC5zZXJ2aWNlLmQgXQp0aGVuCiAgZWNob2RhdGUgIkNhbid0IGZpbmQga3ViZWxldCBzZXJ2aWNlIGV4dHJhcyBkaXJlY3RvcnkiCiAgZXhpdCAxCmVsc2UKICBlY2hvIC1lICJbU2VydmljZV1cbkVudmlyb25tZW50PVwiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XCJcbkVudmlyb25tZW50PVwiS1VCRUxFVF9IT1NUTkFNRT0ke0ZVTExfSE9TVE5BTUV9XCIiID4gL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZC9ub2RlaXAuY29uZgpmaQo=

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKZmVhdHVyZUdhdGVzOgogIEdyYWNlZnVsTm9kZVNodXRkb3duOiB0cnVlCiAgSWRlbnRpZnlQb2RPUzogZmFsc2UKcHJvdGVjdEtlcm5lbERlZmF1bHRzOiB0cnVlCnJlYWRPbmx5UG9ydDogMApyb3RhdGVDZXJ0aWZpY2F0ZXM6IHRydWUKc2VydmVyVExTQm9vdHN0cmFwOiB0cnVlCnN0YXRpY1BvZFBhdGg6IC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMKa3ViZVJlc2VydmVkOgogIGNwdTogMzBtCiAgZXBoZW1lcmFsLXN0b3JhZ2U6IDMwR2kKc3lzdGVtUmVzZXJ2ZWQ6CiAgY3B1OiAzMG0KICBlcGhlbWVyYWwtc3RvcmFnZTogMzBHaQpldmljdGlvbkhhcmQ6CiAgbWVtb3J5LmF2YWlsYWJsZTogMzBNaQptYXhQb2RzOiAxMTAKdGxzQ2lwaGVyU3VpdGVzOgotIFRMU19BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0NIQUNIQTIwX1BPTFkxMzA1X1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1Ci0gVExTX0VDREhFX1JTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfUlNBX1dJVEhfQ0hBQ0hBMjBfUE9MWTEzMDUKdm9sdW1lUGx1Z2luRGlyOiAvdmFyL2xpYi9rdWJlbGV0L3ZvbHVtZXBsdWdpbnMK

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/opt/disable-swap.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKIyBNYWtlIHN1cmUgd2UgYWx3YXlzIGRpc2FibGUgc3dhcCAtIE90aGVyd2lzZSB0aGUga3ViZWxldCB3b24ndCBzdGFydCBhcyBmb3Igc29tZSBjbG91ZAojIHByb3ZpZGVycyBzd2FwIGdldHMgZW5hYmxlZCBvbiByZWJvb3Qgb3IgYWZ0ZXIgdGhlIHNldHVwIHNjcmlwdCBoYXMgZmluaXNoZWQgZXhlY3V0aW5nLgpzZWQgLWkub3JpZyAnLy4qc3dhcC4qL2QnIC9ldGMvZnN0YWIKc3dhcG9mZiAtYQo=

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/systemd/system/docker.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/docker/daemon.json'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    eyJleGVjLW9wdHMiOlsibmF0aXZlLmNncm91cGRyaXZlcj1zeXN0ZW1kIl0sInN0b3JhZ2UtZHJpdmVyIjoib3ZlcmxheTIiLCJsb2ctZHJpdmVyIjoianNvbi1maWxlIiwibG9nLW9wdHMiOnsibWF4LWZpbGUiOiIzMCIsIm1heC1zaXplIjoiMzAwbSJ9LCJpbnNlY3VyZS1yZWdpc3RyaWVzIjpbIjE5Mi4xNjguMTAwLjEwMDo1MDAwIiwiMTAuMC4wLjE6NTAwMCJdLCJyZWdpc3RyeS1taXJyb3JzIjpbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdfQ==

- path: '/root/.docker/config.json'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    
 immutable: true kind: Secret metadata: diff --git a/pkg/controllers/osc/testdata/secret-rhel-8.x-azure-containerd.yaml b/pkg/controllers/osc/testdata/secret-rhel-8.x-azure-containerd.yaml index 587ef77b..c4c3f252 100644 --- a/pkg/controllers/osc/testdata/secret-rhel-8.x-azure-containerd.yaml +++ b/pkg/controllers/osc/testdata/secret-rhel-8.x-azure-containerd.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdGFibGVzCm1vZHByb2JlIGlwX3ZzCm1vZHByb2JlIGlwX3ZzX3JyCm1vZHByb2JlIGlwX3ZzX3dycgptb2Rwcm9iZSBpcF92c19zaAoKaWYgbW9kaW5mbyBuZl9jb25udHJhY2tfaXB2NCAmPiAvZGV2L251bGw7IHRoZW4KICBtb2Rwcm9iZSBuZl9jb25udHJhY2tfaXB2NAplbHNlCiAgbW9kcHJvYmUgbmZfY29ubnRyYWNrCmZpCg==

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/selinux/config'
  encoding: 'b64'
  content: |-
    IyBUaGlzIGZpbGUgY29udHJvbHMgdGhlIHN0YXRlIG9mIFNFTGludXggb24gdGhlIHN5c3RlbS4KIyBTRUxJTlVYPSBjYW4gdGFrZSBvbmUgb2YgdGhlc2UgdGhyZWUgdmFsdWVzOgojICAgICBlbmZvcmNpbmcgLSBTRUxpbnV4IHNlY3VyaXR5IHBvbGljeSBpcyBlbmZvcmNlZC4KIyAgICAgcGVybWlzc2l2ZSAtIFNFTGludXggcHJpbnRzIHdhcm5pbmdzIGluc3RlYWQgb2YgZW5mb3JjaW5nLgojICAgICBkaXNhYmxlZCAtIE5vIFNFTGludXggcG9saWN5IGlzIGxvYWRlZC4KU0VMSU5VWD1wZXJtaXNzaXZlCiMgU0VMSU5VWFRZUEU9IGNhbiB0YWtlIG9uZSBvZiB0aHJlZSB0d28gdmFsdWVzOgojICAgICB0YXJnZXRlZCAtIFRhcmdldGVkIHByb2Nlc3NlcyBhcmUgcHJvdGVjdGVkLAojICAgICBtaW5pbXVtIC0gTW9kaWZpY2F0aW9uIG9mIHRhcmdldGVkIHBvbGljeS4gT25seSBzZWxlY3RlZCBwcm9jZXNzZXMgYXJlIHByb3RlY3RlZC4KIyAgICAgbWxzIC0gTXVsdGkgTGV2ZWwgU2VjdXJpdHkgcHJvdGVjdGlvbi4KU0VMSU5VWFRZUEU9dGFyZ2V0ZWQK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWNvbnRhaW5lcmQuc2VydmljZQpSZXF1aXJlcz1jb250YWluZXJkLnNlcnZpY2UKCkRlc2NyaXB0aW9uPWt1YmVsZXQ6IFRoZSBLdWJlcm5ldGVzIE5vZGUgQWdlbnQKRG9jdW1lbnRhdGlvbj1odHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy9ob21lLwoKW1NlcnZpY2VdClVzZXI9cm9vdApSZXN0YXJ0PWFsd2F5cwpTdGFydExpbWl0SW50ZXJ2YWw9MApSZXN0YXJ0U2VjPTEwCkNQVUFjY291bnRpbmc9dHJ1ZQpNZW1vcnlBY2NvdW50aW5nPXRydWUKCkVudmlyb25tZW50PSJQQVRIPS9vcHQvYmluOi9iaW46L3Vzci9sb2NhbC9zYmluOi91c3IvbG9jYWwvYmluOi91c3Ivc2JpbjovdXNyL2Jpbjovc2Jpbi8iCkVudmlyb25tZW50RmlsZT0tL2V0Yy9lbnZpcm9ubWVudAoKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2xvYWQta2VybmVsLW1vZHVsZXMuc2gKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Jpbi9zZXR1cF9uZXRfZW52LnNoCkV4ZWNTdGFydD0vb3B0L2Jpbi9rdWJlbGV0ICRLVUJFTEVUX0VYVFJBX0FSR1MgXAogIC0tYm9vdHN0cmFwLWt1YmVjb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Jvb3RzdHJhcC1rdWJlbGV0LmNvbmYgXAogIC0ta3ViZWNvbmZpZz0vdmFyL2xpYi9rdWJlbGV0L2t1YmVjb25maWcgXAogIC0tY29uZmlnPS9ldGMva3ViZXJuZXRlcy9rdWJlbGV0LmNvbmYgXAogIC0tbmV0d29yay1wbHVnaW49Y25pIFwKICAtLWNlcnQtZGlyPS9ldGMva3ViZXJuZXRlcy9wa2kgXAogIC0tY2xvdWQtcHJvdmlkZXI9YXp1cmUgXAogIC0tY2xvdWQtY29uZmlnPS9ldGMva3ViZXJuZXRlcy9jbG91ZC1jb25maWcgXAogIC0taG9zdG5hbWUtb3ZlcnJpZGU9JHtLVUJFTEVUX0hPU1ROQU1FfSBcCiAgLS1keW5hbWljLWNvbmZpZy1kaXI9L2V0Yy9rdWJlcm5ldGVzL2R5bmFtaWMtY29uZmlnLWRpciBcCiAgLS1mZWF0dXJlLWdhdGVzPUR5bmFtaWNLdWJlbGV0Q29uZmlnPXRydWUgXAogIC0tZXhpdC1vbi1sb2NrLWNvbnRlbnRpb24gXAogIC0tbG9jay1maWxlPS90bXAva3ViZWxldC5sb2NrIFwKICAtLWNvbnRhaW5lci1ydW50aW1lPXJlbW90ZSBcCiAgLS1jb250YWluZXItcnVudGltZS1lbmRwb2ludD11bml4Oi8vL3J1bi9jb250YWluZXJkL2NvbnRhaW5lcmQuc29jayBcCiAgLS1ub2RlLWlwICR7S1VCRUxFVF9OT0RFX0lQfQoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    eyJjbG91ZCI6IkFaVVJFUFVCTElDQ0xPVUQiLCJ0ZW5hbnRJZCI6IiIsInN1YnNjcmlwdGlvbklkIjoiIiwiYWFkQ2xpZW50SWQiOiIiLCJhYWRDbGllbnRTZWNyZXQiOiIiLCJyZXNvdXJjZUdyb3VwIjoiIiwibG9jYXRpb24iOiIiLCJ2bmV0TmFtZSI6IiIsInN1Ym5ldE5hbWUiOiIiLCJyb3V0ZVRhYmxlTmFtZSI6IiIsInNlY3VyaXR5R3JvdXBOYW1lIjoiZmFrZS1zZyIsInByaW1hcnlBdmFpbGFiaWxpdHlTZXROYW1lIjoiIiwidm5ldFJlc291cmNlR3JvdXAiOiIiLCJ1c2VJbnN0YW5jZU1ldGFkYXRhIjp0cnVlLCJsb2FkQmFsYW5jZXJTa3UiOiIifQo=

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKIyBnZXQgdGhlIGZ1bGwgaG9zdG5hbWUKRlVMTF9IT1NUTkFNRT0kKGhvc3RuYW1lIC1mKQojIGlmIC9ldGMvaG9zdG5hbWUgaXMgbm90IGVtcHR5IHRoZW4gdXNlIHRoZSBob3N0bmFtZSBmcm9tIHRoZXJlCmlmIFsgLXMgL2V0Yy9ob3N0bmFtZSBdOyB0aGVuCiAgRlVMTF9IT1NUTkFNRT0kKGNhdCAvZXRjL2hvc3RuYW1lKQpmaQoKIyB3cml0ZSB0aGUgbm9kZWlwX2VudiBmaWxlCiMgd2UgbmVlZCB0aGUgbGluZSBiZWxvdyBiZWNhdXNlIGZsYXRjYXIgaGFzIHRoZSBzYW1lIHN0cmluZyAiY29yZW9zIiBpbiB0aGF0IGZpbGUKaWYgZ3JlcCAtcSBjb3Jlb3MgL2V0Yy9vcy1yZWxlYXNlCnRoZW4KICBlY2hvICJLVUJFTEVUX05PREVfSVA9JHtERUZBVUxUX0lGQ19JUH1cbktVQkVMRVRfSE9TVE5BTUU9JHtGVUxMX0hPU1ROQU1FfSIgPiAvZXRjL2t1YmVybmV0ZXMvbm9kZWlwLmNvbmYKZWxpZiBbICEgLWQgL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZCBdCnRoZW4KICBlY2hvZGF0ZSAiQ2FuJ3QgZmluZCBrdWJlbGV0IHNlcnZpY2UgZXh0cmFzIGRpcmVjdG9yeSIKICBleGl0IDEKZWxzZQogIGVjaG8gLWUgIltTZXJ2aWNlXVxuRW52aXJvbm1lbnQ9XCJLVUJFTEVUX05PREVfSVA9JHtERUZBVUxUX0lGQ19JUH1cIlxuRW52aXJvbm1lbnQ9XCJLVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX1cIiIgPiAvZXRjL3N5c3RlbWQvc3lzdGVtL2t1YmVsZXQuc2VydmljZS5kL25vZGVpcC5jb25mCmZpCg==

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKY29udGFpbmVyTG9nTWF4U2l6ZTogMTAwTWkKY29udGFpbmVyTG9nTWF4RmlsZXM6IDUKZmVhdHVyZUdhdGVzOgogIEdyYWNlZnVsTm9kZVNodXRkb3duOiB0cnVlCiAgSWRlbnRpZnlQb2RPUzogZmFsc2UKcHJvdGVjdEtlcm5lbERlZmF1bHRzOiB0cnVlCnJlYWRPbmx5UG9ydDogMApyb3RhdGVDZXJ0aWZpY2F0ZXM6IHRydWUKc2VydmVyVExTQm9vdHN0cmFwOiB0cnVlCnN0YXRpY1BvZFBhdGg6IC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMKa3ViZVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCnN5c3RlbVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCmV2aWN0aW9uSGFyZDoKICBpbWFnZWZzLmF2YWlsYWJsZTogMTUlCiAgbWVtb3J5LmF2YWlsYWJsZTogMTAwTWkKICBub2RlZnMuYXZhaWxhYmxlOiAxMCUKICBub2RlZnMuaW5vZGVzRnJlZTogNSUKdGxzQ2lwaGVyU3VpdGVzOgotIFRMU19BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0NIQUNIQTIwX1BPTFkxMzA1X1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1Ci0gVExTX0VDREhFX1JTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfUlNBX1dJVEhfQ0hBQ0hBMjBfUE9MWTEzMDUKdm9sdW1lUGx1Z2luRGlyOiAvdmFyL2xpYi9rdWJlbGV0L3ZvbHVtZXBsdWdpbnMK

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/etc/crictl.yaml'
  content: |-
    runtime-endpoint: unix:///run/containerd/containerd.sock
    

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/containerd/config.toml'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    dmVyc2lvbiA9IDIKClttZXRyaWNzXQphZGRyZXNzID0gIjEyNy4wLjAuMToxMzM4IgoKW3BsdWdpbnNdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIl0Kc2FuZGJveF9pbWFnZSA9ICIxOTIuMTY4LjEwMC4xMDA6NTAwMC9rdWJlcm5ldGVzL3BhdXNlOnYzLjEiCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5jb250YWluZXJkXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIuY29udGFpbmVyZC5ydW50aW1lc10KW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuY10KcnVudGltZV90eXBlID0gImlvLmNvbnRhaW5lcmQucnVuYy52MiIKW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuYy5vcHRpb25zXQpTeXN0ZW1kQ2dyb3VwID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnldCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5taXJyb3JzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkubWlycm9ycy4iZG9ja2VyLmlvIl0KZW5kcG9pbnQgPSBbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTAuMC4wLjE6NTAwMCJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzLiIxMC4wLjAuMTo1MDAwIi50bHNdCmluc2VjdXJlX3NraXBfdmVyaWZ5ID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiLnRsc10KaW5zZWN1cmVfc2tpcF92ZXJpZnkgPSB0cnVlCgo=

rh_subscription:
    auto-attach: false
    password: 
    username:  + cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdGFibGVzCm1vZHByb2JlIGlwX3ZzCm1vZHByb2JlIGlwX3ZzX3JyCm1vZHByb2JlIGlwX3ZzX3dycgptb2Rwcm9iZSBpcF92c19zaAoKaWYgbW9kaW5mbyBuZl9jb25udHJhY2tfaXB2NCAmPiAvZGV2L251bGw7IHRoZW4KICBtb2Rwcm9iZSBuZl9jb25udHJhY2tfaXB2NAplbHNlCiAgbW9kcHJvYmUgbmZfY29ubnRyYWNrCmZpCg==

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/selinux/config'
  encoding: 'b64'
  content: |-
    IyBUaGlzIGZpbGUgY29udHJvbHMgdGhlIHN0YXRlIG9mIFNFTGludXggb24gdGhlIHN5c3RlbS4KIyBTRUxJTlVYPSBjYW4gdGFrZSBvbmUgb2YgdGhlc2UgdGhyZWUgdmFsdWVzOgojICAgICBlbmZvcmNpbmcgLSBTRUxpbnV4IHNlY3VyaXR5IHBvbGljeSBpcyBlbmZvcmNlZC4KIyAgICAgcGVybWlzc2l2ZSAtIFNFTGludXggcHJpbnRzIHdhcm5pbmdzIGluc3RlYWQgb2YgZW5mb3JjaW5nLgojICAgICBkaXNhYmxlZCAtIE5vIFNFTGludXggcG9saWN5IGlzIGxvYWRlZC4KU0VMSU5VWD1wZXJtaXNzaXZlCiMgU0VMSU5VWFRZUEU9IGNhbiB0YWtlIG9uZSBvZiB0aHJlZSB0d28gdmFsdWVzOgojICAgICB0YXJnZXRlZCAtIFRhcmdldGVkIHByb2Nlc3NlcyBhcmUgcHJvdGVjdGVkLAojICAgICBtaW5pbXVtIC0gTW9kaWZpY2F0aW9uIG9mIHRhcmdldGVkIHBvbGljeS4gT25seSBzZWxlY3RlZCBwcm9jZXNzZXMgYXJlIHByb3RlY3RlZC4KIyAgICAgbWxzIC0gTXVsdGkgTGV2ZWwgU2VjdXJpdHkgcHJvdGVjdGlvbi4KU0VMSU5VWFRZUEU9dGFyZ2V0ZWQK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCgpzZXRlbmZvcmNlIDAgfHwgdHJ1ZQpzeXN0ZW1jdGwgcmVzdGFydCBzeXN0ZW1kLW1vZHVsZXMtbG9hZC5zZXJ2aWNlCnN5c2N0bCAtLXN5c3RlbQoKeXVtIGluc3RhbGwgLXkgXAogIGRldmljZS1tYXBwZXItcGVyc2lzdGVudC1kYXRhIFwKICBsdm0yIFwKICBlYnRhYmxlcyBcCiAgZXRodG9vbCBcCiAgbmZzLXV0aWxzIFwKICBiYXNoLWNvbXBsZXRpb24gXAogIHN1ZG8gXAogIHNvY2F0IFwKICB3Z2V0IFwKICBjdXJsIFwKICBpcHZzYWRtCgpzeXN0ZW1jdGwgZGlzYWJsZSAtLW5vdyBmaXJld2FsbGQgfHwgdHJ1ZQp5dW0gaW5zdGFsbCAteSB5dW0tdXRpbHMKeXVtLWNvbmZpZy1tYW5hZ2VyIC0tYWRkLXJlcG89aHR0cHM6Ly9kb3dubG9hZC5kb2NrZXIuY29tL2xpbnV4L2NlbnRvcy9kb2NrZXItY2UucmVwbwp5dW0tY29uZmlnLW1hbmFnZXIgLS1zYXZlIC0tc2V0b3B0PWRvY2tlci1jZS1zdGFibGUubW9kdWxlX2hvdGZpeGVzPXRydWUKCnl1bSBpbnN0YWxsIC15IGNvbnRhaW5lcmQuaW8tMS41KiB5dW0tcGx1Z2luLXZlcnNpb25sb2NrCnl1bSB2ZXJzaW9ubG9jayBhZGQgY29udGFpbmVyZC5pbwoKc3lzdGVtY3RsIGRhZW1vbi1yZWxvYWQKc3lzdGVtY3RsIGVuYWJsZSAtLW5vdyBjb250YWluZXJkCgpvcHRfYmluPS9vcHQvYmluCnVzcl9sb2NhbF9iaW49L3Vzci9sb2NhbC9iaW4KY25pX2Jpbl9kaXI9L29wdC9jbmkvYmluCm1rZGlyIC1wIC9ldGMvY25pL25ldC5kIC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMgIiRvcHRfYmluIiAiJGNuaV9iaW5fZGlyIgpta2RpciAtcCAvZXRjL2t1YmVybmV0ZXMvZHluYW1pYy1jb25maWctZGlyCmFyY2g9JHtIT1NUX0FSQ0gtfQppZiBbIC16ICIkYXJjaCIgXQp0aGVuCmNhc2UgJCh1bmFtZSAtbSkgaW4KeDg2XzY0KQogICAgYXJjaD0iYW1kNjQiCiAgICA7OwphYXJjaDY0KQogICAgYXJjaD0iYXJtNjQiCiAgICA7OwoqKQogICAgZWNobyAidW5zdXBwb3J0ZWQgQ1BVIGFyY2hpdGVjdHVyZSwgZXhpdGluZyIKICAgIGV4aXQgMQogICAgOzsKZXNhYwpmaQpDTklfVkVSU0lPTj0iJHtDTklfVkVSU0lPTjotdjAuOC43fSIKY25pX2Jhc2VfdXJsPSJodHRwczovL2dpdGh1Yi5jb20vY29udGFpbmVybmV0d29ya2luZy9wbHVnaW5zL3JlbGVhc2VzL2Rvd25sb2FkLyRDTklfVkVSU0lPTiIKY25pX2ZpbGVuYW1lPSJjbmktcGx1Z2lucy1saW51eC0kYXJjaC0kQ05JX1ZFUlNJT04udGd6IgpjdXJsIC1MZm8gIiRjbmlfYmluX2Rpci8kY25pX2ZpbGVuYW1lIiAiJGNuaV9iYXNlX3VybC8kY25pX2ZpbGVuYW1lIgpjbmlfc3VtPSQoY3VybCAtTGYgIiRjbmlfYmFzZV91cmwvJGNuaV9maWxlbmFtZS5zaGEyNTYiKQpjZCAiJGNuaV9iaW5fZGlyIgpzaGEyNTZzdW0gLWMgPDw8IiRjbmlfc3VtIgp0YXIgeHZmICIkY25pX2ZpbGVuYW1lIgpybSAtZiAiJGNuaV9maWxlbmFtZSIKY2QgLQpDUklfVE9PTFNfUkVMRUFTRT0iJHtDUklfVE9PTFNfUkVMRUFTRTotdjEuMjIuMH0iCmNyaV90b29sc19iYXNlX3VybD0iaHR0cHM6Ly9naXRodWIuY29tL2t1YmVybmV0ZXMtc2lncy9jcmktdG9vbHMvcmVsZWFzZXMvZG93bmxvYWQvJHtDUklfVE9PTFNfUkVMRUFTRX0iCmNyaV90b29sc19maWxlbmFtZT0iY3JpY3RsLSR7Q1JJX1RPT0xTX1JFTEVBU0V9LWxpbnV4LSR7YXJjaH0udGFyLmd6IgpjdXJsIC1MZm8gIiRvcHRfYmluLyRjcmlfdG9vbHNfZmlsZW5hbWUiICIkY3JpX3Rvb2xzX2Jhc2VfdXJsLyRjcmlfdG9vbHNfZmlsZW5hbWUiCmNyaV90b29sc19zdW09JChjdXJsIC1MZiAiJGNyaV90b29sc19iYXNlX3VybC8kY3JpX3Rvb2xzX2ZpbGVuYW1lLnNoYTI1NiIgfCBzZWQgJ3MvXCpcLy8vJykKY2QgIiRvcHRfYmluIgpzaGEyNTZzdW0gLWMgPDw8IiRjcmlfdG9vbHNfc3VtIgp0YXIgeHZmICIkY3JpX3Rvb2xzX2ZpbGVuYW1lIgpybSAtZiAiJGNyaV90b29sc19maWxlbmFtZSIKbG4gLXNmICIkb3B0X2Jpbi9jcmljdGwiICIkdXNyX2xvY2FsX2JpbiIvY3JpY3RsIHx8IGVjaG8gInN5bWJvbGljIGxpbmsgaXMgc2tpcHBlZCIKY2QgLQpLVUJFX1ZFUlNJT049IiR7S1VCRV9WRVJTSU9OOi12MS4yMi4yfSIKa3ViZV9kaXI9IiRvcHRfYmluL2t1YmVybmV0ZXMtJEtVQkVfVkVSU0lPTiIKa3ViZV9iYXNlX3VybD0iaHR0cHM6Ly9zdG9yYWdlLmdvb2dsZWFwaXMuY29tL2t1YmVybmV0ZXMtcmVsZWFzZS9yZWxlYXNlLyRLVUJFX1ZFUlNJT04vYmluL2xpbnV4LyRhcmNoIgprdWJlX3N1bV9maWxlPSIka3ViZV9kaXIvc2hhMjU2Igpta2RpciAtcCAiJGt1YmVfZGlyIgo6ID4iJGt1YmVfc3VtX2ZpbGUiCgpmb3IgYmluIGluIGt1YmVsZXQga3ViZWFkbSBrdWJlY3RsOyBkbwogICAgY3VybCAtTGZvICIka3ViZV9kaXIvJGJpbiIgIiRrdWJlX2Jhc2VfdXJsLyRiaW4iCiAgICBjaG1vZCAreCAiJGt1YmVfZGlyLyRiaW4iCiAgICBzdW09JChjdXJsIC1MZiAiJGt1YmVfYmFzZV91cmwvJGJpbi5zaGEyNTYiKQogICAgZWNobyAiJHN1bSAgJGt1YmVfZGlyLyRiaW4iID4+IiRrdWJlX3N1bV9maWxlIgpkb25lCnNoYTI1NnN1bSAtYyAiJGt1YmVfc3VtX2ZpbGUiCgpmb3IgYmluIGluIGt1YmVsZXQga3ViZWFkbSBrdWJlY3RsOyBkbwogICAgbG4gLXNmICIka3ViZV9kaXIvJGJpbiIgIiRvcHRfYmluIi8kYmluCmRvbmUKCkRFRkFVTFRfSUZDX05BTUU9JChpcCAtbyByb3V0ZSBnZXQgMSAgfCBncmVwIC1vUCAiZGV2IFxLXFMrIikKCiMgZW5hYmxlIERIQ1B2NiBvbiB0aGUgZGVmYXVsdCBpbnRlcmZhY2UKZWNobyBORVRXT1JLSU5HX0lQVjY9eWVzID4+IC9ldGMvc3lzY29uZmlnL25ldHdvcmsKZWNobyBJUFY2SU5JVD15ZXMgPj4gL2V0Yy9zeXNjb25maWcvbmV0d29yay1zY3JpcHRzL2lmY2ZnLSRERUZBVUxUX0lGQ19OQU1FCmVjaG8gREhDUFY2Qz15ZXMgPj4gL2V0Yy9zeXNjb25maWcvbmV0d29yay1zY3JpcHRzL2lmY2ZnLSRERUZBVUxUX0lGQ19OQU1FCmlmZG93biAkREVGQVVMVF9JRkNfTkFNRSAmJiBpZnVwICRERUZBVUxUX0lGQ19OQU1FCgpta2RpciAtcCAvZXRjL3N5c3RlbWQvc3lzdGVtL2t1YmVsZXQuc2VydmljZS5kLwojIHNldCBrdWJlbGV0IG5vZGVpcCBlbnZpcm9ubWVudCB2YXJpYWJsZQovb3B0L2Jpbi9zZXR1cF9uZXRfZW52LnNoCgpzeXN0ZW1jdGwgZW5hYmxlIC0tbm93IGt1YmVsZXQKc3lzdGVtY3RsIGVuYWJsZSAtLW5vdyAtLW5vLWJsb2NrIGt1YmVsZXQtaGVhbHRoY2hlY2suc2VydmljZQo=

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWNvbnRhaW5lcmQuc2VydmljZQpSZXF1aXJlcz1jb250YWluZXJkLnNlcnZpY2UKCkRlc2NyaXB0aW9uPWt1YmVsZXQ6IFRoZSBLdWJlcm5ldGVzIE5vZGUgQWdlbnQKRG9jdW1lbnRhdGlvbj1odHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy9ob21lLwoKW1NlcnZpY2VdClVzZXI9cm9vdApSZXN0YXJ0PWFsd2F5cwpTdGFydExpbWl0SW50ZXJ2YWw9MApSZXN0YXJ0U2VjPTEwCkNQVUFjY291bnRpbmc9dHJ1ZQpNZW1vcnlBY2NvdW50aW5nPXRydWUKCkVudmlyb25tZW50PSJQQVRIPS9vcHQvYmluOi9iaW46L3Vzci9sb2NhbC9zYmluOi91c3IvbG9jYWwvYmluOi91c3Ivc2JpbjovdXNyL2Jpbjovc2Jpbi8iCkVudmlyb25tZW50RmlsZT0tL2V0Yy9lbnZpcm9ubWVudAoKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Rpc2FibGUtc3dhcC5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvbG9hZC1rZXJuZWwtbW9kdWxlcy5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvYmluL3NldHVwX25ldF9lbnYuc2gKRXhlY1N0YXJ0PS9vcHQvYmluL2t1YmVsZXQgJEtVQkVMRVRfRVhUUkFfQVJHUyBcCiAgLS1ib290c3RyYXAta3ViZWNvbmZpZz0vZXRjL2t1YmVybmV0ZXMvYm9vdHN0cmFwLWt1YmVsZXQuY29uZiBcCiAgLS1rdWJlY29uZmlnPS92YXIvbGliL2t1YmVsZXQva3ViZWNvbmZpZyBcCiAgLS1jb25maWc9L2V0Yy9rdWJlcm5ldGVzL2t1YmVsZXQuY29uZiBcCiAgLS1uZXR3b3JrLXBsdWdpbj1jbmkgXAogIC0tY2VydC1kaXI9L2V0Yy9rdWJlcm5ldGVzL3BraSBcCiAgLS1jbG91ZC1wcm92aWRlcj1henVyZSBcCiAgLS1jbG91ZC1jb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Nsb3VkLWNvbmZpZyBcCiAgLS1ob3N0bmFtZS1vdmVycmlkZT0ke0tVQkVMRVRfSE9TVE5BTUV9IFwKICAtLWR5bmFtaWMtY29uZmlnLWRpcj0vZXRjL2t1YmVybmV0ZXMvZHluYW1pYy1jb25maWctZGlyIFwKICAtLWZlYXR1cmUtZ2F0ZXM9RHluYW1pY0t1YmVsZXRDb25maWc9dHJ1ZSBcCiAgLS1leGl0LW9uLWxvY2stY29udGVudGlvbiBcCiAgLS1sb2NrLWZpbGU9L3RtcC9rdWJlbGV0LmxvY2sgXAogIC0tY29udGFpbmVyLXJ1bnRpbWU9cmVtb3RlIFwKICAtLWNvbnRhaW5lci1ydW50aW1lLWVuZHBvaW50PXVuaXg6Ly8vcnVuL2NvbnRhaW5lcmQvY29udGFpbmVyZC5zb2NrIFwKICAtLW5vZGUtaXAgJHtLVUJFTEVUX05PREVfSVB9CgpbSW5zdGFsbF0KV2FudGVkQnk9bXVsdGktdXNlci50YXJnZXQK

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    eyJjbG91ZCI6IkFaVVJFUFVCTElDQ0xPVUQiLCJ0ZW5hbnRJZCI6IiIsInN1YnNjcmlwdGlvbklkIjoiIiwiYWFkQ2xpZW50SWQiOiIiLCJhYWRDbGllbnRTZWNyZXQiOiIiLCJyZXNvdXJjZUdyb3VwIjoiIiwibG9jYXRpb24iOiIiLCJ2bmV0TmFtZSI6IiIsInN1Ym5ldE5hbWUiOiIiLCJyb3V0ZVRhYmxlTmFtZSI6IiIsInNlY3VyaXR5R3JvdXBOYW1lIjoiZmFrZS1zZyIsInByaW1hcnlBdmFpbGFiaWxpdHlTZXROYW1lIjoiIiwidm5ldFJlc291cmNlR3JvdXAiOiIiLCJ1c2VJbnN0YW5jZU1ldGFkYXRhIjp0cnVlLCJsb2FkQmFsYW5jZXJTa3UiOiIifQo=

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKIyBnZXQgdGhlIGZ1bGwgaG9zdG5hbWUKRlVMTF9IT1NUTkFNRT0kKGhvc3RuYW1lIC1mKQojIGlmIC9ldGMvaG9zdG5hbWUgaXMgbm90IGVtcHR5IHRoZW4gdXNlIHRoZSBob3N0bmFtZSBmcm9tIHRoZXJlCmlmIFsgLXMgL2V0Yy9ob3N0bmFtZSBdOyB0aGVuCiAgRlVMTF9IT1NUTkFNRT0kKGNhdCAvZXRjL2hvc3RuYW1lKQpmaQoKIyB3cml0ZSB0aGUgbm9kZWlwX2VudiBmaWxlCiMgd2UgbmVlZCB0aGUgbGluZSBiZWxvdyBiZWNhdXNlIGZsYXRjYXIgaGFzIHRoZSBzYW1lIHN0cmluZyAiY29yZW9zIiBpbiB0aGF0IGZpbGUKaWYgZ3JlcCAtcSBjb3Jlb3MgL2V0Yy9vcy1yZWxlYXNlCnRoZW4KICBlY2hvICJLVUJFTEVUX05PREVfSVA9JHtERUZBVUxUX0lGQ19JUH1cbktVQkVMRVRfSE9TVE5BTUU9JHtGVUxMX0hPU1ROQU1FfSIgPiAvZXRjL2t1YmVybmV0ZXMvbm9kZWlwLmNvbmYKZWxpZiBbICEgLWQgL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZCBdCnRoZW4KICBlY2hvZGF0ZSAiQ2FuJ3QgZmluZCBrdWJlbGV0IHNlcnZpY2UgZXh0cmFzIGRpcmVjdG9yeSIKICBleGl0IDEKZWxzZQogIGVjaG8gLWUgIltTZXJ2aWNlXVxuRW52aXJvbm1lbnQ9XCJLVUJFTEVUX05PREVfSVA9JHtERUZBVUxUX0lGQ19JUH1cIlxuRW52aXJvbm1lbnQ9XCJLVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX1cIiIgPiAvZXRjL3N5c3RlbWQvc3lzdGVtL2t1YmVsZXQuc2VydmljZS5kL25vZGVpcC5jb25mCmZpCg==

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKY29udGFpbmVyTG9nTWF4U2l6ZTogMTAwTWkKY29udGFpbmVyTG9nTWF4RmlsZXM6IDUKZmVhdHVyZUdhdGVzOgogIEdyYWNlZnVsTm9kZVNodXRkb3duOiB0cnVlCiAgSWRlbnRpZnlQb2RPUzogZmFsc2UKcHJvdGVjdEtlcm5lbERlZmF1bHRzOiB0cnVlCnJlYWRPbmx5UG9ydDogMApyb3RhdGVDZXJ0aWZpY2F0ZXM6IHRydWUKc2VydmVyVExTQm9vdHN0cmFwOiB0cnVlCnN0YXRpY1BvZFBhdGg6IC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMKa3ViZVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCnN5c3RlbVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCmV2aWN0aW9uSGFyZDoKICBpbWFnZWZzLmF2YWlsYWJsZTogMTUlCiAgbWVtb3J5LmF2YWlsYWJsZTogMTAwTWkKICBub2RlZnMuYXZhaWxhYmxlOiAxMCUKICBub2RlZnMuaW5vZGVzRnJlZTogNSUKdGxzQ2lwaGVyU3VpdGVzOgotIFRMU19BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0NIQUNIQTIwX1BPTFkxMzA1X1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1Ci0gVExTX0VDREhFX1JTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfUlNBX1dJVEhfQ0hBQ0hBMjBfUE9MWTEzMDUKdm9sdW1lUGx1Z2luRGlyOiAvdmFyL2xpYi9rdWJlbGV0L3ZvbHVtZXBsdWdpbnMK

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/opt/disable-swap.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKIyBNYWtlIHN1cmUgd2UgYWx3YXlzIGRpc2FibGUgc3dhcCAtIE90aGVyd2lzZSB0aGUga3ViZWxldCB3b24ndCBzdGFydCBhcyBmb3Igc29tZSBjbG91ZAojIHByb3ZpZGVycyBzd2FwIGdldHMgZW5hYmxlZCBvbiByZWJvb3Qgb3IgYWZ0ZXIgdGhlIHNldHVwIHNjcmlwdCBoYXMgZmluaXNoZWQgZXhlY3V0aW5nLgpzZWQgLWkub3JpZyAnLy4qc3dhcC4qL2QnIC9ldGMvZnN0YWIKc3dhcG9mZiAtYQo=

- path: '/etc/crictl.yaml'
  content: |-
    runtime-endpoint: unix:///run/containerd/containerd.sock
    

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/containerd/config.toml'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    dmVyc2lvbiA9IDIKClttZXRyaWNzXQphZGRyZXNzID0gIjEyNy4wLjAuMToxMzM4IgoKW3BsdWdpbnNdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIl0Kc2FuZGJveF9pbWFnZSA9ICIxOTIuMTY4LjEwMC4xMDA6NTAwMC9rdWJlcm5ldGVzL3BhdXNlOnYzLjEiCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5jb250YWluZXJkXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIuY29udGFpbmVyZC5ydW50aW1lc10KW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuY10KcnVudGltZV90eXBlID0gImlvLmNvbnRhaW5lcmQucnVuYy52MiIKW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuYy5vcHRpb25zXQpTeXN0ZW1kQ2dyb3VwID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnldCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5taXJyb3JzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkubWlycm9ycy4iZG9ja2VyLmlvIl0KZW5kcG9pbnQgPSBbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTAuMC4wLjE6NTAwMCJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzLiIxMC4wLjAuMTo1MDAwIi50bHNdCmluc2VjdXJlX3NraXBfdmVyaWZ5ID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiLnRsc10KaW5zZWN1cmVfc2tpcF92ZXJpZnkgPSB0cnVlCgo=

rh_subscription:
    auto-attach: false
    password: 
    username:  immutable: true kind: Secret metadata: diff --git a/pkg/controllers/osc/testdata/secret-rhel-8.x-containerd.yaml b/pkg/controllers/osc/testdata/secret-rhel-8.x-containerd.yaml index 125a5b12..c81c2dc1 100644 --- a/pkg/controllers/osc/testdata/secret-rhel-8.x-containerd.yaml +++ b/pkg/controllers/osc/testdata/secret-rhel-8.x-containerd.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdGFibGVzCm1vZHByb2JlIGlwX3ZzCm1vZHByb2JlIGlwX3ZzX3JyCm1vZHByb2JlIGlwX3ZzX3dycgptb2Rwcm9iZSBpcF92c19zaAoKaWYgbW9kaW5mbyBuZl9jb25udHJhY2tfaXB2NCAmPiAvZGV2L251bGw7IHRoZW4KICBtb2Rwcm9iZSBuZl9jb25udHJhY2tfaXB2NAplbHNlCiAgbW9kcHJvYmUgbmZfY29ubnRyYWNrCmZpCg==

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/selinux/config'
  encoding: 'b64'
  content: |-
    IyBUaGlzIGZpbGUgY29udHJvbHMgdGhlIHN0YXRlIG9mIFNFTGludXggb24gdGhlIHN5c3RlbS4KIyBTRUxJTlVYPSBjYW4gdGFrZSBvbmUgb2YgdGhlc2UgdGhyZWUgdmFsdWVzOgojICAgICBlbmZvcmNpbmcgLSBTRUxpbnV4IHNlY3VyaXR5IHBvbGljeSBpcyBlbmZvcmNlZC4KIyAgICAgcGVybWlzc2l2ZSAtIFNFTGludXggcHJpbnRzIHdhcm5pbmdzIGluc3RlYWQgb2YgZW5mb3JjaW5nLgojICAgICBkaXNhYmxlZCAtIE5vIFNFTGludXggcG9saWN5IGlzIGxvYWRlZC4KU0VMSU5VWD1wZXJtaXNzaXZlCiMgU0VMSU5VWFRZUEU9IGNhbiB0YWtlIG9uZSBvZiB0aHJlZSB0d28gdmFsdWVzOgojICAgICB0YXJnZXRlZCAtIFRhcmdldGVkIHByb2Nlc3NlcyBhcmUgcHJvdGVjdGVkLAojICAgICBtaW5pbXVtIC0gTW9kaWZpY2F0aW9uIG9mIHRhcmdldGVkIHBvbGljeS4gT25seSBzZWxlY3RlZCBwcm9jZXNzZXMgYXJlIHByb3RlY3RlZC4KIyAgICAgbWxzIC0gTXVsdGkgTGV2ZWwgU2VjdXJpdHkgcHJvdGVjdGlvbi4KU0VMSU5VWFRZUEU9dGFyZ2V0ZWQK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWNvbnRhaW5lcmQuc2VydmljZQpSZXF1aXJlcz1jb250YWluZXJkLnNlcnZpY2UKCkRlc2NyaXB0aW9uPWt1YmVsZXQ6IFRoZSBLdWJlcm5ldGVzIE5vZGUgQWdlbnQKRG9jdW1lbnRhdGlvbj1odHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy9ob21lLwoKW1NlcnZpY2VdClVzZXI9cm9vdApSZXN0YXJ0PWFsd2F5cwpTdGFydExpbWl0SW50ZXJ2YWw9MApSZXN0YXJ0U2VjPTEwCkNQVUFjY291bnRpbmc9dHJ1ZQpNZW1vcnlBY2NvdW50aW5nPXRydWUKCkVudmlyb25tZW50PSJQQVRIPS9vcHQvYmluOi9iaW46L3Vzci9sb2NhbC9zYmluOi91c3IvbG9jYWwvYmluOi91c3Ivc2JpbjovdXNyL2Jpbjovc2Jpbi8iCkVudmlyb25tZW50RmlsZT0tL2V0Yy9lbnZpcm9ubWVudAoKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2xvYWQta2VybmVsLW1vZHVsZXMuc2gKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Jpbi9zZXR1cF9uZXRfZW52LnNoCkV4ZWNTdGFydD0vb3B0L2Jpbi9rdWJlbGV0ICRLVUJFTEVUX0VYVFJBX0FSR1MgXAogIC0tYm9vdHN0cmFwLWt1YmVjb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Jvb3RzdHJhcC1rdWJlbGV0LmNvbmYgXAogIC0ta3ViZWNvbmZpZz0vdmFyL2xpYi9rdWJlbGV0L2t1YmVjb25maWcgXAogIC0tY29uZmlnPS9ldGMva3ViZXJuZXRlcy9rdWJlbGV0LmNvbmYgXAogIC0tbmV0d29yay1wbHVnaW49Y25pIFwKICAtLWNlcnQtZGlyPS9ldGMva3ViZXJuZXRlcy9wa2kgXAogIC0tY2xvdWQtcHJvdmlkZXI9YXdzIFwKICAtLWNsb3VkLWNvbmZpZz0vZXRjL2t1YmVybmV0ZXMvY2xvdWQtY29uZmlnIFwKICAtLWR5bmFtaWMtY29uZmlnLWRpcj0vZXRjL2t1YmVybmV0ZXMvZHluYW1pYy1jb25maWctZGlyIFwKICAtLWZlYXR1cmUtZ2F0ZXM9RHluYW1pY0t1YmVsZXRDb25maWc9dHJ1ZSBcCiAgLS1leGl0LW9uLWxvY2stY29udGVudGlvbiBcCiAgLS1sb2NrLWZpbGU9L3RtcC9rdWJlbGV0LmxvY2sgXAogIC0tY29udGFpbmVyLXJ1bnRpbWU9cmVtb3RlIFwKICAtLWNvbnRhaW5lci1ydW50aW1lLWVuZHBvaW50PXVuaXg6Ly8vcnVuL2NvbnRhaW5lcmQvY29udGFpbmVyZC5zb2NrIFwKICAtLW5vZGUtaXAgJHtLVUJFTEVUX05PREVfSVB9CgpbSW5zdGFsbF0KV2FudGVkQnk9bXVsdGktdXNlci50YXJnZXQK

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    W2dsb2JhbF0KWm9uZT0iZXUtY2VudHJhbC0xYiIKVlBDPSJlLTEyM2YiClN1Ym5ldElEPSJ0ZXN0LXN1Ym5ldCIKCg==

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKIyBnZXQgdGhlIGZ1bGwgaG9zdG5hbWUKRlVMTF9IT1NUTkFNRT0kKGhvc3RuYW1lIC1mKQojIGlmIC9ldGMvaG9zdG5hbWUgaXMgbm90IGVtcHR5IHRoZW4gdXNlIHRoZSBob3N0bmFtZSBmcm9tIHRoZXJlCmlmIFsgLXMgL2V0Yy9ob3N0bmFtZSBdOyB0aGVuCiAgRlVMTF9IT1NUTkFNRT0kKGNhdCAvZXRjL2hvc3RuYW1lKQpmaQoKIyB3cml0ZSB0aGUgbm9kZWlwX2VudiBmaWxlCiMgd2UgbmVlZCB0aGUgbGluZSBiZWxvdyBiZWNhdXNlIGZsYXRjYXIgaGFzIHRoZSBzYW1lIHN0cmluZyAiY29yZW9zIiBpbiB0aGF0IGZpbGUKaWYgZ3JlcCAtcSBjb3Jlb3MgL2V0Yy9vcy1yZWxlYXNlCnRoZW4KICBlY2hvICJLVUJFTEVUX05PREVfSVA9JHtERUZBVUxUX0lGQ19JUH1cbktVQkVMRVRfSE9TVE5BTUU9JHtGVUxMX0hPU1ROQU1FfSIgPiAvZXRjL2t1YmVybmV0ZXMvbm9kZWlwLmNvbmYKZWxpZiBbICEgLWQgL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZCBdCnRoZW4KICBlY2hvZGF0ZSAiQ2FuJ3QgZmluZCBrdWJlbGV0IHNlcnZpY2UgZXh0cmFzIGRpcmVjdG9yeSIKICBleGl0IDEKZWxzZQogIGVjaG8gLWUgIltTZXJ2aWNlXVxuRW52aXJvbm1lbnQ9XCJLVUJFTEVUX05PREVfSVA9JHtERUZBVUxUX0lGQ19JUH1cIlxuRW52aXJvbm1lbnQ9XCJLVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX1cIiIgPiAvZXRjL3N5c3RlbWQvc3lzdGVtL2t1YmVsZXQuc2VydmljZS5kL25vZGVpcC5jb25mCmZpCg==

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKY29udGFpbmVyTG9nTWF4U2l6ZTogMTAwTWkKY29udGFpbmVyTG9nTWF4RmlsZXM6IDUKZmVhdHVyZUdhdGVzOgogIEdyYWNlZnVsTm9kZVNodXRkb3duOiB0cnVlCiAgSWRlbnRpZnlQb2RPUzogZmFsc2UKcHJvdGVjdEtlcm5lbERlZmF1bHRzOiB0cnVlCnJlYWRPbmx5UG9ydDogMApyb3RhdGVDZXJ0aWZpY2F0ZXM6IHRydWUKc2VydmVyVExTQm9vdHN0cmFwOiB0cnVlCnN0YXRpY1BvZFBhdGg6IC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMKa3ViZVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCnN5c3RlbVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCmV2aWN0aW9uSGFyZDoKICBpbWFnZWZzLmF2YWlsYWJsZTogMTUlCiAgbWVtb3J5LmF2YWlsYWJsZTogMTAwTWkKICBub2RlZnMuYXZhaWxhYmxlOiAxMCUKICBub2RlZnMuaW5vZGVzRnJlZTogNSUKdGxzQ2lwaGVyU3VpdGVzOgotIFRMU19BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0NIQUNIQTIwX1BPTFkxMzA1X1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1Ci0gVExTX0VDREhFX1JTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfUlNBX1dJVEhfQ0hBQ0hBMjBfUE9MWTEzMDUKdm9sdW1lUGx1Z2luRGlyOiAvdmFyL2xpYi9rdWJlbGV0L3ZvbHVtZXBsdWdpbnMK

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/etc/crictl.yaml'
  content: |-
    runtime-endpoint: unix:///run/containerd/containerd.sock
    

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/containerd/config.toml'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    dmVyc2lvbiA9IDIKClttZXRyaWNzXQphZGRyZXNzID0gIjEyNy4wLjAuMToxMzM4IgoKW3BsdWdpbnNdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIl0Kc2FuZGJveF9pbWFnZSA9ICIxOTIuMTY4LjEwMC4xMDA6NTAwMC9rdWJlcm5ldGVzL3BhdXNlOnYzLjEiCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5jb250YWluZXJkXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIuY29udGFpbmVyZC5ydW50aW1lc10KW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuY10KcnVudGltZV90eXBlID0gImlvLmNvbnRhaW5lcmQucnVuYy52MiIKW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuYy5vcHRpb25zXQpTeXN0ZW1kQ2dyb3VwID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnldCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5taXJyb3JzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkubWlycm9ycy4iZG9ja2VyLmlvIl0KZW5kcG9pbnQgPSBbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTAuMC4wLjE6NTAwMCJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzLiIxMC4wLjAuMTo1MDAwIi50bHNdCmluc2VjdXJlX3NraXBfdmVyaWZ5ID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiLnRsc10KaW5zZWN1cmVfc2tpcF92ZXJpZnkgPSB0cnVlCgo=

rh_subscription:
    auto-attach: false
    password: 
    username:  + cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdGFibGVzCm1vZHByb2JlIGlwX3ZzCm1vZHByb2JlIGlwX3ZzX3JyCm1vZHByb2JlIGlwX3ZzX3dycgptb2Rwcm9iZSBpcF92c19zaAoKaWYgbW9kaW5mbyBuZl9jb25udHJhY2tfaXB2NCAmPiAvZGV2L251bGw7IHRoZW4KICBtb2Rwcm9iZSBuZl9jb25udHJhY2tfaXB2NAplbHNlCiAgbW9kcHJvYmUgbmZfY29ubnRyYWNrCmZpCg==

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/selinux/config'
  encoding: 'b64'
  content: |-
    IyBUaGlzIGZpbGUgY29udHJvbHMgdGhlIHN0YXRlIG9mIFNFTGludXggb24gdGhlIHN5c3RlbS4KIyBTRUxJTlVYPSBjYW4gdGFrZSBvbmUgb2YgdGhlc2UgdGhyZWUgdmFsdWVzOgojICAgICBlbmZvcmNpbmcgLSBTRUxpbnV4IHNlY3VyaXR5IHBvbGljeSBpcyBlbmZvcmNlZC4KIyAgICAgcGVybWlzc2l2ZSAtIFNFTGludXggcHJpbnRzIHdhcm5pbmdzIGluc3RlYWQgb2YgZW5mb3JjaW5nLgojICAgICBkaXNhYmxlZCAtIE5vIFNFTGludXggcG9saWN5IGlzIGxvYWRlZC4KU0VMSU5VWD1wZXJtaXNzaXZlCiMgU0VMSU5VWFRZUEU9IGNhbiB0YWtlIG9uZSBvZiB0aHJlZSB0d28gdmFsdWVzOgojICAgICB0YXJnZXRlZCAtIFRhcmdldGVkIHByb2Nlc3NlcyBhcmUgcHJvdGVjdGVkLAojICAgICBtaW5pbXVtIC0gTW9kaWZpY2F0aW9uIG9mIHRhcmdldGVkIHBvbGljeS4gT25seSBzZWxlY3RlZCBwcm9jZXNzZXMgYXJlIHByb3RlY3RlZC4KIyAgICAgbWxzIC0gTXVsdGkgTGV2ZWwgU2VjdXJpdHkgcHJvdGVjdGlvbi4KU0VMSU5VWFRZUEU9dGFyZ2V0ZWQK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWNvbnRhaW5lcmQuc2VydmljZQpSZXF1aXJlcz1jb250YWluZXJkLnNlcnZpY2UKCkRlc2NyaXB0aW9uPWt1YmVsZXQ6IFRoZSBLdWJlcm5ldGVzIE5vZGUgQWdlbnQKRG9jdW1lbnRhdGlvbj1odHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy9ob21lLwoKW1NlcnZpY2VdClVzZXI9cm9vdApSZXN0YXJ0PWFsd2F5cwpTdGFydExpbWl0SW50ZXJ2YWw9MApSZXN0YXJ0U2VjPTEwCkNQVUFjY291bnRpbmc9dHJ1ZQpNZW1vcnlBY2NvdW50aW5nPXRydWUKCkVudmlyb25tZW50PSJQQVRIPS9vcHQvYmluOi9iaW46L3Vzci9sb2NhbC9zYmluOi91c3IvbG9jYWwvYmluOi91c3Ivc2JpbjovdXNyL2Jpbjovc2Jpbi8iCkVudmlyb25tZW50RmlsZT0tL2V0Yy9lbnZpcm9ubWVudAoKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Rpc2FibGUtc3dhcC5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvbG9hZC1rZXJuZWwtbW9kdWxlcy5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvYmluL3NldHVwX25ldF9lbnYuc2gKRXhlY1N0YXJ0PS9vcHQvYmluL2t1YmVsZXQgJEtVQkVMRVRfRVhUUkFfQVJHUyBcCiAgLS1ib290c3RyYXAta3ViZWNvbmZpZz0vZXRjL2t1YmVybmV0ZXMvYm9vdHN0cmFwLWt1YmVsZXQuY29uZiBcCiAgLS1rdWJlY29uZmlnPS92YXIvbGliL2t1YmVsZXQva3ViZWNvbmZpZyBcCiAgLS1jb25maWc9L2V0Yy9rdWJlcm5ldGVzL2t1YmVsZXQuY29uZiBcCiAgLS1uZXR3b3JrLXBsdWdpbj1jbmkgXAogIC0tY2VydC1kaXI9L2V0Yy9rdWJlcm5ldGVzL3BraSBcCiAgLS1jbG91ZC1wcm92aWRlcj1hd3MgXAogIC0tY2xvdWQtY29uZmlnPS9ldGMva3ViZXJuZXRlcy9jbG91ZC1jb25maWcgXAogIC0tZHluYW1pYy1jb25maWctZGlyPS9ldGMva3ViZXJuZXRlcy9keW5hbWljLWNvbmZpZy1kaXIgXAogIC0tZmVhdHVyZS1nYXRlcz1EeW5hbWljS3ViZWxldENvbmZpZz10cnVlIFwKICAtLWV4aXQtb24tbG9jay1jb250ZW50aW9uIFwKICAtLWxvY2stZmlsZT0vdG1wL2t1YmVsZXQubG9jayBcCiAgLS1jb250YWluZXItcnVudGltZT1yZW1vdGUgXAogIC0tY29udGFpbmVyLXJ1bnRpbWUtZW5kcG9pbnQ9dW5peDovLy9ydW4vY29udGFpbmVyZC9jb250YWluZXJkLnNvY2sgXAogIC0tbm9kZS1pcCAke0tVQkVMRVRfTk9ERV9JUH0KCltJbnN0YWxsXQpXYW50ZWRCeT1tdWx0aS11c2VyLnRhcmdldAo=

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    W2dsb2JhbF0KWm9uZT0iZXUtY2VudHJhbC0xYiIKVlBDPSJlLTEyM2YiClN1Ym5ldElEPSJ0ZXN0LXN1Ym5ldCIKCg==

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKIyBnZXQgdGhlIGZ1bGwgaG9zdG5hbWUKRlVMTF9IT1NUTkFNRT0kKGhvc3RuYW1lIC1mKQojIGlmIC9ldGMvaG9zdG5hbWUgaXMgbm90IGVtcHR5IHRoZW4gdXNlIHRoZSBob3N0bmFtZSBmcm9tIHRoZXJlCmlmIFsgLXMgL2V0Yy9ob3N0bmFtZSBdOyB0aGVuCiAgRlVMTF9IT1NUTkFNRT0kKGNhdCAvZXRjL2hvc3RuYW1lKQpmaQoKIyB3cml0ZSB0aGUgbm9kZWlwX2VudiBmaWxlCiMgd2UgbmVlZCB0aGUgbGluZSBiZWxvdyBiZWNhdXNlIGZsYXRjYXIgaGFzIHRoZSBzYW1lIHN0cmluZyAiY29yZW9zIiBpbiB0aGF0IGZpbGUKaWYgZ3JlcCAtcSBjb3Jlb3MgL2V0Yy9vcy1yZWxlYXNlCnRoZW4KICBlY2hvICJLVUJFTEVUX05PREVfSVA9JHtERUZBVUxUX0lGQ19JUH1cbktVQkVMRVRfSE9TVE5BTUU9JHtGVUxMX0hPU1ROQU1FfSIgPiAvZXRjL2t1YmVybmV0ZXMvbm9kZWlwLmNvbmYKZWxpZiBbICEgLWQgL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZCBdCnRoZW4KICBlY2hvZGF0ZSAiQ2FuJ3QgZmluZCBrdWJlbGV0IHNlcnZpY2UgZXh0cmFzIGRpcmVjdG9yeSIKICBleGl0IDEKZWxzZQogIGVjaG8gLWUgIltTZXJ2aWNlXVxuRW52aXJvbm1lbnQ9XCJLVUJFTEVUX05PREVfSVA9JHtERUZBVUxUX0lGQ19JUH1cIlxuRW52aXJvbm1lbnQ9XCJLVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX1cIiIgPiAvZXRjL3N5c3RlbWQvc3lzdGVtL2t1YmVsZXQuc2VydmljZS5kL25vZGVpcC5jb25mCmZpCg==

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKY29udGFpbmVyTG9nTWF4U2l6ZTogMTAwTWkKY29udGFpbmVyTG9nTWF4RmlsZXM6IDUKZmVhdHVyZUdhdGVzOgogIEdyYWNlZnVsTm9kZVNodXRkb3duOiB0cnVlCiAgSWRlbnRpZnlQb2RPUzogZmFsc2UKcHJvdGVjdEtlcm5lbERlZmF1bHRzOiB0cnVlCnJlYWRPbmx5UG9ydDogMApyb3RhdGVDZXJ0aWZpY2F0ZXM6IHRydWUKc2VydmVyVExTQm9vdHN0cmFwOiB0cnVlCnN0YXRpY1BvZFBhdGg6IC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMKa3ViZVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCnN5c3RlbVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCmV2aWN0aW9uSGFyZDoKICBpbWFnZWZzLmF2YWlsYWJsZTogMTUlCiAgbWVtb3J5LmF2YWlsYWJsZTogMTAwTWkKICBub2RlZnMuYXZhaWxhYmxlOiAxMCUKICBub2RlZnMuaW5vZGVzRnJlZTogNSUKdGxzQ2lwaGVyU3VpdGVzOgotIFRMU19BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0NIQUNIQTIwX1BPTFkxMzA1X1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1Ci0gVExTX0VDREhFX1JTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfUlNBX1dJVEhfQ0hBQ0hBMjBfUE9MWTEzMDUKdm9sdW1lUGx1Z2luRGlyOiAvdmFyL2xpYi9rdWJlbGV0L3ZvbHVtZXBsdWdpbnMK

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/opt/disable-swap.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKIyBNYWtlIHN1cmUgd2UgYWx3YXlzIGRpc2FibGUgc3dhcCAtIE90aGVyd2lzZSB0aGUga3ViZWxldCB3b24ndCBzdGFydCBhcyBmb3Igc29tZSBjbG91ZAojIHByb3ZpZGVycyBzd2FwIGdldHMgZW5hYmxlZCBvbiByZWJvb3Qgb3IgYWZ0ZXIgdGhlIHNldHVwIHNjcmlwdCBoYXMgZmluaXNoZWQgZXhlY3V0aW5nLgpzZWQgLWkub3JpZyAnLy4qc3dhcC4qL2QnIC9ldGMvZnN0YWIKc3dhcG9mZiAtYQo=

- path: '/etc/crictl.yaml'
  content: |-
    runtime-endpoint: unix:///run/containerd/containerd.sock
    

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/containerd/config.toml'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    dmVyc2lvbiA9IDIKClttZXRyaWNzXQphZGRyZXNzID0gIjEyNy4wLjAuMToxMzM4IgoKW3BsdWdpbnNdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIl0Kc2FuZGJveF9pbWFnZSA9ICIxOTIuMTY4LjEwMC4xMDA6NTAwMC9rdWJlcm5ldGVzL3BhdXNlOnYzLjEiCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5jb250YWluZXJkXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIuY29udGFpbmVyZC5ydW50aW1lc10KW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuY10KcnVudGltZV90eXBlID0gImlvLmNvbnRhaW5lcmQucnVuYy52MiIKW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuYy5vcHRpb25zXQpTeXN0ZW1kQ2dyb3VwID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnldCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5taXJyb3JzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkubWlycm9ycy4iZG9ja2VyLmlvIl0KZW5kcG9pbnQgPSBbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTAuMC4wLjE6NTAwMCJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzLiIxMC4wLjAuMTo1MDAwIi50bHNdCmluc2VjdXJlX3NraXBfdmVyaWZ5ID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiLnRsc10KaW5zZWN1cmVfc2tpcF92ZXJpZnkgPSB0cnVlCgo=

rh_subscription:
    auto-attach: false
    password: 
    username:  immutable: true kind: Secret metadata: diff --git a/pkg/controllers/osc/testdata/secret-ubuntu-aws-containerd.yaml b/pkg/controllers/osc/testdata/secret-ubuntu-aws-containerd.yaml index d51f92d8..4f8ac79f 100644 --- a/pkg/controllers/osc/testdata/secret-ubuntu-aws-containerd.yaml +++ b/pkg/controllers/osc/testdata/secret-ubuntu-aws-containerd.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdnMKbW9kcHJvYmUgaXBfdnNfcnIKbW9kcHJvYmUgaXBfdnNfd3JyCm1vZHByb2JlIGlwX3ZzX3NoCgppZiBtb2RpbmZvIG5mX2Nvbm50cmFja19pcHY0ICY+IC9kZXYvbnVsbDsgdGhlbgogIG1vZHByb2JlIG5mX2Nvbm50cmFja19pcHY0CmVsc2UKICBtb2Rwcm9iZSBuZl9jb25udHJhY2sKZmkK

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/default/grub.d/60-swap-accounting.cfg'
  encoding: 'b64'
  content: |-
    IyBBZGRlZCBieSBrdWJlcm1hdGljIG1hY2hpbmUtY29udHJvbGxlcgojIEVuYWJsZSBjZ3JvdXBzIG1lbW9yeSBhbmQgc3dhcCBhY2NvdW50aW5nCkdSVUJfQ01ETElORV9MSU5VWD0iY2dyb3VwX2VuYWJsZT1tZW1vcnkgc3dhcGFjY291bnQ9MSIK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWNvbnRhaW5lcmQuc2VydmljZQpSZXF1aXJlcz1jb250YWluZXJkLnNlcnZpY2UKCkRlc2NyaXB0aW9uPWt1YmVsZXQ6IFRoZSBLdWJlcm5ldGVzIE5vZGUgQWdlbnQKRG9jdW1lbnRhdGlvbj1odHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy9ob21lLwoKW1NlcnZpY2VdClVzZXI9cm9vdApSZXN0YXJ0PWFsd2F5cwpTdGFydExpbWl0SW50ZXJ2YWw9MApSZXN0YXJ0U2VjPTEwCkNQVUFjY291bnRpbmc9dHJ1ZQpNZW1vcnlBY2NvdW50aW5nPXRydWUKCkVudmlyb25tZW50PSJQQVRIPS9vcHQvYmluOi9iaW46L3Vzci9sb2NhbC9zYmluOi91c3IvbG9jYWwvYmluOi91c3Ivc2JpbjovdXNyL2Jpbjovc2Jpbi8iCkVudmlyb25tZW50RmlsZT0tL2V0Yy9lbnZpcm9ubWVudAoKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2xvYWQta2VybmVsLW1vZHVsZXMuc2gKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Jpbi9zZXR1cF9uZXRfZW52LnNoCkV4ZWNTdGFydD0vb3B0L2Jpbi9rdWJlbGV0ICRLVUJFTEVUX0VYVFJBX0FSR1MgXAogIC0tYm9vdHN0cmFwLWt1YmVjb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Jvb3RzdHJhcC1rdWJlbGV0LmNvbmYgXAogIC0ta3ViZWNvbmZpZz0vdmFyL2xpYi9rdWJlbGV0L2t1YmVjb25maWcgXAogIC0tY29uZmlnPS9ldGMva3ViZXJuZXRlcy9rdWJlbGV0LmNvbmYgXAogIC0tY2VydC1kaXI9L2V0Yy9rdWJlcm5ldGVzL3BraSBcCiAgLS1jbG91ZC1wcm92aWRlcj1hd3MgXAogIC0tY2xvdWQtY29uZmlnPS9ldGMva3ViZXJuZXRlcy9jbG91ZC1jb25maWcgXAogIC0tZXhpdC1vbi1sb2NrLWNvbnRlbnRpb24gXAogIC0tbG9jay1maWxlPS90bXAva3ViZWxldC5sb2NrIFwKICAtLWNvbnRhaW5lci1ydW50aW1lPXJlbW90ZSBcCiAgLS1jb250YWluZXItcnVudGltZS1lbmRwb2ludD11bml4Oi8vL3J1bi9jb250YWluZXJkL2NvbnRhaW5lcmQuc29jayBcCiAgLS1ub2RlLWlwICR7S1VCRUxFVF9OT0RFX0lQfQoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/etc/systemd/system/kubelet.service.d/extras.conf'
  encoding: 'b64'
  content: |-
    W1NlcnZpY2VdCkVudmlyb25tZW50PSJLVUJFTEVUX0VYVFJBX0FSR1M9LS1yZXNvbHYtY29uZj0vcnVuL3N5c3RlbWQvcmVzb2x2ZS9yZXNvbHYuY29uZiIK

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    W2dsb2JhbF0KWm9uZT0iZXUtY2VudHJhbC0xYiIKVlBDPSJlLTEyM2YiClN1Ym5ldElEPSJ0ZXN0LXN1Ym5ldCIKCg==

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKCiMgZ2V0IHRoZSBmdWxsIGhvc3RuYW1lCkZVTExfSE9TVE5BTUU9JChob3N0bmFtZSAtZikKIyBpZiAvZXRjL2hvc3RuYW1lIGlzIG5vdCBlbXB0eSB0aGVuIHVzZSB0aGUgaG9zdG5hbWUgZnJvbSB0aGVyZQppZiBbIC1zIC9ldGMvaG9zdG5hbWUgXTsgdGhlbgogIEZVTExfSE9TVE5BTUU9JChjYXQgL2V0Yy9ob3N0bmFtZSkKZmkKCiMgd3JpdGUgdGhlIG5vZGVpcF9lbnYgZmlsZQojIHdlIG5lZWQgdGhlIGxpbmUgYmVsb3cgYmVjYXVzZSBmbGF0Y2FyIGhhcyB0aGUgc2FtZSBzdHJpbmcgImNvcmVvcyIgaW4gdGhhdCBmaWxlCmlmIGdyZXAgLXEgY29yZW9zIC9ldGMvb3MtcmVsZWFzZQp0aGVuCiAgZWNobyAiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XG5LVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX0iID4gL2V0Yy9rdWJlcm5ldGVzL25vZGVpcC5jb25mCmVsaWYgWyAhIC1kIC9ldGMvc3lzdGVtZC9zeXN0ZW0va3ViZWxldC5zZXJ2aWNlLmQgXQp0aGVuCiAgZWNob2RhdGUgIkNhbid0IGZpbmQga3ViZWxldCBzZXJ2aWNlIGV4dHJhcyBkaXJlY3RvcnkiCiAgZXhpdCAxCmVsc2UKICBlY2hvIC1lICJbU2VydmljZV1cbkVudmlyb25tZW50PVwiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XCJcbkVudmlyb25tZW50PVwiS1VCRUxFVF9IT1NUTkFNRT0ke0ZVTExfSE9TVE5BTUV9XCIiID4gL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZC9ub2RlaXAuY29uZgpmaQo=

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKY29udGFpbmVyTG9nTWF4U2l6ZTogMTAwTWkKY29udGFpbmVyTG9nTWF4RmlsZXM6IDUKZmVhdHVyZUdhdGVzOgogIEdyYWNlZnVsTm9kZVNodXRkb3duOiB0cnVlCiAgSWRlbnRpZnlQb2RPUzogZmFsc2UKcHJvdGVjdEtlcm5lbERlZmF1bHRzOiB0cnVlCnJlYWRPbmx5UG9ydDogMApyb3RhdGVDZXJ0aWZpY2F0ZXM6IHRydWUKc2VydmVyVExTQm9vdHN0cmFwOiB0cnVlCnN0YXRpY1BvZFBhdGg6IC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMKa3ViZVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCnN5c3RlbVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCmV2aWN0aW9uSGFyZDoKICBpbWFnZWZzLmF2YWlsYWJsZTogMTUlCiAgbWVtb3J5LmF2YWlsYWJsZTogMTAwTWkKICBub2RlZnMuYXZhaWxhYmxlOiAxMCUKICBub2RlZnMuaW5vZGVzRnJlZTogNSUKdGxzQ2lwaGVyU3VpdGVzOgotIFRMU19BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0NIQUNIQTIwX1BPTFkxMzA1X1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1Ci0gVExTX0VDREhFX1JTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfUlNBX1dJVEhfQ0hBQ0hBMjBfUE9MWTEzMDUKdm9sdW1lUGx1Z2luRGlyOiAvdmFyL2xpYi9rdWJlbGV0L3ZvbHVtZXBsdWdpbnMK

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/etc/crictl.yaml'
  content: |-
    runtime-endpoint: unix:///run/containerd/containerd.sock
    

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/containerd/config.toml'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    dmVyc2lvbiA9IDIKClttZXRyaWNzXQphZGRyZXNzID0gIjEyNy4wLjAuMToxMzM4IgoKW3BsdWdpbnNdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIl0Kc2FuZGJveF9pbWFnZSA9ICIxOTIuMTY4LjEwMC4xMDA6NTAwMC9rdWJlcm5ldGVzL3BhdXNlOnYzLjEiCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5jb250YWluZXJkXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIuY29udGFpbmVyZC5ydW50aW1lc10KW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuY10KcnVudGltZV90eXBlID0gImlvLmNvbnRhaW5lcmQucnVuYy52MiIKW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuYy5vcHRpb25zXQpTeXN0ZW1kQ2dyb3VwID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnldCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5taXJyb3JzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkubWlycm9ycy4iZG9ja2VyLmlvIl0KZW5kcG9pbnQgPSBbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTAuMC4wLjE6NTAwMCJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzLiIxMC4wLjAuMTo1MDAwIi50bHNdCmluc2VjdXJlX3NraXBfdmVyaWZ5ID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiLnRsc10KaW5zZWN1cmVfc2tpcF92ZXJpZnkgPSB0cnVlCgo=
 + cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdnMKbW9kcHJvYmUgaXBfdnNfcnIKbW9kcHJvYmUgaXBfdnNfd3JyCm1vZHByb2JlIGlwX3ZzX3NoCgppZiBtb2RpbmZvIG5mX2Nvbm50cmFja19pcHY0ICY+IC9kZXYvbnVsbDsgdGhlbgogIG1vZHByb2JlIG5mX2Nvbm50cmFja19pcHY0CmVsc2UKICBtb2Rwcm9iZSBuZl9jb25udHJhY2sKZmkK

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/default/grub.d/60-swap-accounting.cfg'
  encoding: 'b64'
  content: |-
    IyBBZGRlZCBieSBrdWJlcm1hdGljIG1hY2hpbmUtY29udHJvbGxlcgojIEVuYWJsZSBjZ3JvdXBzIG1lbW9yeSBhbmQgc3dhcCBhY2NvdW50aW5nCkdSVUJfQ01ETElORV9MSU5VWD0iY2dyb3VwX2VuYWJsZT1tZW1vcnkgc3dhcGFjY291bnQ9MSIK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWNvbnRhaW5lcmQuc2VydmljZQpSZXF1aXJlcz1jb250YWluZXJkLnNlcnZpY2UKCkRlc2NyaXB0aW9uPWt1YmVsZXQ6IFRoZSBLdWJlcm5ldGVzIE5vZGUgQWdlbnQKRG9jdW1lbnRhdGlvbj1odHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy9ob21lLwoKW1NlcnZpY2VdClVzZXI9cm9vdApSZXN0YXJ0PWFsd2F5cwpTdGFydExpbWl0SW50ZXJ2YWw9MApSZXN0YXJ0U2VjPTEwCkNQVUFjY291bnRpbmc9dHJ1ZQpNZW1vcnlBY2NvdW50aW5nPXRydWUKCkVudmlyb25tZW50PSJQQVRIPS9vcHQvYmluOi9iaW46L3Vzci9sb2NhbC9zYmluOi91c3IvbG9jYWwvYmluOi91c3Ivc2JpbjovdXNyL2Jpbjovc2Jpbi8iCkVudmlyb25tZW50RmlsZT0tL2V0Yy9lbnZpcm9ubWVudAoKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Rpc2FibGUtc3dhcC5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvbG9hZC1rZXJuZWwtbW9kdWxlcy5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvYmluL3NldHVwX25ldF9lbnYuc2gKRXhlY1N0YXJ0PS9vcHQvYmluL2t1YmVsZXQgJEtVQkVMRVRfRVhUUkFfQVJHUyBcCiAgLS1ib290c3RyYXAta3ViZWNvbmZpZz0vZXRjL2t1YmVybmV0ZXMvYm9vdHN0cmFwLWt1YmVsZXQuY29uZiBcCiAgLS1rdWJlY29uZmlnPS92YXIvbGliL2t1YmVsZXQva3ViZWNvbmZpZyBcCiAgLS1jb25maWc9L2V0Yy9rdWJlcm5ldGVzL2t1YmVsZXQuY29uZiBcCiAgLS1jZXJ0LWRpcj0vZXRjL2t1YmVybmV0ZXMvcGtpIFwKICAtLWNsb3VkLXByb3ZpZGVyPWF3cyBcCiAgLS1jbG91ZC1jb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Nsb3VkLWNvbmZpZyBcCiAgLS1leGl0LW9uLWxvY2stY29udGVudGlvbiBcCiAgLS1sb2NrLWZpbGU9L3RtcC9rdWJlbGV0LmxvY2sgXAogIC0tY29udGFpbmVyLXJ1bnRpbWU9cmVtb3RlIFwKICAtLWNvbnRhaW5lci1ydW50aW1lLWVuZHBvaW50PXVuaXg6Ly8vcnVuL2NvbnRhaW5lcmQvY29udGFpbmVyZC5zb2NrIFwKICAtLW5vZGUtaXAgJHtLVUJFTEVUX05PREVfSVB9CgpbSW5zdGFsbF0KV2FudGVkQnk9bXVsdGktdXNlci50YXJnZXQK

- path: '/etc/systemd/system/kubelet.service.d/extras.conf'
  encoding: 'b64'
  content: |-
    W1NlcnZpY2VdCkVudmlyb25tZW50PSJLVUJFTEVUX0VYVFJBX0FSR1M9LS1yZXNvbHYtY29uZj0vcnVuL3N5c3RlbWQvcmVzb2x2ZS9yZXNvbHYuY29uZiIK

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    W2dsb2JhbF0KWm9uZT0iZXUtY2VudHJhbC0xYiIKVlBDPSJlLTEyM2YiClN1Ym5ldElEPSJ0ZXN0LXN1Ym5ldCIKCg==

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKCiMgZ2V0IHRoZSBmdWxsIGhvc3RuYW1lCkZVTExfSE9TVE5BTUU9JChob3N0bmFtZSAtZikKIyBpZiAvZXRjL2hvc3RuYW1lIGlzIG5vdCBlbXB0eSB0aGVuIHVzZSB0aGUgaG9zdG5hbWUgZnJvbSB0aGVyZQppZiBbIC1zIC9ldGMvaG9zdG5hbWUgXTsgdGhlbgogIEZVTExfSE9TVE5BTUU9JChjYXQgL2V0Yy9ob3N0bmFtZSkKZmkKCiMgd3JpdGUgdGhlIG5vZGVpcF9lbnYgZmlsZQojIHdlIG5lZWQgdGhlIGxpbmUgYmVsb3cgYmVjYXVzZSBmbGF0Y2FyIGhhcyB0aGUgc2FtZSBzdHJpbmcgImNvcmVvcyIgaW4gdGhhdCBmaWxlCmlmIGdyZXAgLXEgY29yZW9zIC9ldGMvb3MtcmVsZWFzZQp0aGVuCiAgZWNobyAiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XG5LVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX0iID4gL2V0Yy9rdWJlcm5ldGVzL25vZGVpcC5jb25mCmVsaWYgWyAhIC1kIC9ldGMvc3lzdGVtZC9zeXN0ZW0va3ViZWxldC5zZXJ2aWNlLmQgXQp0aGVuCiAgZWNob2RhdGUgIkNhbid0IGZpbmQga3ViZWxldCBzZXJ2aWNlIGV4dHJhcyBkaXJlY3RvcnkiCiAgZXhpdCAxCmVsc2UKICBlY2hvIC1lICJbU2VydmljZV1cbkVudmlyb25tZW50PVwiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XCJcbkVudmlyb25tZW50PVwiS1VCRUxFVF9IT1NUTkFNRT0ke0ZVTExfSE9TVE5BTUV9XCIiID4gL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZC9ub2RlaXAuY29uZgpmaQo=

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKY29udGFpbmVyTG9nTWF4U2l6ZTogMTAwTWkKY29udGFpbmVyTG9nTWF4RmlsZXM6IDUKZmVhdHVyZUdhdGVzOgogIEdyYWNlZnVsTm9kZVNodXRkb3duOiB0cnVlCiAgSWRlbnRpZnlQb2RPUzogZmFsc2UKcHJvdGVjdEtlcm5lbERlZmF1bHRzOiB0cnVlCnJlYWRPbmx5UG9ydDogMApyb3RhdGVDZXJ0aWZpY2F0ZXM6IHRydWUKc2VydmVyVExTQm9vdHN0cmFwOiB0cnVlCnN0YXRpY1BvZFBhdGg6IC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMKa3ViZVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCnN5c3RlbVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCmV2aWN0aW9uSGFyZDoKICBpbWFnZWZzLmF2YWlsYWJsZTogMTUlCiAgbWVtb3J5LmF2YWlsYWJsZTogMTAwTWkKICBub2RlZnMuYXZhaWxhYmxlOiAxMCUKICBub2RlZnMuaW5vZGVzRnJlZTogNSUKdGxzQ2lwaGVyU3VpdGVzOgotIFRMU19BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0NIQUNIQTIwX1BPTFkxMzA1X1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1Ci0gVExTX0VDREhFX1JTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfUlNBX1dJVEhfQ0hBQ0hBMjBfUE9MWTEzMDUKdm9sdW1lUGx1Z2luRGlyOiAvdmFyL2xpYi9rdWJlbGV0L3ZvbHVtZXBsdWdpbnMK

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/opt/disable-swap.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKIyBNYWtlIHN1cmUgd2UgYWx3YXlzIGRpc2FibGUgc3dhcCAtIE90aGVyd2lzZSB0aGUga3ViZWxldCB3b24ndCBzdGFydCBhcyBmb3Igc29tZSBjbG91ZAojIHByb3ZpZGVycyBzd2FwIGdldHMgZW5hYmxlZCBvbiByZWJvb3Qgb3IgYWZ0ZXIgdGhlIHNldHVwIHNjcmlwdCBoYXMgZmluaXNoZWQgZXhlY3V0aW5nLgpzZWQgLWkub3JpZyAnLy4qc3dhcC4qL2QnIC9ldGMvZnN0YWIKc3dhcG9mZiAtYQo=

- path: '/etc/crictl.yaml'
  content: |-
    runtime-endpoint: unix:///run/containerd/containerd.sock
    

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/containerd/config.toml'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    dmVyc2lvbiA9IDIKClttZXRyaWNzXQphZGRyZXNzID0gIjEyNy4wLjAuMToxMzM4IgoKW3BsdWdpbnNdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIl0Kc2FuZGJveF9pbWFnZSA9ICIxOTIuMTY4LjEwMC4xMDA6NTAwMC9rdWJlcm5ldGVzL3BhdXNlOnYzLjEiCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5jb250YWluZXJkXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIuY29udGFpbmVyZC5ydW50aW1lc10KW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuY10KcnVudGltZV90eXBlID0gImlvLmNvbnRhaW5lcmQucnVuYy52MiIKW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuYy5vcHRpb25zXQpTeXN0ZW1kQ2dyb3VwID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnldCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5taXJyb3JzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkubWlycm9ycy4iZG9ja2VyLmlvIl0KZW5kcG9pbnQgPSBbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTAuMC4wLjE6NTAwMCJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzLiIxMC4wLjAuMTo1MDAwIi50bHNdCmluc2VjdXJlX3NraXBfdmVyaWZ5ID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiLnRsc10KaW5zZWN1cmVfc2tpcF92ZXJpZnkgPSB0cnVlCgo=
 immutable: true kind: Secret metadata: diff --git a/pkg/controllers/osc/testdata/secret-ubuntu-aws-docker.yaml b/pkg/controllers/osc/testdata/secret-ubuntu-aws-docker.yaml index 30807d86..af77960b 100644 --- a/pkg/controllers/osc/testdata/secret-ubuntu-aws-docker.yaml +++ b/pkg/controllers/osc/testdata/secret-ubuntu-aws-docker.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdnMKbW9kcHJvYmUgaXBfdnNfcnIKbW9kcHJvYmUgaXBfdnNfd3JyCm1vZHByb2JlIGlwX3ZzX3NoCgppZiBtb2RpbmZvIG5mX2Nvbm50cmFja19pcHY0ICY+IC9kZXYvbnVsbDsgdGhlbgogIG1vZHByb2JlIG5mX2Nvbm50cmFja19pcHY0CmVsc2UKICBtb2Rwcm9iZSBuZl9jb25udHJhY2sKZmkK

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/default/grub.d/60-swap-accounting.cfg'
  encoding: 'b64'
  content: |-
    IyBBZGRlZCBieSBrdWJlcm1hdGljIG1hY2hpbmUtY29udHJvbGxlcgojIEVuYWJsZSBjZ3JvdXBzIG1lbW9yeSBhbmQgc3dhcCBhY2NvdW50aW5nCkdSVUJfQ01ETElORV9MSU5VWD0iY2dyb3VwX2VuYWJsZT1tZW1vcnkgc3dhcGFjY291bnQ9MSIK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWRvY2tlci5zZXJ2aWNlClJlcXVpcmVzPWRvY2tlci5zZXJ2aWNlCgpEZXNjcmlwdGlvbj1rdWJlbGV0OiBUaGUgS3ViZXJuZXRlcyBOb2RlIEFnZW50CkRvY3VtZW50YXRpb249aHR0cHM6Ly9rdWJlcm5ldGVzLmlvL2RvY3MvaG9tZS8KCltTZXJ2aWNlXQpVc2VyPXJvb3QKUmVzdGFydD1hbHdheXMKU3RhcnRMaW1pdEludGVydmFsPTAKUmVzdGFydFNlYz0xMApDUFVBY2NvdW50aW5nPXRydWUKTWVtb3J5QWNjb3VudGluZz10cnVlCgpFbnZpcm9ubWVudD0iUEFUSD0vb3B0L2JpbjovYmluOi91c3IvbG9jYWwvc2JpbjovdXNyL2xvY2FsL2JpbjovdXNyL3NiaW46L3Vzci9iaW46L3NiaW4vIgpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKCkV4ZWNTdGFydFByZT0vYmluL2Jhc2ggL29wdC9sb2FkLWtlcm5lbC1tb2R1bGVzLnNoCkV4ZWNTdGFydFByZT0vYmluL2Jhc2ggL29wdC9iaW4vc2V0dXBfbmV0X2Vudi5zaApFeGVjU3RhcnQ9L29wdC9iaW4va3ViZWxldCAkS1VCRUxFVF9FWFRSQV9BUkdTIFwKICAtLWJvb3RzdHJhcC1rdWJlY29uZmlnPS9ldGMva3ViZXJuZXRlcy9ib290c3RyYXAta3ViZWxldC5jb25mIFwKICAtLWt1YmVjb25maWc9L3Zhci9saWIva3ViZWxldC9rdWJlY29uZmlnIFwKICAtLWNvbmZpZz0vZXRjL2t1YmVybmV0ZXMva3ViZWxldC5jb25mIFwKICAtLW5ldHdvcmstcGx1Z2luPWNuaSBcCiAgLS1jZXJ0LWRpcj0vZXRjL2t1YmVybmV0ZXMvcGtpIFwKICAtLWNsb3VkLXByb3ZpZGVyPWF3cyBcCiAgLS1jbG91ZC1jb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Nsb3VkLWNvbmZpZyBcCiAgLS1keW5hbWljLWNvbmZpZy1kaXI9L2V0Yy9rdWJlcm5ldGVzL2R5bmFtaWMtY29uZmlnLWRpciBcCiAgLS1mZWF0dXJlLWdhdGVzPUR5bmFtaWNLdWJlbGV0Q29uZmlnPXRydWUgXAogIC0tZXhpdC1vbi1sb2NrLWNvbnRlbnRpb24gXAogIC0tbG9jay1maWxlPS90bXAva3ViZWxldC5sb2NrIFwKICAtLWNvbnRhaW5lci1ydW50aW1lPWRvY2tlciBcCiAgLS1jb250YWluZXItcnVudGltZS1lbmRwb2ludD11bml4Oi8vL3Zhci9ydW4vZG9ja2Vyc2hpbS5zb2NrIFwKICAtLW5vZGUtaXAgJHtLVUJFTEVUX05PREVfSVB9CgpbSW5zdGFsbF0KV2FudGVkQnk9bXVsdGktdXNlci50YXJnZXQK

- path: '/etc/systemd/system/kubelet.service.d/extras.conf'
  encoding: 'b64'
  content: |-
    W1NlcnZpY2VdCkVudmlyb25tZW50PSJLVUJFTEVUX0VYVFJBX0FSR1M9LS1yZXNvbHYtY29uZj0vcnVuL3N5c3RlbWQvcmVzb2x2ZS9yZXNvbHYuY29uZiIK

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    W2dsb2JhbF0KWm9uZT0iZXUtY2VudHJhbC0xYiIKVlBDPSJlLTEyM2YiClN1Ym5ldElEPSJ0ZXN0LXN1Ym5ldCIKCg==

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKCiMgZ2V0IHRoZSBmdWxsIGhvc3RuYW1lCkZVTExfSE9TVE5BTUU9JChob3N0bmFtZSAtZikKIyBpZiAvZXRjL2hvc3RuYW1lIGlzIG5vdCBlbXB0eSB0aGVuIHVzZSB0aGUgaG9zdG5hbWUgZnJvbSB0aGVyZQppZiBbIC1zIC9ldGMvaG9zdG5hbWUgXTsgdGhlbgogIEZVTExfSE9TVE5BTUU9JChjYXQgL2V0Yy9ob3N0bmFtZSkKZmkKCiMgd3JpdGUgdGhlIG5vZGVpcF9lbnYgZmlsZQojIHdlIG5lZWQgdGhlIGxpbmUgYmVsb3cgYmVjYXVzZSBmbGF0Y2FyIGhhcyB0aGUgc2FtZSBzdHJpbmcgImNvcmVvcyIgaW4gdGhhdCBmaWxlCmlmIGdyZXAgLXEgY29yZW9zIC9ldGMvb3MtcmVsZWFzZQp0aGVuCiAgZWNobyAiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XG5LVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX0iID4gL2V0Yy9rdWJlcm5ldGVzL25vZGVpcC5jb25mCmVsaWYgWyAhIC1kIC9ldGMvc3lzdGVtZC9zeXN0ZW0va3ViZWxldC5zZXJ2aWNlLmQgXQp0aGVuCiAgZWNob2RhdGUgIkNhbid0IGZpbmQga3ViZWxldCBzZXJ2aWNlIGV4dHJhcyBkaXJlY3RvcnkiCiAgZXhpdCAxCmVsc2UKICBlY2hvIC1lICJbU2VydmljZV1cbkVudmlyb25tZW50PVwiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XCJcbkVudmlyb25tZW50PVwiS1VCRUxFVF9IT1NUTkFNRT0ke0ZVTExfSE9TVE5BTUV9XCIiID4gL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZC9ub2RlaXAuY29uZgpmaQo=

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKZmVhdHVyZUdhdGVzOgogIEdyYWNlZnVsTm9kZVNodXRkb3duOiB0cnVlCiAgSWRlbnRpZnlQb2RPUzogZmFsc2UKcHJvdGVjdEtlcm5lbERlZmF1bHRzOiB0cnVlCnJlYWRPbmx5UG9ydDogMApyb3RhdGVDZXJ0aWZpY2F0ZXM6IHRydWUKc2VydmVyVExTQm9vdHN0cmFwOiB0cnVlCnN0YXRpY1BvZFBhdGg6IC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMKa3ViZVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCnN5c3RlbVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCmV2aWN0aW9uSGFyZDoKICBpbWFnZWZzLmF2YWlsYWJsZTogMTUlCiAgbWVtb3J5LmF2YWlsYWJsZTogMTAwTWkKICBub2RlZnMuYXZhaWxhYmxlOiAxMCUKICBub2RlZnMuaW5vZGVzRnJlZTogNSUKdGxzQ2lwaGVyU3VpdGVzOgotIFRMU19BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0NIQUNIQTIwX1BPTFkxMzA1X1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1Ci0gVExTX0VDREhFX1JTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfUlNBX1dJVEhfQ0hBQ0hBMjBfUE9MWTEzMDUKdm9sdW1lUGx1Z2luRGlyOiAvdmFyL2xpYi9rdWJlbGV0L3ZvbHVtZXBsdWdpbnMK

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/systemd/system/docker.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/docker/daemon.json'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    eyJleGVjLW9wdHMiOlsibmF0aXZlLmNncm91cGRyaXZlcj1zeXN0ZW1kIl0sInN0b3JhZ2UtZHJpdmVyIjoib3ZlcmxheTIiLCJsb2ctZHJpdmVyIjoianNvbi1maWxlIiwibG9nLW9wdHMiOnsibWF4LWZpbGUiOiI1IiwibWF4LXNpemUiOiIxMDBtIn0sImluc2VjdXJlLXJlZ2lzdHJpZXMiOlsiMTkyLjE2OC4xMDAuMTAwOjUwMDAiLCIxMC4wLjAuMTo1MDAwIl0sInJlZ2lzdHJ5LW1pcnJvcnMiOlsiaHR0cHM6Ly9yZWdpc3RyeS5kb2NrZXItY24uY29tIl19

- path: '/root/.docker/config.json'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    
 + cloud-config: #cloud-config

ssh_pwauth: no
ssh_authorized_keys:
- 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c'
write_files:
- path: '/opt/bin/health-monitor.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/journald.conf.d/max_disk_use.conf'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

- path: '/opt/load-kernel-modules.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKbW9kcHJvYmUgaXBfdnMKbW9kcHJvYmUgaXBfdnNfcnIKbW9kcHJvYmUgaXBfdnNfd3JyCm1vZHByb2JlIGlwX3ZzX3NoCgppZiBtb2RpbmZvIG5mX2Nvbm50cmFja19pcHY0ICY+IC9kZXYvbnVsbDsgdGhlbgogIG1vZHByb2JlIG5mX2Nvbm50cmFja19pcHY0CmVsc2UKICBtb2Rwcm9iZSBuZl9jb25udHJhY2sKZmkK

- path: '/etc/sysctl.d/k8s.conf'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQp2bS5vdmVyY29tbWl0X21lbW9yeSA9IDEKZnMuaW5vdGlmeS5tYXhfdXNlcl93YXRjaGVzID0gMTA0ODU3Ngpmcy5pbm90aWZ5Lm1heF91c2VyX2luc3RhbmNlcyA9IDgxOTIK

- path: '/etc/default/grub.d/60-swap-accounting.cfg'
  encoding: 'b64'
  content: |-
    IyBBZGRlZCBieSBrdWJlcm1hdGljIG1hY2hpbmUtY29udHJvbGxlcgojIEVuYWJsZSBjZ3JvdXBzIG1lbW9yeSBhbmQgc3dhcCBhY2NvdW50aW5nCkdSVUJfQ01ETElORV9MSU5VWD0iY2dyb3VwX2VuYWJsZT1tZW1vcnkgc3dhcGFjY291bnQ9MSIK

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    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

- path: '/opt/bin/supervise.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCndoaWxlICEgIiRAIjsgZG8KICBzbGVlcCAxCmRvbmUK

- path: '/etc/systemd/system/kubelet.service'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWRvY2tlci5zZXJ2aWNlClJlcXVpcmVzPWRvY2tlci5zZXJ2aWNlCgpEZXNjcmlwdGlvbj1rdWJlbGV0OiBUaGUgS3ViZXJuZXRlcyBOb2RlIEFnZW50CkRvY3VtZW50YXRpb249aHR0cHM6Ly9rdWJlcm5ldGVzLmlvL2RvY3MvaG9tZS8KCltTZXJ2aWNlXQpVc2VyPXJvb3QKUmVzdGFydD1hbHdheXMKU3RhcnRMaW1pdEludGVydmFsPTAKUmVzdGFydFNlYz0xMApDUFVBY2NvdW50aW5nPXRydWUKTWVtb3J5QWNjb3VudGluZz10cnVlCgpFbnZpcm9ubWVudD0iUEFUSD0vb3B0L2JpbjovYmluOi91c3IvbG9jYWwvc2JpbjovdXNyL2xvY2FsL2JpbjovdXNyL3NiaW46L3Vzci9iaW46L3NiaW4vIgpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKCkV4ZWNTdGFydFByZT0vYmluL2Jhc2ggL29wdC9kaXNhYmxlLXN3YXAuc2gKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2xvYWQta2VybmVsLW1vZHVsZXMuc2gKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Jpbi9zZXR1cF9uZXRfZW52LnNoCkV4ZWNTdGFydD0vb3B0L2Jpbi9rdWJlbGV0ICRLVUJFTEVUX0VYVFJBX0FSR1MgXAogIC0tYm9vdHN0cmFwLWt1YmVjb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Jvb3RzdHJhcC1rdWJlbGV0LmNvbmYgXAogIC0ta3ViZWNvbmZpZz0vdmFyL2xpYi9rdWJlbGV0L2t1YmVjb25maWcgXAogIC0tY29uZmlnPS9ldGMva3ViZXJuZXRlcy9rdWJlbGV0LmNvbmYgXAogIC0tbmV0d29yay1wbHVnaW49Y25pIFwKICAtLWNlcnQtZGlyPS9ldGMva3ViZXJuZXRlcy9wa2kgXAogIC0tY2xvdWQtcHJvdmlkZXI9YXdzIFwKICAtLWNsb3VkLWNvbmZpZz0vZXRjL2t1YmVybmV0ZXMvY2xvdWQtY29uZmlnIFwKICAtLWR5bmFtaWMtY29uZmlnLWRpcj0vZXRjL2t1YmVybmV0ZXMvZHluYW1pYy1jb25maWctZGlyIFwKICAtLWZlYXR1cmUtZ2F0ZXM9RHluYW1pY0t1YmVsZXRDb25maWc9dHJ1ZSBcCiAgLS1leGl0LW9uLWxvY2stY29udGVudGlvbiBcCiAgLS1sb2NrLWZpbGU9L3RtcC9rdWJlbGV0LmxvY2sgXAogIC0tY29udGFpbmVyLXJ1bnRpbWU9ZG9ja2VyIFwKICAtLWNvbnRhaW5lci1ydW50aW1lLWVuZHBvaW50PXVuaXg6Ly8vdmFyL3J1bi9kb2NrZXJzaGltLnNvY2sgXAogIC0tbm9kZS1pcCAke0tVQkVMRVRfTk9ERV9JUH0KCltJbnN0YWxsXQpXYW50ZWRCeT1tdWx0aS11c2VyLnRhcmdldAo=

- path: '/etc/systemd/system/kubelet.service.d/extras.conf'
  encoding: 'b64'
  content: |-
    W1NlcnZpY2VdCkVudmlyb25tZW50PSJLVUJFTEVUX0VYVFJBX0FSR1M9LS1yZXNvbHYtY29uZj0vcnVuL3N5c3RlbWQvcmVzb2x2ZS9yZXNvbHYuY29uZiIK

- path: '/etc/kubernetes/cloud-config'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    W2dsb2JhbF0KWm9uZT0iZXUtY2VudHJhbC0xYiIKVlBDPSJlLTEyM2YiClN1Ym5ldElEPSJ0ZXN0LXN1Ym5ldCIKCg==

- path: '/opt/bin/setup_net_env.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaAplY2hvZGF0ZSgpIHsKICBlY2hvICJbJChkYXRlIC1JcyldIiAiJEAiCn0KCiMgZ2V0IHRoZSBkZWZhdWx0IGludGVyZmFjZSBJUCBhZGRyZXNzCkRFRkFVTFRfSUZDX0lQPSQoaXAgLW8gIHJvdXRlIGdldCAxIHwgZ3JlcCAtb1AgInNyYyBcS1xTKyIpCgppZiBbIC16ICIke0RFRkFVTFRfSUZDX0lQfSIgXQp0aGVuCiAgZWNob2RhdGUgIkZhaWxlZCB0byBnZXQgSVAgYWRkcmVzcyBmb3IgdGhlIGRlZmF1bHQgcm91dGUgaW50ZXJmYWNlIgogIGV4aXQgMQpmaQoKCiMgZ2V0IHRoZSBmdWxsIGhvc3RuYW1lCkZVTExfSE9TVE5BTUU9JChob3N0bmFtZSAtZikKIyBpZiAvZXRjL2hvc3RuYW1lIGlzIG5vdCBlbXB0eSB0aGVuIHVzZSB0aGUgaG9zdG5hbWUgZnJvbSB0aGVyZQppZiBbIC1zIC9ldGMvaG9zdG5hbWUgXTsgdGhlbgogIEZVTExfSE9TVE5BTUU9JChjYXQgL2V0Yy9ob3N0bmFtZSkKZmkKCiMgd3JpdGUgdGhlIG5vZGVpcF9lbnYgZmlsZQojIHdlIG5lZWQgdGhlIGxpbmUgYmVsb3cgYmVjYXVzZSBmbGF0Y2FyIGhhcyB0aGUgc2FtZSBzdHJpbmcgImNvcmVvcyIgaW4gdGhhdCBmaWxlCmlmIGdyZXAgLXEgY29yZW9zIC9ldGMvb3MtcmVsZWFzZQp0aGVuCiAgZWNobyAiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XG5LVUJFTEVUX0hPU1ROQU1FPSR7RlVMTF9IT1NUTkFNRX0iID4gL2V0Yy9rdWJlcm5ldGVzL25vZGVpcC5jb25mCmVsaWYgWyAhIC1kIC9ldGMvc3lzdGVtZC9zeXN0ZW0va3ViZWxldC5zZXJ2aWNlLmQgXQp0aGVuCiAgZWNob2RhdGUgIkNhbid0IGZpbmQga3ViZWxldCBzZXJ2aWNlIGV4dHJhcyBkaXJlY3RvcnkiCiAgZXhpdCAxCmVsc2UKICBlY2hvIC1lICJbU2VydmljZV1cbkVudmlyb25tZW50PVwiS1VCRUxFVF9OT0RFX0lQPSR7REVGQVVMVF9JRkNfSVB9XCJcbkVudmlyb25tZW50PVwiS1VCRUxFVF9IT1NUTkFNRT0ke0ZVTExfSE9TVE5BTUV9XCIiID4gL2V0Yy9zeXN0ZW1kL3N5c3RlbS9rdWJlbGV0LnNlcnZpY2UuZC9ub2RlaXAuY29uZgpmaQo=

- path: '/etc/kubernetes/pki/ca.crt'
  encoding: 'b64'
  content: |-
    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

- path: '/etc/systemd/system/setup.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0CgpbVW5pdF0KUmVxdWlyZXM9bmV0d29yay1vbmxpbmUudGFyZ2V0CkFmdGVyPW5ldHdvcmstb25saW5lLnRhcmdldAoKW1NlcnZpY2VdClR5cGU9b25lc2hvdApSZW1haW5BZnRlckV4aXQ9dHJ1ZQpFbnZpcm9ubWVudEZpbGU9LS9ldGMvZW52aXJvbm1lbnQKRXhlY1N0YXJ0PS9vcHQvYmluL3N1cGVydmlzZS5zaCAvb3B0L2Jpbi9zZXR1cAo=

- path: '/etc/profile.d/opt-bin-path.sh'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    ZXhwb3J0IFBBVEg9Ii9vcHQvYmluOiRQQVRIIgo=

- path: '/etc/kubernetes/kubelet.conf'
  encoding: 'b64'
  content: |-
    YXBpVmVyc2lvbjoga3ViZWxldC5jb25maWcuazhzLmlvL3YxYmV0YTEKa2luZDogS3ViZWxldENvbmZpZ3VyYXRpb24KYXV0aGVudGljYXRpb246CiAgYW5vbnltb3VzOgogICAgZW5hYmxlZDogZmFsc2UKICB3ZWJob29rOgogICAgZW5hYmxlZDogdHJ1ZQogIHg1MDk6CiAgICBjbGllbnRDQUZpbGU6IC9ldGMva3ViZXJuZXRlcy9wa2kvY2EuY3J0CmF1dGhvcml6YXRpb246CiAgbW9kZTogV2ViaG9vawpjZ3JvdXBEcml2ZXI6IHN5c3RlbWQKY2x1c3RlckROUzoKLSAiMTAuMC4wLjAiCmNsdXN0ZXJEb21haW46IGNsdXN0ZXIubG9jYWwKZmVhdHVyZUdhdGVzOgogIEdyYWNlZnVsTm9kZVNodXRkb3duOiB0cnVlCiAgSWRlbnRpZnlQb2RPUzogZmFsc2UKcHJvdGVjdEtlcm5lbERlZmF1bHRzOiB0cnVlCnJlYWRPbmx5UG9ydDogMApyb3RhdGVDZXJ0aWZpY2F0ZXM6IHRydWUKc2VydmVyVExTQm9vdHN0cmFwOiB0cnVlCnN0YXRpY1BvZFBhdGg6IC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMKa3ViZVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCnN5c3RlbVJlc2VydmVkOgogIGNwdTogMjAwbQogIGVwaGVtZXJhbC1zdG9yYWdlOiAxR2kKICBtZW1vcnk6IDIwME1pCmV2aWN0aW9uSGFyZDoKICBpbWFnZWZzLmF2YWlsYWJsZTogMTUlCiAgbWVtb3J5LmF2YWlsYWJsZTogMTAwTWkKICBub2RlZnMuYXZhaWxhYmxlOiAxMCUKICBub2RlZnMuaW5vZGVzRnJlZTogNSUKdGxzQ2lwaGVyU3VpdGVzOgotIFRMU19BRVNfMTI4X0dDTV9TSEEyNTYKLSBUTFNfQUVTXzI1Nl9HQ01fU0hBMzg0Ci0gVExTX0NIQUNIQTIwX1BPTFkxMzA1X1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0FFU18yNTZfR0NNX1NIQTM4NAotIFRMU19FQ0RIRV9FQ0RTQV9XSVRIX0NIQUNIQTIwX1BPTFkxMzA1Ci0gVExTX0VDREhFX1JTQV9XSVRIX0FFU18xMjhfR0NNX1NIQTI1NgotIFRMU19FQ0RIRV9SU0FfV0lUSF9BRVNfMjU2X0dDTV9TSEEzODQKLSBUTFNfRUNESEVfUlNBX1dJVEhfQ0hBQ0hBMjBfUE9MWTEzMDUKdm9sdW1lUGx1Z2luRGlyOiAvdmFyL2xpYi9rdWJlbGV0L3ZvbHVtZXBsdWdpbnMK

- path: '/etc/systemd/system/kubelet-healthcheck.service'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdClJlcXVpcmVzPWt1YmVsZXQuc2VydmljZQpBZnRlcj1rdWJlbGV0LnNlcnZpY2UKCltTZXJ2aWNlXQpFeGVjU3RhcnQ9L29wdC9iaW4vaGVhbHRoLW1vbml0b3Iuc2gga3ViZWxldAoKW0luc3RhbGxdCldhbnRlZEJ5PW11bHRpLXVzZXIudGFyZ2V0Cg==

- path: '/opt/disable-swap.sh'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvdXNyL2Jpbi9lbnYgYmFzaApzZXQgLWV1byBwaXBlZmFpbAoKIyBNYWtlIHN1cmUgd2UgYWx3YXlzIGRpc2FibGUgc3dhcCAtIE90aGVyd2lzZSB0aGUga3ViZWxldCB3b24ndCBzdGFydCBhcyBmb3Igc29tZSBjbG91ZAojIHByb3ZpZGVycyBzd2FwIGdldHMgZW5hYmxlZCBvbiByZWJvb3Qgb3IgYWZ0ZXIgdGhlIHNldHVwIHNjcmlwdCBoYXMgZmluaXNoZWQgZXhlY3V0aW5nLgpzZWQgLWkub3JpZyAnLy4qc3dhcC4qL2QnIC9ldGMvZnN0YWIKc3dhcG9mZiAtYQo=

- path: '/etc/systemd/system/containerd.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/systemd/system/docker.service.d/environment.conf'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

- path: '/etc/docker/daemon.json'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    eyJleGVjLW9wdHMiOlsibmF0aXZlLmNncm91cGRyaXZlcj1zeXN0ZW1kIl0sInN0b3JhZ2UtZHJpdmVyIjoib3ZlcmxheTIiLCJsb2ctZHJpdmVyIjoianNvbi1maWxlIiwibG9nLW9wdHMiOnsibWF4LWZpbGUiOiI1IiwibWF4LXNpemUiOiIxMDBtIn0sImluc2VjdXJlLXJlZ2lzdHJpZXMiOlsiMTkyLjE2OC4xMDAuMTAwOjUwMDAiLCIxMC4wLjAuMTo1MDAwIl0sInJlZ2lzdHJ5LW1pcnJvcnMiOlsiaHR0cHM6Ly9yZWdpc3RyeS5kb2NrZXItY24uY29tIl19

- path: '/root/.docker/config.json'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    
 immutable: true kind: Secret metadata: diff --git a/pkg/crd/osm/v1alpha1/common_types.go b/pkg/crd/osm/v1alpha1/common_types.go index c84af8d8..79d42b1b 100644 --- a/pkg/crd/osm/v1alpha1/common_types.go +++ b/pkg/crd/osm/v1alpha1/common_types.go @@ -21,7 +21,7 @@ import ( ) // OperatingSystem represents supported operating system. -// +kubebuilder:validation:Enum=flatcar;rhel;centos;ubuntu;sles;amzn2 +// +kubebuilder:validation:Enum=flatcar;rhel;centos;ubuntu;sles;amzn2;rockylinux type OperatingSystem string const ( @@ -31,30 +31,32 @@ const ( OperatingSystemUbuntu OperatingSystem = "ubuntu" OperatingSystemSLES OperatingSystem = "sles" OperatingSystemAmazonLinux2 OperatingSystem = "amzn2" + OperatingSystemRockyLinux OperatingSystem = "rockylinux" ) // CloudProvider represents supported cloud provider. -// +kubebuilder:validation:Enum=aws;azure;digitalocean;gce;hetzner;kubevirt;linode;nutanix;openstack;equinixmetal;vsphere;fake;alibaba;anexia;scaleway;baremetal;external +// +kubebuilder:validation:Enum=aws;azure;digitalocean;gce;hetzner;kubevirt;linode;nutanix;openstack;equinixmetal;vsphere;fake;alibaba;anexia;scaleway;baremetal;external;vmware-cloud-director type CloudProvider string const ( - CloudProviderAlibaba CloudProvider = "alibaba" - CloudProviderAnexia CloudProvider = "anexia" - CloudProviderAWS CloudProvider = "aws" - CloudProviderAzure CloudProvider = "azure" - CloudProviderBaremetal CloudProvider = "baremetal" - CloudProviderDigitalocean CloudProvider = "digitalocean" - CloudProviderEquinixMetal CloudProvider = "equinixmetal" - CloudProviderExternal CloudProvider = "external" - CloudProviderFake CloudProvider = "fake" - CloudProviderGoogle CloudProvider = "gce" - CloudProviderHetzner CloudProvider = "hetzner" - CloudProviderKubeVirt CloudProvider = "kubevirt" - CloudProviderLinode CloudProvider = "linode" - CloudProviderNutanix CloudProvider = "nutanix" - CloudProviderOpenstack CloudProvider = "openstack" - CloudProviderVsphere CloudProvider = "vsphere" - CloudProviderScaleway CloudProvider = "scaleway" + CloudProviderAlibaba CloudProvider = "alibaba" + CloudProviderAnexia CloudProvider = "anexia" + CloudProviderAWS CloudProvider = "aws" + CloudProviderAzure CloudProvider = "azure" + CloudProviderBaremetal CloudProvider = "baremetal" + CloudProviderDigitalocean CloudProvider = "digitalocean" + CloudProviderEquinixMetal CloudProvider = "equinixmetal" + CloudProviderExternal CloudProvider = "external" + CloudProviderFake CloudProvider = "fake" + CloudProviderGoogle CloudProvider = "gce" + CloudProviderHetzner CloudProvider = "hetzner" + CloudProviderKubeVirt CloudProvider = "kubevirt" + CloudProviderLinode CloudProvider = "linode" + CloudProviderNutanix CloudProvider = "nutanix" + CloudProviderOpenstack CloudProvider = "openstack" + CloudProviderVsphere CloudProvider = "vsphere" + CloudProviderVMwareCloudDirector CloudProvider = "vmware-cloud-director" + CloudProviderScaleway CloudProvider = "scaleway" ) // ContainerRuntime represents supported container runtime diff --git a/pkg/providerconfig/rockylinux/rockylinux.go b/pkg/providerconfig/rockylinux/rockylinux.go new file mode 100644 index 00000000..94a5d1d0 --- /dev/null +++ b/pkg/providerconfig/rockylinux/rockylinux.go @@ -0,0 +1,47 @@ +/* +Copyright 2022 The Operating System Manager contributors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package rockylinux + +import ( + "encoding/json" + + "k8s.io/apimachinery/pkg/runtime" +) + +// Config contains specific configuration for Rocky Linux. +type Config struct { + DistUpgradeOnBoot bool `json:"distUpgradeOnBoot"` +} + +func DefaultConfig(operatingSystemSpec runtime.RawExtension) runtime.RawExtension { + if operatingSystemSpec.Raw == nil { + operatingSystemSpec.Raw, _ = json.Marshal(Config{}) + } + + return operatingSystemSpec +} + +// LoadConfig retrieves the Rocky Linux configuration from raw data. +func LoadConfig(r runtime.RawExtension) (*Config, error) { + r = DefaultConfig(r) + cfg := Config{} + + if err := json.Unmarshal(r.Raw, &cfg); err != nil { + return nil, err + } + return &cfg, nil +}