X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=installers%2Finstall_kubeadm_cluster.sh;h=70f6d9daf7c6b764c0d954891b536198333ae457;hb=HEAD;hp=972fef16f5559c103a9eb108b52f013b025636e0;hpb=c1ae239c3440000ce6d9ec47386e13d67c13e815;p=osm%2Fdevops.git

diff --git a/installers/install_kubeadm_cluster.sh b/installers/install_kubeadm_cluster.sh
index 972fef16..f0171d0d 100755
--- a/installers/install_kubeadm_cluster.sh
+++ b/installers/install_kubeadm_cluster.sh
@@ -15,221 +15,104 @@
 
 set +eux
 
-#installs kubernetes packages
+K8S_VERSION=1.29
+K8S_PACKAGE_VERSION="$K8S_VERSION".3-1.1
+
+# installs kubernetes packages
 function install_kube() {
     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
-    K8S_VERSION=1.20.14-00
     # Kubernetes releases can be found here: https://kubernetes.io/releases/
     # To check other available versions, run the following command
     # curl -s https://packages.cloud.google.com/apt/dists/kubernetes-xenial/main/binary-amd64/Packages | grep Version | awk '{print $2}'
-    sudo apt-get update && sudo apt-get install -y apt-transport-https
-    sudo apt-get update && sudo apt-get install -y apt-transport-https
-    curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
-    sudo add-apt-repository "deb https://apt.kubernetes.io/ kubernetes-xenial main"
-    sudo apt-get update
+    sudo apt-get -y update && sudo apt-get install -y apt-transport-https ca-certificates curl
+    curl -fsSL https://pkgs.k8s.io/core:/stable:/v"$K8S_VERSION"/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
+    echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v'$K8S_VERSION'/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
+    sudo apt-get -y update
     echo "Installing Kubernetes Packages ..."
-    sudo apt-get install -y kubelet=${K8S_VERSION} kubeadm=${K8S_VERSION} kubectl=${K8S_VERSION}
+    sudo apt-get install -y kubelet=${K8S_PACKAGE_VERSION} kubeadm=${K8S_PACKAGE_VERSION} kubectl=${K8S_PACKAGE_VERSION}
     sudo apt-mark hold kubelet kubeadm kubectl
     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 }
 
-#initializes kubernetes control plane
+# check and track kube packages installation
+function check_and_track_kube_install() {
+    [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
+    kubelet_version=$(dpkg -s kubelet|grep Version|awk '{print $2}')
+    [ -n "${kubelet_version}" ] || FATAL_TRACK k8scluster "Kubelet was not installed."
+    kubeadm_version=$(dpkg -s kubeadm|grep Version|awk '{print $2}')
+    [ -n "${kubeadm_version}" ] || FATAL_TRACK k8scluster "Kubeadm was not installed."
+    kubectl_version=$(dpkg -s kubectl|grep Version|awk '{print $2}')
+    [ -n "${kubectl_version}" ] || FATAL_TRACK k8scluster "Kubectl was not installed."
+    track k8scluster install_k8s_ok none none none kubelet ${kubelet_version} none none kubeadm ${kubeadm_version} none none kubectl ${kubectl_version} none none
+    [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
+}
+
+# initializes kubernetes control plane
 function init_kubeadm() {
     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
     sudo swapoff -a
     sudo sed -i.bak '/.*none.*swap/s/^\(.*\)$/#\1/g' /etc/fstab
+    sudo kubeadm init --config $1 --dry-run || FATAL_TRACK k8scluster "kubeadm init dry-run failed"
     sudo kubeadm init --config $1
     sleep 5
     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 }
 
+# Initializes kubeconfig file
 function kube_config_dir() {
     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
     K8S_MANIFEST_DIR="/etc/kubernetes/manifests"
-    [ ! -d $K8S_MANIFEST_DIR ] && FATAL "Cannot Install Kubernetes"
+    [ ! -d $K8S_MANIFEST_DIR ] && FATAL_TRACK k8scluster "Kubernetes folder $K8S_MANIFEST_DIR was not found"
     mkdir -p $HOME/.kube
     sudo cp /etc/kubernetes/admin.conf $HOME/.kube/config
     sudo chown $(id -u):$(id -g) $HOME/.kube/config
     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 }
 
-#deploys flannel as daemonsets
+# test kubernetes installation
+function check_and_track_init_k8s() {
+    [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
+    echo "Reading existing namespaces"
+    kubectl get ns || FATAL_TRACK k8scluster "Failed getting namespaces"
+    track k8scluster init_k8s_ok
+    [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
+}
+
+# deploys flannel as daemonsets
 function deploy_cni_provider() {
     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
     CNI_DIR="$(mktemp -d -q --tmpdir "flannel.XXXXXX")"
     trap 'rm -rf "${CNI_DIR}"' EXIT
-    wget -q https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml -P $CNI_DIR
+    KUBE_FLANNEL_FILE_URL="https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml"
+    wget --retry-on-host-error --retry-on-http-error 404,429,503 --tries=5 "${KUBE_FLANNEL_FILE_URL}" -P $CNI_DIR
+    [ ! -f $CNI_DIR/kube-flannel.yml ] && FATAL_TRACK k8scluster "Cannot Install Flannel because $CNI_DIR/kube-flannel.yml was not found. Maybe the file ${KUBE_FLANNEL_FILE_URL} is temporarily not accessible"
     kubectl apply -f $CNI_DIR
-    [ $? -ne 0 ] && FATAL "Cannot Install Flannel"
+    [ $? -ne 0 ] && FATAL_TRACK k8scluster "Cannot Install Flannel"
     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 }
 
-#taints K8s master node
+# taints K8s master node
 function taint_master_node() {
     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
-    K8S_MASTER=$(kubectl get nodes | awk '$3~/master/'| awk '{print $1}')
-    kubectl taint node $K8S_MASTER node-role.kubernetes.io/master:NoSchedule-
+    K8S_MASTER=$(kubectl get nodes | awk '$3~/control-plane/'| awk '{print $1; exit}')
+    kubectl taint node $K8S_MASTER node-role.kubernetes.io/control-plane:NoSchedule-
     sleep 5
     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 }
 
-#Install Helm v3
-#Helm releases can be found here: https://github.com/helm/helm/releases
-function install_helm() {
-    [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
-    HELM_VERSION="v3.7.2"
-    if ! [[ "$(helm version --short 2>/dev/null)" =~ ^v3.* ]]; then
-        # Helm is not installed. Install helm
-        echo "Helm3 is not installed, installing ..."
-        curl https://get.helm.sh/helm-${HELM_VERSION}-linux-amd64.tar.gz --output helm-${HELM_VERSION}.tar.gz
-        tar -zxvf helm-${HELM_VERSION}.tar.gz
-        sudo mv linux-amd64/helm /usr/local/bin/helm
-        rm -r linux-amd64
-        rm helm-${HELM_VERSION}.tar.gz
-    else
-        echo "Helm3 is already installed. Skipping installation..."
-    fi
-    helm repo add stable https://charts.helm.sh/stable
-    helm repo update
-    [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
-}
-
-function install_k8s_storageclass() {
-    [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
-    OPENEBS_VERSION="1.12.0"
-    echo "Installing OpenEBS"
-    helm repo add openebs https://openebs.github.io/charts
-    helm repo update
-    helm install --create-namespace --namespace openebs openebs openebs/openebs --version ${OPENEBS_VERSION}
-    helm ls -n openebs
-    local storageclass_timeout=400
-    local counter=0
-    local storageclass_ready=""
-    echo "Waiting for storageclass"
-    while (( counter < storageclass_timeout ))
-    do
-        kubectl get storageclass openebs-hostpath &> /dev/null
-
-        if [ $? -eq 0 ] ; then
-            echo "Storageclass available"
-            storageclass_ready="y"
-            break
-        else
-            counter=$((counter + 15))
-            sleep 15
-        fi
-    done
-    [ -n "$storageclass_ready" ] || FATAL "Storageclass not ready after $storageclass_timeout seconds. Cannot install openebs"
-    kubectl patch storageclass openebs-hostpath -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'
-    [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
-}
-
-#installs metallb from helm
-function install_helm_metallb() {
+# check and track kube packages installation
+function check_and_track_k8s_ready_before_helm() {
     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
-    echo "Installing MetalLB"
-    METALLB_VERSION="0.11.0"
-    METALLB_IP_RANGE="$DEFAULT_IP/32"
-    echo "configInline:
-  address-pools:
-   - name: default
-     protocol: layer2
-     addresses:
-     - $METALLB_IP_RANGE" | sudo tee -a ${OSM_DOCKER_WORK_DIR}/metallb-config.yaml
-    helm repo add metallb https://metallb.github.io/metallb
-    helm repo update
-    helm install --create-namespace --namespace metallb-system metallb metallb/metallb --version ${METALLB_VERSION} -f ${OSM_DOCKER_WORK_DIR}/metallb-config.yaml
+    kubectl get events || FATAL_TRACK k8scluster "Failed getting events"
+    track k8scluster k8s_ready_before_helm
     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 }
 
-#checks openebs and metallb readiness
-function check_for_readiness() {
-    [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
-    # Default input values
-    sampling_period=2       # seconds
-    time_for_readiness=20   # seconds ready
-    time_for_failure=200    # seconds broken
-    OPENEBS_NAMESPACE=openebs
-    METALLB_NAMESPACE=metallb-system
-    # STACK_NAME=osm          # By default, "osm"
-
-    # Equivalent number of samples
-    oks_threshold=$((time_for_readiness/${sampling_period}))     # No. ok samples to declare the system ready
-    failures_threshold=$((time_for_failure/${sampling_period}))  # No. nok samples to declare the system broken
-    failures_in_a_row=0
-    oks_in_a_row=0
-
-    ####################################################################################
-    # Loop to check system readiness
-    ####################################################################################
-    while [[ (${failures_in_a_row} -lt ${failures_threshold}) && (${oks_in_a_row} -lt ${oks_threshold}) ]]
-    do
-        # State of OpenEBS
-        OPENEBS_STATE=$(kubectl get pod -n ${OPENEBS_NAMESPACE} --no-headers 2>&1)
-        OPENEBS_READY=$(echo "${OPENEBS_STATE}" | awk '$2=="1/1" || $2=="2/2" {printf ("%s\t%s\t\n", $1, $2)}')
-        OPENEBS_NOT_READY=$(echo "${OPENEBS_STATE}" | awk '$2!="1/1" && $2!="2/2" {printf ("%s\t%s\t\n", $1, $2)}')
-        COUNT_OPENEBS_READY=$(echo "${OPENEBS_READY}"| grep -v -e '^$' | wc -l)
-        COUNT_OPENEBS_NOT_READY=$(echo "${OPENEBS_NOT_READY}" | grep -v -e '^$' | wc -l)
-
-        # State of MetalLB
-        METALLB_STATE=$(kubectl get pod -n ${METALLB_NAMESPACE} --no-headers 2>&1)
-        METALLB_READY=$(echo "${METALLB_STATE}" | awk '$2=="1/1" || $2=="2/2" {printf ("%s\t%s\t\n", $1, $2)}')
-        METALLB_NOT_READY=$(echo "${METALLB_STATE}" | awk '$2!="1/1" && $2!="2/2" {printf ("%s\t%s\t\n", $1, $2)}')
-        COUNT_METALLB_READY=$(echo "${METALLB_READY}" | grep -v -e '^$' | wc -l)
-        COUNT_METALLB_NOT_READY=$(echo "${METALLB_NOT_READY}" | grep -v -e '^$' | wc -l)
-
-        # OK sample
-        if [[ $((${COUNT_OPENEBS_NOT_READY}+${COUNT_METALLB_NOT_READY})) -eq 0 ]]
-        then
-            ((++oks_in_a_row))
-            failures_in_a_row=0
-            echo -ne ===\> Successful checks: "${oks_in_a_row}"/${oks_threshold}\\r
-        # NOK sample
-        else
-            ((++failures_in_a_row))
-            oks_in_a_row=0
-            echo
-            echo Bootstraping... "${failures_in_a_row}" checks of ${failures_threshold}
-
-            # Reports failed pods in OpenEBS
-            if [[ "${COUNT_OPENEBS_NOT_READY}" -ne 0 ]]
-            then
-                echo "OpenEBS: Waiting for ${COUNT_OPENEBS_NOT_READY} of $((${COUNT_OPENEBS_NOT_READY}+${COUNT_OPENEBS_READY})) pods to be ready:"
-                echo "${OPENEBS_NOT_READY}"
-                echo
-            fi
-
-            # Reports failed statefulsets
-            if [[ "${COUNT_METALLB_NOT_READY}" -ne 0 ]]
-            then
-                echo "MetalLB: Waiting for ${COUNT_METALLB_NOT_READY} of $((${COUNT_METALLB_NOT_READY}+${COUNT_METALLB_READY})) pods to be ready:"
-                echo "${METALLB_NOT_READY}"
-                echo
-            fi
-        fi
-
-        #------------ NEXT SAMPLE
-        sleep ${sampling_period}
-    done
-
-    ####################################################################################
-    # OUTCOME
-    ####################################################################################
-    if [[ (${failures_in_a_row} -ge ${failures_threshold}) ]]
-    then
-        echo
-        FATAL "K8S CLUSTER IS BROKEN"
-    else
-        echo
-        echo "K8S CLUSTER IS READY"
-    fi
-    [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
-}
-
-#removes osm deployments and services
+# removes osm deployments and services
 function remove_k8s_namespace() {
     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
-    kubectl delete ns $1
+    echo "Deleting existing namespace $1: kubectl delete ns $1"
+    kubectl delete ns $1 2>/dev/null
     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 }
 
@@ -240,7 +123,7 @@ while getopts ":D:d:i:-: " o; do
             DEFAULT_IP="${OPTARG}"
             ;;
         d)
-            OSM_DOCKER_WORK_DIR="${OPTARG}"
+            OSM_CLUSTER_WORK_DIR="${OPTARG}"
             ;;
         D)
             OSM_DEVOPS="${OPTARG}"
@@ -268,33 +151,31 @@ source $OSM_DEVOPS/common/logging
 source $OSM_DEVOPS/common/track
 
 echo "DEBUG_INSTALL=$DEBUG_INSTALL"
-echo "DEFAULT_IP=$DEFAULT_IP"
 echo "OSM_DEVOPS=$OSM_DEVOPS"
-echo "OSM_DOCKER_WORK_DIR=$OSM_DOCKER_WORK_DIR"
-echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR"
+echo "OSM_CLUSTER_WORK_DIR=$OSM_CLUSTER_WORK_DIR"
 echo "HOME=$HOME"
 
+echo "Creating folders for installation"
+[ ! -d "$OSM_CLUSTER_WORK_DIR" ] && sudo mkdir -p $OSM_CLUSTER_WORK_DIR
+echo "Copying kubeadm-config from $OSM_DEVOPS/installers/kubeadm-config.yaml to $OSM_CLUSTER_WORK_DIR/kubeadm-config.yaml"
+sudo cp -b $OSM_DEVOPS/installers/kubeadm-config.yaml $OSM_CLUSTER_WORK_DIR/kubeadm-config.yaml
 
 install_kube
-track k8scluster install_k8s_ok
-init_kubeadm $OSM_DOCKER_WORK_DIR/cluster-config.yaml
+check_and_track_kube_install
+
+init_kubeadm $OSM_CLUSTER_WORK_DIR/kubeadm-config.yaml
 kube_config_dir
-track k8scluster init_k8s_ok
-if [ -n "$INSTALL_K8S_MONITOR" ]; then
-    # uninstall OSM MONITORING
-    uninstall_k8s_monitoring
-    track k8scluster uninstall_k8s_monitoring_ok
-fi
-#remove old namespace
-remove_k8s_namespace osm
+check_and_track_init_k8s
+
 deploy_cni_provider
 taint_master_node
-install_helm
+check_and_track_k8s_ready_before_helm
+
+remove_k8s_namespace osm
+
+# install_helm has been moved to install_helm_client.sh, run from full_install_osm.sh,
+# but tracking is still here because the installation analytics still expects it
 track k8scluster install_helm_ok
-install_k8s_storageclass
-track k8scluster k8s_storageclass_ok
-install_helm_metallb
-track k8scluster k8s_metallb_ok
-check_for_readiness
-track k8scluster k8s_ready_ok
 
+# Installation of storage class, metallb and cert-manager has been moved
+# to install_cluster_addons.sh, run from full_install_osm.sh