| #!/bin/bash |
| # |
| # 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. |
| # |
| |
| function usage(){ |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| echo -e "usage: $0 [OPTIONS]" |
| echo -e "Install OSM" |
| echo -e " OPTIONS" |
| echo -e " -h / --help: print this help" |
| echo -e " -y: do not prompt for confirmation, assumes yes" |
| echo -e " -r <repo>: use specified repository name for osm packages" |
| echo -e " -R <release>: use specified release for osm binaries (deb packages, ...)" |
| echo -e " -u <repo base>: use specified repository url for osm packages" |
| echo -e " -k <repo key>: use specified repository public key url" |
| echo -e " -a <apt proxy url>: use this apt proxy url when downloading apt packages (air-gapped installation)" |
| echo -e " -c <kubernetes engine>: use a specific kubernetes engine (options: kubeadm, k3s), default is kubeadm" |
| echo -e " -t <docker tag> specify osm docker tag (default is latest)" |
| echo -e " -M <KUBECONFIG_FILE>: Kubeconfig of an existing cluster to be used as mgmt cluster instead of OSM cluster" |
| echo -e " -G <KUBECONFIG_FILE>: Kubeconfig of an existing cluster to be used as auxiliary cluster instead of OSM cluster" |
| echo -e " --no-mgmt-cluster: Do not provision a mgmt cluster for cloud-native gitops operations in OSM (NEW in Release SIXTEEN) (by default, it is installed)" |
| echo -e " --no-aux-cluster: Do not provision an auxiliary cluster for cloud-native gitops operations in OSM (NEW in Release SIXTEEN) (by default, it is installed)" |
| echo -e " -D <devops path>: use local devops installation path" |
| echo -e " -s <namespace> namespace when installed using k8s, default is osm" |
| echo -e " -w <work dir>: Location to store runtime installation" |
| echo -e " -K: Specifies the name of the controller to use - The controller must be already bootstrapped" |
| echo -e " -d <docker registry URL> use docker registry URL instead of dockerhub" |
| echo -e " -p <docker proxy URL> set docker proxy URL as part of docker CE configuration" |
| echo -e " -T <docker tag> specify docker tag for the modules specified with option -m" |
| echo -e " --debug: debug mode" |
| echo -e " --nodocker: do not install docker, do not initialize a swarm (assumes docker is already installed and a swarm has been initialized)" |
| echo -e " --nohostclient: do not install the osmclient" |
| echo -e " --uninstall: uninstall OSM: remove the containers and delete NAT rules" |
| echo -e " --k8s_monitor: install the OSM kubernetes monitoring with prometheus and grafana" |
| echo -e " --showopts: print chosen options and exit (only for debugging)" |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function generate_secret() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| head /dev/urandom | tr -dc A-Za-z0-9 | head -c 32 |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function check_packages() { |
| NEEDED_PACKAGES="$1" |
| echo -e "Checking required packages: ${NEEDED_PACKAGES}" |
| for PACKAGE in ${NEEDED_PACKAGES} ; do |
| dpkg -L ${PACKAGE} |
| if [ $? -ne 0 ]; then |
| echo -e "Package ${PACKAGE} is not installed." |
| echo -e "Updating apt-cache ..." |
| sudo apt-get update |
| echo -e "Installing ${PACKAGE} ..." |
| sudo apt-get install -y ${PACKAGE} || FATAL "failed to install ${PACKAGE}" |
| fi |
| done |
| echo -e "Required packages are present: ${NEEDED_PACKAGES}" |
| } |
| |
| function ask_user(){ |
| # ask to the user and parse a response among 'y', 'yes', 'n' or 'no'. Case insensitive |
| # Params: $1 text to ask; $2 Action by default, can be 'y' for yes, 'n' for no, other or empty for not allowed |
| # Return: true(0) if user type 'yes'; false (1) if user type 'no' |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| read -e -p "$1" USER_CONFIRMATION |
| while true ; do |
| [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'y' ] && return 0 |
| [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'n' ] && return 1 |
| [ "${USER_CONFIRMATION,,}" == "yes" ] || [ "${USER_CONFIRMATION,,}" == "y" ] && return 0 |
| [ "${USER_CONFIRMATION,,}" == "no" ] || [ "${USER_CONFIRMATION,,}" == "n" ] && return 1 |
| read -e -p "Please type 'yes' or 'no': " USER_CONFIRMATION |
| done |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function install_osmclient(){ |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| CLIENT_RELEASE=${RELEASE#"-R "} |
| CLIENT_REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg" |
| CLIENT_REPOSITORY=${REPOSITORY#"-r "} |
| CLIENT_REPOSITORY_BASE=${REPOSITORY_BASE#"-u "} |
| key_location=$CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE/$CLIENT_REPOSITORY_KEY |
| curl $key_location | sudo APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE=1 apt-key add - |
| sudo add-apt-repository -y "deb [arch=amd64] $CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE $CLIENT_REPOSITORY osmclient IM" |
| sudo apt-get -y update |
| sudo DEBIAN_FRONTEND=noninteractive apt-get install -y python3-pip |
| sudo -H LC_ALL=C python3 -m pip install -U pip |
| sudo DEBIAN_FRONTEND=noninteractive apt-get install -y python3-osm-im python3-osmclient |
| if [ -f /usr/lib/python3/dist-packages/osm_im/requirements.txt ]; then |
| python3 -m pip install -r /usr/lib/python3/dist-packages/osm_im/requirements.txt |
| fi |
| if [ -f /usr/lib/python3/dist-packages/osmclient/requirements.txt ]; then |
| sudo DEBIAN_FRONTEND=noninteractive apt-get install -y libmagic1 |
| python3 -m pip install -r /usr/lib/python3/dist-packages/osmclient/requirements.txt |
| fi |
| echo -e "\nOSM client installed" |
| echo "You can get the OSM NBI endpoint using the following command" |
| echo ' kubectl -n osm get ingress nbi-ingress -o jsonpath="{.spec.rules[0].host}"' |
| echo "You will have to configure this env variable in your .bashrc file:" |
| echo " export OSM_HOSTNAME=nbi.${OSM_K8S_EXTERNAL_IP}.nip.io" |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| return 0 |
| } |
| |
| function docker_login() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| echo "Docker login" |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG "Docker registry user: ${DOCKER_REGISTRY_USER}" |
| sg docker -c "docker login -u ${DOCKER_REGISTRY_USER} -p ${DOCKER_REGISTRY_PASSWORD} --password-stdin" |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| #deploys osm pods and services |
| function deploy_osm_helm_chart() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| # Generate helm values to be passed with -f osm-values.yaml |
| sudo mkdir -p ${OSM_HELM_WORK_DIR} |
| |
| # Generate helm values to be passed with --set |
| OSM_HELM_OPTS="" |
| # OSM_HELM_OPTS="${OSM_HELM_OPTS} --set nbi.useOsmSecret=false" |
| |
| OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.image.repositoryBase=${DOCKER_REGISTRY_URL}${DOCKER_USER}" |
| [ ! "$OSM_DOCKER_TAG" == "testing-daily" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set-string global.image.tag=${OSM_DOCKER_TAG}" |
| [ ! "$OSM_DOCKER_TAG" == "testing-daily" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set prometheus.server.sidecarContainers.prometheus-config-sidecar.image=${DOCKER_REGISTRY_URL}${DOCKER_USER}/prometheus:${OSM_DOCKER_TAG}" |
| |
| OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.hostname=${OSM_K8S_EXTERNAL_IP}.nip.io" |
| OSM_HELM_OPTS="${OSM_HELM_OPTS} --set grafana.ingress.hosts={grafana.${OSM_K8S_EXTERNAL_IP}.nip.io}" |
| OSM_HELM_OPTS="${OSM_HELM_OPTS} --set prometheus.server.ingress.hosts={prometheus.${OSM_K8S_EXTERNAL_IP}.nip.io}" |
| # OSM_HELM_OPTS="${OSM_HELM_OPTS} --set prometheus.alertmanager.ingress.hosts={alertmanager.${OSM_K8S_EXTERNAL_IP}.nip.io}" |
| if [ -z "${INSTALL_MGMT_CLUSTER}" ]; then |
| OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.gitops.enabled=false" |
| else |
| source "${HOME}/.osm/.credentials/gitea_environment.rc" |
| OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.gitops.gitBaseUrl=${GITEA_HTTP_URL}" |
| OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.gitops.gitUser=${GITEA_STD_USERNAME}" |
| AGE_MGMT_PUBKEY=$(tr -d '\n' < ${HOME}/.osm/.credentials/age.mgmt.pub) |
| OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.gitops.pubkey=${AGE_MGMT_PUBKEY}" |
| fi |
| |
| if [ -n "${OSM_BEHIND_PROXY}" ]; then |
| OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.behindHttpProxy=true" |
| [ -n "${HTTP_PROXY}" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.httpProxy.HTTP_PROXY=\"${HTTP_PROXY}\"" |
| [ -n "${HTTPS_PROXY}" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.httpProxy.HTTPS_PROXY=\"${HTTPS_PROXY}\"" |
| if [ -n "${NO_PROXY}" ]; then |
| if [[ ! "${NO_PROXY}" =~ .*".svc".* ]]; then |
| NO_PROXY="${NO_PROXY},.svc" |
| fi |
| if [[ ! "${NO_PROXY}" =~ .*".cluster.local".* ]]; then |
| NO_PROXY="${NO_PROXY},.cluster.local" |
| fi |
| OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.httpProxy.NO_PROXY=\"${NO_PROXY//,/\,}\"" |
| fi |
| fi |
| |
| echo "helm upgrade --install -n $OSM_NAMESPACE --create-namespace $OSM_NAMESPACE $OSM_DEVOPS/installers/helm/osm ${OSM_HELM_OPTS}" |
| helm upgrade --install -n $OSM_NAMESPACE --create-namespace $OSM_NAMESPACE $OSM_DEVOPS/installers/helm/osm ${OSM_HELM_OPTS} |
| # Override existing values.yaml with the final values.yaml used to install OSM |
| helm -n $OSM_NAMESPACE get values $OSM_NAMESPACE | sudo tee -a ${OSM_HELM_WORK_DIR}/osm-values.yaml |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function add_local_k8scluster() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| # OSM_HOSTNAME=$(kubectl get --namespace osm -o jsonpath="{.spec.rules[0].host}" ingress nbi-ingress) |
| OSM_HOSTNAME="nbi.${OSM_K8S_EXTERNAL_IP}.nip.io:443" |
| /usr/bin/osm --hostname ${OSM_HOSTNAME} --all-projects vim-create \ |
| --name _system-osm-vim \ |
| --account_type dummy \ |
| --auth_url http://dummy \ |
| --user osm --password osm --tenant osm \ |
| --description "dummy" \ |
| --config '{management_network_name: mgmt}' |
| /usr/bin/osm --hostname ${OSM_HOSTNAME} --all-projects k8scluster-add \ |
| --creds ${HOME}/.kube/config \ |
| --vim _system-osm-vim \ |
| --k8s-nets '{"net1": null}' \ |
| --version '1.29' \ |
| --description "OSM Internal Cluster" \ |
| _system-osm-k8s |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function configure_apt_proxy() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| OSM_APT_PROXY=$1 |
| OSM_APT_PROXY_FILE="/etc/apt/apt.conf.d/osm-apt" |
| echo "Configuring apt proxy in file ${OSM_APT_PROXY_FILE}" |
| if [ ! -f ${OSM_APT_PROXY_FILE} ]; then |
| sudo bash -c "cat <<EOF > ${OSM_APT_PROXY} |
| Acquire::http { Proxy \"${OSM_APT_PROXY}\"; } |
| EOF" |
| else |
| sudo sed -i "s|Proxy.*|Proxy \"${OSM_APT_PROXY}\"; }|" ${OSM_APT_PROXY_FILE} |
| fi |
| sudo apt-get update || FATAL "Configured apt proxy, but couldn't run 'apt-get update'. Check ${OSM_APT_PROXY_FILE}" |
| track prereq apt_proxy_configured_ok |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function ask_proceed() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| |
| [ -z "$ASSUME_YES" ] && ! ask_user "The installation will do the following |
| 1. Install required packages |
| 2. Install docker CE |
| 3. Disable swap space |
| 4. Install and initialize Kubernetes |
| as pre-requirements. |
| Do you want to proceed (Y/n)? " y && echo "Cancelled!" && exit 1 |
| |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function check_osm_behind_proxy() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| |
| export OSM_BEHIND_PROXY="" |
| export OSM_PROXY_ENV_VARIABLES="" |
| [ -n "${http_proxy}" ] && OSM_BEHIND_PROXY="y" && echo "http_proxy=${http_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} http_proxy" |
| [ -n "${https_proxy}" ] && OSM_BEHIND_PROXY="y" && echo "https_proxy=${https_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} https_proxy" |
| [ -n "${HTTP_PROXY}" ] && OSM_BEHIND_PROXY="y" && echo "HTTP_PROXY=${HTTP_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} HTTP_PROXY" |
| [ -n "${HTTPS_PROXY}" ] && OSM_BEHIND_PROXY="y" && echo "https_proxy=${HTTPS_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} HTTPS_PROXY" |
| [ -n "${no_proxy}" ] && echo "no_proxy=${no_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} no_proxy" |
| [ -n "${NO_PROXY}" ] && echo "NO_PROXY=${NO_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} NO_PROXY" |
| |
| echo "OSM_BEHIND_PROXY=${OSM_BEHIND_PROXY}" |
| echo "OSM_PROXY_ENV_VARIABLES=${OSM_PROXY_ENV_VARIABLES}" |
| |
| if [ -n "${OSM_BEHIND_PROXY}" ]; then |
| [ -z "$ASSUME_YES" ] && ! ask_user " |
| The following env variables have been found for the current user: |
| ${OSM_PROXY_ENV_VARIABLES}. |
| |
| This suggests that this machine is behind a proxy and a special configuration is required. |
| The installer will install Docker CE and a Kubernetes to work behind a proxy using those |
| env variables. |
| |
| Take into account that the installer uses apt, curl, wget and docker. |
| Depending on the program, the env variables to work behind a proxy might be different |
| (e.g. http_proxy vs HTTP_PROXY). |
| |
| For that reason, it is strongly recommended that at least http_proxy, https_proxy, HTTP_PROXY |
| and HTTPS_PROXY are defined. |
| |
| Finally, some of the programs (apt) are run as sudoer, requiring that those env variables |
| are also set for root user. If you are not sure whether those variables are configured for |
| the root user, you can stop the installation now. |
| |
| Do you want to proceed with the installation (Y/n)? " y && echo "Cancelled!" && exit 1 |
| else |
| echo "This machine is not behind a proxy" |
| fi |
| |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function find_devops_folder() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| if [ -z "$OSM_DEVOPS" ]; then |
| echo -e "\nCreating temporary dir for OSM installation" |
| OSM_DEVOPS="$(mktemp -d -q --tmpdir "installosm.XXXXXX")" |
| trap 'rm -rf "$OSM_DEVOPS"' EXIT |
| git clone https://osm.etsi.org/gerrit/osm/devops.git $OSM_DEVOPS |
| fi |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function install_docker_ce() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| DOCKER_CE_OPTS="-D ${OSM_DEVOPS} ${DEBUG_INSTALL}" |
| [ -n "${DOCKER_PROXY_URL}" ] && DOCKER_CE_OPTS="${DOCKER_CE_OPTS} -p ${DOCKER_PROXY_URL}" |
| [ -n "${OSM_BEHIND_PROXY}" ] && DOCKER_CE_OPTS="${DOCKER_CE_OPTS} -P" |
| $OSM_DEVOPS/installers/install_docker_ce.sh ${DOCKER_CE_OPTS} || FATAL_TRACK docker_ce "install_docker_ce.sh failed" |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function install_k8s_cluster() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| if [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ]; then |
| KUBEADM_INSTALL_OPTS="-d ${OSM_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL}" |
| $OSM_DEVOPS/installers/install_kubeadm_cluster.sh ${KUBEADM_INSTALL_OPTS} || \ |
| FATAL_TRACK k8scluster "install_kubeadm_cluster.sh failed" |
| K8SCLUSTER_ADDONS_INSTALL_OPTS="-i ${OSM_DEFAULT_IP} -d ${OSM_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL} --all" |
| $OSM_DEVOPS/installers/install_cluster_addons.sh ${K8SCLUSTER_ADDONS_INSTALL_OPTS} || \ |
| FATAL_TRACK k8scluster "install_cluster_addons.sh failed for kubeadm cluster" |
| elif [ "${K8S_CLUSTER_ENGINE}" == "k3s" ]; then |
| K3S_INSTALL_OPTS="-i ${OSM_DEFAULT_IP} -D ${OSM_DEVOPS} ${DEBUG_INSTALL}" |
| [ "${OSM_K8S_EXTERNAL_IP}" != "${OSM_DEFAULT_IP}" ] && K3S_INSTALL_OPTS="${K3S_INSTALL_OPTS} -e ${OSM_K8S_EXTERNAL_IP}" |
| [ -n "${DOCKER_PROXY_URL}" ] && K3S_INSTALL_OPTS="${K3S_INSTALL_OPTS} -p ${DOCKER_PROXY_URL}" |
| [ -n "${DOCKER_REGISTRY_URL}" ] && K3S_INSTALL_OPTS="${K3S_INSTALL_OPTS} -d ${DOCKER_REGISTRY_URL}" |
| [ -n "${DOCKER_REGISTRY_USER}" ] && K3S_INSTALL_OPTS="${K3S_INSTALL_OPTS} -u ${DOCKER_REGISTRY_USER}" |
| [ -n "${DOCKER_REGISTRY_PASSWORD}" ] && K3S_INSTALL_OPTS="${K3S_INSTALL_OPTS} -P ${DOCKER_REGISTRY_PASSWORD}" |
| # The K3s installation script will automatically take the HTTP_PROXY, HTTPS_PROXY and NO_PROXY, |
| # as well as the CONTAINERD_HTTP_PROXY, CONTAINERD_HTTPS_PROXY and CONTAINERD_NO_PROXY variables |
| # from the shell, if they are present, and write them to the environment file of k3s systemd service, |
| $OSM_DEVOPS/installers/install_k3s_cluster.sh ${K3S_INSTALL_OPTS} || \ |
| FATAL_TRACK k8scluster "install_k3s_cluster.sh failed" |
| K8SCLUSTER_ADDONS_INSTALL_OPTS="-i ${OSM_DEFAULT_IP} -d ${OSM_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL} --certmgr --nginx" |
| $OSM_DEVOPS/installers/install_cluster_addons.sh ${K8SCLUSTER_ADDONS_INSTALL_OPTS} || \ |
| FATAL_TRACK k8scluster "install_cluster_addons.sh failed for k3s cluster" |
| fi |
| echo "Updating fsnotify settings of the system kernel" |
| sudo bash -c "sysctl -w fs.inotify.max_user_watches=699050 > /etc/sysctl.d/99-custom-osm-sysctl.conf" |
| sudo bash -c "sysctl -w fs.inotify.max_user_instances=10922 >> /etc/sysctl.d/99-custom-osm-sysctl.conf" |
| sudo bash -c "sysctl -w fs.inotify.max_queued_events=1398101 >> /etc/sysctl.d/99-custom-osm-sysctl.conf" |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function deploy_osm() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| deploy_osm_helm_chart |
| track deploy_osm deploy_mongodb_ok |
| track deploy_osm deploy_osm_services_k8s_ok |
| track deploy_osm install_osm_ngsa_ok |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function setup_external_ip() { |
| echo "Determining IP address of the interface with the default route" |
| [ -z "$OSM_DEFAULT_IF" ] && OSM_DEFAULT_IF=$(ip route list|awk '$1=="default" {print $5; exit}') |
| [ -z "$OSM_DEFAULT_IF" ] && OSM_DEFAULT_IF=$(route -n |awk '$1~/^0.0.0.0/ {print $8; exit}') |
| [ -z "$OSM_DEFAULT_IF" ] && FATAL "Not possible to determine the interface with the default route 0.0.0.0" |
| OSM_DEFAULT_IP=`ip -o -4 a s ${OSM_DEFAULT_IF} |awk '{split($4,a,"/"); print a[1]; exit}'` |
| [ -z "$OSM_DEFAULT_IP" ] && FATAL "Not possible to determine the IP address of the interface with the default route" |
| OSM_K8S_EXTERNAL_IP=${OSM_K8S_EXTERNAL_IP:-${OSM_DEFAULT_IP}} |
| } |
| |
| function install_osm() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| |
| trap ctrl_c INT |
| |
| check_osm_behind_proxy |
| check_packages "git wget curl tar" |
| find_devops_folder |
| |
| track start release $RELEASE none none docker_tag $OSM_DOCKER_TAG none none installation_type $OSM_INSTALLATION_TYPE none none os_info $os_info none none |
| |
| track checks checkingroot_ok |
| [ "$USER" == "root" ] && FATAL "You are running the installer as root. The installer is prepared to be executed as a normal user with sudo privileges." |
| track checks noroot_ok |
| ask_proceed |
| track checks proceed_ok |
| |
| echo "Installing OSM" |
| |
| [ -n "$DOCKER_REGISTRY_URL" ] && parse_docker_registry_url |
| |
| echo "Setting up external IP address" |
| setup_external_ip |
| |
| # configure apt proxy |
| [ -n "$APT_PROXY_URL" ] && configure_apt_proxy $APT_PROXY_URL |
| |
| track prereq prereqok_ok |
| |
| if [ -n "$INSTALL_DOCKER" ] || [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ]; then |
| if [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ]; then |
| echo "Kubeadm requires docker, so docker will be installed." |
| fi |
| install_docker_ce |
| [ -n "${DOCKER_REGISTRY_URL}" ] && docker_login |
| fi |
| track docker_ce docker_ce_ok |
| |
| echo "Installing helm client ..." |
| $OSM_DEVOPS/installers/install_helm_client.sh -D ${OSM_DEVOPS} ${DEBUG_INSTALL} || \ |
| FATAL_TRACK k8scluster "install_helm_client.sh failed" |
| track helm_client install_helm_client_ok |
| |
| echo "Installing K8s cluster ..." |
| install_k8s_cluster |
| kubectl create namespace ${OSM_NAMESPACE} |
| track k8scluster k8scluster_ok |
| |
| # Install mgmt cluster |
| echo "Installing mgmt cluster ..." |
| MGMTCLUSTER_INSTALL_OPTS="-D ${OSM_DEVOPS} ${DEBUG_INSTALL}" |
| [ -n "${INSTALL_MGMT_CLUSTER}" ] || MGMTCLUSTER_INSTALL_OPTS="${MGMTCLUSTER_INSTALL_OPTS} --no-mgmt-cluster" |
| [ -n "${INSTALL_AUX_CLUSTER}" ] || MGMTCLUSTER_INSTALL_OPTS="${MGMTCLUSTER_INSTALL_OPTS} --no-aux-cluster" |
| export KUBECONFIG_MGMT_CLUSTER=${KUBECONFIG_MGMT_CLUSTER:-"$HOME/.kube/config"} |
| export KUBECONFIG_AUX_CLUSTER=${KUBECONFIG_AUX_CLUSTER:-"$HOME/.kube/config"} |
| MGMTCLUSTER_INSTALL_OPTS="${MGMTCLUSTER_INSTALL_OPTS} -M ${KUBECONFIG_MGMT_CLUSTER}" |
| MGMTCLUSTER_INSTALL_OPTS="${MGMTCLUSTER_INSTALL_OPTS} -G ${KUBECONFIG_AUX_CLUSTER}" |
| echo "Options: ${MGMTCLUSTER_INSTALL_OPTS}" |
| $OSM_DEVOPS/installers/mgmt-cluster/install_mgmt_cluster.sh ${MGMTCLUSTER_INSTALL_OPTS} || \ |
| FATAL_TRACK mgmtcluster "install_mgmt_cluster.sh failed" |
| if [ -n "${INSTALL_MGMT_CLUSTER}" ]; then |
| echo "Credentials stored under ${HOME}/.osm/.credentials" |
| echo "Repos stored under ${HOME}/.osm/repos" |
| fi |
| track mgmtcluster mgmt_and_aux_cluster_ok |
| |
| # Deploy OSM (OSM helm chart) |
| echo "Deploying OSM in the K8s cluster ..." |
| deploy_osm |
| |
| if [ -n "$INSTALL_K8S_MONITOR" ]; then |
| # install OSM MONITORING |
| install_k8s_monitoring |
| track deploy_osm install_k8s_monitoring_ok |
| fi |
| |
| [ -z "$INSTALL_NOHOSTCLIENT" ] && echo "Installing osmclient ..." && install_osmclient |
| track osmclient osmclient_ok |
| |
| echo -e "Checking OSM health state..." |
| $OSM_DEVOPS/installers/osm_health.sh -s ${OSM_NAMESPACE} -k || \ |
| (echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \ |
| echo -e "Check OSM status with: kubectl -n ${OSM_NAMESPACE} get all" && \ |
| track healthchecks osm_unhealthy didnotconverge) |
| track healthchecks after_healthcheck_ok |
| |
| echo -e "Adding local K8s cluster _system-osm-k8s to OSM ..." |
| add_local_k8scluster |
| track final_ops add_local_k8scluster_ok |
| |
| wget -q -O- https://osm-download.etsi.org/ftp/osm-16.0-sixteen/README2.txt &> /dev/null |
| track end |
| sudo find /etc/osm |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| return 0 |
| } |
| |
| function install_k8s_monitoring() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| # install OSM monitoring |
| sudo $OSM_DEVOPS/installers/k8s/install_osm_k8s_monitoring.sh -o ${OSM_NAMESPACE} || FATAL_TRACK install_k8s_monitoring "k8s/install_osm_k8s_monitoring.sh failed" |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function dump_vars(){ |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| echo "APT_PROXY_URL=$APT_PROXY_URL" |
| echo "K8S_CLUSTER_ENGINE=$K8S_CLUSTER_ENGINE" |
| echo "DEBUG_INSTALL=$DEBUG_INSTALL" |
| echo "DOCKER_PROXY_URL=$DOCKER_PROXY_URL" |
| echo "DOCKER_REGISTRY_URL=$DOCKER_REGISTRY_URL" |
| echo "DOCKER_USER=$DOCKER_USER" |
| echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR" |
| echo "INSTALL_DOCKER=$INSTALL_DOCKER" |
| echo "OSM_DEVOPS=$OSM_DEVOPS" |
| echo "OSM_DOCKER_TAG=$OSM_DOCKER_TAG" |
| echo "OSM_K8S_EXTERNAL_IP=$OSM_K8S_EXTERNAL_IP" |
| echo "OSM_HELM_WORK_DIR=$OSM_HELM_WORK_DIR" |
| echo "OSM_NAMESPACE=$OSM_NAMESPACE" |
| echo "OSM_WORK_DIR=$OSM_WORK_DIR" |
| echo "PULL_IMAGES=$PULL_IMAGES" |
| echo "RELEASE=$RELEASE" |
| echo "REPOSITORY=$REPOSITORY" |
| echo "REPOSITORY_BASE=$REPOSITORY_BASE" |
| echo "REPOSITORY_KEY=$REPOSITORY_KEY" |
| echo "SHOWOPTS=$SHOWOPTS" |
| echo "UNINSTALL=$UNINSTALL" |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function parse_docker_registry_url() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| DOCKER_REGISTRY_USER=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[1]}') |
| DOCKER_REGISTRY_PASSWORD=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[2]}') |
| DOCKER_REGISTRY_URL=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); print a[2]}') |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| function ctrl_c() { |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function |
| echo "** Trapped CTRL-C" |
| FATAL "User stopped the installation" |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function |
| } |
| |
| UNINSTALL="" |
| SHOWOPTS="" |
| ASSUME_YES="" |
| APT_PROXY_URL="" |
| K8S_CLUSTER_ENGINE="k3s" |
| DEBUG_INSTALL="" |
| RELEASE="testing-daily" |
| REPOSITORY="testing" |
| INSTALL_K8S_MONITOR="" |
| INSTALL_DOCKER="" |
| INSTALL_NOHOSTCLIENT="" |
| INSTALL_AUX_CLUSTER="y" |
| INSTALL_MGMT_CLUSTER="y" |
| OSM_DEVOPS= |
| OSM_NAMESPACE=osm |
| REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg" |
| REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/debian" |
| OSM_WORK_DIR="/etc/osm" |
| OSM_HELM_WORK_DIR="${OSM_WORK_DIR}/helm" |
| OSM_HOST_VOL="/var/lib/osm" |
| OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_NAMESPACE}" |
| OSM_DOCKER_TAG="testing-daily" |
| DOCKER_USER=opensourcemano |
| PULL_IMAGES="y" |
| KAFKA_TAG=2.11-1.0.2 |
| KIWIGRID_K8S_SIDECAR_TAG="1.15.6" |
| PROMETHEUS_TAG=v2.28.1 |
| GRAFANA_TAG=8.1.1 |
| PROMETHEUS_NODE_EXPORTER_TAG=0.18.1 |
| PROMETHEUS_CADVISOR_TAG=latest |
| KEYSTONEDB_TAG=10 |
| OSM_DATABASE_COMMONKEY= |
| ELASTIC_VERSION=6.4.2 |
| ELASTIC_CURATOR_VERSION=5.5.4 |
| POD_NETWORK_CIDR=10.244.0.0/16 |
| K8S_MANIFEST_DIR="/etc/kubernetes/manifests" |
| RE_CHECK='^[a-z0-9]([-a-z0-9]*[a-z0-9])?$' |
| DOCKER_REGISTRY_URL= |
| DOCKER_PROXY_URL= |
| MODULE_DOCKER_TAG= |
| OSM_INSTALLATION_TYPE="Default" |
| |
| while getopts ":a:c:e:r:n:k:u:R:D:o:O:N:s:t:U:l:L:K:d:p:T:f:F:G:M:-: hy" o; do |
| case "${o}" in |
| a) |
| APT_PROXY_URL=${OPTARG} |
| ;; |
| c) |
| K8S_CLUSTER_ENGINE=${OPTARG} |
| [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ] && continue |
| [ "${K8S_CLUSTER_ENGINE}" == "k3s" ] && continue |
| echo -e "Invalid argument for -c : ' ${K8S_CLUSTER_ENGINE}'\n" >&2 |
| usage && exit 1 |
| ;; |
| e) |
| OSM_K8S_EXTERNAL_IP="${OPTARG}" |
| ;; |
| r) |
| REPOSITORY="${OPTARG}" |
| REPO_ARGS+=(-r "$REPOSITORY") |
| ;; |
| k) |
| REPOSITORY_KEY="${OPTARG}" |
| REPO_ARGS+=(-k "$REPOSITORY_KEY") |
| ;; |
| u) |
| REPOSITORY_BASE="${OPTARG}" |
| REPO_ARGS+=(-u "$REPOSITORY_BASE") |
| ;; |
| R) |
| RELEASE="${OPTARG}" |
| REPO_ARGS+=(-R "$RELEASE") |
| ;; |
| D) |
| OSM_DEVOPS="${OPTARG}" |
| ;; |
| s) |
| OSM_NAMESPACE="${OPTARG}" && [[ ! "${OPTARG}" =~ $RE_CHECK ]] && echo "Namespace $OPTARG is invalid. Regex used for validation is $RE_CHECK" && exit 0 |
| ;; |
| t) |
| OSM_DOCKER_TAG="${OPTARG}" |
| REPO_ARGS+=(-t "$OSM_DOCKER_TAG") |
| ;; |
| U) |
| DOCKER_USER="${OPTARG}" |
| ;; |
| K) |
| CONTROLLER_NAME="${OPTARG}" |
| ;; |
| d) |
| DOCKER_REGISTRY_URL="${OPTARG}" |
| ;; |
| p) |
| DOCKER_PROXY_URL="${OPTARG}" |
| ;; |
| T) |
| MODULE_DOCKER_TAG="${OPTARG}" |
| ;; |
| M) |
| KUBECONFIG_MGMT_CLUSTER="${OPTARG}" |
| ;; |
| G) |
| KUBECONFIG_AUX_CLUSTER="${OPTARG}" |
| ;; |
| -) |
| [ "${OPTARG}" == "help" ] && usage && exit 0 |
| [ "${OPTARG}" == "debug" ] && DEBUG_INSTALL="--debug" && continue |
| [ "${OPTARG}" == "uninstall" ] && UNINSTALL="y" && continue |
| [ "${OPTARG}" == "no-mgmt-cluster" ] && INSTALL_MGMT_CLUSTER="" && continue |
| [ "${OPTARG}" == "no-aux-cluster" ] && INSTALL_AUX_CLUSTER="" && continue |
| [ "${OPTARG}" == "docker" ] && INSTALL_DOCKER="y" && continue |
| [ "${OPTARG}" == "nodocker" ] && INSTALL_DOCKER="" && continue |
| [ "${OPTARG}" == "showopts" ] && SHOWOPTS="y" && continue |
| [ "${OPTARG}" == "nohostclient" ] && INSTALL_NOHOSTCLIENT="y" && continue |
| [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue |
| echo -e "Invalid option: '--$OPTARG'\n" >&2 |
| usage && exit 1 |
| ;; |
| :) |
| echo "Option -$OPTARG requires an argument" >&2 |
| usage && exit 1 |
| ;; |
| \?) |
| echo -e "Invalid option: '-$OPTARG'\n" >&2 |
| usage && exit 1 |
| ;; |
| h) |
| usage && exit 0 |
| ;; |
| y) |
| ASSUME_YES="y" |
| ;; |
| *) |
| usage && exit 1 |
| ;; |
| esac |
| done |
| |
| source $OSM_DEVOPS/common/all_funcs |
| |
| [ -z "${DEBUG_INSTALL}" ] || DEBUG Debug is on |
| [ -n "$SHOWOPTS" ] && dump_vars && exit 0 |
| |
| # Uninstall if "--uninstall" |
| if [ -n "$UNINSTALL" ]; then |
| ${OSM_DEVOPS}/installers/uninstall_osm.sh "$@" || \ |
| FATAL_TRACK community_uninstall "uninstall_osm.sh failed" |
| echo -e "\nDONE" |
| exit 0 |
| fi |
| |
| # Installation starts here |
| |
| # Get README and create OSM_TRACK_INSTALLATION_ID |
| wget -q -O- https://osm-download.etsi.org/ftp/osm-16.0-sixteen/README.txt &> /dev/null |
| export OSM_TRACK_INSTALLATION_ID="$(date +%s)-$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 16)" |
| |
| # Get OS info to be tracked |
| os_distro=$(lsb_release -i 2>/dev/null | awk '{print $3}') |
| echo $os_distro |
| os_release=$(lsb_release -r 2>/dev/null | awk '{print $2}') |
| echo $os_release |
| os_info="${os_distro}_${os_release}" |
| os_info="${os_info// /_}" |
| |
| # Community_installer |
| # This is where installation starts |
| install_osm |
| echo -e "\nDONE" |
| exit 0 |