From 52a7ccdf52ea17ca9078776984e9df553aa147fc Mon Sep 17 00:00:00 2001 From: Waleed Malik Date: Thu, 18 Apr 2024 17:33:02 +0500 Subject: [PATCH] Upgrade k8s CNI to v1.4.1 (#375) Signed-off-by: Waleed Malik --- deploy/osps/default/osp-amzn2.yaml | 2 +- deploy/osps/default/osp-centos.yaml | 2 +- .../osps/default/osp-flatcar-cloud-init.yaml | 2 +- deploy/osps/default/osp-flatcar.yaml | 2 +- deploy/osps/default/osp-rhel.yaml | 2 +- deploy/osps/default/osp-rockylinux.yaml | 2 +- deploy/osps/default/osp-ubuntu.yaml | 2 +- .../testdata/osc-flatcar-aws-containerd.yaml | 2 +- .../osc-kubelet-configuration-containerd.yaml | 2 +- .../osc-rhel-8.x-azure-containerd.yaml | 2 +- .../osc-rhel-8.x-cloud-init-modules.yaml | 2 +- .../testdata/osc-ubuntu-aws-containerd.yaml | 2 +- .../osc-ubuntu-aws-dualstack-IPv6+IPv4.yaml | 2 +- .../testdata/osc-ubuntu-aws-dualstack.yaml | 2 +- .../osc/testdata/osc-ubuntu-aws.yaml | 1279 +++++++++-------- .../osp-rhel-aws-cloud-init-modules.yaml | 2 +- ...t-flatcar-aws-containerd-provisioning.yaml | 2 +- ...configuration-containerd-provisioning.yaml | 2 +- ...l-8.x-cloud-init-modules-provisioning.yaml | 2 +- ...hel-8.x-azure-containerd-provisioning.yaml | 2 +- ...et-ubuntu-aws-containerd-provisioning.yaml | 2 +- ...-aws-dualstack-IPv6+IPv4-provisioning.yaml | 2 +- ...ret-ubuntu-aws-dualstack-provisioning.yaml | 2 +- 23 files changed, 662 insertions(+), 661 deletions(-) diff --git a/deploy/osps/default/osp-amzn2.yaml b/deploy/osps/default/osp-amzn2.yaml index 7697e7ba..7c247f94 100644 --- a/deploy/osps/default/osp-amzn2.yaml +++ b/deploy/osps/default/osp-amzn2.yaml @@ -181,7 +181,7 @@ spec: fi {{- /* # CNI variables */}} - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" diff --git a/deploy/osps/default/osp-centos.yaml b/deploy/osps/default/osp-centos.yaml index bcecff6a..ce6c3f3f 100644 --- a/deploy/osps/default/osp-centos.yaml +++ b/deploy/osps/default/osp-centos.yaml @@ -202,7 +202,7 @@ spec: fi {{- /* # CNI variables */}} - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" diff --git a/deploy/osps/default/osp-flatcar-cloud-init.yaml b/deploy/osps/default/osp-flatcar-cloud-init.yaml index 925c4ef0..c4e11cc7 100644 --- a/deploy/osps/default/osp-flatcar-cloud-init.yaml +++ b/deploy/osps/default/osp-flatcar-cloud-init.yaml @@ -74,7 +74,7 @@ spec: fi {{- /* # CNI variables */}} - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" diff --git a/deploy/osps/default/osp-flatcar.yaml b/deploy/osps/default/osp-flatcar.yaml index 95acf49e..6c48f3b7 100644 --- a/deploy/osps/default/osp-flatcar.yaml +++ b/deploy/osps/default/osp-flatcar.yaml @@ -220,7 +220,7 @@ spec: fi {{- /* # CNI variables */}} - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" diff --git a/deploy/osps/default/osp-rhel.yaml b/deploy/osps/default/osp-rhel.yaml index 3c75d143..ac7d2566 100644 --- a/deploy/osps/default/osp-rhel.yaml +++ b/deploy/osps/default/osp-rhel.yaml @@ -192,7 +192,7 @@ spec: fi {{- /* # CNI variables */}} - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" diff --git a/deploy/osps/default/osp-rockylinux.yaml b/deploy/osps/default/osp-rockylinux.yaml index d8d8817e..cfb1a71c 100644 --- a/deploy/osps/default/osp-rockylinux.yaml +++ b/deploy/osps/default/osp-rockylinux.yaml @@ -196,7 +196,7 @@ spec: fi {{- /* # CNI variables */}} - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" diff --git a/deploy/osps/default/osp-ubuntu.yaml b/deploy/osps/default/osp-ubuntu.yaml index 18214efd..a03c529e 100644 --- a/deploy/osps/default/osp-ubuntu.yaml +++ b/deploy/osps/default/osp-ubuntu.yaml @@ -218,7 +218,7 @@ spec: fi {{- /* # CNI variables */}} - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" diff --git a/pkg/controllers/osc/testdata/osc-flatcar-aws-containerd.yaml b/pkg/controllers/osc/testdata/osc-flatcar-aws-containerd.yaml index fec9568b..714e3852 100644 --- a/pkg/controllers/osc/testdata/osc-flatcar-aws-containerd.yaml +++ b/pkg/controllers/osc/testdata/osc-flatcar-aws-containerd.yaml @@ -316,7 +316,7 @@ spec: ;; esac fi - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" curl -Lfo "$cni_bin_dir/$cni_filename" "$cni_base_url/$cni_filename" diff --git a/pkg/controllers/osc/testdata/osc-kubelet-configuration-containerd.yaml b/pkg/controllers/osc/testdata/osc-kubelet-configuration-containerd.yaml index d96c78bc..6964fc21 100644 --- a/pkg/controllers/osc/testdata/osc-kubelet-configuration-containerd.yaml +++ b/pkg/controllers/osc/testdata/osc-kubelet-configuration-containerd.yaml @@ -317,7 +317,7 @@ spec: ;; esac fi - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" curl -Lfo "$cni_bin_dir/$cni_filename" "$cni_base_url/$cni_filename" 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 46a9c3d9..39994ad3 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 @@ -343,7 +343,7 @@ spec: ;; esac fi - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" curl -Lfo "$cni_bin_dir/$cni_filename" "$cni_base_url/$cni_filename" diff --git a/pkg/controllers/osc/testdata/osc-rhel-8.x-cloud-init-modules.yaml b/pkg/controllers/osc/testdata/osc-rhel-8.x-cloud-init-modules.yaml index 29c8467e..7a5e6853 100644 --- a/pkg/controllers/osc/testdata/osc-rhel-8.x-cloud-init-modules.yaml +++ b/pkg/controllers/osc/testdata/osc-rhel-8.x-cloud-init-modules.yaml @@ -298,7 +298,7 @@ spec: ;; esac fi - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" curl -Lfo "$cni_bin_dir/$cni_filename" "$cni_base_url/$cni_filename" diff --git a/pkg/controllers/osc/testdata/osc-ubuntu-aws-containerd.yaml b/pkg/controllers/osc/testdata/osc-ubuntu-aws-containerd.yaml index b2fc78c6..696bfe67 100644 --- a/pkg/controllers/osc/testdata/osc-ubuntu-aws-containerd.yaml +++ b/pkg/controllers/osc/testdata/osc-ubuntu-aws-containerd.yaml @@ -317,7 +317,7 @@ spec: ;; esac fi - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" curl -Lfo "$cni_bin_dir/$cni_filename" "$cni_base_url/$cni_filename" diff --git a/pkg/controllers/osc/testdata/osc-ubuntu-aws-dualstack-IPv6+IPv4.yaml b/pkg/controllers/osc/testdata/osc-ubuntu-aws-dualstack-IPv6+IPv4.yaml index b1643710..67714413 100644 --- a/pkg/controllers/osc/testdata/osc-ubuntu-aws-dualstack-IPv6+IPv4.yaml +++ b/pkg/controllers/osc/testdata/osc-ubuntu-aws-dualstack-IPv6+IPv4.yaml @@ -316,7 +316,7 @@ spec: ;; esac fi - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" curl -Lfo "$cni_bin_dir/$cni_filename" "$cni_base_url/$cni_filename" diff --git a/pkg/controllers/osc/testdata/osc-ubuntu-aws-dualstack.yaml b/pkg/controllers/osc/testdata/osc-ubuntu-aws-dualstack.yaml index 14a4cebe..37088e71 100644 --- a/pkg/controllers/osc/testdata/osc-ubuntu-aws-dualstack.yaml +++ b/pkg/controllers/osc/testdata/osc-ubuntu-aws-dualstack.yaml @@ -316,7 +316,7 @@ spec: ;; esac fi - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" curl -Lfo "$cni_bin_dir/$cni_filename" "$cni_base_url/$cni_filename" diff --git a/pkg/controllers/osc/testdata/osc-ubuntu-aws.yaml b/pkg/controllers/osc/testdata/osc-ubuntu-aws.yaml index 2afc9101..4c5705e2 100644 --- a/pkg/controllers/osc/testdata/osc-ubuntu-aws.yaml +++ b/pkg/controllers/osc/testdata/osc-ubuntu-aws.yaml @@ -10,64 +10,65 @@ metadata: spec: bootstrapConfig: files: - - content: - inline: - data: | - #!/bin/bash - set -xeuo pipefail - while ! "$@"; do - sleep 1 - done - encoding: b64 - path: /opt/bin/supervise.sh - permissions: 755 - - content: - inline: - data: "#!/bin/bash\nset -xeuo pipefail\n\n# Check if bootstrap phase has - already completed. This is required when we run `cloud-init init` again - since it tries to re-run\n# the bootstrap cloud-config as well, from the - userdata.\nif [ -f /etc/bootstrap-complete ]; then\n exit 0\nfi\n\ncat - < /etc/cloud/cloud.cfg.d/ubuntu-aws-kube-system-provisioning-config.cfg\ncloud-init - clean\n\ncloud-init --file /etc/cloud/cloud.cfg.d/ubuntu-aws-kube-system-provisioning-config.cfg - init\nsystemctl daemon-reload\n\nsystemctl daemon-reload\n\n# cloud-init - should only run on the first boot. From this point forward we don't need - cloud-init anymore.\nsystemctl disable cloud-init\ntouch /etc/cloud/cloud-init.disabled\n\n# - Bootstrap phase for the machine is complete.\ntouch /etc/bootstrap-complete\nsystemctl - disable bootstrap.service\n\n# Start provisioning phase for the machine.\nsystemctl - restart setup.service\n" - encoding: b64 - path: /opt/bin/bootstrap - permissions: 755 - - content: - inline: - 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/bootstrap - encoding: b64 - path: /etc/systemd/system/bootstrap.service - permissions: 644 + - content: + inline: + data: | + #!/bin/bash + set -xeuo pipefail + while ! "$@"; do + sleep 1 + done + encoding: b64 + path: /opt/bin/supervise.sh + permissions: 755 + - content: + inline: + data: + "#!/bin/bash\nset -xeuo pipefail\n\n# Check if bootstrap phase has + already completed. This is required when we run `cloud-init init` again + since it tries to re-run\n# the bootstrap cloud-config as well, from the + userdata.\nif [ -f /etc/bootstrap-complete ]; then\n exit 0\nfi\n\ncat + < /etc/cloud/cloud.cfg.d/ubuntu-aws-kube-system-provisioning-config.cfg\ncloud-init + clean\n\ncloud-init --file /etc/cloud/cloud.cfg.d/ubuntu-aws-kube-system-provisioning-config.cfg + init\nsystemctl daemon-reload\n\nsystemctl daemon-reload\n\n# cloud-init + should only run on the first boot. From this point forward we don't need + cloud-init anymore.\nsystemctl disable cloud-init\ntouch /etc/cloud/cloud-init.disabled\n\n# + Bootstrap phase for the machine is complete.\ntouch /etc/bootstrap-complete\nsystemctl + disable bootstrap.service\n\n# Start provisioning phase for the machine.\nsystemctl + restart setup.service\n" + encoding: b64 + path: /opt/bin/bootstrap + permissions: 755 + - content: + inline: + 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/bootstrap + encoding: b64 + path: /etc/systemd/system/bootstrap.service + permissions: 644 modules: runcmd: - - systemctl restart bootstrap.service - - systemctl daemon-reload + - systemctl restart bootstrap.service + - systemctl daemon-reload userSSHKeys: - - ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c + - ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c cloudProvider: name: aws spec: @@ -78,595 +79,595 @@ spec: osVersion: "20.04" provisioningConfig: files: - - content: - inline: - data: | - #!/usr/bin/env bash - - # Copyright 2016 The Kubernetes Authors. - # - # 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. - - # This script is for master and node instance health monitoring, which is - # packed in kube-manifest tarball. It is executed through a systemd service - # in cluster/gce/gci/.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 + - content: + inline: + data: | + #!/usr/bin/env bash + + # Copyright 2016 The Kubernetes Authors. + # + # 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. + + # This script is for master and node instance health monitoring, which is + # packed in kube-manifest tarball. It is executed through a systemd service + # in cluster/gce/gci/.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 - 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 + # 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 - 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 + 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 + encoding: b64 + path: /opt/bin/health-monitor.sh + permissions: 755 + - content: + inline: + data: | + [Journal] + SystemMaxUse=5G + encoding: b64 + path: /etc/systemd/journald.conf.d/max_disk_use.conf + permissions: 644 + - content: + inline: + 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 + encoding: b64 + path: /opt/load-kernel-modules.sh + permissions: 755 + - content: + inline: + 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 + encoding: b64 + path: /etc/sysctl.d/k8s.conf + permissions: 644 + - content: + inline: + data: | + # Added by kubermatic machine-controller + # Enable cgroups memory and swap accounting + GRUB_CMDLINE_LINUX="cgroup_enable=memory swapaccount=1" + encoding: b64 + path: /etc/default/grub.d/60-swap-accounting.cfg + permissions: 644 + - content: + inline: + data: | + #!/bin/bash + set -xeuo pipefail + if systemctl is-active ufw; then systemctl stop ufw; fi + systemctl mask ufw + systemctl restart systemd-modules-load.service + sysctl --system + + # Override hostname if /etc/machine-name exists + if [ -x "$(command -v hostnamectl)" ] && [ -s /etc/machine-name ]; then + machine_name=$(cat /etc/machine-name) + hostnamectl set-hostname ${machine_name} + fi + + apt-get update + + DEBIAN_FRONTEND=noninteractive apt-get -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold" install -y \ + curl \ + ca-certificates \ + ceph-common \ + cifs-utils \ + conntrack \ + e2fsprogs \ + ebtables \ + ethtool \ + glusterfs-client \ + iptables \ + jq \ + kmod \ + openssh-client \ + nfs-common \ + socat \ + util-linux \ + ipvsadm + apt-get update + apt-get install -y apt-transport-https ca-certificates curl software-properties-common lsb-release + curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add - + add-apt-repository "deb https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" + + apt-get install -y --allow-downgrades containerd.io=1.6* + apt-mark hold containerd.io + + systemctl daemon-reload + systemctl enable --now containerd + + opt_bin=/opt/bin + usr_local_bin=/usr/local/bin + cni_bin_dir=/opt/cni/bin + mkdir -p /etc/cni/net.d /etc/kubernetes/manifests "$opt_bin" "$cni_bin_dir" + 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_VERSION="${CNI_VERSION:-v1.4.1}" + cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" + cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" + curl -Lfo "$cni_bin_dir/$cni_filename" "$cni_base_url/$cni_filename" + cni_sum=$(curl -Lf "$cni_base_url/$cni_filename.sha256") + cd "$cni_bin_dir" + sha256sum -c <<<"$cni_sum" + tar xvf "$cni_filename" + rm -f "$cni_filename" + cd - + CRI_TOOLS_RELEASE="${CRI_TOOLS_RELEASE:-v1.29.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" + curl -Lfo "$opt_bin/$cri_tools_filename" "$cri_tools_base_url/$cri_tools_filename" + cri_tools_sum_value=$(curl -Lf "$cri_tools_base_url/$cri_tools_filename.sha256") + cri_tools_sum="$cri_tools_sum_value $cri_tools_filename" + cd "$opt_bin" + sha256sum -c <<<"$cri_tools_sum" + 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 - + KUBE_VERSION="${KUBE_VERSION:-v1.29.0}" + kube_dir="$opt_bin/kubernetes-$KUBE_VERSION" + kube_base_url="https://dl.k8s.io/$KUBE_VERSION/bin/linux/$arch" + kube_sum_file="$kube_dir/sha256" + mkdir -p "$kube_dir" + : >"$kube_sum_file" + + for bin in kubelet kubeadm kubectl; do + curl -Lfo "$kube_dir/$bin" "$kube_base_url/$bin" + chmod +x "$kube_dir/$bin" + sum=$(curl -Lf "$kube_base_url/$bin.sha256") + echo "$sum $kube_dir/$bin" >>"$kube_sum_file" 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 + sha256sum -c "$kube_sum_file" - 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 + for bin in kubelet kubeadm kubectl; do + ln -sf "$kube_dir/$bin" "$opt_bin"/$bin 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 - encoding: b64 - path: /opt/bin/health-monitor.sh - permissions: 755 - - content: - inline: - data: | - [Journal] - SystemMaxUse=5G - encoding: b64 - path: /etc/systemd/journald.conf.d/max_disk_use.conf - permissions: 644 - - content: - inline: - 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 - encoding: b64 - path: /opt/load-kernel-modules.sh - permissions: 755 - - content: - inline: - 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 - encoding: b64 - path: /etc/sysctl.d/k8s.conf - permissions: 644 - - content: - inline: - data: | - # Added by kubermatic machine-controller - # Enable cgroups memory and swap accounting - GRUB_CMDLINE_LINUX="cgroup_enable=memory swapaccount=1" - encoding: b64 - path: /etc/default/grub.d/60-swap-accounting.cfg - permissions: 644 - - content: - inline: - data: | - #!/bin/bash - set -xeuo pipefail - if systemctl is-active ufw; then systemctl stop ufw; fi - systemctl mask ufw - systemctl restart systemd-modules-load.service - sysctl --system - - # Override hostname if /etc/machine-name exists - if [ -x "$(command -v hostnamectl)" ] && [ -s /etc/machine-name ]; then - machine_name=$(cat /etc/machine-name) - hostnamectl set-hostname ${machine_name} - fi - - apt-get update - - DEBIAN_FRONTEND=noninteractive apt-get -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold" install -y \ - curl \ - ca-certificates \ - ceph-common \ - cifs-utils \ - conntrack \ - e2fsprogs \ - ebtables \ - ethtool \ - glusterfs-client \ - iptables \ - jq \ - kmod \ - openssh-client \ - nfs-common \ - socat \ - util-linux \ - ipvsadm - apt-get update - apt-get install -y apt-transport-https ca-certificates curl software-properties-common lsb-release - curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add - - add-apt-repository "deb https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" - - apt-get install -y --allow-downgrades containerd.io=1.6* - apt-mark hold containerd.io - - systemctl daemon-reload - systemctl enable --now containerd - - opt_bin=/opt/bin - usr_local_bin=/usr/local/bin - cni_bin_dir=/opt/cni/bin - mkdir -p /etc/cni/net.d /etc/kubernetes/manifests "$opt_bin" "$cni_bin_dir" - arch=${HOST_ARCH-} - if [ -z "$arch" ] - then - case $(uname -m) in - x86_64) - arch="amd64" - ;; - aarch64) - arch="arm64" - ;; - *) - echo "unsupported CPU architecture, exiting" + + # set kubelet nodeip environment variable + /opt/bin/setup_net_env.sh + curl -s -k -v --header 'Authorization: Bearer top-secret' https://foo.bar:6443/api/v1/namespaces/cloud-init-settings/secrets/kube-system-ubuntu-aws-kubelet-bootstrap-config | jq '.data["kubeconfig"]' -r| base64 -d > /etc/kubernetes/bootstrap-kubelet.conf + + systemctl enable --now kubelet + systemctl enable --now --no-block kubelet-healthcheck.service + systemctl disable setup.service + encoding: b64 + path: /opt/bin/setup + permissions: 755 + - content: + inline: + data: | + [Unit] + After=containerd.service + Requires=containerd.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 \ + --bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf \ + --kubeconfig=/var/lib/kubelet/kubeconfig \ + --config=/etc/kubernetes/kubelet.conf \ + --cert-dir=/etc/kubernetes/pki \ + --cloud-provider=aws \ + --cloud-config=/etc/kubernetes/cloud-config \ + --exit-on-lock-contention \ + --lock-file=/tmp/kubelet.lock \ + --container-runtime-endpoint=unix:///run/containerd/containerd.sock \ + --node-ip ${KUBELET_NODE_IP} + + [Install] + WantedBy=multi-user.target + encoding: b64 + path: /etc/systemd/system/kubelet.service + permissions: 644 + - content: + inline: + data: |+ + [global] + Zone="eu-central-1b" + VPC="e-123f" + SubnetID="test-subnet" + + encoding: b64 + path: /etc/kubernetes/cloud-config + permissions: 600 + - content: + inline: + 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 - ;; - esac - fi - CNI_VERSION="${CNI_VERSION:-v1.2.0}" - cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" - cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" - curl -Lfo "$cni_bin_dir/$cni_filename" "$cni_base_url/$cni_filename" - cni_sum=$(curl -Lf "$cni_base_url/$cni_filename.sha256") - cd "$cni_bin_dir" - sha256sum -c <<<"$cni_sum" - tar xvf "$cni_filename" - rm -f "$cni_filename" - cd - - CRI_TOOLS_RELEASE="${CRI_TOOLS_RELEASE:-v1.29.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" - curl -Lfo "$opt_bin/$cri_tools_filename" "$cri_tools_base_url/$cri_tools_filename" - cri_tools_sum_value=$(curl -Lf "$cri_tools_base_url/$cri_tools_filename.sha256") - cri_tools_sum="$cri_tools_sum_value $cri_tools_filename" - cd "$opt_bin" - sha256sum -c <<<"$cri_tools_sum" - 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 - - KUBE_VERSION="${KUBE_VERSION:-v1.29.0}" - kube_dir="$opt_bin/kubernetes-$KUBE_VERSION" - kube_base_url="https://dl.k8s.io/$KUBE_VERSION/bin/linux/$arch" - kube_sum_file="$kube_dir/sha256" - mkdir -p "$kube_dir" - : >"$kube_sum_file" - - for bin in kubelet kubeadm kubectl; do - curl -Lfo "$kube_dir/$bin" "$kube_base_url/$bin" - chmod +x "$kube_dir/$bin" - sum=$(curl -Lf "$kube_base_url/$bin.sha256") - echo "$sum $kube_dir/$bin" >>"$kube_sum_file" - done - sha256sum -c "$kube_sum_file" - - for bin in kubelet kubeadm kubectl; do - ln -sf "$kube_dir/$bin" "$opt_bin"/$bin - done - - # set kubelet nodeip environment variable - /opt/bin/setup_net_env.sh - curl -s -k -v --header 'Authorization: Bearer top-secret' https://foo.bar:6443/api/v1/namespaces/cloud-init-settings/secrets/kube-system-ubuntu-aws-kubelet-bootstrap-config | jq '.data["kubeconfig"]' -r| base64 -d > /etc/kubernetes/bootstrap-kubelet.conf - - systemctl enable --now kubelet - systemctl enable --now --no-block kubelet-healthcheck.service - systemctl disable setup.service - encoding: b64 - path: /opt/bin/setup - permissions: 755 - - content: - inline: - data: | - [Unit] - After=containerd.service - Requires=containerd.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 \ - --bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf \ - --kubeconfig=/var/lib/kubelet/kubeconfig \ - --config=/etc/kubernetes/kubelet.conf \ - --cert-dir=/etc/kubernetes/pki \ - --cloud-provider=aws \ - --cloud-config=/etc/kubernetes/cloud-config \ - --exit-on-lock-contention \ - --lock-file=/tmp/kubelet.lock \ - --container-runtime-endpoint=unix:///run/containerd/containerd.sock \ - --node-ip ${KUBELET_NODE_IP} - - [Install] - WantedBy=multi-user.target - encoding: b64 - path: /etc/systemd/system/kubelet.service - permissions: 644 - - content: - inline: - data: |+ - [global] - Zone="eu-central-1b" - VPC="e-123f" - SubnetID="test-subnet" - - encoding: b64 - path: /etc/kubernetes/cloud-config - permissions: 600 - - content: - inline: - 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/machine-name is not empty then use the hostname from there - if [ -s /etc/machine-name ]; then - FULL_HOSTNAME=$(cat /etc/machine-name) - 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 - else - mkdir -p /etc/systemd/system/kubelet.service.d - echo -e "[Service]\nEnvironment=\"KUBELET_NODE_IP=${DEFAULT_IFC_IP}\"\nEnvironment=\"KUBELET_HOSTNAME=${FULL_HOSTNAME}\"" > /etc/systemd/system/kubelet.service.d/nodeip.conf - fi - encoding: b64 - path: /opt/bin/setup_net_env.sh - permissions: 755 - - content: - inline: - data: | - -----BEGIN CERTIFICATE----- - MIIEWjCCA0KgAwIBAgIJALfRlWsI8YQHMA0GCSqGSIb3DQEBBQUAMHsxCzAJBgNV - BAYTAlVTMQswCQYDVQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEUMBIG - A1UEChMLQnJhZGZpdHppbmMxEjAQBgNVBAMTCWxvY2FsaG9zdDEdMBsGCSqGSIb3 - DQEJARYOYnJhZEBkYW5nYS5jb20wHhcNMTQwNzE1MjA0NjA1WhcNMTcwNTA0MjA0 - NjA1WjB7MQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExFjAUBgNVBAcTDVNhbiBG - cmFuY2lzY28xFDASBgNVBAoTC0JyYWRmaXR6aW5jMRIwEAYDVQQDEwlsb2NhbGhv - c3QxHTAbBgkqhkiG9w0BCQEWDmJyYWRAZGFuZ2EuY29tMIIBIjANBgkqhkiG9w0B - AQEFAAOCAQ8AMIIBCgKCAQEAt5fAjp4fTcekWUTfzsp0kyih1OYbsGL0KX1eRbSS - R8Od0+9Q62Hyny+GFwMTb4A/KU8mssoHvcceSAAbwfbxFK/+s51TobqUnORZrOoT - ZjkUygbyXDSK99YBbcR1Pip8vwMTm4XKuLtCigeBBdjjAQdgUO28LENGlsMnmeYk - JfODVGnVmr5Ltb9ANA8IKyTfsnHJ4iOCS/PlPbUj2q7YnoVLposUBMlgUb/CykX3 - mOoLb4yJJQyA/iST6ZxiIEj36D4yWZ5lg7YJl+UiiBQHGCnPdGyipqV06ex0heYW - caiW8LWZSUQ93jQ+WVCH8hT7DQO1dmsvUmXlq/JeAlwQ/QIDAQABo4HgMIHdMB0G - A1UdDgQWBBRcAROthS4P4U7vTfjByC569R7E6DCBrQYDVR0jBIGlMIGigBRcAROt - hS4P4U7vTfjByC569R7E6KF/pH0wezELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkNB - MRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMRQwEgYDVQQKEwtCcmFkZml0emluYzES - MBAGA1UEAxMJbG9jYWxob3N0MR0wGwYJKoZIhvcNAQkBFg5icmFkQGRhbmdhLmNv - bYIJALfRlWsI8YQHMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAG6h - U9f9sNH0/6oBbGGy2EVU0UgITUQIrFWo9rFkrW5k/XkDjQm+3lzjT0iGR4IxE/Ao - eU6sQhua7wrWeFEn47GL98lnCsJdD7oZNhFmQ95Tb/LnDUjs5Yj9brP0NWzXfYU4 - UK2ZnINJRcJpB8iRCaCxE8DdcUF0XqIEq6pA272snoLmiXLMvNl3kYEdm+je6voD - 58SNVEUsztzQyXmJEhCpwVI0A6QCjzXj+qvpmw3ZZHi8JwXei8ZZBLTSFBki8Z7n - sH9BBH38/SzUmAN4QHSPy1gjqm00OAE8NaYDkh/bzE4d7mLGGMWp/WE3KPSu82HF - kPe6XoSbiLm/kxk32T0= - -----END CERTIFICATE----- - encoding: b64 - path: /etc/kubernetes/pki/ca.crt - permissions: 644 - - content: - inline: - 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 - encoding: b64 - path: /etc/systemd/system/setup.service - permissions: 644 - - content: - inline: - data: | - export PATH="/opt/bin:$PATH" - encoding: b64 - path: /etc/profile.d/opt-bin-path.sh - permissions: 644 - - content: - inline: - data: | - apiVersion: kubelet.config.k8s.io/v1beta1 - kind: KubeletConfiguration - authentication: - anonymous: - enabled: false - webhook: - cacheTTL: 0s - enabled: true - x509: - clientCAFile: /etc/kubernetes/pki/ca.crt - authorization: - mode: Webhook - webhook: - cacheAuthorizedTTL: 0s - cacheUnauthorizedTTL: 0s - cgroupDriver: systemd - clusterDNS: - - "10.0.0.0" - clusterDomain: cluster.local - containerLogMaxSize: 100Mi - containerLogMaxFiles: 5 - cpuManagerReconcilePeriod: 0s - evictionPressureTransitionPeriod: 0s - featureGates: - DisableCloudProviders: false - fileCheckFrequency: 0s - httpCheckFrequency: 0s - imageMinimumGCAge: 0s - logging: - flushFrequency: 0 - options: - json: - infoBufferSize: "0" - verbosity: 0 - memorySwap: {} - nodeStatusReportFrequency: 0s - nodeStatusUpdateFrequency: 0s - protectKernelDefaults: true - readOnlyPort: 0 - rotateCertificates: true - runtimeRequestTimeout: 0s - serverTLSBootstrap: true - shutdownGracePeriod: 0s - shutdownGracePeriodCriticalPods: 0s - staticPodPath: /etc/kubernetes/manifests - streamingConnectionIdleTimeout: 0s - syncFrequency: 0s - kubeReserved: - cpu: 200m - ephemeral-storage: 1Gi - memory: 200Mi - systemReserved: - cpu: 200m - ephemeral-storage: 1Gi - memory: 200Mi - evictionHard: - imagefs.available: 15% - memory.available: 100Mi - nodefs.available: 10% - nodefs.inodesFree: 5% - 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 - volumeStatsAggPeriod: 0s - resolvConf: /run/systemd/resolve/resolv.conf - encoding: b64 - path: /etc/kubernetes/kubelet.conf - permissions: 644 - - content: - inline: - data: | - [Unit] - Requires=kubelet.service - After=kubelet.service - - [Service] - EnvironmentFile=-/etc/environment - ExecStart=/opt/bin/health-monitor.sh kubelet - - [Install] - WantedBy=multi-user.target - encoding: b64 - path: /etc/systemd/system/kubelet-healthcheck.service - permissions: 644 - - 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: 755 - - content: - inline: - data: | - [Service] - Restart=always - EnvironmentFile=-/etc/environment - path: /etc/systemd/system/containerd.service.d/environment.conf - permissions: 644 - - content: - inline: - data: | - runtime-endpoint: unix:///run/containerd/containerd.sock - path: /etc/crictl.yaml - permissions: 644 - - content: - inline: - data: |+ - version = 2 - - [metrics] - address = "127.0.0.1:1338" - - [plugins] - [plugins."io.containerd.grpc.v1.cri"] - sandbox_image = "192.168.100.100:5000/kubernetes/pause:v3.1" - [plugins."io.containerd.grpc.v1.cri".containerd] - [plugins."io.containerd.grpc.v1.cri".containerd.runtimes] - [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc] - runtime_type = "io.containerd.runc.v2" - [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options] - SystemdCgroup = true - [plugins."io.containerd.grpc.v1.cri".registry] - [plugins."io.containerd.grpc.v1.cri".registry.mirrors] - [plugins."io.containerd.grpc.v1.cri".registry.mirrors."docker.io"] - endpoint = ["https://registry.docker-cn.com"] - [plugins."io.containerd.grpc.v1.cri".registry.configs] - [plugins."io.containerd.grpc.v1.cri".registry.configs."10.0.0.1:5000"] - [plugins."io.containerd.grpc.v1.cri".registry.configs."10.0.0.1:5000".tls] - insecure_skip_verify = true - [plugins."io.containerd.grpc.v1.cri".registry.configs."192.168.100.100:5000"] - [plugins."io.containerd.grpc.v1.cri".registry.configs."192.168.100.100:5000".tls] - insecure_skip_verify = true - - encoding: b64 - path: /etc/containerd/config.toml - permissions: 600 + fi + + # get the full hostname + FULL_HOSTNAME=$(hostname -f) + # if /etc/machine-name is not empty then use the hostname from there + if [ -s /etc/machine-name ]; then + FULL_HOSTNAME=$(cat /etc/machine-name) + 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 + else + mkdir -p /etc/systemd/system/kubelet.service.d + echo -e "[Service]\nEnvironment=\"KUBELET_NODE_IP=${DEFAULT_IFC_IP}\"\nEnvironment=\"KUBELET_HOSTNAME=${FULL_HOSTNAME}\"" > /etc/systemd/system/kubelet.service.d/nodeip.conf + fi + encoding: b64 + path: /opt/bin/setup_net_env.sh + permissions: 755 + - content: + inline: + data: | + -----BEGIN CERTIFICATE----- + MIIEWjCCA0KgAwIBAgIJALfRlWsI8YQHMA0GCSqGSIb3DQEBBQUAMHsxCzAJBgNV + BAYTAlVTMQswCQYDVQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEUMBIG + A1UEChMLQnJhZGZpdHppbmMxEjAQBgNVBAMTCWxvY2FsaG9zdDEdMBsGCSqGSIb3 + DQEJARYOYnJhZEBkYW5nYS5jb20wHhcNMTQwNzE1MjA0NjA1WhcNMTcwNTA0MjA0 + NjA1WjB7MQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExFjAUBgNVBAcTDVNhbiBG + cmFuY2lzY28xFDASBgNVBAoTC0JyYWRmaXR6aW5jMRIwEAYDVQQDEwlsb2NhbGhv + c3QxHTAbBgkqhkiG9w0BCQEWDmJyYWRAZGFuZ2EuY29tMIIBIjANBgkqhkiG9w0B + AQEFAAOCAQ8AMIIBCgKCAQEAt5fAjp4fTcekWUTfzsp0kyih1OYbsGL0KX1eRbSS + R8Od0+9Q62Hyny+GFwMTb4A/KU8mssoHvcceSAAbwfbxFK/+s51TobqUnORZrOoT + ZjkUygbyXDSK99YBbcR1Pip8vwMTm4XKuLtCigeBBdjjAQdgUO28LENGlsMnmeYk + JfODVGnVmr5Ltb9ANA8IKyTfsnHJ4iOCS/PlPbUj2q7YnoVLposUBMlgUb/CykX3 + mOoLb4yJJQyA/iST6ZxiIEj36D4yWZ5lg7YJl+UiiBQHGCnPdGyipqV06ex0heYW + caiW8LWZSUQ93jQ+WVCH8hT7DQO1dmsvUmXlq/JeAlwQ/QIDAQABo4HgMIHdMB0G + A1UdDgQWBBRcAROthS4P4U7vTfjByC569R7E6DCBrQYDVR0jBIGlMIGigBRcAROt + hS4P4U7vTfjByC569R7E6KF/pH0wezELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkNB + MRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMRQwEgYDVQQKEwtCcmFkZml0emluYzES + MBAGA1UEAxMJbG9jYWxob3N0MR0wGwYJKoZIhvcNAQkBFg5icmFkQGRhbmdhLmNv + bYIJALfRlWsI8YQHMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAG6h + U9f9sNH0/6oBbGGy2EVU0UgITUQIrFWo9rFkrW5k/XkDjQm+3lzjT0iGR4IxE/Ao + eU6sQhua7wrWeFEn47GL98lnCsJdD7oZNhFmQ95Tb/LnDUjs5Yj9brP0NWzXfYU4 + UK2ZnINJRcJpB8iRCaCxE8DdcUF0XqIEq6pA272snoLmiXLMvNl3kYEdm+je6voD + 58SNVEUsztzQyXmJEhCpwVI0A6QCjzXj+qvpmw3ZZHi8JwXei8ZZBLTSFBki8Z7n + sH9BBH38/SzUmAN4QHSPy1gjqm00OAE8NaYDkh/bzE4d7mLGGMWp/WE3KPSu82HF + kPe6XoSbiLm/kxk32T0= + -----END CERTIFICATE----- + encoding: b64 + path: /etc/kubernetes/pki/ca.crt + permissions: 644 + - content: + inline: + 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 + encoding: b64 + path: /etc/systemd/system/setup.service + permissions: 644 + - content: + inline: + data: | + export PATH="/opt/bin:$PATH" + encoding: b64 + path: /etc/profile.d/opt-bin-path.sh + permissions: 644 + - content: + inline: + data: | + apiVersion: kubelet.config.k8s.io/v1beta1 + kind: KubeletConfiguration + authentication: + anonymous: + enabled: false + webhook: + cacheTTL: 0s + enabled: true + x509: + clientCAFile: /etc/kubernetes/pki/ca.crt + authorization: + mode: Webhook + webhook: + cacheAuthorizedTTL: 0s + cacheUnauthorizedTTL: 0s + cgroupDriver: systemd + clusterDNS: + - "10.0.0.0" + clusterDomain: cluster.local + containerLogMaxSize: 100Mi + containerLogMaxFiles: 5 + cpuManagerReconcilePeriod: 0s + evictionPressureTransitionPeriod: 0s + featureGates: + DisableCloudProviders: false + fileCheckFrequency: 0s + httpCheckFrequency: 0s + imageMinimumGCAge: 0s + logging: + flushFrequency: 0 + options: + json: + infoBufferSize: "0" + verbosity: 0 + memorySwap: {} + nodeStatusReportFrequency: 0s + nodeStatusUpdateFrequency: 0s + protectKernelDefaults: true + readOnlyPort: 0 + rotateCertificates: true + runtimeRequestTimeout: 0s + serverTLSBootstrap: true + shutdownGracePeriod: 0s + shutdownGracePeriodCriticalPods: 0s + staticPodPath: /etc/kubernetes/manifests + streamingConnectionIdleTimeout: 0s + syncFrequency: 0s + kubeReserved: + cpu: 200m + ephemeral-storage: 1Gi + memory: 200Mi + systemReserved: + cpu: 200m + ephemeral-storage: 1Gi + memory: 200Mi + evictionHard: + imagefs.available: 15% + memory.available: 100Mi + nodefs.available: 10% + nodefs.inodesFree: 5% + 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 + volumeStatsAggPeriod: 0s + resolvConf: /run/systemd/resolve/resolv.conf + encoding: b64 + path: /etc/kubernetes/kubelet.conf + permissions: 644 + - content: + inline: + data: | + [Unit] + Requires=kubelet.service + After=kubelet.service + + [Service] + EnvironmentFile=-/etc/environment + ExecStart=/opt/bin/health-monitor.sh kubelet + + [Install] + WantedBy=multi-user.target + encoding: b64 + path: /etc/systemd/system/kubelet-healthcheck.service + permissions: 644 + - 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: 755 + - content: + inline: + data: | + [Service] + Restart=always + EnvironmentFile=-/etc/environment + path: /etc/systemd/system/containerd.service.d/environment.conf + permissions: 644 + - content: + inline: + data: | + runtime-endpoint: unix:///run/containerd/containerd.sock + path: /etc/crictl.yaml + permissions: 644 + - content: + inline: + data: |+ + version = 2 + + [metrics] + address = "127.0.0.1:1338" + + [plugins] + [plugins."io.containerd.grpc.v1.cri"] + sandbox_image = "192.168.100.100:5000/kubernetes/pause:v3.1" + [plugins."io.containerd.grpc.v1.cri".containerd] + [plugins."io.containerd.grpc.v1.cri".containerd.runtimes] + [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc] + runtime_type = "io.containerd.runc.v2" + [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options] + SystemdCgroup = true + [plugins."io.containerd.grpc.v1.cri".registry] + [plugins."io.containerd.grpc.v1.cri".registry.mirrors] + [plugins."io.containerd.grpc.v1.cri".registry.mirrors."docker.io"] + endpoint = ["https://registry.docker-cn.com"] + [plugins."io.containerd.grpc.v1.cri".registry.configs] + [plugins."io.containerd.grpc.v1.cri".registry.configs."10.0.0.1:5000"] + [plugins."io.containerd.grpc.v1.cri".registry.configs."10.0.0.1:5000".tls] + insecure_skip_verify = true + [plugins."io.containerd.grpc.v1.cri".registry.configs."192.168.100.100:5000"] + [plugins."io.containerd.grpc.v1.cri".registry.configs."192.168.100.100:5000".tls] + insecure_skip_verify = true + + encoding: b64 + path: /etc/containerd/config.toml + permissions: 600 userSSHKeys: - - ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c + - ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c provisioningUtility: cloud-init diff --git a/pkg/controllers/osc/testdata/osp-rhel-aws-cloud-init-modules.yaml b/pkg/controllers/osc/testdata/osp-rhel-aws-cloud-init-modules.yaml index 8e842a80..f0a34b77 100644 --- a/pkg/controllers/osc/testdata/osp-rhel-aws-cloud-init-modules.yaml +++ b/pkg/controllers/osc/testdata/osp-rhel-aws-cloud-init-modules.yaml @@ -192,7 +192,7 @@ spec: fi {{- /* # CNI variables */}} - CNI_VERSION="${CNI_VERSION:-v1.2.0}" + CNI_VERSION="${CNI_VERSION:-v1.4.1}" cni_base_url="https://github.com/containernetworking/plugins/releases/download/$CNI_VERSION" cni_filename="cni-plugins-linux-$arch-$CNI_VERSION.tgz" diff --git a/pkg/controllers/osc/testdata/secret-flatcar-aws-containerd-provisioning.yaml b/pkg/controllers/osc/testdata/secret-flatcar-aws-containerd-provisioning.yaml index e4081048..3b24a1c8 100644 --- a/pkg/controllers/osc/testdata/secret-flatcar-aws-containerd-provisioning.yaml +++ b/pkg/controllers/osc/testdata/secret-flatcar-aws-containerd-provisioning.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: {"ignition":{"config":{},"security":{"tls":{}},"timeouts":{},"version":"2.3.0"},"networkd":{},"passwd":{"users":[{"name":"core","sshAuthorizedKeys":["ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c"]}]},"storage":{"files":[{"filesystem":"root","path":"/opt/bin/health-monitor.sh","contents":{"source":"data:,%23!%2Fusr%2Fbin%2Fenv%20bash%0A%0A%23%20Copyright%202016%20The%20Kubernetes%20Authors.%0A%23%0A%23%20Licensed%20under%20the%20Apache%20License%2C%20Version%202.0%20(the%20%22License%22)%3B%0A%23%20you%20may%20not%20use%20this%20file%20except%20in%20compliance%20with%20the%20License.%0A%23%20You%20may%20obtain%20a%20copy%20of%20the%20License%20at%0A%23%0A%23%20%20%20%20%20http%3A%2F%2Fwww.apache.org%2Flicenses%2FLICENSE-2.0%0A%23%0A%23%20Unless%20required%20by%20applicable%20law%20or%20agreed%20to%20in%20writing%2C%20software%0A%23%20distributed%20under%20the%20License%20is%20distributed%20on%20an%20%22AS%20IS%22%20BASIS%2C%0A%23%20WITHOUT%20WARRANTIES%20OR%20CONDITIONS%20OF%20ANY%20KIND%2C%20either%20express%20or%20implied.%0A%23%20See%20the%20License%20for%20the%20specific%20language%20governing%20permissions%20and%0A%23%20limitations%20under%20the%20License.%0A%0A%23%20This%20script%20is%20for%20master%20and%20node%20instance%20health%20monitoring%2C%20which%20is%0A%23%20packed%20in%20kube-manifest%20tarball.%20It%20is%20executed%20through%20a%20systemd%20service%0A%23%20in%20cluster%2Fgce%2Fgci%2F%3Cmaster%2Fnode%3E.yaml.%20The%20env%20variables%20come%20from%20an%20env%0A%23%20file%20provided%20by%20the%20systemd%20service.%0A%0A%23%20This%20script%20is%20a%20slightly%20adjusted%20version%20of%0A%23%20https%3A%2F%2Fgithub.com%2Fkubernetes%2Fkubernetes%2Fblob%2Fe1a1aa211224fcd9b213420b80b2ae680669683d%2Fcluster%2Fgce%2Fgci%2Fhealth-monitor.sh%0A%23%20Adjustments%20are%3A%0A%23%20*%20Kubelet%20health%20port%20is%2010248%20not%2010255%0A%23%20*%20Removal%20of%20all%20all%20references%20to%20the%20KUBE_ENV%20file%0A%0Aset%20-o%20nounset%0Aset%20-o%20pipefail%0A%0A%23%20We%20simply%20kill%20the%20process%20when%20there%20is%20a%20failure.%20Another%20systemd%20service%20will%0A%23%20automatically%20restart%20the%20process.%0Afunction%20container_runtime_monitoring()%20%7B%0A%20%20local%20-r%20max_attempts%3D5%0A%20%20local%20attempt%3D1%0A%20%20local%20-r%20container_runtime_name%3D%22%24%7BCONTAINER_RUNTIME_NAME%3A-docker%7D%22%0A%20%20%23%20We%20still%20need%20to%20use%20'docker%20ps'%20when%20container%20runtime%20is%20%22docker%22.%20This%20is%20because%0A%20%20%23%20dockershim%20is%20still%20part%20of%20kubelet%20today.%20When%20kubelet%20is%20down%2C%20crictl%20pods%0A%20%20%23%20will%20also%20fail%2C%20and%20docker%20will%20be%20killed.%20This%20is%20undesirable%20especially%20when%0A%20%20%23%20docker%20live%20restore%20is%20disabled.%0A%20%20local%20healthcheck_command%3D%22docker%20ps%22%0A%20%20if%20%5B%5B%20%22%24%7BCONTAINER_RUNTIME%3A-docker%7D%22%20!%3D%20%22docker%22%20%5D%5D%3B%20then%0A%20%20%20%20healthcheck_command%3D%22crictl%20pods%22%0A%20%20fi%0A%20%20%23%20Container%20runtime%20startup%20takes%20time.%20Make%20initial%20attempts%20before%20starting%0A%20%20%23%20killing%20the%20container%20runtime.%0A%20%20until%20timeout%2060%20%24%7Bhealthcheck_command%7D%20%3E%20%2Fdev%2Fnull%3B%20do%0A%20%20%20%20if%20((attempt%20%3D%3D%20max_attempts))%3B%20then%0A%20%20%20%20%20%20echo%20%22Max%20attempt%20%24%7Bmax_attempts%7D%20reached!%20Proceeding%20to%20monitor%20container%20runtime%20healthiness.%22%0A%20%20%20%20%20%20break%0A%20%20%20%20fi%0A%20%20%20%20echo%20%22%24attempt%20initial%20attempt%20%5C%22%24%7Bhealthcheck_command%7D%5C%22!%20Trying%20again%20in%20%24attempt%20seconds...%22%0A%20%20%20%20sleep%20%22%24((2%20**%20attempt%2B%2B))%22%0A%20%20done%0A%20%20while%20true%3B%20do%0A%20%20%20%20if%20!%20timeout%2060%20%24%7Bhealthcheck_command%7D%20%3E%20%2Fdev%2Fnull%3B%20then%0A%20%20%20%20%20%20echo%20%22Container%20runtime%20%24%7Bcontainer_runtime_name%7D%20failed!%22%0A%20%20%20%20%20%20if%20%5B%5B%20%22%24container_runtime_name%22%20%3D%3D%20%22docker%22%20%5D%5D%3B%20then%0A%20%20%20%20%20%20%20%20%23%20Dump%20stack%20of%20docker%20daemon%20for%20investigation.%0A%20%20%20%20%20%20%20%20%23%20Log%20file%20name%20looks%20like%20goroutine-stacks-TIMESTAMP%20and%20will%20be%20saved%20to%0A%20%20%20%20%20%20%20%20%23%20the%20exec%20root%20directory%2C%20which%20is%20%2Fvar%2Frun%2Fdocker%2F%20on%20Ubuntu%20and%20COS.%0A%20%20%20%20%20%20%20%20pkill%20-SIGUSR1%20dockerd%0A%20%20%20%20%20%20fi%0A%20%20%20%20%20%20systemctl%20kill%20--kill-who%3Dmain%20%22%24%7Bcontainer_runtime_name%7D%22%0A%20%20%20%20%20%20%23%20Wait%20for%20a%20while%2C%20as%20we%20don't%20want%20to%20kill%20it%20again%20before%20it%20is%20really%20up.%0A%20%20%20%20%20%20sleep%20120%0A%20%20%20%20else%0A%20%20%20%20%20%20sleep%20%22%24%7BSLEEP_SECONDS%7D%22%0A%20%20%20%20fi%0A%20%20done%0A%7D%0A%0Afunction%20kubelet_monitoring()%20%7B%0A%20%20echo%20%22Wait%20for%202%20minutes%20for%20kubelet%20to%20be%20functional%22%0A%20%20sleep%20120%0A%20%20local%20-r%20max_seconds%3D10%0A%20%20local%20output%3D%22%22%0A%20%20while%20true%3B%20do%0A%20%20%20%20local%20failed%3Dfalse%0A%0A%20%20%20%20if%20journalctl%20-u%20kubelet%20-n%201%20%7C%20grep%20-q%20%22use%20of%20closed%20network%20connection%22%3B%20then%0A%20%20%20%20%20%20failed%3Dtrue%0A%20%20%20%20%20%20echo%20%22Kubelet%20stopped%20posting%20node%20status.%20Restarting%22%0A%20%20%20%20elif%20!%20output%3D%24(curl%20-m%20%22%24%7Bmax_seconds%7D%22%20-f%20-s%20-S%20http%3A%2F%2F127.0.0.1%3A10248%2Fhealthz%202%3E%261)%3B%20then%0A%20%20%20%20%20%20failed%3Dtrue%0A%20%20%20%20%20%20%23%20Print%20the%20response%20and%2For%20errors.%0A%20%20%20%20%20%20echo%20%22%24output%22%0A%20%20%20%20fi%0A%0A%20%20%20%20if%20%5B%5B%20%22%24failed%22%20%3D%3D%20%22true%22%20%5D%5D%3B%20then%0A%20%20%20%20%20%20echo%20%22Kubelet%20is%20unhealthy!%22%0A%20%20%20%20%20%20systemctl%20kill%20kubelet%0A%20%20%20%20%20%20%23%20Wait%20for%20a%20while%2C%20as%20we%20don't%20want%20to%20kill%20it%20again%20before%20it%20is%20really%20up.%0A%20%20%20%20%20%20sleep%2060%0A%20%20%20%20else%0A%20%20%20%20%20%20sleep%20%22%24%7BSLEEP_SECONDS%7D%22%0A%20%20%20%20fi%0A%20%20done%0A%7D%0A%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%20Main%20Function%20%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0Aif%20%5B%5B%20%22%24%23%22%20-ne%201%20%5D%5D%3B%20then%0A%20%20echo%20%22Usage%3A%20health-monitor.sh%20%3Ccontainer-runtime%2Fkubelet%3E%22%0A%20%20exit%201%0Afi%0A%0ASLEEP_SECONDS%3D10%0Acomponent%3D%241%0Aecho%20%22Start%20kubernetes%20health%20monitoring%20for%20%24%7Bcomponent%7D%22%0Aif%20%5B%5B%20%22%24%7Bcomponent%7D%22%20%3D%3D%20%22container-runtime%22%20%5D%5D%3B%20then%0A%20%20container_runtime_monitoring%0Aelif%20%5B%5B%20%22%24%7Bcomponent%7D%22%20%3D%3D%20%22kubelet%22%20%5D%5D%3B%20then%0A%20%20kubelet_monitoring%0Aelse%0A%20%20echo%20%22Health%20monitoring%20for%20component%20%24%7Bcomponent%7D%20is%20not%20supported!%22%0Afi%0A","verification":{}},"mode":493},{"filesystem":"root","path":"/etc/systemd/journald.conf.d/max_disk_use.conf","contents":{"source":"data:,%5BJournal%5D%0ASystemMaxUse%3D5G%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/opt/load-kernel-modules.sh","contents":{"source":"data:,%23!%2Fusr%2Fbin%2Fenv%20bash%0Aset%20-euo%20pipefail%0A%0Amodprobe%20ip_vs%0Amodprobe%20ip_vs_rr%0Amodprobe%20ip_vs_wrr%0Amodprobe%20ip_vs_sh%0A%0Aif%20modinfo%20nf_conntrack_ipv4%20%26%3E%20%2Fdev%2Fnull%3B%20then%0A%20%20modprobe%20nf_conntrack_ipv4%0Aelse%0A%20%20modprobe%20nf_conntrack%0Afi%0A","verification":{}},"mode":493},{"filesystem":"root","path":"/etc/sysctl.d/k8s.conf","contents":{"source":"data:,net.bridge.bridge-nf-call-ip6tables%20%3D%201%0Anet.bridge.bridge-nf-call-iptables%20%3D%201%0Akernel.panic_on_oops%20%3D%201%0Akernel.panic%20%3D%2010%0Anet.ipv4.ip_forward%20%3D%201%0Avm.overcommit_memory%20%3D%201%0Afs.inotify.max_user_watches%20%3D%201048576%0Afs.inotify.max_user_instances%20%3D%208192%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/opt/bin/setup_net_env.sh","contents":{"source":"data:,%23!%2Fusr%2Fbin%2Fenv%20bash%0Aechodate()%20%7B%0A%20%20echo%20%22%5B%24(date%20-Is)%5D%22%20%22%24%40%22%0A%7D%0A%0A%23%20get%20the%20default%20interface%20IP%20address%0ADEFAULT_IFC_IP%3D%24(ip%20-o%20%20route%20get%201%20%7C%20grep%20-oP%20%22src%20%5CK%5CS%2B%22)%0A%0Aif%20%5B%20-z%20%22%24%7BDEFAULT_IFC_IP%7D%22%20%5D%0Athen%0A%20%20echodate%20%22Failed%20to%20get%20IP%20address%20for%20the%20default%20route%20interface%22%0A%20%20exit%201%0Afi%0A%0A%23%20get%20the%20full%20hostname%0AFULL_HOSTNAME%3D%24(hostname%20-f)%0A%23%20if%20%2Fetc%2Fmachine-name%20is%20not%20empty%20then%20use%20the%20hostname%20from%20there%0Aif%20%5B%20-s%20%2Fetc%2Fmachine-name%20%5D%3B%20then%0A%20%20%20%20FULL_HOSTNAME%3D%24(cat%20%2Fetc%2Fmachine-name)%0Afi%0A%0A%23%20write%20the%20nodeip_env%20file%0A%23%20we%20need%20the%20line%20below%20because%20flatcar%20has%20the%20same%20string%20%22coreos%22%20in%20that%20file%0Aif%20grep%20-q%20coreos%20%2Fetc%2Fos-release%0Athen%0A%20%20echo%20-e%20%22KUBELET_NODE_IP%3D%24%7BDEFAULT_IFC_IP%7D%5CnKUBELET_HOSTNAME%3D%24%7BFULL_HOSTNAME%7D%22%20%3E%20%2Fetc%2Fkubernetes%2Fnodeip.conf%0Aelse%0A%20%20mkdir%20-p%20%2Fetc%2Fsystemd%2Fsystem%2Fkubelet.service.d%0A%20%20echo%20-e%20%22%5BService%5D%5CnEnvironment%3D%5C%22KUBELET_NODE_IP%3D%24%7BDEFAULT_IFC_IP%7D%5C%22%5CnEnvironment%3D%5C%22KUBELET_HOSTNAME%3D%24%7BFULL_HOSTNAME%7D%5C%22%22%20%3E%20%2Fetc%2Fsystemd%2Fsystem%2Fkubelet.service.d%2Fnodeip.conf%0Afi%0A","verification":{}},"mode":493},{"filesystem":"root","path":"/etc/systemd/network/zz-default.network.d/ipv6-fix.conf","contents":{"source":"data:,%5BNetwork%5D%0AIPv6AcceptRA%3Dtrue%0A","verification":{}},"mode":493},{"filesystem":"root","path":"/opt/bin/setup","contents":{"source":"data:,%23!%2Fbin%2Fbash%0Aset%20-xeuo%20pipefail%0Acat%20%3C%3C%20EOF%20%7C%20tee%20%2Fetc%2Fpolkit-1%2Frules.d%2F60-noreboot_norestart.rules%0Apolkit.addRule(function(action%2C%20subject)%20%7B%0A%20%20if%20(action.id%20%3D%3D%20%22org.freedesktop.login1.reboot%22%20%7C%7C%0A%20%20%20%20%20%20action.id%20%3D%3D%20%22org.freedesktop.login1.reboot-multiple-sessions%22)%20%7B%0A%20%20%20%20%20%20if%20(subject.user%20%3D%3D%20%22core%22)%20%7B%0A%20%20%20%20%20%20%20%20%20%20return%20polkit.Result.YES%3B%0A%20%20%20%20%20%20%7D%20else%20%7B%0A%20%20%20%20%20%20%20%20%20%20return%20polkit.Result.AUTH_ADMIN%3B%0A%20%20%20%20%20%20%7D%0A%20%20%7D%0A%7D)%3B%0AEOF%0Amkdir%20-p%20%2Fetc%2Fsystemd%2Fsystem%2Fupdate-engine.service.d%2F%0Acat%20%3C%3CEOF%20%7C%20tee%20-a%20%2Fetc%2Fsystemd%2Fsystem%2Fupdate-engine.service.d%2F50-proxy.conf%0A%5BService%5D%0AEnvironment%3DALL_PROXY%3Dhttp%3A%2F%2Ftest-http-proxy.com%0AEOF%0Asystemctl%20daemon-reload%0Asystemctl%20restart%20update-engine.service%0A%0Asystemctl%20daemon-reload%0Asystemctl%20stop%20docker%0Asystemctl%20disable%20docker%0Asystemctl%20restart%20containerd%0A%0A%23%20Override%20hostname%20if%20%2Fetc%2Fmachine-name%20exists%0Aif%20%5B%20-x%20%22%24(command%20-v%20hostnamectl)%22%20%5D%20%26%26%20%5B%20-s%20%2Fetc%2Fmachine-name%20%5D%3B%20then%0A%20%20machine_name%3D%24(cat%20%2Fetc%2Fmachine-name)%0A%20%20hostnamectl%20set-hostname%20%24%7Bmachine_name%7D%0Afi%0A%0Aopt_bin%3D%2Fopt%2Fbin%0Ausr_local_bin%3D%2Fusr%2Flocal%2Fbin%0Acni_bin_dir%3D%2Fopt%2Fcni%2Fbin%0Amkdir%20-p%20%2Fetc%2Fcni%2Fnet.d%20%2Fetc%2Fkubernetes%2Fmanifests%20%22%24opt_bin%22%20%22%24cni_bin_dir%22%0Aarch%3D%24%7BHOST_ARCH-%7D%0Aif%20%5B%20-z%20%22%24arch%22%20%5D%0Athen%0Acase%20%24(uname%20-m)%20in%0Ax86_64)%0A%20%20%20%20arch%3D%22amd64%22%0A%20%20%20%20%3B%3B%0Aaarch64)%0A%20%20%20%20arch%3D%22arm64%22%0A%20%20%20%20%3B%3B%0A*)%0A%20%20%20%20echo%20%22unsupported%20CPU%20architecture%2C%20exiting%22%0A%20%20%20%20exit%201%0A%20%20%20%20%3B%3B%0Aesac%0Afi%0ACNI_VERSION%3D%22%24%7BCNI_VERSION%3A-v1.2.0%7D%22%0Acni_base_url%3D%22https%3A%2F%2Fgithub.com%2Fcontainernetworking%2Fplugins%2Freleases%2Fdownload%2F%24CNI_VERSION%22%0Acni_filename%3D%22cni-plugins-linux-%24arch-%24CNI_VERSION.tgz%22%0Acurl%20-Lfo%20%22%24cni_bin_dir%2F%24cni_filename%22%20%22%24cni_base_url%2F%24cni_filename%22%0Acni_sum%3D%24(curl%20-Lf%20%22%24cni_base_url%2F%24cni_filename.sha256%22)%0Acd%20%22%24cni_bin_dir%22%0Asha256sum%20-c%20%3C%3C%3C%22%24cni_sum%22%0Atar%20xvf%20%22%24cni_filename%22%0Arm%20-f%20%22%24cni_filename%22%0Acd%20-%0ACRI_TOOLS_RELEASE%3D%22%24%7BCRI_TOOLS_RELEASE%3A-v1.29.0%7D%22%0Acri_tools_base_url%3D%22https%3A%2F%2Fgithub.com%2Fkubernetes-sigs%2Fcri-tools%2Freleases%2Fdownload%2F%24%7BCRI_TOOLS_RELEASE%7D%22%0Acri_tools_filename%3D%22crictl-%24%7BCRI_TOOLS_RELEASE%7D-linux-%24%7Barch%7D.tar.gz%22%0Acurl%20-Lfo%20%22%24opt_bin%2F%24cri_tools_filename%22%20%22%24cri_tools_base_url%2F%24cri_tools_filename%22%0Acri_tools_sum_value%3D%24(curl%20-Lf%20%22%24cri_tools_base_url%2F%24cri_tools_filename.sha256%22)%0Acri_tools_sum%3D%22%24cri_tools_sum_value%20%24cri_tools_filename%22%0Acd%20%22%24opt_bin%22%0Asha256sum%20-c%20%3C%3C%3C%22%24cri_tools_sum%22%0Atar%20xvf%20%22%24cri_tools_filename%22%0Arm%20-f%20%22%24cri_tools_filename%22%0Aln%20-sf%20%22%24opt_bin%2Fcrictl%22%20%22%24usr_local_bin%22%2Fcrictl%20%7C%7C%20echo%20%22symbolic%20link%20is%20skipped%22%0Acd%20-%0AKUBE_VERSION%3D%22%24%7BKUBE_VERSION%3A-v1.29.0%7D%22%0Akube_dir%3D%22%24opt_bin%2Fkubernetes-%24KUBE_VERSION%22%0Akube_base_url%3D%22https%3A%2F%2Fdl.k8s.io%2F%24KUBE_VERSION%2Fbin%2Flinux%2F%24arch%22%0Akube_sum_file%3D%22%24kube_dir%2Fsha256%22%0Amkdir%20-p%20%22%24kube_dir%22%0A%3A%20%3E%22%24kube_sum_file%22%0A%0Afor%20bin%20in%20kubelet%20kubeadm%20kubectl%3B%20do%0A%20%20%20%20curl%20-Lfo%20%22%24kube_dir%2F%24bin%22%20%22%24kube_base_url%2F%24bin%22%0A%20%20%20%20chmod%20%2Bx%20%22%24kube_dir%2F%24bin%22%0A%20%20%20%20sum%3D%24(curl%20-Lf%20%22%24kube_base_url%2F%24bin.sha256%22)%0A%20%20%20%20echo%20%22%24sum%20%20%24kube_dir%2F%24bin%22%20%3E%3E%22%24kube_sum_file%22%0Adone%0Asha256sum%20-c%20%22%24kube_sum_file%22%0A%0Afor%20bin%20in%20kubelet%20kubeadm%20kubectl%3B%20do%0A%20%20%20%20ln%20-sf%20%22%24kube_dir%2F%24bin%22%20%22%24opt_bin%22%2F%24bin%0Adone%0A%0A%23%20set%20kubelet%20nodeip%20environment%20variable%0A%2Fopt%2Fbin%2Fsetup_net_env.sh%0Acurl%20-s%20-k%20-v%20--header%20'Authorization%3A%20Bearer%20top-secret'%20https%3A%2F%2Ffoo.bar%3A6443%2Fapi%2Fv1%2Fnamespaces%2Fcloud-init-settings%2Fsecrets%2Fkube-system-flatcar-aws-containerd-kubelet-bootstrap-config%20%7C%20jq%20'.data%5B%22kubeconfig%22%5D'%20-r%7C%20base64%20-d%20%3E%20%2Fetc%2Fkubernetes%2Fbootstrap-kubelet.conf%0A%0Asystemctl%20enable%20--now%20kubelet%0Asystemctl%20enable%20--now%20--no-block%20kubelet-healthcheck.service%0Asystemctl%20disable%20setup.service%0A","verification":{}},"mode":493},{"filesystem":"root","path":"/etc/kubernetes/pki/ca.crt","contents":{"source":"data:,-----BEGIN%20CERTIFICATE-----%0AMIIEWjCCA0KgAwIBAgIJALfRlWsI8YQHMA0GCSqGSIb3DQEBBQUAMHsxCzAJBgNV%0ABAYTAlVTMQswCQYDVQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEUMBIG%0AA1UEChMLQnJhZGZpdHppbmMxEjAQBgNVBAMTCWxvY2FsaG9zdDEdMBsGCSqGSIb3%0ADQEJARYOYnJhZEBkYW5nYS5jb20wHhcNMTQwNzE1MjA0NjA1WhcNMTcwNTA0MjA0%0ANjA1WjB7MQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExFjAUBgNVBAcTDVNhbiBG%0AcmFuY2lzY28xFDASBgNVBAoTC0JyYWRmaXR6aW5jMRIwEAYDVQQDEwlsb2NhbGhv%0Ac3QxHTAbBgkqhkiG9w0BCQEWDmJyYWRAZGFuZ2EuY29tMIIBIjANBgkqhkiG9w0B%0AAQEFAAOCAQ8AMIIBCgKCAQEAt5fAjp4fTcekWUTfzsp0kyih1OYbsGL0KX1eRbSS%0AR8Od0%2B9Q62Hyny%2BGFwMTb4A%2FKU8mssoHvcceSAAbwfbxFK%2F%2Bs51TobqUnORZrOoT%0AZjkUygbyXDSK99YBbcR1Pip8vwMTm4XKuLtCigeBBdjjAQdgUO28LENGlsMnmeYk%0AJfODVGnVmr5Ltb9ANA8IKyTfsnHJ4iOCS%2FPlPbUj2q7YnoVLposUBMlgUb%2FCykX3%0AmOoLb4yJJQyA%2FiST6ZxiIEj36D4yWZ5lg7YJl%2BUiiBQHGCnPdGyipqV06ex0heYW%0AcaiW8LWZSUQ93jQ%2BWVCH8hT7DQO1dmsvUmXlq%2FJeAlwQ%2FQIDAQABo4HgMIHdMB0G%0AA1UdDgQWBBRcAROthS4P4U7vTfjByC569R7E6DCBrQYDVR0jBIGlMIGigBRcAROt%0AhS4P4U7vTfjByC569R7E6KF%2FpH0wezELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkNB%0AMRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMRQwEgYDVQQKEwtCcmFkZml0emluYzES%0AMBAGA1UEAxMJbG9jYWxob3N0MR0wGwYJKoZIhvcNAQkBFg5icmFkQGRhbmdhLmNv%0AbYIJALfRlWsI8YQHMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAG6h%0AU9f9sNH0%2F6oBbGGy2EVU0UgITUQIrFWo9rFkrW5k%2FXkDjQm%2B3lzjT0iGR4IxE%2FAo%0AeU6sQhua7wrWeFEn47GL98lnCsJdD7oZNhFmQ95Tb%2FLnDUjs5Yj9brP0NWzXfYU4%0AUK2ZnINJRcJpB8iRCaCxE8DdcUF0XqIEq6pA272snoLmiXLMvNl3kYEdm%2Bje6voD%0A58SNVEUsztzQyXmJEhCpwVI0A6QCjzXj%2Bqvpmw3ZZHi8JwXei8ZZBLTSFBki8Z7n%0AsH9BBH38%2FSzUmAN4QHSPy1gjqm00OAE8NaYDkh%2FbzE4d7mLGGMWp%2FWE3KPSu82HF%0AkPe6XoSbiLm%2Fkxk32T0%3D%0A-----END%20CERTIFICATE-----%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/systemd/system/kubelet.service","contents":{"source":"data:,%5BUnit%5D%0AAfter%3Dcontainerd.service%0ARequires%3Dcontainerd.service%0A%0ADescription%3Dkubelet%3A%20The%20Kubernetes%20Node%20Agent%0ADocumentation%3Dhttps%3A%2F%2Fkubernetes.io%2Fdocs%2Fhome%2F%0A%0A%5BService%5D%0AUser%3Droot%0ARestart%3Dalways%0AStartLimitInterval%3D0%0ARestartSec%3D10%0ACPUAccounting%3Dtrue%0AMemoryAccounting%3Dtrue%0A%0AEnvironment%3D%22PATH%3D%2Fopt%2Fbin%3A%2Fbin%3A%2Fusr%2Flocal%2Fsbin%3A%2Fusr%2Flocal%2Fbin%3A%2Fusr%2Fsbin%3A%2Fusr%2Fbin%3A%2Fsbin%2F%22%0AEnvironmentFile%3D-%2Fetc%2Fenvironment%0AEnvironmentFile%3D%2Fetc%2Fkubernetes%2Fnodeip.conf%0A%0AExecStartPre%3D%2Fbin%2Fbash%20%2Fopt%2Fload-kernel-modules.sh%0AExecStartPre%3D%2Fbin%2Fbash%20%2Fopt%2Fbin%2Fsetup_net_env.sh%0AExecStart%3D%2Fopt%2Fbin%2Fkubelet%20%5C%0A%20%20--bootstrap-kubeconfig%3D%2Fetc%2Fkubernetes%2Fbootstrap-kubelet.conf%20%5C%0A%20%20--kubeconfig%3D%2Fvar%2Flib%2Fkubelet%2Fkubeconfig%20%5C%0A%20%20--config%3D%2Fetc%2Fkubernetes%2Fkubelet.conf%20%5C%0A%20%20--cert-dir%3D%2Fetc%2Fkubernetes%2Fpki%20%5C%0A%20%20--exit-on-lock-contention%20%5C%0A%20%20--lock-file%3D%2Ftmp%2Fkubelet.lock%20%5C%0A%20%20--container-runtime-endpoint%3Dunix%3A%2F%2F%2Frun%2Fcontainerd%2Fcontainerd.sock%20%5C%0A%20%20--node-ip%20%24%7BKUBELET_NODE_IP%7D%0A%0A%5BInstall%5D%0AWantedBy%3Dmulti-user.target%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/kubernetes/cloud-config","contents":{"source":"data:,","verification":{}},"mode":384},{"filesystem":"root","path":"/etc/kubernetes/kubelet.conf","contents":{"source":"data:,apiVersion%3A%20kubelet.config.k8s.io%2Fv1beta1%0Akind%3A%20KubeletConfiguration%0Aauthentication%3A%0A%20%20anonymous%3A%0A%20%20%20%20enabled%3A%20false%0A%20%20webhook%3A%0A%20%20%20%20cacheTTL%3A%200s%0A%20%20%20%20enabled%3A%20true%0A%20%20x509%3A%0A%20%20%20%20clientCAFile%3A%20%2Fetc%2Fkubernetes%2Fpki%2Fca.crt%0Aauthorization%3A%0A%20%20mode%3A%20Webhook%0A%20%20webhook%3A%0A%20%20%20%20cacheAuthorizedTTL%3A%200s%0A%20%20%20%20cacheUnauthorizedTTL%3A%200s%0AcgroupDriver%3A%20systemd%0AclusterDNS%3A%0A-%20%2210.0.0.0%22%0AclusterDomain%3A%20cluster.local%0AcontainerLogMaxSize%3A%20100Mi%0AcontainerLogMaxFiles%3A%205%0AcpuManagerReconcilePeriod%3A%200s%0AevictionPressureTransitionPeriod%3A%200s%0AfeatureGates%3A%0A%20%20GracefulNodeShutdown%3A%20true%0A%20%20IdentifyPodOS%3A%20false%0AfileCheckFrequency%3A%200s%0AhttpCheckFrequency%3A%200s%0AimageMinimumGCAge%3A%200s%0Alogging%3A%0A%20%20flushFrequency%3A%200%0A%20%20options%3A%0A%20%20%20%20json%3A%0A%20%20%20%20%20%20infoBufferSize%3A%20%220%22%0A%20%20verbosity%3A%200%0AmemorySwap%3A%20%7B%7D%0AnodeStatusReportFrequency%3A%200s%0AnodeStatusUpdateFrequency%3A%200s%0AprotectKernelDefaults%3A%20true%0AreadOnlyPort%3A%200%0ArotateCertificates%3A%20true%0AruntimeRequestTimeout%3A%200s%0AserverTLSBootstrap%3A%20true%0AshutdownGracePeriod%3A%200s%0AshutdownGracePeriodCriticalPods%3A%200s%0AstaticPodPath%3A%20%2Fetc%2Fkubernetes%2Fmanifests%0AstreamingConnectionIdleTimeout%3A%200s%0AsyncFrequency%3A%200s%0AkubeReserved%3A%0A%20%20cpu%3A%20200m%0A%20%20ephemeral-storage%3A%201Gi%0A%20%20memory%3A%20200Mi%0AsystemReserved%3A%0A%20%20cpu%3A%20200m%0A%20%20ephemeral-storage%3A%201Gi%0A%20%20memory%3A%20200Mi%0AevictionHard%3A%0A%20%20imagefs.available%3A%2015%25%0A%20%20memory.available%3A%20100Mi%0A%20%20nodefs.available%3A%2010%25%0A%20%20nodefs.inodesFree%3A%205%25%0AtlsCipherSuites%3A%0A-%20TLS_AES_128_GCM_SHA256%0A-%20TLS_AES_256_GCM_SHA384%0A-%20TLS_CHACHA20_POLY1305_SHA256%0A-%20TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256%0A-%20TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384%0A-%20TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305%0A-%20TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256%0A-%20TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384%0A-%20TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305%0AvolumePluginDir%3A%20%2Fvar%2Flib%2Fkubelet%2Fvolumeplugins%0AvolumeStatsAggPeriod%3A%200s%0AresolvConf%3A%20%2Frun%2Fsystemd%2Fresolve%2Fresolv.conf%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/systemd/system/kubelet-healthcheck.service","contents":{"source":"data:,%5BUnit%5D%0ARequires%3Dkubelet.service%0AAfter%3Dkubelet.service%0A%0A%5BService%5D%0AEnvironmentFile%3D-%2Fetc%2Fenvironment%0AExecStart%3D%2Fopt%2Fbin%2Fhealth-monitor.sh%20kubelet%0A%0A%5BInstall%5D%0AWantedBy%3Dmulti-user.target%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/proc/sys/kernel/panic_on_oops","contents":{"source":"data:,1%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/proc/sys/kernel/panic","contents":{"source":"data:,10%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/proc/sys/vm/overcommit_memory","contents":{"source":"data:,1%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/ssh/sshd_config","contents":{"source":"data:,%23%20Use%20most%20defaults%20for%20sshd%20configuration.%0ASubsystem%20sftp%20internal-sftp%0AClientAliveInterval%20180%0AUseDNS%20no%0AUsePAM%20yes%0APrintLastLog%20no%20%23%20handled%20by%20PAM%0APrintMotd%20no%20%23%20handled%20by%20PAM%0APasswordAuthentication%20no%0AChallengeResponseAuthentication%20no%0A","verification":{}},"mode":384},{"filesystem":"root","path":"/etc/systemd/system/systemd-networkd.service.d/10-static-network.conf","contents":{"source":"data:,","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/systemd/system/containerd.service.d/environment.conf","contents":{"source":"data:,%5BService%5D%0ARestart%3Dalways%0AEnvironmentFile%3D-%2Fetc%2Fenvironment%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/crictl.yaml","contents":{"source":"data:,runtime-endpoint%3A%20unix%3A%2F%2F%2Frun%2Fcontainerd%2Fcontainerd.sock%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/containerd/config.toml","contents":{"source":"data:,version%20%3D%202%0A%0A%5Bmetrics%5D%0Aaddress%20%3D%20%22127.0.0.1%3A1338%22%0A%0A%5Bplugins%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22%5D%0Asandbox_image%20%3D%20%22192.168.100.100%3A5000%2Fkubernetes%2Fpause%3Av3.1%22%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.containerd%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.containerd.runtimes%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.containerd.runtimes.runc%5D%0Aruntime_type%20%3D%20%22io.containerd.runc.v2%22%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.containerd.runtimes.runc.options%5D%0ASystemdCgroup%20%3D%20true%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.mirrors%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.mirrors.%22docker.io%22%5D%0Aendpoint%20%3D%20%5B%22https%3A%2F%2Fregistry.docker-cn.com%22%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.configs%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.configs.%2210.0.0.1%3A5000%22%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.configs.%2210.0.0.1%3A5000%22.tls%5D%0Ainsecure_skip_verify%20%3D%20true%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.configs.%22192.168.100.100%3A5000%22%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.configs.%22192.168.100.100%3A5000%22.tls%5D%0Ainsecure_skip_verify%20%3D%20true%0A","verification":{}},"mode":384},{"filesystem":"root","path":"/etc/systemd/system/containerd.service.d/10-custom.conf","contents":{"source":"data:,%5BService%5D%0AEnvironmentFile%3D-%2Frun%2Fmetadata%2Ftorcx%0AEnvironment%3DCONTAINERD_CONFIG%3D%2Fetc%2Fcontainerd%2Fconfig.toml%0AExecStart%3D%0AExecStart%3D%2Fusr%2Fbin%2Fenv%20PATH%3D%24%7BTORCX_BINDIR%7D%3A%24%7BPATH%7D%20containerd%20--config%20%24%7BCONTAINERD_CONFIG%7D%0A","verification":{}},"mode":420}]},"systemd":{"units":[{"contents":"[Install]\nWantedBy=multi-user.target\n\n[Unit]\nRequires=network-online.target\nAfter=network-online.target\n\n[Service]\nType=oneshot\nRemainAfterExit=true\nEnvironmentFile=-/etc/environment\nExecStart=/opt/bin/supervise.sh /opt/bin/setup\n","enabled":true,"name":"setup.service"}]}} + cloud-config: {"ignition":{"config":{},"security":{"tls":{}},"timeouts":{},"version":"2.3.0"},"networkd":{},"passwd":{"users":[{"name":"core","sshAuthorizedKeys":["ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDdOIhYmzCK5DSVLu3c"]}]},"storage":{"files":[{"filesystem":"root","path":"/opt/bin/health-monitor.sh","contents":{"source":"data:,%23!%2Fusr%2Fbin%2Fenv%20bash%0A%0A%23%20Copyright%202016%20The%20Kubernetes%20Authors.%0A%23%0A%23%20Licensed%20under%20the%20Apache%20License%2C%20Version%202.0%20(the%20%22License%22)%3B%0A%23%20you%20may%20not%20use%20this%20file%20except%20in%20compliance%20with%20the%20License.%0A%23%20You%20may%20obtain%20a%20copy%20of%20the%20License%20at%0A%23%0A%23%20%20%20%20%20http%3A%2F%2Fwww.apache.org%2Flicenses%2FLICENSE-2.0%0A%23%0A%23%20Unless%20required%20by%20applicable%20law%20or%20agreed%20to%20in%20writing%2C%20software%0A%23%20distributed%20under%20the%20License%20is%20distributed%20on%20an%20%22AS%20IS%22%20BASIS%2C%0A%23%20WITHOUT%20WARRANTIES%20OR%20CONDITIONS%20OF%20ANY%20KIND%2C%20either%20express%20or%20implied.%0A%23%20See%20the%20License%20for%20the%20specific%20language%20governing%20permissions%20and%0A%23%20limitations%20under%20the%20License.%0A%0A%23%20This%20script%20is%20for%20master%20and%20node%20instance%20health%20monitoring%2C%20which%20is%0A%23%20packed%20in%20kube-manifest%20tarball.%20It%20is%20executed%20through%20a%20systemd%20service%0A%23%20in%20cluster%2Fgce%2Fgci%2F%3Cmaster%2Fnode%3E.yaml.%20The%20env%20variables%20come%20from%20an%20env%0A%23%20file%20provided%20by%20the%20systemd%20service.%0A%0A%23%20This%20script%20is%20a%20slightly%20adjusted%20version%20of%0A%23%20https%3A%2F%2Fgithub.com%2Fkubernetes%2Fkubernetes%2Fblob%2Fe1a1aa211224fcd9b213420b80b2ae680669683d%2Fcluster%2Fgce%2Fgci%2Fhealth-monitor.sh%0A%23%20Adjustments%20are%3A%0A%23%20*%20Kubelet%20health%20port%20is%2010248%20not%2010255%0A%23%20*%20Removal%20of%20all%20all%20references%20to%20the%20KUBE_ENV%20file%0A%0Aset%20-o%20nounset%0Aset%20-o%20pipefail%0A%0A%23%20We%20simply%20kill%20the%20process%20when%20there%20is%20a%20failure.%20Another%20systemd%20service%20will%0A%23%20automatically%20restart%20the%20process.%0Afunction%20container_runtime_monitoring()%20%7B%0A%20%20local%20-r%20max_attempts%3D5%0A%20%20local%20attempt%3D1%0A%20%20local%20-r%20container_runtime_name%3D%22%24%7BCONTAINER_RUNTIME_NAME%3A-docker%7D%22%0A%20%20%23%20We%20still%20need%20to%20use%20'docker%20ps'%20when%20container%20runtime%20is%20%22docker%22.%20This%20is%20because%0A%20%20%23%20dockershim%20is%20still%20part%20of%20kubelet%20today.%20When%20kubelet%20is%20down%2C%20crictl%20pods%0A%20%20%23%20will%20also%20fail%2C%20and%20docker%20will%20be%20killed.%20This%20is%20undesirable%20especially%20when%0A%20%20%23%20docker%20live%20restore%20is%20disabled.%0A%20%20local%20healthcheck_command%3D%22docker%20ps%22%0A%20%20if%20%5B%5B%20%22%24%7BCONTAINER_RUNTIME%3A-docker%7D%22%20!%3D%20%22docker%22%20%5D%5D%3B%20then%0A%20%20%20%20healthcheck_command%3D%22crictl%20pods%22%0A%20%20fi%0A%20%20%23%20Container%20runtime%20startup%20takes%20time.%20Make%20initial%20attempts%20before%20starting%0A%20%20%23%20killing%20the%20container%20runtime.%0A%20%20until%20timeout%2060%20%24%7Bhealthcheck_command%7D%20%3E%20%2Fdev%2Fnull%3B%20do%0A%20%20%20%20if%20((attempt%20%3D%3D%20max_attempts))%3B%20then%0A%20%20%20%20%20%20echo%20%22Max%20attempt%20%24%7Bmax_attempts%7D%20reached!%20Proceeding%20to%20monitor%20container%20runtime%20healthiness.%22%0A%20%20%20%20%20%20break%0A%20%20%20%20fi%0A%20%20%20%20echo%20%22%24attempt%20initial%20attempt%20%5C%22%24%7Bhealthcheck_command%7D%5C%22!%20Trying%20again%20in%20%24attempt%20seconds...%22%0A%20%20%20%20sleep%20%22%24((2%20**%20attempt%2B%2B))%22%0A%20%20done%0A%20%20while%20true%3B%20do%0A%20%20%20%20if%20!%20timeout%2060%20%24%7Bhealthcheck_command%7D%20%3E%20%2Fdev%2Fnull%3B%20then%0A%20%20%20%20%20%20echo%20%22Container%20runtime%20%24%7Bcontainer_runtime_name%7D%20failed!%22%0A%20%20%20%20%20%20if%20%5B%5B%20%22%24container_runtime_name%22%20%3D%3D%20%22docker%22%20%5D%5D%3B%20then%0A%20%20%20%20%20%20%20%20%23%20Dump%20stack%20of%20docker%20daemon%20for%20investigation.%0A%20%20%20%20%20%20%20%20%23%20Log%20file%20name%20looks%20like%20goroutine-stacks-TIMESTAMP%20and%20will%20be%20saved%20to%0A%20%20%20%20%20%20%20%20%23%20the%20exec%20root%20directory%2C%20which%20is%20%2Fvar%2Frun%2Fdocker%2F%20on%20Ubuntu%20and%20COS.%0A%20%20%20%20%20%20%20%20pkill%20-SIGUSR1%20dockerd%0A%20%20%20%20%20%20fi%0A%20%20%20%20%20%20systemctl%20kill%20--kill-who%3Dmain%20%22%24%7Bcontainer_runtime_name%7D%22%0A%20%20%20%20%20%20%23%20Wait%20for%20a%20while%2C%20as%20we%20don't%20want%20to%20kill%20it%20again%20before%20it%20is%20really%20up.%0A%20%20%20%20%20%20sleep%20120%0A%20%20%20%20else%0A%20%20%20%20%20%20sleep%20%22%24%7BSLEEP_SECONDS%7D%22%0A%20%20%20%20fi%0A%20%20done%0A%7D%0A%0Afunction%20kubelet_monitoring()%20%7B%0A%20%20echo%20%22Wait%20for%202%20minutes%20for%20kubelet%20to%20be%20functional%22%0A%20%20sleep%20120%0A%20%20local%20-r%20max_seconds%3D10%0A%20%20local%20output%3D%22%22%0A%20%20while%20true%3B%20do%0A%20%20%20%20local%20failed%3Dfalse%0A%0A%20%20%20%20if%20journalctl%20-u%20kubelet%20-n%201%20%7C%20grep%20-q%20%22use%20of%20closed%20network%20connection%22%3B%20then%0A%20%20%20%20%20%20failed%3Dtrue%0A%20%20%20%20%20%20echo%20%22Kubelet%20stopped%20posting%20node%20status.%20Restarting%22%0A%20%20%20%20elif%20!%20output%3D%24(curl%20-m%20%22%24%7Bmax_seconds%7D%22%20-f%20-s%20-S%20http%3A%2F%2F127.0.0.1%3A10248%2Fhealthz%202%3E%261)%3B%20then%0A%20%20%20%20%20%20failed%3Dtrue%0A%20%20%20%20%20%20%23%20Print%20the%20response%20and%2For%20errors.%0A%20%20%20%20%20%20echo%20%22%24output%22%0A%20%20%20%20fi%0A%0A%20%20%20%20if%20%5B%5B%20%22%24failed%22%20%3D%3D%20%22true%22%20%5D%5D%3B%20then%0A%20%20%20%20%20%20echo%20%22Kubelet%20is%20unhealthy!%22%0A%20%20%20%20%20%20systemctl%20kill%20kubelet%0A%20%20%20%20%20%20%23%20Wait%20for%20a%20while%2C%20as%20we%20don't%20want%20to%20kill%20it%20again%20before%20it%20is%20really%20up.%0A%20%20%20%20%20%20sleep%2060%0A%20%20%20%20else%0A%20%20%20%20%20%20sleep%20%22%24%7BSLEEP_SECONDS%7D%22%0A%20%20%20%20fi%0A%20%20done%0A%7D%0A%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%20Main%20Function%20%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0Aif%20%5B%5B%20%22%24%23%22%20-ne%201%20%5D%5D%3B%20then%0A%20%20echo%20%22Usage%3A%20health-monitor.sh%20%3Ccontainer-runtime%2Fkubelet%3E%22%0A%20%20exit%201%0Afi%0A%0ASLEEP_SECONDS%3D10%0Acomponent%3D%241%0Aecho%20%22Start%20kubernetes%20health%20monitoring%20for%20%24%7Bcomponent%7D%22%0Aif%20%5B%5B%20%22%24%7Bcomponent%7D%22%20%3D%3D%20%22container-runtime%22%20%5D%5D%3B%20then%0A%20%20container_runtime_monitoring%0Aelif%20%5B%5B%20%22%24%7Bcomponent%7D%22%20%3D%3D%20%22kubelet%22%20%5D%5D%3B%20then%0A%20%20kubelet_monitoring%0Aelse%0A%20%20echo%20%22Health%20monitoring%20for%20component%20%24%7Bcomponent%7D%20is%20not%20supported!%22%0Afi%0A","verification":{}},"mode":493},{"filesystem":"root","path":"/etc/systemd/journald.conf.d/max_disk_use.conf","contents":{"source":"data:,%5BJournal%5D%0ASystemMaxUse%3D5G%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/opt/load-kernel-modules.sh","contents":{"source":"data:,%23!%2Fusr%2Fbin%2Fenv%20bash%0Aset%20-euo%20pipefail%0A%0Amodprobe%20ip_vs%0Amodprobe%20ip_vs_rr%0Amodprobe%20ip_vs_wrr%0Amodprobe%20ip_vs_sh%0A%0Aif%20modinfo%20nf_conntrack_ipv4%20%26%3E%20%2Fdev%2Fnull%3B%20then%0A%20%20modprobe%20nf_conntrack_ipv4%0Aelse%0A%20%20modprobe%20nf_conntrack%0Afi%0A","verification":{}},"mode":493},{"filesystem":"root","path":"/etc/sysctl.d/k8s.conf","contents":{"source":"data:,net.bridge.bridge-nf-call-ip6tables%20%3D%201%0Anet.bridge.bridge-nf-call-iptables%20%3D%201%0Akernel.panic_on_oops%20%3D%201%0Akernel.panic%20%3D%2010%0Anet.ipv4.ip_forward%20%3D%201%0Avm.overcommit_memory%20%3D%201%0Afs.inotify.max_user_watches%20%3D%201048576%0Afs.inotify.max_user_instances%20%3D%208192%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/opt/bin/setup_net_env.sh","contents":{"source":"data:,%23!%2Fusr%2Fbin%2Fenv%20bash%0Aechodate()%20%7B%0A%20%20echo%20%22%5B%24(date%20-Is)%5D%22%20%22%24%40%22%0A%7D%0A%0A%23%20get%20the%20default%20interface%20IP%20address%0ADEFAULT_IFC_IP%3D%24(ip%20-o%20%20route%20get%201%20%7C%20grep%20-oP%20%22src%20%5CK%5CS%2B%22)%0A%0Aif%20%5B%20-z%20%22%24%7BDEFAULT_IFC_IP%7D%22%20%5D%0Athen%0A%20%20echodate%20%22Failed%20to%20get%20IP%20address%20for%20the%20default%20route%20interface%22%0A%20%20exit%201%0Afi%0A%0A%23%20get%20the%20full%20hostname%0AFULL_HOSTNAME%3D%24(hostname%20-f)%0A%23%20if%20%2Fetc%2Fmachine-name%20is%20not%20empty%20then%20use%20the%20hostname%20from%20there%0Aif%20%5B%20-s%20%2Fetc%2Fmachine-name%20%5D%3B%20then%0A%20%20%20%20FULL_HOSTNAME%3D%24(cat%20%2Fetc%2Fmachine-name)%0Afi%0A%0A%23%20write%20the%20nodeip_env%20file%0A%23%20we%20need%20the%20line%20below%20because%20flatcar%20has%20the%20same%20string%20%22coreos%22%20in%20that%20file%0Aif%20grep%20-q%20coreos%20%2Fetc%2Fos-release%0Athen%0A%20%20echo%20-e%20%22KUBELET_NODE_IP%3D%24%7BDEFAULT_IFC_IP%7D%5CnKUBELET_HOSTNAME%3D%24%7BFULL_HOSTNAME%7D%22%20%3E%20%2Fetc%2Fkubernetes%2Fnodeip.conf%0Aelse%0A%20%20mkdir%20-p%20%2Fetc%2Fsystemd%2Fsystem%2Fkubelet.service.d%0A%20%20echo%20-e%20%22%5BService%5D%5CnEnvironment%3D%5C%22KUBELET_NODE_IP%3D%24%7BDEFAULT_IFC_IP%7D%5C%22%5CnEnvironment%3D%5C%22KUBELET_HOSTNAME%3D%24%7BFULL_HOSTNAME%7D%5C%22%22%20%3E%20%2Fetc%2Fsystemd%2Fsystem%2Fkubelet.service.d%2Fnodeip.conf%0Afi%0A","verification":{}},"mode":493},{"filesystem":"root","path":"/etc/systemd/network/zz-default.network.d/ipv6-fix.conf","contents":{"source":"data:,%5BNetwork%5D%0AIPv6AcceptRA%3Dtrue%0A","verification":{}},"mode":493},{"filesystem":"root","path":"/opt/bin/setup","contents":{"source":"data:,%23!%2Fbin%2Fbash%0Aset%20-xeuo%20pipefail%0Acat%20%3C%3C%20EOF%20%7C%20tee%20%2Fetc%2Fpolkit-1%2Frules.d%2F60-noreboot_norestart.rules%0Apolkit.addRule(function(action%2C%20subject)%20%7B%0A%20%20if%20(action.id%20%3D%3D%20%22org.freedesktop.login1.reboot%22%20%7C%7C%0A%20%20%20%20%20%20action.id%20%3D%3D%20%22org.freedesktop.login1.reboot-multiple-sessions%22)%20%7B%0A%20%20%20%20%20%20if%20(subject.user%20%3D%3D%20%22core%22)%20%7B%0A%20%20%20%20%20%20%20%20%20%20return%20polkit.Result.YES%3B%0A%20%20%20%20%20%20%7D%20else%20%7B%0A%20%20%20%20%20%20%20%20%20%20return%20polkit.Result.AUTH_ADMIN%3B%0A%20%20%20%20%20%20%7D%0A%20%20%7D%0A%7D)%3B%0AEOF%0Amkdir%20-p%20%2Fetc%2Fsystemd%2Fsystem%2Fupdate-engine.service.d%2F%0Acat%20%3C%3CEOF%20%7C%20tee%20-a%20%2Fetc%2Fsystemd%2Fsystem%2Fupdate-engine.service.d%2F50-proxy.conf%0A%5BService%5D%0AEnvironment%3DALL_PROXY%3Dhttp%3A%2F%2Ftest-http-proxy.com%0AEOF%0Asystemctl%20daemon-reload%0Asystemctl%20restart%20update-engine.service%0A%0Asystemctl%20daemon-reload%0Asystemctl%20stop%20docker%0Asystemctl%20disable%20docker%0Asystemctl%20restart%20containerd%0A%0A%23%20Override%20hostname%20if%20%2Fetc%2Fmachine-name%20exists%0Aif%20%5B%20-x%20%22%24(command%20-v%20hostnamectl)%22%20%5D%20%26%26%20%5B%20-s%20%2Fetc%2Fmachine-name%20%5D%3B%20then%0A%20%20machine_name%3D%24(cat%20%2Fetc%2Fmachine-name)%0A%20%20hostnamectl%20set-hostname%20%24%7Bmachine_name%7D%0Afi%0A%0Aopt_bin%3D%2Fopt%2Fbin%0Ausr_local_bin%3D%2Fusr%2Flocal%2Fbin%0Acni_bin_dir%3D%2Fopt%2Fcni%2Fbin%0Amkdir%20-p%20%2Fetc%2Fcni%2Fnet.d%20%2Fetc%2Fkubernetes%2Fmanifests%20%22%24opt_bin%22%20%22%24cni_bin_dir%22%0Aarch%3D%24%7BHOST_ARCH-%7D%0Aif%20%5B%20-z%20%22%24arch%22%20%5D%0Athen%0Acase%20%24(uname%20-m)%20in%0Ax86_64)%0A%20%20%20%20arch%3D%22amd64%22%0A%20%20%20%20%3B%3B%0Aaarch64)%0A%20%20%20%20arch%3D%22arm64%22%0A%20%20%20%20%3B%3B%0A*)%0A%20%20%20%20echo%20%22unsupported%20CPU%20architecture%2C%20exiting%22%0A%20%20%20%20exit%201%0A%20%20%20%20%3B%3B%0Aesac%0Afi%0ACNI_VERSION%3D%22%24%7BCNI_VERSION%3A-v1.4.1%7D%22%0Acni_base_url%3D%22https%3A%2F%2Fgithub.com%2Fcontainernetworking%2Fplugins%2Freleases%2Fdownload%2F%24CNI_VERSION%22%0Acni_filename%3D%22cni-plugins-linux-%24arch-%24CNI_VERSION.tgz%22%0Acurl%20-Lfo%20%22%24cni_bin_dir%2F%24cni_filename%22%20%22%24cni_base_url%2F%24cni_filename%22%0Acni_sum%3D%24(curl%20-Lf%20%22%24cni_base_url%2F%24cni_filename.sha256%22)%0Acd%20%22%24cni_bin_dir%22%0Asha256sum%20-c%20%3C%3C%3C%22%24cni_sum%22%0Atar%20xvf%20%22%24cni_filename%22%0Arm%20-f%20%22%24cni_filename%22%0Acd%20-%0ACRI_TOOLS_RELEASE%3D%22%24%7BCRI_TOOLS_RELEASE%3A-v1.29.0%7D%22%0Acri_tools_base_url%3D%22https%3A%2F%2Fgithub.com%2Fkubernetes-sigs%2Fcri-tools%2Freleases%2Fdownload%2F%24%7BCRI_TOOLS_RELEASE%7D%22%0Acri_tools_filename%3D%22crictl-%24%7BCRI_TOOLS_RELEASE%7D-linux-%24%7Barch%7D.tar.gz%22%0Acurl%20-Lfo%20%22%24opt_bin%2F%24cri_tools_filename%22%20%22%24cri_tools_base_url%2F%24cri_tools_filename%22%0Acri_tools_sum_value%3D%24(curl%20-Lf%20%22%24cri_tools_base_url%2F%24cri_tools_filename.sha256%22)%0Acri_tools_sum%3D%22%24cri_tools_sum_value%20%24cri_tools_filename%22%0Acd%20%22%24opt_bin%22%0Asha256sum%20-c%20%3C%3C%3C%22%24cri_tools_sum%22%0Atar%20xvf%20%22%24cri_tools_filename%22%0Arm%20-f%20%22%24cri_tools_filename%22%0Aln%20-sf%20%22%24opt_bin%2Fcrictl%22%20%22%24usr_local_bin%22%2Fcrictl%20%7C%7C%20echo%20%22symbolic%20link%20is%20skipped%22%0Acd%20-%0AKUBE_VERSION%3D%22%24%7BKUBE_VERSION%3A-v1.29.0%7D%22%0Akube_dir%3D%22%24opt_bin%2Fkubernetes-%24KUBE_VERSION%22%0Akube_base_url%3D%22https%3A%2F%2Fdl.k8s.io%2F%24KUBE_VERSION%2Fbin%2Flinux%2F%24arch%22%0Akube_sum_file%3D%22%24kube_dir%2Fsha256%22%0Amkdir%20-p%20%22%24kube_dir%22%0A%3A%20%3E%22%24kube_sum_file%22%0A%0Afor%20bin%20in%20kubelet%20kubeadm%20kubectl%3B%20do%0A%20%20%20%20curl%20-Lfo%20%22%24kube_dir%2F%24bin%22%20%22%24kube_base_url%2F%24bin%22%0A%20%20%20%20chmod%20%2Bx%20%22%24kube_dir%2F%24bin%22%0A%20%20%20%20sum%3D%24(curl%20-Lf%20%22%24kube_base_url%2F%24bin.sha256%22)%0A%20%20%20%20echo%20%22%24sum%20%20%24kube_dir%2F%24bin%22%20%3E%3E%22%24kube_sum_file%22%0Adone%0Asha256sum%20-c%20%22%24kube_sum_file%22%0A%0Afor%20bin%20in%20kubelet%20kubeadm%20kubectl%3B%20do%0A%20%20%20%20ln%20-sf%20%22%24kube_dir%2F%24bin%22%20%22%24opt_bin%22%2F%24bin%0Adone%0A%0A%23%20set%20kubelet%20nodeip%20environment%20variable%0A%2Fopt%2Fbin%2Fsetup_net_env.sh%0Acurl%20-s%20-k%20-v%20--header%20'Authorization%3A%20Bearer%20top-secret'%20https%3A%2F%2Ffoo.bar%3A6443%2Fapi%2Fv1%2Fnamespaces%2Fcloud-init-settings%2Fsecrets%2Fkube-system-flatcar-aws-containerd-kubelet-bootstrap-config%20%7C%20jq%20'.data%5B%22kubeconfig%22%5D'%20-r%7C%20base64%20-d%20%3E%20%2Fetc%2Fkubernetes%2Fbootstrap-kubelet.conf%0A%0Asystemctl%20enable%20--now%20kubelet%0Asystemctl%20enable%20--now%20--no-block%20kubelet-healthcheck.service%0Asystemctl%20disable%20setup.service%0A","verification":{}},"mode":493},{"filesystem":"root","path":"/etc/kubernetes/pki/ca.crt","contents":{"source":"data:,-----BEGIN%20CERTIFICATE-----%0AMIIEWjCCA0KgAwIBAgIJALfRlWsI8YQHMA0GCSqGSIb3DQEBBQUAMHsxCzAJBgNV%0ABAYTAlVTMQswCQYDVQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEUMBIG%0AA1UEChMLQnJhZGZpdHppbmMxEjAQBgNVBAMTCWxvY2FsaG9zdDEdMBsGCSqGSIb3%0ADQEJARYOYnJhZEBkYW5nYS5jb20wHhcNMTQwNzE1MjA0NjA1WhcNMTcwNTA0MjA0%0ANjA1WjB7MQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExFjAUBgNVBAcTDVNhbiBG%0AcmFuY2lzY28xFDASBgNVBAoTC0JyYWRmaXR6aW5jMRIwEAYDVQQDEwlsb2NhbGhv%0Ac3QxHTAbBgkqhkiG9w0BCQEWDmJyYWRAZGFuZ2EuY29tMIIBIjANBgkqhkiG9w0B%0AAQEFAAOCAQ8AMIIBCgKCAQEAt5fAjp4fTcekWUTfzsp0kyih1OYbsGL0KX1eRbSS%0AR8Od0%2B9Q62Hyny%2BGFwMTb4A%2FKU8mssoHvcceSAAbwfbxFK%2F%2Bs51TobqUnORZrOoT%0AZjkUygbyXDSK99YBbcR1Pip8vwMTm4XKuLtCigeBBdjjAQdgUO28LENGlsMnmeYk%0AJfODVGnVmr5Ltb9ANA8IKyTfsnHJ4iOCS%2FPlPbUj2q7YnoVLposUBMlgUb%2FCykX3%0AmOoLb4yJJQyA%2FiST6ZxiIEj36D4yWZ5lg7YJl%2BUiiBQHGCnPdGyipqV06ex0heYW%0AcaiW8LWZSUQ93jQ%2BWVCH8hT7DQO1dmsvUmXlq%2FJeAlwQ%2FQIDAQABo4HgMIHdMB0G%0AA1UdDgQWBBRcAROthS4P4U7vTfjByC569R7E6DCBrQYDVR0jBIGlMIGigBRcAROt%0AhS4P4U7vTfjByC569R7E6KF%2FpH0wezELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkNB%0AMRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMRQwEgYDVQQKEwtCcmFkZml0emluYzES%0AMBAGA1UEAxMJbG9jYWxob3N0MR0wGwYJKoZIhvcNAQkBFg5icmFkQGRhbmdhLmNv%0AbYIJALfRlWsI8YQHMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAG6h%0AU9f9sNH0%2F6oBbGGy2EVU0UgITUQIrFWo9rFkrW5k%2FXkDjQm%2B3lzjT0iGR4IxE%2FAo%0AeU6sQhua7wrWeFEn47GL98lnCsJdD7oZNhFmQ95Tb%2FLnDUjs5Yj9brP0NWzXfYU4%0AUK2ZnINJRcJpB8iRCaCxE8DdcUF0XqIEq6pA272snoLmiXLMvNl3kYEdm%2Bje6voD%0A58SNVEUsztzQyXmJEhCpwVI0A6QCjzXj%2Bqvpmw3ZZHi8JwXei8ZZBLTSFBki8Z7n%0AsH9BBH38%2FSzUmAN4QHSPy1gjqm00OAE8NaYDkh%2FbzE4d7mLGGMWp%2FWE3KPSu82HF%0AkPe6XoSbiLm%2Fkxk32T0%3D%0A-----END%20CERTIFICATE-----%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/systemd/system/kubelet.service","contents":{"source":"data:,%5BUnit%5D%0AAfter%3Dcontainerd.service%0ARequires%3Dcontainerd.service%0A%0ADescription%3Dkubelet%3A%20The%20Kubernetes%20Node%20Agent%0ADocumentation%3Dhttps%3A%2F%2Fkubernetes.io%2Fdocs%2Fhome%2F%0A%0A%5BService%5D%0AUser%3Droot%0ARestart%3Dalways%0AStartLimitInterval%3D0%0ARestartSec%3D10%0ACPUAccounting%3Dtrue%0AMemoryAccounting%3Dtrue%0A%0AEnvironment%3D%22PATH%3D%2Fopt%2Fbin%3A%2Fbin%3A%2Fusr%2Flocal%2Fsbin%3A%2Fusr%2Flocal%2Fbin%3A%2Fusr%2Fsbin%3A%2Fusr%2Fbin%3A%2Fsbin%2F%22%0AEnvironmentFile%3D-%2Fetc%2Fenvironment%0AEnvironmentFile%3D%2Fetc%2Fkubernetes%2Fnodeip.conf%0A%0AExecStartPre%3D%2Fbin%2Fbash%20%2Fopt%2Fload-kernel-modules.sh%0AExecStartPre%3D%2Fbin%2Fbash%20%2Fopt%2Fbin%2Fsetup_net_env.sh%0AExecStart%3D%2Fopt%2Fbin%2Fkubelet%20%5C%0A%20%20--bootstrap-kubeconfig%3D%2Fetc%2Fkubernetes%2Fbootstrap-kubelet.conf%20%5C%0A%20%20--kubeconfig%3D%2Fvar%2Flib%2Fkubelet%2Fkubeconfig%20%5C%0A%20%20--config%3D%2Fetc%2Fkubernetes%2Fkubelet.conf%20%5C%0A%20%20--cert-dir%3D%2Fetc%2Fkubernetes%2Fpki%20%5C%0A%20%20--exit-on-lock-contention%20%5C%0A%20%20--lock-file%3D%2Ftmp%2Fkubelet.lock%20%5C%0A%20%20--container-runtime-endpoint%3Dunix%3A%2F%2F%2Frun%2Fcontainerd%2Fcontainerd.sock%20%5C%0A%20%20--node-ip%20%24%7BKUBELET_NODE_IP%7D%0A%0A%5BInstall%5D%0AWantedBy%3Dmulti-user.target%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/kubernetes/cloud-config","contents":{"source":"data:,","verification":{}},"mode":384},{"filesystem":"root","path":"/etc/kubernetes/kubelet.conf","contents":{"source":"data:,apiVersion%3A%20kubelet.config.k8s.io%2Fv1beta1%0Akind%3A%20KubeletConfiguration%0Aauthentication%3A%0A%20%20anonymous%3A%0A%20%20%20%20enabled%3A%20false%0A%20%20webhook%3A%0A%20%20%20%20cacheTTL%3A%200s%0A%20%20%20%20enabled%3A%20true%0A%20%20x509%3A%0A%20%20%20%20clientCAFile%3A%20%2Fetc%2Fkubernetes%2Fpki%2Fca.crt%0Aauthorization%3A%0A%20%20mode%3A%20Webhook%0A%20%20webhook%3A%0A%20%20%20%20cacheAuthorizedTTL%3A%200s%0A%20%20%20%20cacheUnauthorizedTTL%3A%200s%0AcgroupDriver%3A%20systemd%0AclusterDNS%3A%0A-%20%2210.0.0.0%22%0AclusterDomain%3A%20cluster.local%0AcontainerLogMaxSize%3A%20100Mi%0AcontainerLogMaxFiles%3A%205%0AcpuManagerReconcilePeriod%3A%200s%0AevictionPressureTransitionPeriod%3A%200s%0AfeatureGates%3A%0A%20%20GracefulNodeShutdown%3A%20true%0A%20%20IdentifyPodOS%3A%20false%0AfileCheckFrequency%3A%200s%0AhttpCheckFrequency%3A%200s%0AimageMinimumGCAge%3A%200s%0Alogging%3A%0A%20%20flushFrequency%3A%200%0A%20%20options%3A%0A%20%20%20%20json%3A%0A%20%20%20%20%20%20infoBufferSize%3A%20%220%22%0A%20%20verbosity%3A%200%0AmemorySwap%3A%20%7B%7D%0AnodeStatusReportFrequency%3A%200s%0AnodeStatusUpdateFrequency%3A%200s%0AprotectKernelDefaults%3A%20true%0AreadOnlyPort%3A%200%0ArotateCertificates%3A%20true%0AruntimeRequestTimeout%3A%200s%0AserverTLSBootstrap%3A%20true%0AshutdownGracePeriod%3A%200s%0AshutdownGracePeriodCriticalPods%3A%200s%0AstaticPodPath%3A%20%2Fetc%2Fkubernetes%2Fmanifests%0AstreamingConnectionIdleTimeout%3A%200s%0AsyncFrequency%3A%200s%0AkubeReserved%3A%0A%20%20cpu%3A%20200m%0A%20%20ephemeral-storage%3A%201Gi%0A%20%20memory%3A%20200Mi%0AsystemReserved%3A%0A%20%20cpu%3A%20200m%0A%20%20ephemeral-storage%3A%201Gi%0A%20%20memory%3A%20200Mi%0AevictionHard%3A%0A%20%20imagefs.available%3A%2015%25%0A%20%20memory.available%3A%20100Mi%0A%20%20nodefs.available%3A%2010%25%0A%20%20nodefs.inodesFree%3A%205%25%0AtlsCipherSuites%3A%0A-%20TLS_AES_128_GCM_SHA256%0A-%20TLS_AES_256_GCM_SHA384%0A-%20TLS_CHACHA20_POLY1305_SHA256%0A-%20TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256%0A-%20TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384%0A-%20TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305%0A-%20TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256%0A-%20TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384%0A-%20TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305%0AvolumePluginDir%3A%20%2Fvar%2Flib%2Fkubelet%2Fvolumeplugins%0AvolumeStatsAggPeriod%3A%200s%0AresolvConf%3A%20%2Frun%2Fsystemd%2Fresolve%2Fresolv.conf%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/systemd/system/kubelet-healthcheck.service","contents":{"source":"data:,%5BUnit%5D%0ARequires%3Dkubelet.service%0AAfter%3Dkubelet.service%0A%0A%5BService%5D%0AEnvironmentFile%3D-%2Fetc%2Fenvironment%0AExecStart%3D%2Fopt%2Fbin%2Fhealth-monitor.sh%20kubelet%0A%0A%5BInstall%5D%0AWantedBy%3Dmulti-user.target%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/proc/sys/kernel/panic_on_oops","contents":{"source":"data:,1%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/proc/sys/kernel/panic","contents":{"source":"data:,10%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/proc/sys/vm/overcommit_memory","contents":{"source":"data:,1%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/ssh/sshd_config","contents":{"source":"data:,%23%20Use%20most%20defaults%20for%20sshd%20configuration.%0ASubsystem%20sftp%20internal-sftp%0AClientAliveInterval%20180%0AUseDNS%20no%0AUsePAM%20yes%0APrintLastLog%20no%20%23%20handled%20by%20PAM%0APrintMotd%20no%20%23%20handled%20by%20PAM%0APasswordAuthentication%20no%0AChallengeResponseAuthentication%20no%0A","verification":{}},"mode":384},{"filesystem":"root","path":"/etc/systemd/system/systemd-networkd.service.d/10-static-network.conf","contents":{"source":"data:,","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/systemd/system/containerd.service.d/environment.conf","contents":{"source":"data:,%5BService%5D%0ARestart%3Dalways%0AEnvironmentFile%3D-%2Fetc%2Fenvironment%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/crictl.yaml","contents":{"source":"data:,runtime-endpoint%3A%20unix%3A%2F%2F%2Frun%2Fcontainerd%2Fcontainerd.sock%0A","verification":{}},"mode":420},{"filesystem":"root","path":"/etc/containerd/config.toml","contents":{"source":"data:,version%20%3D%202%0A%0A%5Bmetrics%5D%0Aaddress%20%3D%20%22127.0.0.1%3A1338%22%0A%0A%5Bplugins%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22%5D%0Asandbox_image%20%3D%20%22192.168.100.100%3A5000%2Fkubernetes%2Fpause%3Av3.1%22%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.containerd%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.containerd.runtimes%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.containerd.runtimes.runc%5D%0Aruntime_type%20%3D%20%22io.containerd.runc.v2%22%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.containerd.runtimes.runc.options%5D%0ASystemdCgroup%20%3D%20true%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.mirrors%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.mirrors.%22docker.io%22%5D%0Aendpoint%20%3D%20%5B%22https%3A%2F%2Fregistry.docker-cn.com%22%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.configs%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.configs.%2210.0.0.1%3A5000%22%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.configs.%2210.0.0.1%3A5000%22.tls%5D%0Ainsecure_skip_verify%20%3D%20true%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.configs.%22192.168.100.100%3A5000%22%5D%0A%5Bplugins.%22io.containerd.grpc.v1.cri%22.registry.configs.%22192.168.100.100%3A5000%22.tls%5D%0Ainsecure_skip_verify%20%3D%20true%0A","verification":{}},"mode":384},{"filesystem":"root","path":"/etc/systemd/system/containerd.service.d/10-custom.conf","contents":{"source":"data:,%5BService%5D%0AEnvironmentFile%3D-%2Frun%2Fmetadata%2Ftorcx%0AEnvironment%3DCONTAINERD_CONFIG%3D%2Fetc%2Fcontainerd%2Fconfig.toml%0AExecStart%3D%0AExecStart%3D%2Fusr%2Fbin%2Fenv%20PATH%3D%24%7BTORCX_BINDIR%7D%3A%24%7BPATH%7D%20containerd%20--config%20%24%7BCONTAINERD_CONFIG%7D%0A","verification":{}},"mode":420}]},"systemd":{"units":[{"contents":"[Install]\nWantedBy=multi-user.target\n\n[Unit]\nRequires=network-online.target\nAfter=network-online.target\n\n[Service]\nType=oneshot\nRemainAfterExit=true\nEnvironmentFile=-/etc/environment\nExecStart=/opt/bin/supervise.sh /opt/bin/setup\n","enabled":true,"name":"setup.service"}]}} immutable: true kind: Secret metadata: diff --git a/pkg/controllers/osc/testdata/secret-kubelet-configuration-containerd-provisioning.yaml b/pkg/controllers/osc/testdata/secret-kubelet-configuration-containerd-provisioning.yaml index 280bcb99..f7f7edaa 100644 --- a/pkg/controllers/osc/testdata/secret-kubelet-configuration-containerd-provisioning.yaml +++ b/pkg/controllers/osc/testdata/secret-kubelet-configuration-containerd-provisioning.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

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

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

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

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

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

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

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

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

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

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

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

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

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

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

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

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

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

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

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

- path: '/etc/kubernetes/pki/ca.crt'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUVXakNDQTBLZ0F3SUJBZ0lKQUxmUmxXc0k4WVFITUEwR0NTcUdTSWIzRFFFQkJRVUFNSHN4Q3pBSkJnTlYKQkFZVEFsVlRNUXN3Q1FZRFZRUUlFd0pEUVRFV01CUUdBMVVFQnhNTlUyRnVJRVp5WVc1amFYTmpiekVVTUJJRwpBMVVFQ2hNTFFuSmhaR1pwZEhwcGJtTXhFakFRQmdOVkJBTVRDV3h2WTJGc2FHOXpkREVkTUJzR0NTcUdTSWIzCkRRRUpBUllPWW5KaFpFQmtZVzVuWVM1amIyMHdIaGNOTVRRd056RTFNakEwTmpBMVdoY05NVGN3TlRBME1qQTAKTmpBMVdqQjdNUXN3Q1FZRFZRUUdFd0pWVXpFTE1Ba0dBMVVFQ0JNQ1EwRXhGakFVQmdOVkJBY1REVk5oYmlCRwpjbUZ1WTJselkyOHhGREFTQmdOVkJBb1RDMEp5WVdSbWFYUjZhVzVqTVJJd0VBWURWUVFERXdsc2IyTmhiR2h2CmMzUXhIVEFiQmdrcWhraUc5dzBCQ1FFV0RtSnlZV1JBWkdGdVoyRXVZMjl0TUlJQklqQU5CZ2txaGtpRzl3MEIKQVFFRkFBT0NBUThBTUlJQkNnS0NBUUVBdDVmQWpwNGZUY2VrV1VUZnpzcDBreWloMU9ZYnNHTDBLWDFlUmJTUwpSOE9kMCs5UTYySHlueStHRndNVGI0QS9LVThtc3NvSHZjY2VTQUFid2ZieEZLLytzNTFUb2JxVW5PUlpyT29UClpqa1V5Z2J5WERTSzk5WUJiY1IxUGlwOHZ3TVRtNFhLdUx0Q2lnZUJCZGpqQVFkZ1VPMjhMRU5HbHNNbm1lWWsKSmZPRFZHblZtcjVMdGI5QU5BOElLeVRmc25ISjRpT0NTL1BsUGJVajJxN1lub1ZMcG9zVUJNbGdVYi9DeWtYMwptT29MYjR5SkpReUEvaVNUNlp4aUlFajM2RDR5V1o1bGc3WUpsK1VpaUJRSEdDblBkR3lpcHFWMDZleDBoZVlXCmNhaVc4TFdaU1VROTNqUStXVkNIOGhUN0RRTzFkbXN2VW1YbHEvSmVBbHdRL1FJREFRQUJvNEhnTUlIZE1CMEcKQTFVZERnUVdCQlJjQVJPdGhTNFA0VTd2VGZqQnlDNTY5UjdFNkRDQnJRWURWUjBqQklHbE1JR2lnQlJjQVJPdApoUzRQNFU3dlRmakJ5QzU2OVI3RTZLRi9wSDB3ZXpFTE1Ba0dBMVVFQmhNQ1ZWTXhDekFKQmdOVkJBZ1RBa05CCk1SWXdGQVlEVlFRSEV3MVRZVzRnUm5KaGJtTnBjMk52TVJRd0VnWURWUVFLRXd0Q2NtRmtabWwwZW1sdVl6RVMKTUJBR0ExVUVBeE1KYkc5allXeG9iM04wTVIwd0d3WUpLb1pJaHZjTkFRa0JGZzVpY21Ga1FHUmhibWRoTG1OdgpiWUlKQUxmUmxXc0k4WVFITUF3R0ExVWRFd1FGTUFNQkFmOHdEUVlKS29aSWh2Y05BUUVGQlFBRGdnRUJBRzZoClU5ZjlzTkgwLzZvQmJHR3kyRVZVMFVnSVRVUUlyRldvOXJGa3JXNWsvWGtEalFtKzNsempUMGlHUjRJeEUvQW8KZVU2c1FodWE3d3JXZUZFbjQ3R0w5OGxuQ3NKZEQ3b1pOaEZtUTk1VGIvTG5EVWpzNVlqOWJyUDBOV3pYZllVNApVSzJabklOSlJjSnBCOGlSQ2FDeEU4RGRjVUYwWHFJRXE2cEEyNzJzbm9MbWlYTE12Tmwza1lFZG0ramU2dm9ECjU4U05WRVVzenR6UXlYbUpFaENwd1ZJMEE2UUNqelhqK3F2cG13M1paSGk4SndYZWk4WlpCTFRTRkJraThaN24Kc0g5QkJIMzgvU3pVbUFONFFIU1B5MWdqcW0wME9BRThOYVlEa2gvYnpFNGQ3bUxHR01XcC9XRTNLUFN1ODJIRgprUGU2WG9TYmlMbS9reGszMlQwPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==

- 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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    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

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

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

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

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

- path: '/etc/containerd/config.toml'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    dmVyc2lvbiA9IDIKClttZXRyaWNzXQphZGRyZXNzID0gIjEyNy4wLjAuMToxMzM4IgoKW3BsdWdpbnNdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIl0Kc2FuZGJveF9pbWFnZSA9ICIxOTIuMTY4LjEwMC4xMDA6NTAwMC9rdWJlcm5ldGVzL3BhdXNlOnYzLjEiCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5jb250YWluZXJkXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIuY29udGFpbmVyZC5ydW50aW1lc10KW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuY10KcnVudGltZV90eXBlID0gImlvLmNvbnRhaW5lcmQucnVuYy52MiIKW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuYy5vcHRpb25zXQpTeXN0ZW1kQ2dyb3VwID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnldCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5taXJyb3JzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkubWlycm9ycy4iZG9ja2VyLmlvIl0KZW5kcG9pbnQgPSBbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTAuMC4wLjE6NTAwMCJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzLiIxMC4wLjAuMTo1MDAwIi50bHNdCmluc2VjdXJlX3NraXBfdmVyaWZ5ID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiLnRsc10KaW5zZWN1cmVfc2tpcF92ZXJpZnkgPSB0cnVlCgo=
 immutable: true kind: Secret metadata: diff --git a/pkg/controllers/osc/testdata/secret-osc-rhel-8.x-cloud-init-modules-provisioning.yaml b/pkg/controllers/osc/testdata/secret-osc-rhel-8.x-cloud-init-modules-provisioning.yaml index ce0706c8..5b30808c 100644 --- a/pkg/controllers/osc/testdata/secret-osc-rhel-8.x-cloud-init-modules-provisioning.yaml +++ b/pkg/controllers/osc/testdata/secret-osc-rhel-8.x-cloud-init-modules-provisioning.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

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

- path: '/etc/selinux/config'
  permissions: '0644'
  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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWNvbnRhaW5lcmQuc2VydmljZQpSZXF1aXJlcz1jb250YWluZXJkLnNlcnZpY2UKCkRlc2NyaXB0aW9uPWt1YmVsZXQ6IFRoZSBLdWJlcm5ldGVzIE5vZGUgQWdlbnQKRG9jdW1lbnRhdGlvbj1odHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy9ob21lLwoKW1NlcnZpY2VdClVzZXI9cm9vdApSZXN0YXJ0PWFsd2F5cwpTdGFydExpbWl0SW50ZXJ2YWw9MApSZXN0YXJ0U2VjPTEwCkNQVUFjY291bnRpbmc9dHJ1ZQpNZW1vcnlBY2NvdW50aW5nPXRydWUKCkVudmlyb25tZW50PSJQQVRIPS9vcHQvYmluOi9iaW46L3Vzci9sb2NhbC9zYmluOi91c3IvbG9jYWwvYmluOi91c3Ivc2JpbjovdXNyL2Jpbjovc2Jpbi8iCkVudmlyb25tZW50RmlsZT0tL2V0Yy9lbnZpcm9ubWVudAoKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Rpc2FibGUtc3dhcC5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvbG9hZC1rZXJuZWwtbW9kdWxlcy5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvYmluL3NldHVwX25ldF9lbnYuc2gKRXhlY1N0YXJ0PS9vcHQvYmluL2t1YmVsZXQgXAogIC0tYm9vdHN0cmFwLWt1YmVjb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Jvb3RzdHJhcC1rdWJlbGV0LmNvbmYgXAogIC0ta3ViZWNvbmZpZz0vdmFyL2xpYi9rdWJlbGV0L2t1YmVjb25maWcgXAogIC0tY29uZmlnPS9ldGMva3ViZXJuZXRlcy9rdWJlbGV0LmNvbmYgXAogIC0tY2VydC1kaXI9L2V0Yy9rdWJlcm5ldGVzL3BraSBcCiAgLS1leGl0LW9uLWxvY2stY29udGVudGlvbiBcCiAgLS1sb2NrLWZpbGU9L3RtcC9rdWJlbGV0LmxvY2sgXAogIC0tY29udGFpbmVyLXJ1bnRpbWU9cmVtb3RlIFwKICAtLWNvbnRhaW5lci1ydW50aW1lLWVuZHBvaW50PXVuaXg6Ly8vcnVuL2NvbnRhaW5lcmQvY29udGFpbmVyZC5zb2NrIFwKICAtLW5vZGUtaXAgJHtLVUJFTEVUX05PREVfSVB9CgpbSW5zdGFsbF0KV2FudGVkQnk9bXVsdGktdXNlci50YXJnZXQK

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

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

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

- 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'
  permissions: '0644'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

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

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

rh_subscription:
    auto-attach: false
    password: 
    username: 

yum_repos:
    cloud-init-daily:
       baseurl: https://k8c.io/osm
       enabled_metadata: 1
       gpgcheck: true
       gpgkey: https://k8c.io/osm/pubkey.gpg
       name: test cloud-init yum repos
       skip_if_unavailable: true
       type: rpm-md

yum_repo_dir: /store/custom/yum.repos.d + cloud-config: #cloud-config

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

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

- path: '/etc/selinux/config'
  permissions: '0644'
  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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W1VuaXRdCkFmdGVyPWNvbnRhaW5lcmQuc2VydmljZQpSZXF1aXJlcz1jb250YWluZXJkLnNlcnZpY2UKCkRlc2NyaXB0aW9uPWt1YmVsZXQ6IFRoZSBLdWJlcm5ldGVzIE5vZGUgQWdlbnQKRG9jdW1lbnRhdGlvbj1odHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy9ob21lLwoKW1NlcnZpY2VdClVzZXI9cm9vdApSZXN0YXJ0PWFsd2F5cwpTdGFydExpbWl0SW50ZXJ2YWw9MApSZXN0YXJ0U2VjPTEwCkNQVUFjY291bnRpbmc9dHJ1ZQpNZW1vcnlBY2NvdW50aW5nPXRydWUKCkVudmlyb25tZW50PSJQQVRIPS9vcHQvYmluOi9iaW46L3Vzci9sb2NhbC9zYmluOi91c3IvbG9jYWwvYmluOi91c3Ivc2JpbjovdXNyL2Jpbjovc2Jpbi8iCkVudmlyb25tZW50RmlsZT0tL2V0Yy9lbnZpcm9ubWVudAoKRXhlY1N0YXJ0UHJlPS9iaW4vYmFzaCAvb3B0L2Rpc2FibGUtc3dhcC5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvbG9hZC1rZXJuZWwtbW9kdWxlcy5zaApFeGVjU3RhcnRQcmU9L2Jpbi9iYXNoIC9vcHQvYmluL3NldHVwX25ldF9lbnYuc2gKRXhlY1N0YXJ0PS9vcHQvYmluL2t1YmVsZXQgXAogIC0tYm9vdHN0cmFwLWt1YmVjb25maWc9L2V0Yy9rdWJlcm5ldGVzL2Jvb3RzdHJhcC1rdWJlbGV0LmNvbmYgXAogIC0ta3ViZWNvbmZpZz0vdmFyL2xpYi9rdWJlbGV0L2t1YmVjb25maWcgXAogIC0tY29uZmlnPS9ldGMva3ViZXJuZXRlcy9rdWJlbGV0LmNvbmYgXAogIC0tY2VydC1kaXI9L2V0Yy9rdWJlcm5ldGVzL3BraSBcCiAgLS1leGl0LW9uLWxvY2stY29udGVudGlvbiBcCiAgLS1sb2NrLWZpbGU9L3RtcC9rdWJlbGV0LmxvY2sgXAogIC0tY29udGFpbmVyLXJ1bnRpbWU9cmVtb3RlIFwKICAtLWNvbnRhaW5lci1ydW50aW1lLWVuZHBvaW50PXVuaXg6Ly8vcnVuL2NvbnRhaW5lcmQvY29udGFpbmVyZC5zb2NrIFwKICAtLW5vZGUtaXAgJHtLVUJFTEVUX05PREVfSVB9CgpbSW5zdGFsbF0KV2FudGVkQnk9bXVsdGktdXNlci50YXJnZXQK

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

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

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

- 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'
  permissions: '0644'
  content: |-
    [Service]
    Restart=always
    EnvironmentFile=-/etc/environment
    

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

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

rh_subscription:
    auto-attach: false
    password: 
    username: 

yum_repos:
    cloud-init-daily:
       baseurl: https://k8c.io/osm
       enabled_metadata: 1
       gpgcheck: true
       gpgkey: https://k8c.io/osm/pubkey.gpg
       name: test cloud-init yum repos
       skip_if_unavailable: true
       type: rpm-md

yum_repo_dir: /store/custom/yum.repos.d immutable: true kind: Secret metadata: diff --git a/pkg/controllers/osc/testdata/secret-rhel-8.x-azure-containerd-provisioning.yaml b/pkg/controllers/osc/testdata/secret-rhel-8.x-azure-containerd-provisioning.yaml index f4d35bc5..75a67591 100644 --- a/pkg/controllers/osc/testdata/secret-rhel-8.x-azure-containerd-provisioning.yaml +++ b/pkg/controllers/osc/testdata/secret-rhel-8.x-azure-containerd-provisioning.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

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

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

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

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

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

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

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

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

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

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

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

- 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-provisioning.yaml b/pkg/controllers/osc/testdata/secret-ubuntu-aws-containerd-provisioning.yaml index acbffcf5..a22765bd 100644 --- a/pkg/controllers/osc/testdata/secret-ubuntu-aws-containerd-provisioning.yaml +++ b/pkg/controllers/osc/testdata/secret-ubuntu-aws-containerd-provisioning.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

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

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

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

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

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

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

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

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

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

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

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

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

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

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

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

- path: '/opt/bin/setup'
  permissions: '0755'
  encoding: 'b64'
  content: |-
    IyEvYmluL2Jhc2gKc2V0IC14ZXVvIHBpcGVmYWlsCmlmIHN5c3RlbWN0bCBpcy1hY3RpdmUgdWZ3OyB0aGVuIHN5c3RlbWN0bCBzdG9wIHVmdzsgZmkKc3lzdGVtY3RsIG1hc2sgdWZ3CnN5c3RlbWN0bCByZXN0YXJ0IHN5c3RlbWQtbW9kdWxlcy1sb2FkLnNlcnZpY2UKc3lzY3RsIC0tc3lzdGVtCgojIE92ZXJyaWRlIGhvc3RuYW1lIGlmIC9ldGMvbWFjaGluZS1uYW1lIGV4aXN0cwppZiBbIC14ICIkKGNvbW1hbmQgLXYgaG9zdG5hbWVjdGwpIiBdICYmIFsgLXMgL2V0Yy9tYWNoaW5lLW5hbWUgXTsgdGhlbgogIG1hY2hpbmVfbmFtZT0kKGNhdCAvZXRjL21hY2hpbmUtbmFtZSkKICBob3N0bmFtZWN0bCBzZXQtaG9zdG5hbWUgJHttYWNoaW5lX25hbWV9CmZpCgphcHQtZ2V0IHVwZGF0ZQoKREVCSUFOX0ZST05URU5EPW5vbmludGVyYWN0aXZlIGFwdC1nZXQgLW8gRHBrZzo6T3B0aW9uczo6PSItLWZvcmNlLWNvbmZkZWYiIC1vIERwa2c6Ok9wdGlvbnM6Oj0iLS1mb3JjZS1jb25mb2xkIiBpbnN0YWxsIC15IFwKICBjdXJsIFwKICBjYS1jZXJ0aWZpY2F0ZXMgXAogIGNlcGgtY29tbW9uIFwKICBjaWZzLXV0aWxzIFwKICBjb25udHJhY2sgXAogIGUyZnNwcm9ncyBcCiAgZWJ0YWJsZXMgXAogIGV0aHRvb2wgXAogIGdsdXN0ZXJmcy1jbGllbnQgXAogIGlwdGFibGVzIFwKICBqcSBcCiAga21vZCBcCiAgb3BlbnNzaC1jbGllbnQgXAogIG5mcy1jb21tb24gXAogIHNvY2F0IFwKICB1dGlsLWxpbnV4IFwKICBpcHZzYWRtCmFwdC1nZXQgdXBkYXRlCmFwdC1nZXQgaW5zdGFsbCAteSBhcHQtdHJhbnNwb3J0LWh0dHBzIGNhLWNlcnRpZmljYXRlcyBjdXJsIHNvZnR3YXJlLXByb3BlcnRpZXMtY29tbW9uIGxzYi1yZWxlYXNlCmN1cmwgLWZzU0wgaHR0cHM6Ly9kb3dubG9hZC5kb2NrZXIuY29tL2xpbnV4L3VidW50dS9ncGcgfCBhcHQta2V5IGFkZCAtCmFkZC1hcHQtcmVwb3NpdG9yeSAiZGViIGh0dHBzOi8vZG93bmxvYWQuZG9ja2VyLmNvbS9saW51eC91YnVudHUgJChsc2JfcmVsZWFzZSAtY3MpIHN0YWJsZSIKCmFwdC1nZXQgaW5zdGFsbCAteSAtLWFsbG93LWRvd25ncmFkZXMgY29udGFpbmVyZC5pbz0xLjYqCmFwdC1tYXJrIGhvbGQgY29udGFpbmVyZC5pbwoKc3lzdGVtY3RsIGRhZW1vbi1yZWxvYWQKc3lzdGVtY3RsIGVuYWJsZSAtLW5vdyBjb250YWluZXJkCgpvcHRfYmluPS9vcHQvYmluCnVzcl9sb2NhbF9iaW49L3Vzci9sb2NhbC9iaW4KY25pX2Jpbl9kaXI9L29wdC9jbmkvYmluCm1rZGlyIC1wIC9ldGMvY25pL25ldC5kIC9ldGMva3ViZXJuZXRlcy9tYW5pZmVzdHMgIiRvcHRfYmluIiAiJGNuaV9iaW5fZGlyIgphcmNoPSR7SE9TVF9BUkNILX0KaWYgWyAteiAiJGFyY2giIF0KdGhlbgpjYXNlICQodW5hbWUgLW0pIGluCng4Nl82NCkKICAgIGFyY2g9ImFtZDY0IgogICAgOzsKYWFyY2g2NCkKICAgIGFyY2g9ImFybTY0IgogICAgOzsKKikKICAgIGVjaG8gInVuc3VwcG9ydGVkIENQVSBhcmNoaXRlY3R1cmUsIGV4aXRpbmciCiAgICBleGl0IDEKICAgIDs7CmVzYWMKZmkKQ05JX1ZFUlNJT049IiR7Q05JX1ZFUlNJT046LXYxLjQuMX0iCmNuaV9iYXNlX3VybD0iaHR0cHM6Ly9naXRodWIuY29tL2NvbnRhaW5lcm5ldHdvcmtpbmcvcGx1Z2lucy9yZWxlYXNlcy9kb3dubG9hZC8kQ05JX1ZFUlNJT04iCmNuaV9maWxlbmFtZT0iY25pLXBsdWdpbnMtbGludXgtJGFyY2gtJENOSV9WRVJTSU9OLnRneiIKY3VybCAtTGZvICIkY25pX2Jpbl9kaXIvJGNuaV9maWxlbmFtZSIgIiRjbmlfYmFzZV91cmwvJGNuaV9maWxlbmFtZSIKY25pX3N1bT0kKGN1cmwgLUxmICIkY25pX2Jhc2VfdXJsLyRjbmlfZmlsZW5hbWUuc2hhMjU2IikKY2QgIiRjbmlfYmluX2RpciIKc2hhMjU2c3VtIC1jIDw8PCIkY25pX3N1bSIKdGFyIHh2ZiAiJGNuaV9maWxlbmFtZSIKcm0gLWYgIiRjbmlfZmlsZW5hbWUiCmNkIC0KQ1JJX1RPT0xTX1JFTEVBU0U9IiR7Q1JJX1RPT0xTX1JFTEVBU0U6LXYxLjI5LjB9IgpjcmlfdG9vbHNfYmFzZV91cmw9Imh0dHBzOi8vZ2l0aHViLmNvbS9rdWJlcm5ldGVzLXNpZ3MvY3JpLXRvb2xzL3JlbGVhc2VzL2Rvd25sb2FkLyR7Q1JJX1RPT0xTX1JFTEVBU0V9IgpjcmlfdG9vbHNfZmlsZW5hbWU9ImNyaWN0bC0ke0NSSV9UT09MU19SRUxFQVNFfS1saW51eC0ke2FyY2h9LnRhci5neiIKY3VybCAtTGZvICIkb3B0X2Jpbi8kY3JpX3Rvb2xzX2ZpbGVuYW1lIiAiJGNyaV90b29sc19iYXNlX3VybC8kY3JpX3Rvb2xzX2ZpbGVuYW1lIgpjcmlfdG9vbHNfc3VtX3ZhbHVlPSQoY3VybCAtTGYgIiRjcmlfdG9vbHNfYmFzZV91cmwvJGNyaV90b29sc19maWxlbmFtZS5zaGEyNTYiKQpjcmlfdG9vbHNfc3VtPSIkY3JpX3Rvb2xzX3N1bV92YWx1ZSAkY3JpX3Rvb2xzX2ZpbGVuYW1lIgpjZCAiJG9wdF9iaW4iCnNoYTI1NnN1bSAtYyA8PDwiJGNyaV90b29sc19zdW0iCnRhciB4dmYgIiRjcmlfdG9vbHNfZmlsZW5hbWUiCnJtIC1mICIkY3JpX3Rvb2xzX2ZpbGVuYW1lIgpsbiAtc2YgIiRvcHRfYmluL2NyaWN0bCIgIiR1c3JfbG9jYWxfYmluIi9jcmljdGwgfHwgZWNobyAic3ltYm9saWMgbGluayBpcyBza2lwcGVkIgpjZCAtCktVQkVfVkVSU0lPTj0iJHtLVUJFX1ZFUlNJT046LXYxLjI5LjB9IgprdWJlX2Rpcj0iJG9wdF9iaW4va3ViZXJuZXRlcy0kS1VCRV9WRVJTSU9OIgprdWJlX2Jhc2VfdXJsPSJodHRwczovL2RsLms4cy5pby8kS1VCRV9WRVJTSU9OL2Jpbi9saW51eC8kYXJjaCIKa3ViZV9zdW1fZmlsZT0iJGt1YmVfZGlyL3NoYTI1NiIKbWtkaXIgLXAgIiRrdWJlX2RpciIKOiA+IiRrdWJlX3N1bV9maWxlIgoKZm9yIGJpbiBpbiBrdWJlbGV0IGt1YmVhZG0ga3ViZWN0bDsgZG8KICAgIGN1cmwgLUxmbyAiJGt1YmVfZGlyLyRiaW4iICIka3ViZV9iYXNlX3VybC8kYmluIgogICAgY2htb2QgK3ggIiRrdWJlX2Rpci8kYmluIgogICAgc3VtPSQoY3VybCAtTGYgIiRrdWJlX2Jhc2VfdXJsLyRiaW4uc2hhMjU2IikKICAgIGVjaG8gIiRzdW0gICRrdWJlX2Rpci8kYmluIiA+PiIka3ViZV9zdW1fZmlsZSIKZG9uZQpzaGEyNTZzdW0gLWMgIiRrdWJlX3N1bV9maWxlIgoKZm9yIGJpbiBpbiBrdWJlbGV0IGt1YmVhZG0ga3ViZWN0bDsgZG8KICAgIGxuIC1zZiAiJGt1YmVfZGlyLyRiaW4iICIkb3B0X2JpbiIvJGJpbgpkb25lCgojIHNldCBrdWJlbGV0IG5vZGVpcCBlbnZpcm9ubWVudCB2YXJpYWJsZQovb3B0L2Jpbi9zZXR1cF9uZXRfZW52LnNoCmN1cmwgLXMgLWsgLXYgLS1oZWFkZXIgJ0F1dGhvcml6YXRpb246IEJlYXJlciB0b3Atc2VjcmV0JyBodHRwczovL2Zvby5iYXI6NjQ0My9hcGkvdjEvbmFtZXNwYWNlcy9jbG91ZC1pbml0LXNldHRpbmdzL3NlY3JldHMva3ViZS1zeXN0ZW0tdWJ1bnR1LWF3cy1rdWJlbGV0LWJvb3RzdHJhcC1jb25maWcgfCBqcSAnLmRhdGFbImt1YmVjb25maWciXScgLXJ8IGJhc2U2NCAtZCA+IC9ldGMva3ViZXJuZXRlcy9ib290c3RyYXAta3ViZWxldC5jb25mCgpzeXN0ZW1jdGwgZW5hYmxlIC0tbm93IGt1YmVsZXQKc3lzdGVtY3RsIGVuYWJsZSAtLW5vdyAtLW5vLWJsb2NrIGt1YmVsZXQtaGVhbHRoY2hlY2suc2VydmljZQpzeXN0ZW1jdGwgZGlzYWJsZSBzZXR1cC5zZXJ2aWNlCg==

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

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

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

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

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

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

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

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

- 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-dualstack-IPv6+IPv4-provisioning.yaml b/pkg/controllers/osc/testdata/secret-ubuntu-aws-dualstack-IPv6+IPv4-provisioning.yaml index 14c5a908..82720c59 100644 --- a/pkg/controllers/osc/testdata/secret-ubuntu-aws-dualstack-IPv6+IPv4-provisioning.yaml +++ b/pkg/controllers/osc/testdata/secret-ubuntu-aws-dualstack-IPv6+IPv4-provisioning.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

- path: '/etc/sysctl.d/k8s.conf'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQpuZXQuaXB2Ni5jb25mLmFsbC5mb3J3YXJkaW5nID0gMQojIENvbmZpZ3VyZSBMaW51eCB0byBhY2NlcHQgcm91dGVyIGFkdmVydGlzZW1lbnRzIHRvIGVuc3VyZSB0aGUgZGVmYXVsdAojIElQdjYgcm91dGUgaXMgbm90IHJlbW92ZWQgZnJvbSB0aGUgcm91dGluZyB0YWJsZSB3aGVuIHRoZSBEb2NrZXIgc2VydmljZSBzdGFydHMuCiMgRm9yIG1vcmUgaW5mb3JtYXRpb246IGh0dHBzOi8vZ2l0aHViLmNvbS9kb2NrZXIvZm9yLWxpbnV4L2lzc3Vlcy84NDQKbmV0LmlwdjYuY29uZi5hbGwuYWNjZXB0X3JhCQk9IDIKdm0ub3ZlcmNvbW1pdF9tZW1vcnkgPSAxCmZzLmlub3RpZnkubWF4X3VzZXJfd2F0Y2hlcyA9IDEwNDg1NzYKZnMuaW5vdGlmeS5tYXhfdXNlcl9pbnN0YW5jZXMgPSA4MTkyCg==

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

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

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

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

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

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

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

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

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

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

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

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

- path: '/etc/sysctl.d/k8s.conf'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQpuZXQuaXB2Ni5jb25mLmFsbC5mb3J3YXJkaW5nID0gMQojIENvbmZpZ3VyZSBMaW51eCB0byBhY2NlcHQgcm91dGVyIGFkdmVydGlzZW1lbnRzIHRvIGVuc3VyZSB0aGUgZGVmYXVsdAojIElQdjYgcm91dGUgaXMgbm90IHJlbW92ZWQgZnJvbSB0aGUgcm91dGluZyB0YWJsZSB3aGVuIHRoZSBEb2NrZXIgc2VydmljZSBzdGFydHMuCiMgRm9yIG1vcmUgaW5mb3JtYXRpb246IGh0dHBzOi8vZ2l0aHViLmNvbS9kb2NrZXIvZm9yLWxpbnV4L2lzc3Vlcy84NDQKbmV0LmlwdjYuY29uZi5hbGwuYWNjZXB0X3JhCQk9IDIKdm0ub3ZlcmNvbW1pdF9tZW1vcnkgPSAxCmZzLmlub3RpZnkubWF4X3VzZXJfd2F0Y2hlcyA9IDEwNDg1NzYKZnMuaW5vdGlmeS5tYXhfdXNlcl9pbnN0YW5jZXMgPSA4MTkyCg==

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

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

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

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

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

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

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

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

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

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

- 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-dualstack-provisioning.yaml b/pkg/controllers/osc/testdata/secret-ubuntu-aws-dualstack-provisioning.yaml index 8f2039b5..ec475ae6 100644 --- a/pkg/controllers/osc/testdata/secret-ubuntu-aws-dualstack-provisioning.yaml +++ b/pkg/controllers/osc/testdata/secret-ubuntu-aws-dualstack-provisioning.yaml @@ -1,6 +1,6 @@ apiVersion: v1 data: - cloud-config: #cloud-config

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

- path: '/etc/sysctl.d/k8s.conf'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQpuZXQuaXB2Ni5jb25mLmFsbC5mb3J3YXJkaW5nID0gMQojIENvbmZpZ3VyZSBMaW51eCB0byBhY2NlcHQgcm91dGVyIGFkdmVydGlzZW1lbnRzIHRvIGVuc3VyZSB0aGUgZGVmYXVsdAojIElQdjYgcm91dGUgaXMgbm90IHJlbW92ZWQgZnJvbSB0aGUgcm91dGluZyB0YWJsZSB3aGVuIHRoZSBEb2NrZXIgc2VydmljZSBzdGFydHMuCiMgRm9yIG1vcmUgaW5mb3JtYXRpb246IGh0dHBzOi8vZ2l0aHViLmNvbS9kb2NrZXIvZm9yLWxpbnV4L2lzc3Vlcy84NDQKbmV0LmlwdjYuY29uZi5hbGwuYWNjZXB0X3JhCQk9IDIKdm0ub3ZlcmNvbW1pdF9tZW1vcnkgPSAxCmZzLmlub3RpZnkubWF4X3VzZXJfd2F0Y2hlcyA9IDEwNDg1NzYKZnMuaW5vdGlmeS5tYXhfdXNlcl9pbnN0YW5jZXMgPSA4MTkyCg==

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

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

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

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

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

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

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

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

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

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

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

ssh_pwauth: false

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'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    W0pvdXJuYWxdClN5c3RlbU1heFVzZT01Rwo=

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

- path: '/etc/sysctl.d/k8s.conf'
  permissions: '0644'
  encoding: 'b64'
  content: |-
    bmV0LmJyaWRnZS5icmlkZ2UtbmYtY2FsbC1pcDZ0YWJsZXMgPSAxCm5ldC5icmlkZ2UuYnJpZGdlLW5mLWNhbGwtaXB0YWJsZXMgPSAxCmtlcm5lbC5wYW5pY19vbl9vb3BzID0gMQprZXJuZWwucGFuaWMgPSAxMApuZXQuaXB2NC5pcF9mb3J3YXJkID0gMQpuZXQuaXB2Ni5jb25mLmFsbC5mb3J3YXJkaW5nID0gMQojIENvbmZpZ3VyZSBMaW51eCB0byBhY2NlcHQgcm91dGVyIGFkdmVydGlzZW1lbnRzIHRvIGVuc3VyZSB0aGUgZGVmYXVsdAojIElQdjYgcm91dGUgaXMgbm90IHJlbW92ZWQgZnJvbSB0aGUgcm91dGluZyB0YWJsZSB3aGVuIHRoZSBEb2NrZXIgc2VydmljZSBzdGFydHMuCiMgRm9yIG1vcmUgaW5mb3JtYXRpb246IGh0dHBzOi8vZ2l0aHViLmNvbS9kb2NrZXIvZm9yLWxpbnV4L2lzc3Vlcy84NDQKbmV0LmlwdjYuY29uZi5hbGwuYWNjZXB0X3JhCQk9IDIKdm0ub3ZlcmNvbW1pdF9tZW1vcnkgPSAxCmZzLmlub3RpZnkubWF4X3VzZXJfd2F0Y2hlcyA9IDEwNDg1NzYKZnMuaW5vdGlmeS5tYXhfdXNlcl9pbnN0YW5jZXMgPSA4MTkyCg==

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

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

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

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

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

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

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

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

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

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

- path: '/etc/containerd/config.toml'
  permissions: '0600'
  encoding: 'b64'
  content: |-
    dmVyc2lvbiA9IDIKClttZXRyaWNzXQphZGRyZXNzID0gIjEyNy4wLjAuMToxMzM4IgoKW3BsdWdpbnNdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIl0Kc2FuZGJveF9pbWFnZSA9ICIxOTIuMTY4LjEwMC4xMDA6NTAwMC9rdWJlcm5ldGVzL3BhdXNlOnYzLjEiCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5jb250YWluZXJkXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIuY29udGFpbmVyZC5ydW50aW1lc10KW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuY10KcnVudGltZV90eXBlID0gImlvLmNvbnRhaW5lcmQucnVuYy52MiIKW3BsdWdpbnMuImlvLmNvbnRhaW5lcmQuZ3JwYy52MS5jcmkiLmNvbnRhaW5lcmQucnVudGltZXMucnVuYy5vcHRpb25zXQpTeXN0ZW1kQ2dyb3VwID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnldCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5taXJyb3JzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkubWlycm9ycy4iZG9ja2VyLmlvIl0KZW5kcG9pbnQgPSBbImh0dHBzOi8vcmVnaXN0cnkuZG9ja2VyLWNuLmNvbSJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTAuMC4wLjE6NTAwMCJdCltwbHVnaW5zLiJpby5jb250YWluZXJkLmdycGMudjEuY3JpIi5yZWdpc3RyeS5jb25maWdzLiIxMC4wLjAuMTo1MDAwIi50bHNdCmluc2VjdXJlX3NraXBfdmVyaWZ5ID0gdHJ1ZQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiXQpbcGx1Z2lucy4iaW8uY29udGFpbmVyZC5ncnBjLnYxLmNyaSIucmVnaXN0cnkuY29uZmlncy4iMTkyLjE2OC4xMDAuMTAwOjUwMDAiLnRsc10KaW5zZWN1cmVfc2tpcF92ZXJpZnkgPSB0cnVlCgo=
 immutable: true kind: Secret metadata: