2 # Copyright 2016 Telefónica Investigación y Desarrollo S.A.U.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
17 echo -e "usage: $0 [OPTIONS]"
18 echo -e "Install OSM from binaries or source code (by default, from binaries)"
20 echo -e " -h / --help: print this help"
21 echo -e " -y: do not prompt for confirmation, assumes yes"
22 echo -e " -r <repo>: use specified repository name for osm packages"
23 echo -e " -R <release>: use specified release for osm binaries (deb packages, lxd images, ...)"
24 echo -e " -u <repo base>: use specified repository url for osm packages"
25 echo -e " -k <repo key>: use specified repository public key url"
26 echo -e " -b <refspec>: install OSM from source code using a specific branch (master, v2.0, ...) or tag"
27 echo -e " -b master (main dev branch)"
28 echo -e " -b v2.0 (v2.0 branch)"
29 echo -e " -b tags/v1.1.0 (a specific tag)"
31 echo -e " -c <orchestrator> deploy osm services using container <orchestrator>. Valid values are <k8s> or <swarm>. If -c is not used then osm will be deployed using default orchestrator. When used with --uninstall, osm services deployed by the orchestrator will be uninstalled"
32 echo -e " -s <stack name> or <namespace> user defined stack name when installed using swarm or namespace when installed using k8s, default is osm"
33 echo -e " -H <VCA host> use specific juju host controller IP"
34 echo -e " -S <VCA secret> use VCA/juju secret key"
35 echo -e " -P <VCA pubkey> use VCA/juju public key file"
36 echo -e " -C <VCA cacert> use VCA/juju CA certificate file"
37 echo -e " -A <VCA apiproxy> use VCA/juju API proxy"
38 echo -e " --vimemu: additionally deploy the VIM emulator as a docker container"
39 echo -e " --elk_stack: additionally deploy an ELK docker stack for event logging"
40 echo -e " --pla: install the PLA module for placement support"
41 echo -e " -m <MODULE>: install OSM but only rebuild or pull the specified docker images (NG-UI, NBI, LCM, RO, MON, POL, PLA, KAFKA, MONGO, PROMETHEUS, PROMETHEUS-CADVISOR, KEYSTONE-DB, NONE)"
42 echo -e " -o <ADDON>: ONLY (un)installs one of the addons (vimemu, elk_stack, k8s_monitor)"
43 echo -e " -O <openrc file path/cloud name>: Install OSM to an OpenStack infrastructure. <openrc file/cloud name> is required. If a <cloud name> is used, the clouds.yaml file should be under ~/.config/openstack/ or /etc/openstack/"
44 echo -e " -N <openstack public network name/ID>: Public network name required to setup OSM to OpenStack"
45 echo -e " -f <path to SSH public key>: Public SSH key to use to deploy OSM to OpenStack"
46 echo -e " -F <path to cloud-init file>: Cloud-Init userdata file to deploy OSM to OpenStack"
47 echo -e " -D <devops path> use local devops installation path"
48 echo -e " -w <work dir> Location to store runtime installation"
49 echo -e " -t <docker tag> specify osm docker tag (default is latest)"
50 echo -e " -l: LXD cloud yaml file"
51 echo -e " -L: LXD credentials yaml file"
52 echo -e " -K: Specifies the name of the controller to use - The controller must be already bootstrapped"
53 echo -e " -d <docker registry URL> use docker registry URL instead of dockerhub"
54 echo -e " -p <docker proxy URL> set docker proxy URL as part of docker CE configuration"
55 echo -e " -T <docker tag> specify docker tag for the modules specified with option -m"
56 echo -e " --nocachelxdimages: do not cache local lxd images, do not create cronjob for that cache (will save installation time, might affect instantiation time)"
57 echo -e " --nolxd: do not install and configure LXD, allowing unattended installations (assumes LXD is already installed and confifured)"
58 echo -e " --nodocker: do not install docker, do not initialize a swarm (assumes docker is already installed and a swarm has been initialized)"
59 echo -e " --nojuju: do not juju, assumes already installed"
60 echo -e " --nodockerbuild:do not build docker images (use existing locally cached images)"
61 echo -e " --nohostports: do not expose docker ports to host (useful for creating multiple instances of osm on the same host)"
62 echo -e " --nohostclient: do not install the osmclient"
63 echo -e " --uninstall: uninstall OSM: remove the containers and delete NAT rules"
64 echo -e " --source: install OSM from source code using the latest stable tag"
65 echo -e " --develop: (deprecated, use '-b master') install OSM from source code using the master branch"
66 echo -e " --pullimages: pull/run osm images from docker.io/opensourcemano"
67 echo -e " --k8s_monitor: install the OSM kubernetes monitoring with prometheus and grafana"
68 echo -e " --volume: create a VM volume when installing to OpenStack"
69 # echo -e " --reconfigure: reconfigure the modules (DO NOT change NAT rules)"
70 # echo -e " --update: update to the latest stable release or to the latest commit if using a specific branch"
71 echo -e " --showopts: print chosen options and exit (only for debugging)"
72 echo -e " --charmed: Deploy and operate OSM with Charms on k8s"
73 echo -e " [--bundle <bundle path>]: Specify with which bundle to deploy OSM with charms (--charmed option)"
74 echo -e " [--k8s <kubeconfig path>]: Specify with which kubernetes to deploy OSM with charms (--charmed option)"
75 echo -e " [--vca <name>]: Specifies the name of the controller to use - The controller must be already bootstrapped (--charmed option)"
76 echo -e " [--lxd <yaml path>]: Takes a YAML file as a parameter with the LXD Cloud information (--charmed option)"
77 echo -e " [--lxd-cred <yaml path>]: Takes a YAML file as a parameter with the LXD Credentials information (--charmed option)"
78 echo -e " [--microstack]: Installs microstack as a vim. (--charmed option)"
79 echo -e " [--overlay]: Add an overlay to override some defaults of the default bundle (--charmed option)"
80 echo -e " [--ha]: Installs High Availability bundle. (--charmed option)"
81 echo -e " [--tag]: Docker image tag. (--charmed option)"
82 echo -e " [--registry]: Docker registry with optional credentials as user:pass@hostname:port (--charmed option)"
86 # takes a juju/accounts.yaml file and returns the password specific
87 # for a controller. I wrote this using only bash tools to minimize
88 # additions of other packages
89 function parse_juju_password
{
90 password_file
="${HOME}/.local/share/juju/accounts.yaml"
91 local controller_name
=$1
92 local s
='[[:space:]]*' w
='[a-zA-Z0-9_-]*' fs
=$
(echo @|
tr @
'\034')
93 sed -ne "s|^\($s\):|\1|" \
94 -e "s|^\($s\)\($w\)$s:$s[\"']\(.*\)[\"']$s\$|\1$fs\2$fs\3|p" \
95 -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p" $password_file |
96 awk -F$fs -v controller
=$controller_name '{
97 indent = length($1)/2;
99 for (i in vname) {if (i > indent) {delete vname[i]}}
100 if (length($3) > 0) {
101 vn=""; for (i=0; i<indent; i++) {vn=(vn)(vname[i])("_")}
102 if (match(vn,controller) && match($2,"password")) {
109 function generate_secret
() {
110 head /dev
/urandom |
tr -dc A-Za-z0-9 |
head -c 32
113 function remove_volumes
() {
114 if [ -n "$KUBERNETES" ]; then
116 echo "Removing ${k8_volume}"
117 $WORKDIR_SUDO rm -rf ${k8_volume}
120 volumes
="mongo_db mon_db osm_packages ro_db pol_db prom_db ro"
121 for volume
in $volumes; do
122 sg docker
-c "docker volume rm ${stack}_${volume}"
127 function remove_network
() {
129 sg docker
-c "docker network rm net${stack}"
132 function remove_iptables
() {
134 if [ -z "$OSM_VCA_HOST" ]; then
135 OSM_VCA_HOST
=`sg lxd -c "juju show-controller ${stack}"|grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
136 [ -z "$OSM_VCA_HOST" ] && FATAL
"Cannot obtain juju controller IP address"
139 if [ -z "$DEFAULT_IP" ]; then
140 DEFAULT_IF
=$
(ip route list|
awk '$1=="default" {print $5; exit}')
141 [ -z "$DEFAULT_IF" ] && DEFAULT_IF
=$
(ip route list|
awk '$1=="default" {print $5; exit}')
142 [ -z "$DEFAULT_IF" ] && FATAL
"Not possible to determine the interface with the default route 0.0.0.0"
143 DEFAULT_IP
=`ip -o -4 a |grep ${DEFAULT_IF}|awk '{split($4,a,"/"); print a[1]}'`
144 [ -z "$DEFAULT_IP" ] && FATAL
"Not possible to determine the IP address of the interface with the default route"
147 if sudo iptables
-t nat
-C PREROUTING
-p tcp
-m tcp
-d $DEFAULT_IP --dport 17070 -j DNAT
--to-destination $OSM_VCA_HOST; then
148 sudo iptables
-t nat
-D PREROUTING
-p tcp
-m tcp
-d $DEFAULT_IP --dport 17070 -j DNAT
--to-destination $OSM_VCA_HOST
149 sudo netfilter-persistent save
153 function remove_stack
() {
155 if sg docker
-c "docker stack ps ${stack}" ; then
156 echo -e "\nRemoving stack ${stack}" && sg docker
-c "docker stack rm ${stack}"
159 while [ ${COUNTER} -lt 30 ]; do
160 result
=$
(sg docker
-c "docker stack ps ${stack}" |
wc -l)
161 #echo "Dockers running: $result"
162 if [ "${result}" == "0" ]; then
165 let COUNTER
=COUNTER
+1
168 if [ "${result}" == "0" ]; then
169 echo "All dockers of the stack ${stack} were removed"
171 FATAL
"Some dockers of the stack ${stack} could not be removed. Could not clean it."
177 #removes osm deployments and services
178 function remove_k8s_namespace
() {
182 #removes helm only if there is nothing deployed in helm
183 function remove_helm
() {
184 if [ "$(helm ls -q)" == "" ] ; then
185 sudo helm
reset --force
186 kubectl delete
--namespace kube-system serviceaccount tiller
187 kubectl delete clusterrolebinding tiller-cluster-rule
188 sudo
rm /usr
/local
/bin
/helm
193 function remove_crontab_job
() {
194 crontab
-l |
grep -v '${OSM_DEVOPS}/installers/update-juju-lxc-images' | crontab
-
198 function uninstall_osmclient
() {
199 sudo apt-get remove
--purge -y python-osmclient
200 sudo apt-get remove
--purge -y python3-osmclient
203 #Uninstall lightweight OSM: remove dockers
204 function uninstall_lightweight
() {
205 if [ -n "$INSTALL_ONLY" ]; then
206 if [ -n "$INSTALL_ELK" ]; then
207 echo -e "\nUninstalling OSM ELK stack"
209 $WORKDIR_SUDO rm -rf $OSM_DOCKER_WORK_DIR/osm_elk
212 echo -e "\nUninstalling OSM"
213 if [ -n "$KUBERNETES" ]; then
214 if [ -n "$INSTALL_K8S_MONITOR" ]; then
215 # uninstall OSM MONITORING
216 uninstall_k8s_monitoring
218 remove_k8s_namespace
$OSM_STACK_NAME
220 remove_stack
$OSM_STACK_NAME
223 echo "Now osm docker images and volumes will be deleted"
224 # TODO: clean-up of images should take into account if other tags were used for specific modules
225 newgrp docker
<< EONG
226 for module in ro lcm keystone nbi mon pol pla osmclient; do
227 docker image rm ${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module}:${OSM_DOCKER_TAG}
231 sg docker
-c "docker image rm ${DOCKER_REGISTRY_URL}${DOCKER_USER}/ng-ui:${OSM_DOCKER_TAG}"
233 if [ -n "$KUBERNETES" ]; then
234 OSM_NAMESPACE_VOL
="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
235 remove_volumes
$OSM_NAMESPACE_VOL
237 remove_volumes
$OSM_STACK_NAME
238 remove_network
$OSM_STACK_NAME
239 [ -z "$CONTROLLER_NAME" ] && remove_iptables
$OSM_STACK_NAME
241 echo "Removing $OSM_DOCKER_WORK_DIR"
242 $WORKDIR_SUDO rm -rf $OSM_DOCKER_WORK_DIR
243 [ -z "$CONTROLLER_NAME" ] && sg lxd
-c "juju kill-controller -t 0 -y $OSM_STACK_NAME"
247 # Cleanup Openstack installer venv
248 if [ -d "$OPENSTACK_PYTHON_VENV" ]; then
249 rm -r $OPENSTACK_PYTHON_VENV
252 [ -z "$INSTALL_NOHOSTCLIENT" ] && uninstall_osmclient
253 echo "Some docker images will be kept in case they are used by other docker stacks"
254 echo "To remove them, just run 'docker image prune' in a terminal"
258 #Safe unattended install of iptables-persistent
259 function check_install_iptables_persistent
(){
260 echo -e "\nChecking required packages: iptables-persistent"
261 if ! dpkg
-l iptables-persistent
&>/dev
/null
; then
262 echo -e " Not installed.\nInstalling iptables-persistent requires root privileges"
263 echo iptables-persistent iptables-persistent
/autosave_v4 boolean true | sudo debconf-set-selections
264 echo iptables-persistent iptables-persistent
/autosave_v6 boolean true | sudo debconf-set-selections
265 sudo apt-get
-yq install iptables-persistent
269 #Configure NAT rules, based on the current IP addresses of containers
271 check_install_iptables_persistent
273 echo -e "\nConfiguring NAT rules"
274 echo -e " Required root privileges"
275 sudo
$OSM_DEVOPS/installers
/nat_osm
279 echo "FATAL error: Cannot install OSM due to \"$1\""
283 function update_juju_images
(){
284 crontab
-l |
grep update-juju-lxc-images ||
(crontab
-l 2>/dev
/null
; echo "0 4 * * 6 $USER ${OSM_DEVOPS}/installers/update-juju-lxc-images --xenial --bionic") | crontab
-
285 ${OSM_DEVOPS}/installers
/update-juju-lxc-images
--xenial --bionic
288 function install_lxd
() {
289 # Apply sysctl production values for optimal performance
290 sudo
cp ${OSM_DEVOPS}/installers
/60-lxd-production.conf
/etc
/sysctl.d
/60-lxd-production.conf
294 sudo apt-get remove
--purge -y liblxc1 lxc-common lxcfs lxd lxd-client
295 sudo snap
install lxd
298 sudo usermod
-a -G lxd
`whoami`
299 cat ${OSM_DEVOPS}/installers
/lxd-preseed.conf |
sed 's/^config: {}/config:\n core.https_address: '$DEFAULT_IP':8443/' | sg lxd
-c "lxd init --preseed"
300 sg lxd
-c "lxd waitready"
301 DEFAULT_INTERFACE
=$
(ip route list|
awk '$1=="default" {print $5; exit}')
302 [ -z "$DEFAULT_INTERFACE" ] && DEFAULT_INTERFACE
=$
(route
-n |
awk '$1~/^0.0.0.0/ {print $8; exit}')
303 DEFAULT_MTU
=$
(ip addr show
$DEFAULT_INTERFACE | perl
-ne 'if (/mtu\s(\d+)/) {print $1;}')
304 sg lxd
-c "lxc profile device set default eth0 mtu $DEFAULT_MTU"
305 sg lxd
-c "lxc network set lxdbr0 bridge.mtu $DEFAULT_MTU"
306 #sudo systemctl stop lxd-bridge
307 #sudo systemctl --system daemon-reload
308 #sudo systemctl enable lxd-bridge
309 #sudo systemctl start lxd-bridge
313 # ask to the user and parse a response among 'y', 'yes', 'n' or 'no'. Case insensitive
314 # Params: $1 text to ask; $2 Action by default, can be 'y' for yes, 'n' for no, other or empty for not allowed
315 # Return: true(0) if user type 'yes'; false (1) if user type 'no'
316 read -e -p "$1" USER_CONFIRMATION
318 [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'y' ] && return 0
319 [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'n' ] && return 1
320 [ "${USER_CONFIRMATION,,}" == "yes" ] ||
[ "${USER_CONFIRMATION,,}" == "y" ] && return 0
321 [ "${USER_CONFIRMATION,,}" == "no" ] ||
[ "${USER_CONFIRMATION,,}" == "n" ] && return 1
322 read -e -p "Please type 'yes' or 'no': " USER_CONFIRMATION
326 function install_osmclient
(){
327 CLIENT_RELEASE
=${RELEASE#"-R "}
328 CLIENT_REPOSITORY_KEY
="OSM%20ETSI%20Release%20Key.gpg"
329 CLIENT_REPOSITORY
=${REPOSITORY#"-r "}
330 CLIENT_REPOSITORY_BASE
=${REPOSITORY_BASE#"-u "}
331 key_location
=$CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE/$CLIENT_REPOSITORY_KEY
332 curl
$key_location | sudo apt-key add
-
333 sudo add-apt-repository
-y "deb [arch=amd64] $CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE $CLIENT_REPOSITORY osmclient IM"
335 sudo apt-get
install -y python3-pip
336 sudo
-H LC_ALL
=C python3
-m pip
install -U pip
337 sudo
-H LC_ALL
=C python3
-m pip
install -U python-magic pyangbind verboselogs
338 sudo apt-get
install -y python3-osm-im python3-osmclient
339 if [ -f /usr
/lib
/python
3/dist-packages
/osm_im
/requirements.txt
]; then
340 python3
-m pip
install -r /usr
/lib
/python
3/dist-packages
/osm_im
/requirements.txt
342 if [ -f /usr
/lib
/python
3/dist-packages
/osmclient
/requirements.txt
]; then
343 sudo apt-get
install -y libcurl4-openssl-dev libssl-dev
344 python3
-m pip
install -r /usr
/lib
/python
3/dist-packages
/osmclient
/requirements.txt
346 #sed 's,OSM_SOL005=[^$]*,OSM_SOL005=True,' -i ${HOME}/.bashrc
347 #echo 'export OSM_HOSTNAME=localhost' >> ${HOME}/.bashrc
348 #echo 'export OSM_SOL005=True' >> ${HOME}/.bashrc
349 [ -z "$INSTALL_LIGHTWEIGHT" ] && export OSM_HOSTNAME
=`lxc list | awk '($2=="SO-ub"){print $6}'`
350 [ -z "$INSTALL_LIGHTWEIGHT" ] && export OSM_RO_HOSTNAME
=`lxc list | awk '($2=="RO"){print $6}'`
351 echo -e "\nOSM client installed"
352 if [ -z "$INSTALL_LIGHTWEIGHT" ]; then
353 echo -e "You might be interested in adding the following OSM client env variables to your .bashrc file:"
354 echo " export OSM_HOSTNAME=${OSM_HOSTNAME}"
355 echo " export OSM_RO_HOSTNAME=${OSM_RO_HOSTNAME}"
357 echo -e "OSM client assumes that OSM host is running in localhost (127.0.0.1)."
358 echo -e "In case you want to interact with a different OSM host, you will have to configure this env variable in your .bashrc file:"
359 echo " export OSM_HOSTNAME=<OSM_host>"
364 function install_prometheus_nodeexporter
(){
365 if (systemctl
-q is-active node_exporter
)
367 echo "Node Exporter is already running."
369 echo "Node Exporter is not active, installing..."
370 if getent passwd node_exporter
> /dev
/null
2>&1; then
371 echo "node_exporter user exists"
373 echo "Creating user node_exporter"
374 sudo useradd
--no-create-home --shell /bin
/false node_exporter
376 wget
-q https
://github.com
/prometheus
/node_exporter
/releases
/download
/v
$PROMETHEUS_NODE_EXPORTER_TAG/node_exporter-
$PROMETHEUS_NODE_EXPORTER_TAG.linux-amd64.
tar.gz
-P /tmp
/
377 sudo
tar -C /tmp
-xf /tmp
/node_exporter-
$PROMETHEUS_NODE_EXPORTER_TAG.linux-amd64.
tar.gz
378 sudo
cp /tmp
/node_exporter-
$PROMETHEUS_NODE_EXPORTER_TAG.linux-amd64
/node_exporter
/usr
/local
/bin
379 sudo chown node_exporter
:node_exporter
/usr
/local
/bin
/node_exporter
380 sudo
rm -rf /tmp
/node_exporter-
$PROMETHEUS_NODE_EXPORTER_TAG.linux-amd64
*
381 sudo
cp ${OSM_DEVOPS}/installers
/docker
/prometheus_exporters
/node_exporter.service
/etc
/systemd
/system
/node_exporter.service
382 sudo systemctl daemon-reload
383 sudo systemctl restart node_exporter
384 sudo systemctl
enable node_exporter
385 echo "Node Exporter has been activated in this host."
390 function uninstall_prometheus_nodeexporter
(){
391 sudo systemctl stop node_exporter
392 sudo systemctl disable node_exporter
393 sudo
rm /etc
/systemd
/system
/node_exporter.service
394 sudo systemctl daemon-reload
395 sudo userdel node_exporter
396 sudo
rm /usr
/local
/bin
/node_exporter
400 function install_docker_ce
() {
401 # installs and configures Docker CE
402 echo "Installing Docker CE ..."
403 sudo apt-get
-qq update
404 sudo apt-get
install -y apt-transport-https ca-certificates software-properties-common
405 curl
-fsSL https
://download.docker.com
/linux
/ubuntu
/gpg | sudo apt-key add
-
406 sudo add-apt-repository
"deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
407 sudo apt-get
-qq update
408 sudo apt-get
install -y docker-ce
409 echo "Adding user to group 'docker'"
410 sudo groupadd
-f docker
411 sudo usermod
-aG docker
$USER
413 sudo service docker restart
414 echo "... restarted Docker service"
415 if [ -n "${DOCKER_PROXY_URL}" ]; then
416 echo "Configuring docker proxy ..."
417 if [ -f /etc
/docker
/daemon.json
]; then
418 if grep -q registry-mirrors
/etc
/docker
/daemon.json
; then
419 sudo
sed -i "s|registry-mirrors.*|registry-mirrors\": [\"${DOCKER_PROXY_URL}\"] |" /etc
/docker
/daemon.json
421 sudo
sed -i "s|{|{\n \"registry-mirrors\": [\"${DOCKER_PROXY_URL}\"],|" /etc
/docker
/daemon.json
424 sudo bash
-c "cat << EOF > /etc/docker/daemon.json
426 \"registry-mirrors\": [\"${DOCKER_PROXY_URL}\"]
430 sudo systemctl daemon-reload
431 sudo service docker restart
432 echo "... restarted Docker service again"
434 sg docker
-c "docker version" || FATAL
"Docker installation failed"
435 echo "... Docker CE installation done"
439 function install_docker_compose
() {
440 # installs and configures docker-compose
441 echo "Installing Docker Compose ..."
442 sudo curl
-L https
://github.com
/docker
/compose
/releases
/download
/1.18.0/docker-compose-
`uname -s`-`uname -m` -o /usr
/local
/bin
/docker-compose
443 sudo
chmod +x
/usr
/local
/bin
/docker-compose
444 echo "... Docker Compose installation done"
447 function install_juju
() {
448 echo "Installing juju"
449 sudo snap
install juju
--classic --channel=2.8/stable
450 [[ ":$PATH": != *":/snap/bin:"* ]] && PATH
="/snap/bin:${PATH}"
451 [ -n "$INSTALL_NOCACHELXDIMAGES" ] || update_juju_images
452 echo "Finished installation of juju"
456 function juju_createcontroller
() {
457 if ! juju show-controller
$OSM_STACK_NAME &> /dev
/null
; then
458 # Not found created, create the controller
459 sudo usermod
-a -G lxd
${USER}
460 sg lxd
-c "juju bootstrap --bootstrap-series=xenial --agent-version=$JUJU_AGENT_VERSION $OSM_VCA_CLOUDNAME $OSM_STACK_NAME"
462 [ $
(juju controllers |
awk "/^${OSM_STACK_NAME}[\*| ]/{print $1}"|
wc -l) -eq 1 ] || FATAL
"Juju installation failed"
463 juju controller-config features
=[k8s-operators
]
466 function juju_addk8s
() {
467 cat $HOME/.kube
/config | juju add-k8s
$OSM_VCA_K8S_CLOUDNAME --controller $OSM_STACK_NAME --storage openebs-hostpath
470 function juju_createcontroller_k8s
(){
471 cat $HOME/.kube
/config | juju add-k8s
$OSM_VCA_K8S_CLOUDNAME --client
472 juju bootstrap
$OSM_VCA_K8S_CLOUDNAME $OSM_STACK_NAME \
473 --config controller-service-type
=loadbalancer \
474 --agent-version=$JUJU_AGENT_VERSION
478 function juju_addlxd_cloud
(){
480 OSM_VCA_CLOUDNAME
="lxd-cloud"
481 LXDENDPOINT
=$DEFAULT_IP
482 LXD_CLOUD
=/tmp
/.osm
/lxd-cloud.yaml
483 LXD_CREDENTIALS
=/tmp
/.osm
/lxd-credentials.yaml
485 cat << EOF > $LXD_CLOUD
489 auth-types: [certificate]
490 endpoint: "https://$LXDENDPOINT:8443"
492 ssl-hostname-verification: false
494 openssl req
-nodes -new -x509 -keyout /tmp
/.osm
/client.key
-out /tmp
/.osm
/client.crt
-days 365 -subj "/C=FR/ST=Nice/L=Nice/O=ETSI/OU=OSM/CN=osm.etsi.org"
495 local server_cert
=`cat /var/snap/lxd/common/lxd/server.crt | sed 's/^/ /'`
496 local client_cert
=`cat /tmp/.osm/client.crt | sed 's/^/ /'`
497 local client_key
=`cat /tmp/.osm/client.key | sed 's/^/ /'`
499 cat << EOF > $LXD_CREDENTIALS
503 auth-type: certificate
511 lxc config trust add
local: /tmp
/.osm
/client.crt
512 juju add-cloud
-c $OSM_STACK_NAME $OSM_VCA_CLOUDNAME $LXD_CLOUD --force
513 juju add-credential
-c $OSM_STACK_NAME $OSM_VCA_CLOUDNAME -f $LXD_CREDENTIALS
514 sg lxd
-c "lxd waitready"
515 juju controller-config features
=[k8s-operators
]
519 function juju_createproxy
() {
520 check_install_iptables_persistent
522 if ! sudo iptables
-t nat
-C PREROUTING
-p tcp
-m tcp
-d $DEFAULT_IP --dport 17070 -j DNAT
--to-destination $OSM_VCA_HOST; then
523 sudo iptables
-t nat
-A PREROUTING
-p tcp
-m tcp
-d $DEFAULT_IP --dport 17070 -j DNAT
--to-destination $OSM_VCA_HOST
524 sudo netfilter-persistent save
528 function docker_login
() {
530 sg docker
-c "docker login -u ${DOCKER_REGISTRY_USER} -p ${DOCKER_REGISTRY_PASSWORD}"
533 function generate_docker_images
() {
535 ========================================================================================
541 ========================================================================================
545 echo "Pulling and generating docker images"
546 [ -n "${DOCKER_REGISTRY_URL}" ] && docker_login
548 echo "Pulling docker images"
550 if [ -z "$TO_REBUILD" ] ||
echo $TO_REBUILD |
grep -q KAFKA
; then
551 sg docker
-c "docker pull wurstmeister/zookeeper" || FATAL
"cannot get zookeeper docker image"
552 sg docker
-c "docker pull wurstmeister/kafka:${KAFKA_TAG}" || FATAL
"cannot get kafka docker image"
555 if [ -z "$TO_REBUILD" ] ||
echo $TO_REBUILD |
grep -q MONGO
; then
556 sg docker
-c "docker pull mongo" || FATAL
"cannot get mongo docker image"
559 if [ -z "$TO_REBUILD" ] ||
echo $TO_REBUILD |
grep -q PROMETHEUS
; then
560 sg docker
-c "docker pull prom/prometheus:${PROMETHEUS_TAG}" || FATAL
"cannot get prometheus docker image"
563 if [ -z "$TO_REBUILD" ] ||
echo $TO_REBUILD |
grep -q PROMETHEUS-CADVISOR
; then
564 sg docker
-c "docker pull google/cadvisor:${PROMETHEUS_CADVISOR_TAG}" || FATAL
"cannot get prometheus cadvisor docker image"
567 if [ -z "$TO_REBUILD" ] ||
echo $TO_REBUILD |
grep -q GRAFANA
; then
568 sg docker
-c "docker pull grafana/grafana:${GRAFANA_TAG}" || FATAL
"cannot get grafana docker image"
571 if [ -z "$TO_REBUILD" ] ||
echo $TO_REBUILD |
grep -q NBI ||
echo $TO_REBUILD |
grep -q KEYSTONE-DB
; then
572 sg docker
-c "docker pull mariadb:${KEYSTONEDB_TAG}" || FATAL
"cannot get keystone-db docker image"
575 if [ -z "$TO_REBUILD" ] ||
echo $TO_REBUILD |
grep -q RO
; then
576 sg docker
-c "docker pull mysql:5" || FATAL
"cannot get mysql docker image"
579 if [ -n "$PULL_IMAGES" ]; then
580 echo "Pulling OSM docker images"
581 for module
in MON POL NBI KEYSTONE RO LCM NG-UI PLA osmclient
; do
582 module_lower
=${module,,}
583 if [ $module == "PLA" -a ! -n "$INSTALL_PLA" ]; then
586 module_tag
="${OSM_DOCKER_TAG}"
587 if [ -n "${MODULE_DOCKER_TAG}" ] && echo $TO_REBUILD |
grep -q $module ; then
588 module_tag
="${MODULE_DOCKER_TAG}"
590 echo "Pulling ${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module_lower}:${module_tag} docker image"
591 sg docker
-c "docker pull ${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module_lower}:${module_tag}" || FATAL
"cannot pull $module docker image"
594 _build_from
=$COMMIT_ID
595 [ -z "$_build_from" ] && _build_from
="latest"
596 echo "OSM Docker images generated from $_build_from"
598 for module
in MON POL NBI KEYSTONE RO LCM NG-UI PLA
; do
599 if [ -z "$TO_REBUILD" ] ||
echo $TO_REBUILD |
grep -q ${module} ; then
600 module_lower
=${module,,}
601 if [ $module == "PLA" -a ! -n "$INSTALL_PLA" ]; then
604 git
-C ${LWTEMPDIR} clone https
://osm.etsi.org
/gerrit
/osm
/$module
605 git
-C ${LWTEMPDIR}/${module} checkout ${COMMIT_ID}
606 sg docker
-c "docker build ${LWTEMPDIR}/${module} -f ${LWTEMPDIR}/${module}/docker/Dockerfile -t ${DOCKER_USER}/${module_lower} --no-cache" || FATAL "cannot build ${module} docker image"
609 if [ -z "$TO_REBUILD" ] ||
echo $TO_REBUILD |
grep -q osmclient
; then
610 BUILD_ARGS
+=(--build-arg REPOSITORY
="$REPOSITORY")
611 BUILD_ARGS
+=(--build-arg RELEASE
="$RELEASE")
612 BUILD_ARGS
+=(--build-arg REPOSITORY_KEY
="$REPOSITORY_KEY")
613 BUILD_ARGS
+=(--build-arg REPOSITORY_BASE
="$REPOSITORY_BASE")
614 sg docker
-c "docker build -t ${DOCKER_USER}/osmclient ${BUILD_ARGS[@]} -f $OSM_DEVOPS/docker/osmclient ."
616 echo "Finished generation of docker images"
619 echo "Finished pulling and generating docker images"
622 function cmp_overwrite
() {
625 if ! $
(cmp "${file1}" "${file2}" >/dev
/null
2>&1); then
626 if [ -f "${file2}" ]; then
627 ask_user
"The file ${file2} already exists. Overwrite (y/N)? " n && cp -b ${file1} ${file2}
629 cp -b ${file1} ${file2}
634 function generate_docker_compose_files() {
635 $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/docker-compose.yaml $OSM_DOCKER_WORK_DIR/docker-compose.yaml
636 $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/docker-compose-ngui.yaml $OSM_DOCKER_WORK_DIR/docker-compose-ui.yaml
637 if [ -n "$INSTALL_PLA" ]; then
638 $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/osm_pla/docker-compose.yaml $OSM_DOCKER_WORK_DIR/osm_pla/docker-compose.yaml
642 function generate_k8s_manifest_files() {
643 #Kubernetes resources
644 $WORKDIR_SUDO cp -bR ${OSM_DEVOPS}/installers/docker/osm_pods $OSM_DOCKER_WORK_DIR
645 $WORKDIR_SUDO rm -f $OSM_K8S_WORK_DIR/mongo.yaml
646 $WORKDIR_SUDO rm -f $OSM_K8S_WORK_DIR/ng-ui.yaml
649 function generate_prometheus_grafana_files() {
650 [ -n "$KUBERNETES" ] && return
652 $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/prometheus
653 $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/prometheus/prometheus.yml $OSM_DOCKER_WORK_DIR/prometheus/prometheus.yml
656 $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/grafana
657 $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/dashboards-osm.yml $OSM_DOCKER_WORK_DIR/grafana/dashboards-osm.yml
658 $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/datasource-prometheus.yml $OSM_DOCKER_WORK_DIR/grafana/datasource-prometheus.yml
659 $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/osm-sample-dashboard.json $OSM_DOCKER_WORK_DIR/grafana/osm-sample-dashboard.json
660 $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/osm-system-dashboard.json $OSM_DOCKER_WORK_DIR/grafana/osm-system-dashboard.json
662 # Prometheus Exporters files
663 $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/prometheus_exporters
664 $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/prometheus_exporters/node_exporter.service $OSM_DOCKER_WORK_DIR/prometheus_exporters/node_exporter.service
667 function generate_docker_env_files() {
668 echo "Doing a backup of existing env files
"
669 $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/keystone-db.env{,~}
670 $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/keystone.env{,~}
671 $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/lcm.env{,~}
672 $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/mon.env{,~}
673 $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/nbi.env{,~}
674 $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/pol.env{,~}
675 $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/ro-db.env{,~}
676 $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/ro.env{,~}
678 echo "Generating docker env files
"
680 if [ ! -f $OSM_DOCKER_WORK_DIR/lcm.env ]; then
681 echo "OSMLCM_DATABASE_COMMONKEY
=${OSM_DATABASE_COMMONKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
684 if ! grep -Fq "OSMLCM_VCA_HOST
" $OSM_DOCKER_WORK_DIR/lcm.env; then
685 echo "OSMLCM_VCA_HOST
=${OSM_VCA_HOST}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
687 $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_HOST.
*|OSMLCM_VCA_HOST
=$OSM_VCA_HOST|g
" $OSM_DOCKER_WORK_DIR/lcm.env
690 if ! grep -Fq "OSMLCM_VCA_SECRET
" $OSM_DOCKER_WORK_DIR/lcm.env; then
691 echo "OSMLCM_VCA_SECRET
=${OSM_VCA_SECRET}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
693 $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_SECRET.
*|OSMLCM_VCA_SECRET
=$OSM_VCA_SECRET|g
" $OSM_DOCKER_WORK_DIR/lcm.env
696 if ! grep -Fq "OSMLCM_VCA_PUBKEY
" $OSM_DOCKER_WORK_DIR/lcm.env; then
697 echo "OSMLCM_VCA_PUBKEY
=${OSM_VCA_PUBKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
699 $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_PUBKEY.
*|OSMLCM_VCA_PUBKEY
=${OSM_VCA_PUBKEY}|g
" $OSM_DOCKER_WORK_DIR/lcm.env
702 if ! grep -Fq "OSMLCM_VCA_CACERT
" $OSM_DOCKER_WORK_DIR/lcm.env; then
703 echo "OSMLCM_VCA_CACERT
=${OSM_VCA_CACERT}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
705 $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_CACERT.
*|OSMLCM_VCA_CACERT
=${OSM_VCA_CACERT}|g
" $OSM_DOCKER_WORK_DIR/lcm.env
708 if [ -n "$OSM_VCA_APIPROXY" ]; then
709 if ! grep -Fq "OSMLCM_VCA_APIPROXY
" $OSM_DOCKER_WORK_DIR/lcm.env; then
710 echo "OSMLCM_VCA_APIPROXY
=${OSM_VCA_APIPROXY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
712 $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_APIPROXY.
*|OSMLCM_VCA_APIPROXY
=${OSM_VCA_APIPROXY}|g
" $OSM_DOCKER_WORK_DIR/lcm.env
716 if ! grep -Fq "OSMLCM_VCA_ENABLEOSUPGRADE
" $OSM_DOCKER_WORK_DIR/lcm.env; then
717 echo "# OSMLCM_VCA_ENABLEOSUPGRADE=false" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
720 if ! grep -Fq "OSMLCM_VCA_APTMIRROR" $OSM_DOCKER_WORK_DIR/lcm.env
; then
721 echo "# OSMLCM_VCA_APTMIRROR=http://archive.ubuntu.com/ubuntu/" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
724 if ! grep -Fq "OSMLCM_VCA_CLOUD" $OSM_DOCKER_WORK_DIR/lcm.env
; then
725 echo "OSMLCM_VCA_CLOUD=${OSM_VCA_CLOUDNAME}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
727 $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_CLOUD.*|OSMLCM_VCA_CLOUD=${OSM_VCA_CLOUDNAME}|g" $OSM_DOCKER_WORK_DIR/lcm.env
730 if ! grep -Fq "OSMLCM_VCA_K8S_CLOUD" $OSM_DOCKER_WORK_DIR/lcm.env
; then
731 echo "OSMLCM_VCA_K8S_CLOUD=${OSM_VCA_K8S_CLOUDNAME}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
733 $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_K8S_CLOUD.*|OSMLCM_VCA_K8S_CLOUD=${OSM_VCA_K8S_CLOUDNAME}|g" $OSM_DOCKER_WORK_DIR/lcm.env
737 MYSQL_ROOT_PASSWORD
=$
(generate_secret
)
738 if [ ! -f $OSM_DOCKER_WORK_DIR/ro-db.env
]; then
739 echo "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |
$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/ro-db.env
741 if [ ! -f $OSM_DOCKER_WORK_DIR/ro.env
]; then
742 echo "RO_DB_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |
$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/ro.env
744 if ! grep -Fq "OSMRO_DATABASE_COMMONKEY" $OSM_DOCKER_WORK_DIR/ro.env
; then
745 echo "OSMRO_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/ro.env
749 KEYSTONE_DB_PASSWORD
=$
(generate_secret
)
750 SERVICE_PASSWORD
=$
(generate_secret
)
751 if [ ! -f $OSM_DOCKER_WORK_DIR/keystone-db.env
]; then
752 echo "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |
$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/keystone-db.env
754 if [ ! -f $OSM_DOCKER_WORK_DIR/keystone.env
]; then
755 echo "ROOT_DB_PASSWORD=${MYSQL_ROOT_PASSWORD}" |
$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/keystone.env
756 echo "KEYSTONE_DB_PASSWORD=${KEYSTONE_DB_PASSWORD}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/keystone.env
757 echo "SERVICE_PASSWORD=${SERVICE_PASSWORD}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/keystone.env
761 if [ ! -f $OSM_DOCKER_WORK_DIR/nbi.env
]; then
762 echo "OSMNBI_AUTHENTICATION_SERVICE_PASSWORD=${SERVICE_PASSWORD}" |
$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/nbi.env
763 echo "OSMNBI_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/nbi.env
767 if [ ! -f $OSM_DOCKER_WORK_DIR/mon.env
]; then
768 echo "OSMMON_KEYSTONE_SERVICE_PASSWORD=${SERVICE_PASSWORD}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
769 echo "OSMMON_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
770 echo "OSMMON_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/mon" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
773 if ! grep -Fq "OS_NOTIFIER_URI" $OSM_DOCKER_WORK_DIR/mon.env
; then
774 echo "OS_NOTIFIER_URI=http://${DEFAULT_IP}:8662" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
776 $WORKDIR_SUDO sed -i "s|OS_NOTIFIER_URI.*|OS_NOTIFIER_URI=http://$DEFAULT_IP:8662|g" $OSM_DOCKER_WORK_DIR/mon.env
779 if ! grep -Fq "OSMMON_VCA_HOST" $OSM_DOCKER_WORK_DIR/mon.env
; then
780 echo "OSMMON_VCA_HOST=${OSM_VCA_HOST}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
782 $WORKDIR_SUDO sed -i "s|OSMMON_VCA_HOST.*|OSMMON_VCA_HOST=$OSM_VCA_HOST|g" $OSM_DOCKER_WORK_DIR/mon.env
785 if ! grep -Fq "OSMMON_VCA_SECRET" $OSM_DOCKER_WORK_DIR/mon.env
; then
786 echo "OSMMON_VCA_SECRET=${OSM_VCA_SECRET}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
788 $WORKDIR_SUDO sed -i "s|OSMMON_VCA_SECRET.*|OSMMON_VCA_SECRET=$OSM_VCA_SECRET|g" $OSM_DOCKER_WORK_DIR/mon.env
791 if ! grep -Fq "OSMMON_VCA_CACERT" $OSM_DOCKER_WORK_DIR/mon.env
; then
792 echo "OSMMON_VCA_CACERT=${OSM_VCA_CACERT}" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
794 $WORKDIR_SUDO sed -i "s|OSMMON_VCA_CACERT.*|OSMMON_VCA_CACERT=${OSM_VCA_CACERT}|g" $OSM_DOCKER_WORK_DIR/mon.env
799 if [ ! -f $OSM_DOCKER_WORK_DIR/pol.env
]; then
800 echo "OSMPOL_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/pol" |
$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/pol.env
803 echo "Finished generation of docker env files"
806 function generate_osmclient_script
() {
807 echo "docker run -ti --network net${OSM_STACK_NAME} ${DOCKER_REGISTRY_URL}${DOCKER_USER}/osmclient:${OSM_DOCKER_TAG}" |
$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/osm
808 $WORKDIR_SUDO chmod +x
"$OSM_DOCKER_WORK_DIR/osm"
809 echo "osmclient sidecar container can be found at: $OSM_DOCKER_WORK_DIR/osm"
812 #installs kubernetes packages
813 function install_kube
() {
814 sudo apt-get update
&& sudo apt-get
install -y apt-transport-https
815 curl
-fsSL https
://packages.cloud.google.com
/apt
/doc
/apt-key.gpg | sudo apt-key add
-
816 sudo add-apt-repository
"deb https://apt.kubernetes.io/ kubernetes-xenial main"
818 echo "Installing Kubernetes Packages ..."
819 sudo apt-get
install -y kubelet
=1.15.0-00 kubeadm
=1.15.0-00 kubectl
=1.15.0-00
820 sudo apt-mark hold kubelet kubeadm kubectl
823 #initializes kubernetes control plane
824 function init_kubeadm
() {
826 sudo
sed -i.bak
'/.*none.*swap/s/^\(.*\)$/#\1/g' /etc
/fstab
827 sudo kubeadm init
--config $1
831 function kube_config_dir
() {
832 [ ! -d $K8S_MANIFEST_DIR ] && FATAL
"Cannot Install Kubernetes"
834 sudo
cp /etc
/kubernetes
/admin.conf
$HOME/.kube
/config
835 sudo chown $
(id
-u):$
(id
-g) $HOME/.kube
/config
838 function install_k8s_storageclass
() {
839 OPENEBS_DIR
="$(mktemp -d -q --tmpdir "openebs.XXXXXX
")"
840 trap 'rm -rf "${OPENEBS_DIR}"' EXIT
841 wget
-q https
://openebs.github.io
/charts
/openebs-operator-1.6
.0.yaml
-P $OPENEBS_DIR
842 kubectl apply
-f $OPENEBS_DIR
843 local storageclass_timeout
=400
845 local storageclass_ready
=""
846 echo "Waiting for storageclass"
847 while (( counter
< storageclass_timeout
))
849 kubectl get storageclass openebs-hostpath
&> /dev
/null
851 if [ $?
-eq 0 ] ; then
852 echo "Storageclass available"
853 storageclass_ready
="y"
856 counter
=$
((counter
+ 15))
860 [ -n "$storageclass_ready" ] || FATAL
"Storageclass not ready after $storageclass_timeout seconds. Cannot install openebs"
861 kubectl
patch storageclass openebs-hostpath
-p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'
864 function install_k8s_metallb
() {
865 METALLB_IP_RANGE
=$DEFAULT_IP-$DEFAULT_IP
866 cat ${OSM_DEVOPS}/installers
/k8s
/metallb
/metallb.yaml | kubectl apply
-f -
870 namespace: metallb-system
878 - $METALLB_IP_RANGE" | kubectl apply
-f -
880 #deploys flannel as daemonsets
881 function deploy_cni_provider
() {
882 CNI_DIR
="$(mktemp -d -q --tmpdir "flannel.XXXXXX
")"
883 trap 'rm -rf "${CNI_DIR}"' EXIT
884 wget
-q https
://raw.githubusercontent.com
/coreos
/flannel
/master
/Documentation
/kube-flannel.yml
-P $CNI_DIR
885 kubectl apply
-f $CNI_DIR
886 [ $?
-ne 0 ] && FATAL
"Cannot Install Flannel"
889 #creates secrets from env files which will be used by containers
890 function kube_secrets
(){
891 kubectl create ns
$OSM_STACK_NAME
892 kubectl create secret generic lcm-secret
-n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/lcm.env
893 kubectl create secret generic mon-secret
-n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/mon.env
894 kubectl create secret generic nbi-secret
-n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/nbi.env
895 kubectl create secret generic ro-db-secret
-n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/ro-db.env
896 kubectl create secret generic ro-secret
-n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/ro.env
897 kubectl create secret generic keystone-secret
-n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/keystone.env
898 kubectl create secret generic pol-secret
-n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/pol.env
901 #taints K8s master node
902 function taint_master_node
() {
903 K8S_MASTER
=$
(kubectl get nodes |
awk '$3~/master/'|
awk '{print $1}')
904 kubectl taint node
$K8S_MASTER node-role.kubernetes.io
/master
:NoSchedule-
908 #deploys osm pods and services
909 function deploy_osm_services
() {
910 kubectl apply
-n $OSM_STACK_NAME -f $OSM_K8S_WORK_DIR
913 #deploy charmed services
914 function deploy_charmed_services
() {
915 juju add-model
$OSM_STACK_NAME $OSM_VCA_K8S_CLOUDNAME
916 # deploy mongodb charm
917 namespace
=$OSM_STACK_NAME
918 juju deploy cs
:~charmed-osm
/mongodb-k8s \
919 --config enable-sidecar
=true \
920 --config replica-set
=rs0 \
921 --config namespace
=$namespace \
925 function deploy_osm_pla_service
() {
926 # corresponding to namespace_vol
927 $WORKDIR_SUDO sed -i "s#path: /var/lib/osm#path: $OSM_NAMESPACE_VOL#g" $OSM_DOCKER_WORK_DIR/osm_pla
/pla.yaml
928 # corresponding to deploy_osm_services
929 kubectl apply
-n $OSM_STACK_NAME -f $OSM_DOCKER_WORK_DIR/osm_pla
932 #Install helm and tiller
933 function install_helm
() {
934 helm
> /dev
/null
2>&1
935 if [ $?
!= 0 ] ; then
936 # Helm is not installed. Install helm
937 echo "Helm is not installed, installing ..."
938 curl https
://get.helm.sh
/helm-v2.15
.2-linux-amd64.
tar.gz
--output helm-v2.15
.2.
tar.gz
939 tar -zxvf helm-v2.15
.2.
tar.gz
940 sudo
mv linux-amd64
/helm
/usr
/local
/bin
/helm
942 rm helm-v2.15
.2.
tar.gz
945 # Checking if tiller has being configured
946 kubectl
--namespace kube-system get serviceaccount tiller
> /dev
/null
2>&1
947 if [ $?
== 1 ] ; then
948 # tiller account for kubernetes
949 kubectl
--namespace kube-system create serviceaccount tiller
950 kubectl create clusterrolebinding tiller-cluster-rule
--clusterrole=cluster-admin
--serviceaccount=kube-system
:tiller
951 # HELM initialization
952 helm init
--stable-repo-url https
://charts.helm.sh
/stable
--service-account tiller
954 # Wait for Tiller to be up and running. If timeout expires, continue installing
958 while (( counter
< tiller_timeout
))
960 tiller_status
=`kubectl -n kube-system get deployment.apps/tiller-deploy --no-headers | awk '{print $2'}`
961 ( [ ! -z "$tiller_status" ] && [ $tiller_status == "1/1" ] ) && echo "Tiller ready" && break
962 counter
=$
((counter
+ 5))
965 [ "$tiller_status" != "1/1" ] && echo "Tiller is NOT READY YET. Installation will continue"
969 function parse_yaml
() {
973 for module
in $services; do
974 if [ "$module" == "pla" ]; then
975 if [ -n "$INSTALL_PLA" ]; then
976 echo "Updating K8s manifest file from opensourcemano\/${module}:.* to ${DOCKER_REGISTRY_URL}${DOCKER_USER}\/${module}:${TAG}"
977 $WORKDIR_SUDO sed -i "s#opensourcemano/pla:.*#${DOCKER_REGISTRY_URL}${DOCKER_USER}/pla:${TAG}#g" ${OSM_DOCKER_WORK_DIR}/osm_pla/pla.yaml
980 echo "Updating K8s manifest
file from opensourcemano\
/${module}:.* to ${DOCKER_REGISTRY_URL}${DOCKER_USER}\/${module}:${TAG}"
981 $WORKDIR_SUDO sed -i "s
#opensourcemano/${module}:.*#${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module}:${TAG}#g" ${OSM_K8S_WORK_DIR}/${module}.yaml
986 function update_manifest_files
() {
987 osm_services
="nbi lcm ro pol mon ng-ui keystone pla"
989 for module
in $osm_services; do
990 module_upper
="${module^^}"
991 if ! echo $TO_REBUILD |
grep -q $module_upper ; then
992 list_of_services
="$list_of_services $module"
995 if [ ! "$OSM_DOCKER_TAG" == "9" ]; then
996 parse_yaml
$OSM_DOCKER_TAG $list_of_services
998 if [ -n "$MODULE_DOCKER_TAG" ]; then
999 parse_yaml
$MODULE_DOCKER_TAG $list_of_services_to_rebuild
1003 function namespace_vol
() {
1004 osm_services
="nbi lcm ro pol mon kafka mysql prometheus"
1005 for osm
in $osm_services; do
1006 $WORKDIR_SUDO sed -i "s#path: /var/lib/osm#path: $OSM_NAMESPACE_VOL#g" $OSM_K8S_WORK_DIR/$osm.yaml
1010 function init_docker_swarm
() {
1011 if [ "${DEFAULT_MTU}" != "1500" ]; then
1012 DOCKER_NETS
=`sg docker -c "docker network list" | awk '{print $2}' | egrep -v "^ID$" | paste -d " " -s`
1013 DOCKER_GW_NET
=`sg docker -c "docker network inspect ${DOCKER_NETS}" | grep Subnet | awk -F\" '{print $4}' | egrep "^172" | sort -u | tail -1 | awk -F\. '{if ($2 != 255) print $1"."$2+1"."$3"."$4; else print "-1";}'`
1014 sg docker
-c "docker network create --subnet ${DOCKER_GW_NET} --opt com.docker.network.bridge.name=docker_gwbridge --opt com.docker.network.bridge.enable_icc=false --opt com.docker.network.bridge.enable_ip_masquerade=true --opt com.docker.network.driver.mtu=${DEFAULT_MTU} docker_gwbridge"
1016 sg docker
-c "docker swarm init --advertise-addr ${DEFAULT_IP}"
1020 function create_docker_network
() {
1021 echo "creating network"
1022 sg docker
-c "docker network create --driver=overlay --attachable --opt com.docker.network.driver.mtu=${DEFAULT_MTU} net${OSM_STACK_NAME}"
1023 echo "creating network DONE"
1026 function deploy_lightweight
() {
1028 echo "Deploying lightweight build"
1031 OSM_KEYSTONE_PORT
=5000
1035 OSM_PROM_CADVISOR_PORT
=8080
1036 OSM_PROM_HOSTPORT
=9091
1037 OSM_GRAFANA_PORT
=3000
1038 [ -n "$INSTALL_ELK" ] && OSM_ELK_PORT
=5601
1039 #[ -n "$INSTALL_PERFMON" ] && OSM_PM_PORT=3000
1041 if [ -n "$NO_HOST_PORTS" ]; then
1042 OSM_PORTS
+=(OSM_NBI_PORTS
=$OSM_NBI_PORT)
1043 OSM_PORTS
+=(OSM_RO_PORTS
=$OSM_RO_PORT)
1044 OSM_PORTS
+=(OSM_KEYSTONE_PORTS
=$OSM_KEYSTONE_PORT)
1045 OSM_PORTS
+=(OSM_UI_PORTS
=$OSM_UI_PORT)
1046 OSM_PORTS
+=(OSM_MON_PORTS
=$OSM_MON_PORT)
1047 OSM_PORTS
+=(OSM_PROM_PORTS
=$OSM_PROM_PORT)
1048 OSM_PORTS
+=(OSM_PROM_CADVISOR_PORTS
=$OSM_PROM_CADVISOR_PORT)
1049 OSM_PORTS
+=(OSM_GRAFANA_PORTS
=$OSM_GRAFANA_PORT)
1050 #[ -n "$INSTALL_PERFMON" ] && OSM_PORTS+=(OSM_PM_PORTS=$OSM_PM_PORT)
1051 [ -n "$INSTALL_ELK" ] && OSM_PORTS
+=(OSM_ELK_PORTS
=$OSM_ELK_PORT)
1053 OSM_PORTS
+=(OSM_NBI_PORTS
=$OSM_NBI_PORT:$OSM_NBI_PORT)
1054 OSM_PORTS
+=(OSM_RO_PORTS
=$OSM_RO_PORT:$OSM_RO_PORT)
1055 OSM_PORTS
+=(OSM_KEYSTONE_PORTS
=$OSM_KEYSTONE_PORT:$OSM_KEYSTONE_PORT)
1056 OSM_PORTS
+=(OSM_UI_PORTS
=$OSM_UI_PORT:$OSM_UI_PORT)
1057 OSM_PORTS
+=(OSM_MON_PORTS
=$OSM_MON_PORT:$OSM_MON_PORT)
1058 OSM_PORTS
+=(OSM_PROM_PORTS
=$OSM_PROM_HOSTPORT:$OSM_PROM_PORT)
1059 OSM_PORTS
+=(OSM_PROM_CADVISOR_PORTS
=$OSM_PROM_CADVISOR_PORT:$OSM_PROM_CADVISOR_PORT)
1060 OSM_PORTS
+=(OSM_GRAFANA_PORTS
=$OSM_GRAFANA_PORT:$OSM_GRAFANA_PORT)
1061 #[ -n "$INSTALL_PERFMON" ] && OSM_PORTS+=(OSM_PM_PORTS=$OSM_PM_PORT:$OSM_PM_PORT)
1062 [ -n "$INSTALL_ELK" ] && OSM_PORTS
+=(OSM_ELK_PORTS
=$OSM_ELK_PORT:$OSM_ELK_PORT)
1064 echo "export ${OSM_PORTS[@]}" |
$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/osm_ports.sh
1065 echo "export OSM_NETWORK=net${OSM_STACK_NAME}" |
$WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1066 echo "export TAG=${OSM_DOCKER_TAG}" |
$WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1067 echo "export DOCKER_USER=${DOCKER_USER}" |
$WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1068 echo "export KAFKA_TAG=${KAFKA_TAG}" |
$WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1069 echo "export PROMETHEUS_TAG=${PROMETHEUS_TAG}" |
$WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1070 echo "export KEYSTONEDB_TAG=${KEYSTONEDB_TAG}" |
$WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1071 echo "export PROMETHEUS_CADVISOR_TAG=${PROMETHEUS_CADVISOR_TAG}" |
$WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1072 echo "export GRAFANA_TAG=${GRAFANA_TAG}" |
$WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1074 pushd $OSM_DOCKER_WORK_DIR
1075 if [ -n "$INSTALL_PLA" ]; then
1076 track deploy_osm_pla
1077 sg docker
-c ". ./osm_ports.sh; docker stack deploy -c $OSM_DOCKER_WORK_DIR/docker-compose.yaml -c $OSM_DOCKER_WORK_DIR/docker-compose-ui.yaml -c $OSM_DOCKER_WORK_DIR/osm_pla/docker-compose.yaml $OSM_STACK_NAME"
1079 sg docker
-c ". ./osm_ports.sh; docker stack deploy -c $OSM_DOCKER_WORK_DIR/docker-compose.yaml -c $OSM_DOCKER_WORK_DIR/docker-compose-ui.yaml $OSM_STACK_NAME"
1083 echo "Finished deployment of lightweight build"
1086 function deploy_elk
() {
1087 echo "Pulling docker images for ELK"
1088 sg docker
-c "docker pull docker.elastic.co/elasticsearch/elasticsearch-oss:${ELASTIC_VERSION}" || FATAL
"cannot get elasticsearch docker image"
1089 sg docker
-c "docker pull docker.elastic.co/beats/metricbeat:${ELASTIC_VERSION}" || FATAL
"cannot get metricbeat docker image"
1090 sg docker
-c "docker pull docker.elastic.co/beats/filebeat:${ELASTIC_VERSION}" || FATAL
"cannot get filebeat docker image"
1091 sg docker
-c "docker pull docker.elastic.co/kibana/kibana-oss:${ELASTIC_VERSION}" || FATAL
"cannot get kibana docker image"
1092 sg docker
-c "docker pull bobrik/curator:${ELASTIC_CURATOR_VERSION}" || FATAL
"cannot get curator docker image"
1093 echo "Finished pulling elk docker images"
1094 $WORKDIR_SUDO mkdir
-p "$OSM_DOCKER_WORK_DIR/osm_elk"
1095 $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers
/docker
/osm_elk
/* $OSM_DOCKER_WORK_DIR/osm_elk
1096 remove_stack osm_elk
1097 echo "Deploying ELK stack"
1098 sg docker
-c "OSM_NETWORK=net${OSM_STACK_NAME} docker stack deploy -c $OSM_DOCKER_WORK_DIR/osm_elk/docker-compose.yml osm_elk"
1099 echo "Waiting for ELK stack to be up and running"
1104 while [ $time -le $timelength ]; do
1105 if [[ $
(curl
-f -XGET http
://127.0.0.1:5601/status
-I 2>/dev
/null |
grep "HTTP/1.1 200 OK" |
wc -l ) -eq 1 ]]; then
1112 if [ $elk_is_up -eq 0 ]; then
1113 echo "ELK is up and running. Trying to create index pattern..."
1114 #Create index pattern
1115 curl
-f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1116 "http://127.0.0.1:5601/api/saved_objects/index-pattern/filebeat-*" \
1117 -d"{\"attributes\":{\"title\":\"filebeat-*\",\"timeFieldName\":\"@timestamp\"}}" 2>/dev
/null
1118 #Make it the default index
1119 curl
-f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1120 "http://127.0.0.1:5601/api/kibana/settings/defaultIndex" \
1121 -d"{\"value\":\"filebeat-*\"}" 2>/dev
/null
1123 echo "Cannot connect to Kibana to create index pattern."
1124 echo "Once Kibana is running, you can use the following instructions to create index pattern:"
1125 echo 'curl -f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1126 "http://127.0.0.1:5601/api/saved_objects/index-pattern/filebeat-*" \
1127 -d"{\"attributes\":{\"title\":\"filebeat-*\",\"timeFieldName\":\"@timestamp\"}}"'
1128 echo 'curl -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1129 "http://127.0.0.1:5601/api/kibana/settings/defaultIndex" \
1130 -d"{\"value\":\"filebeat-*\"}"'
1132 echo "Finished deployment of ELK stack"
1136 function add_local_k8scluster
() {
1137 /usr
/bin
/osm
--all-projects vim-create \
1138 --name _system-osm-vim \
1139 --account_type dummy \
1140 --auth_url http
://dummy \
1141 --user osm
--password osm
--tenant osm \
1142 --description "dummy" \
1143 --config '{management_network_name: mgmt}'
1144 /usr
/bin
/osm
--all-projects k8scluster-add \
1145 --creds ${HOME}/.kube
/config \
1146 --vim _system-osm-vim \
1147 --k8s-nets '{"net1": null}' \
1149 --description "OSM Internal Cluster" \
1153 function install_lightweight
() {
1155 [ "$USER" == "root" ] && FATAL
"You are running the installer as root. The installer is prepared to be executed as a normal user with sudo privileges."
1158 if [ -n "$KUBERNETES" ]; then
1159 [ -z "$ASSUME_YES" ] && ! ask_user
"The installation will do the following
1160 1. Install and configure LXD
1162 3. Install docker CE
1163 4. Disable swap space
1164 5. Install and initialize Kubernetes
1165 as pre-requirements.
1166 Do you want to proceed (Y/n)? " y
&& echo "Cancelled!" && exit 1
1169 [ -z "$ASSUME_YES" ] && ! ask_user
"The installation will configure LXD, install juju, install docker CE and init a docker swarm, as pre-requirements. Do you want to proceed (Y/n)? " y
&& echo "Cancelled!" && exit 1
1173 echo "Installing lightweight build of OSM"
1174 LWTEMPDIR
="$(mktemp -d -q --tmpdir "installosmlight.XXXXXX
")"
1175 trap 'rm -rf "${LWTEMPDIR}"' EXIT
1176 DEFAULT_IF
=$
(ip route list|
awk '$1=="default" {print $5; exit}')
1177 [ -z "$DEFAULT_IF" ] && DEFAULT_IF
=$
(route
-n |
awk '$1~/^0.0.0.0/ {print $8; exit}')
1178 [ -z "$DEFAULT_IF" ] && FATAL
"Not possible to determine the interface with the default route 0.0.0.0"
1179 DEFAULT_IP
=`ip -o -4 a s ${DEFAULT_IF} |awk '{split($4,a,"/"); print a[1]}'`
1180 [ -z "$DEFAULT_IP" ] && FATAL
"Not possible to determine the IP address of the interface with the default route"
1181 DEFAULT_MTU
=$
(ip addr show
${DEFAULT_IF} | perl
-ne 'if (/mtu\s(\d+)/) {print $1;}')
1183 # if no host is passed in, we need to install lxd/juju, unless explicilty asked not to
1184 if [ -z "$OSM_VCA_HOST" ] && [ -z "$INSTALL_NOLXD" ] && [ -z "$LXD_CLOUD_FILE" ]; then
1185 need_packages_lw
="snapd"
1186 echo -e "Checking required packages: $need_packages_lw"
1187 dpkg
-l $need_packages_lw &>/dev
/null \
1188 ||
! echo -e "One or several required packages are not installed. Updating apt cache requires root privileges." \
1189 || sudo apt-get update \
1190 || FATAL
"failed to run apt-get update"
1191 dpkg
-l $need_packages_lw &>/dev
/null \
1192 ||
! echo -e "Installing $need_packages_lw requires root privileges." \
1193 || sudo apt-get
install -y $need_packages_lw \
1194 || FATAL
"failed to install $need_packages_lw"
1200 [ -n "$INSTALL_NODOCKER" ] ||
(install_docker_ce
&& track docker_ce
)
1202 echo "Creating folders for installation"
1203 [ ! -d "$OSM_DOCKER_WORK_DIR" ] && $WORKDIR_SUDO mkdir
-p $OSM_DOCKER_WORK_DIR
1204 [ ! -d "$OSM_DOCKER_WORK_DIR/osm_pla" -a -n "$INSTALL_PLA" ] && $WORKDIR_SUDO mkdir
-p $OSM_DOCKER_WORK_DIR/osm_pla
1205 [ -n "$KUBERNETES" ] && $WORKDIR_SUDO cp -b $OSM_DEVOPS/installers
/docker
/cluster-config.yaml
$OSM_DOCKER_WORK_DIR/cluster-config.yaml
1207 #Installs Kubernetes
1208 if [ -n "$KUBERNETES" ]; then
1211 init_kubeadm
$OSM_DOCKER_WORK_DIR/cluster-config.yaml
1214 if [ -n "$INSTALL_K8S_MONITOR" ]; then
1215 # uninstall OSM MONITORING
1216 uninstall_k8s_monitoring
1217 track uninstall_k8s_monitoring
1219 #remove old namespace
1220 remove_k8s_namespace
$OSM_STACK_NAME
1223 install_k8s_storageclass
1224 track k8s_storageclass
1228 #install_docker_compose
1229 [ -n "$INSTALL_NODOCKER" ] || init_docker_swarm
1233 [ -z "$INSTALL_NOJUJU" ] && install_juju
1236 if [ -z "$OSM_VCA_HOST" ]; then
1237 if [ -z "$CONTROLLER_NAME" ]; then
1239 if [ -n "$KUBERNETES" ]; then
1240 juju_createcontroller_k8s
1243 if [ -n "$LXD_CLOUD_FILE" ]; then
1244 [ -z "$LXD_CRED_FILE" ] && FATAL
"The installer needs the LXD credential yaml if the LXD is external"
1245 OSM_VCA_CLOUDNAME
="lxd-cloud"
1246 juju add-cloud
$OSM_VCA_CLOUDNAME $LXD_CLOUD_FILE --force || juju update-cloud
$OSM_VCA_CLOUDNAME --client -f $LXD_CLOUD_FILE
1247 juju add-credential
$OSM_VCA_CLOUDNAME -f $LXD_CRED_FILE || juju update-credential
$OSM_VCA_CLOUDNAME lxd-cloud-creds
-f $LXD_CRED_FILE
1249 juju_createcontroller
1253 OSM_VCA_CLOUDNAME
="lxd-cloud"
1254 if [ -n "$LXD_CLOUD_FILE" ]; then
1255 [ -z "$LXD_CRED_FILE" ] && FATAL
"The installer needs the LXD credential yaml if the LXD is external"
1256 juju add-cloud
-c $CONTROLLER_NAME $OSM_VCA_CLOUDNAME $LXD_CLOUD_FILE --force || juju update-cloud lxd-cloud
-c $CONTROLLER_NAME -f $LXD_CLOUD_FILE
1257 juju add-credential
-c $CONTROLLER_NAME $OSM_VCA_CLOUDNAME -f $LXD_CRED_FILE || juju update-credential lxd-cloud
-c $CONTROLLER_NAME -f $LXD_CRED_FILE
1260 cat << EOF > ~/.osm/lxd-cloud.yaml
1264 auth-types: [certificate]
1265 endpoint: "https://$DEFAULT_IP:8443"
1267 ssl-hostname-verification: false
1269 openssl req
-nodes -new -x509 -keyout ~
/.osm
/client.key
-out ~
/.osm
/client.crt
-days 365 -subj "/C=FR/ST=Nice/L=Nice/O=ETSI/OU=OSM/CN=osm.etsi.org"
1270 local server_cert
=`cat /var/snap/lxd/common/lxd/server.crt | sed 's/^/ /'`
1271 local client_cert
=`cat ~/.osm/client.crt | sed 's/^/ /'`
1272 local client_key
=`cat ~/.osm/client.key | sed 's/^/ /'`
1273 cat << EOF > ~/.osm/lxd-credentials.yaml
1277 auth-type: certificate
1285 lxc config trust add
local: ~
/.osm
/client.crt
1286 juju add-cloud
-c $CONTROLLER_NAME $OSM_VCA_CLOUDNAME ~
/.osm
/lxd-cloud.yaml
--force || juju update-cloud lxd-cloud
-c $CONTROLLER_NAME -f ~
/.osm
/lxd-cloud.yaml
1287 juju add-credential
-c $CONTROLLER_NAME $OSM_VCA_CLOUDNAME -f ~
/.osm
/lxd-credentials.yaml || juju update-credential lxd-cloud
-c $CONTROLLER_NAME -f ~
/.osm
/lxd-credentials.yaml
1290 [ -z "$CONTROLLER_NAME" ] && OSM_VCA_HOST
=`sg lxd -c "juju show-controller $OSM_STACK_NAME"|grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
1291 [ -n "$CONTROLLER_NAME" ] && OSM_VCA_HOST
=`juju show-controller $CONTROLLER_NAME |grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
1292 [ -z "$OSM_VCA_HOST" ] && FATAL
"Cannot obtain juju controller IP address"
1294 track juju_controller
1296 if [ -z "$OSM_VCA_SECRET" ]; then
1297 [ -z "$CONTROLLER_NAME" ] && OSM_VCA_SECRET
=$
(parse_juju_password
$OSM_STACK_NAME)
1298 [ -n "$CONTROLLER_NAME" ] && OSM_VCA_SECRET
=$
(parse_juju_password
$CONTROLLER_NAME)
1299 [ -z "$OSM_VCA_SECRET" ] && FATAL
"Cannot obtain juju secret"
1301 if [ -z "$OSM_VCA_PUBKEY" ]; then
1302 OSM_VCA_PUBKEY
=$
(cat $HOME/.local
/share
/juju
/ssh
/juju_id_rsa.pub
)
1303 [ -z "$OSM_VCA_PUBKEY" ] && FATAL
"Cannot obtain juju public key"
1305 if [ -z "$OSM_VCA_CACERT" ]; then
1306 [ -z "$CONTROLLER_NAME" ] && OSM_VCA_CACERT
=$
(juju controllers
--format json | jq
-r --arg controller
$OSM_STACK_NAME '.controllers[$controller]["ca-cert"]' | base64 |
tr -d \\n
)
1307 [ -n "$CONTROLLER_NAME" ] && OSM_VCA_CACERT
=$
(juju controllers
--format json | jq
-r --arg controller
$CONTROLLER_NAME '.controllers[$controller]["ca-cert"]' | base64 |
tr -d \\n
)
1308 [ -z "$OSM_VCA_CACERT" ] && FATAL
"Cannot obtain juju CA certificate"
1311 # Set OSM_VCA_APIPROXY only when it is not a k8s installation
1312 if [ -z "$KUBERNETES" ]; then
1313 if [ -z "$OSM_VCA_APIPROXY" ]; then
1314 OSM_VCA_APIPROXY
=$DEFAULT_IP
1315 [ -z "$OSM_VCA_APIPROXY" ] && FATAL
"Cannot obtain juju api proxy"
1321 if [ -z "$OSM_DATABASE_COMMONKEY" ]; then
1322 OSM_DATABASE_COMMONKEY
=$
(generate_secret
)
1323 [ -z "OSM_DATABASE_COMMONKEY" ] && FATAL
"Cannot generate common db secret"
1326 # Deploy OSM services
1327 [ -z "$DOCKER_NOBUILD" ] && generate_docker_images
1330 if [ -n "$KUBERNETES" ]; then
1331 generate_k8s_manifest_files
1333 generate_docker_compose_files
1335 track manifest_files
1336 generate_prometheus_grafana_files
1337 generate_docker_env_files
1340 if [ -n "$KUBERNETES" ]; then
1341 deploy_charmed_services
1343 update_manifest_files
1346 if [ -n "$INSTALL_PLA"]; then
1347 # optional PLA install
1348 deploy_osm_pla_service
1349 track deploy_osm_pla
1351 track deploy_osm_services_k8s
1354 if [ -n "$INSTALL_K8S_MONITOR" ]; then
1355 # install OSM MONITORING
1356 install_k8s_monitoring
1357 track install_k8s_monitoring
1361 remove_stack
$OSM_STACK_NAME
1362 create_docker_network
1364 generate_osmclient_script
1366 install_prometheus_nodeexporter
1368 [ -n "$INSTALL_VIMEMU" ] && install_vimemu
&& track vimemu
1369 [ -n "$INSTALL_ELK" ] && deploy_elk
&& track elk
1372 [ -z "$INSTALL_NOHOSTCLIENT" ] && install_osmclient
1375 echo -e "Checking OSM health state..."
1376 if [ -n "$KUBERNETES" ]; then
1377 $OSM_DEVOPS/installers
/osm_health.sh
-s ${OSM_STACK_NAME} -k || \
1378 echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
1379 echo -e "Check OSM status with: kubectl -n ${OSM_STACK_NAME} get all" && \
1382 $OSM_DEVOPS/installers
/osm_health.sh
-s ${OSM_STACK_NAME} || \
1383 echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
1384 echo -e "Check OSM status with: docker service ls; docker stack ps ${OSM_STACK_NAME}" && \
1387 track after_healthcheck
1389 [ -n "$KUBERNETES" ] && add_local_k8scluster
1390 track add_local_k8scluster
1392 wget
-q -O- https
://osm-download.etsi.org
/ftp
/osm-9.0
-nine/README2.txt
&> /dev
/null
1397 function install_to_openstack
() {
1399 if [ -z "$2" ]; then
1400 FATAL
"OpenStack installer requires a valid external network name"
1403 # Install Pip for Python3
1404 $WORKDIR_SUDO apt
install -y python3-pip python3-venv
1405 $WORKDIR_SUDO -H LC_ALL
=C python3
-m pip
install -U pip
1407 # Create a venv to avoid conflicts with the host installation
1408 python3
-m venv
$OPENSTACK_PYTHON_VENV
1410 source $OPENSTACK_PYTHON_VENV/bin
/activate
1412 # Install Ansible, OpenStack client and SDK, latest openstack version supported is Train
1413 python
-m pip
install -U wheel
1414 python
-m pip
install -U "python-openstackclient<=4.0.2" "openstacksdk>=0.12.0,<=0.36.2" "ansible>=2.10,<2.11"
1416 # Install the Openstack cloud module (ansible>=2.10)
1417 ansible-galaxy collection
install openstack.cloud
1419 export ANSIBLE_CONFIG
="$OSM_DEVOPS/installers/openstack/ansible.cfg"
1421 OSM_INSTALLER_ARGS
="${REPO_ARGS[@]}"
1423 ANSIBLE_VARS
="external_network_name=$2 setup_volume=$3 server_name=$OPENSTACK_VM_NAME"
1425 if [ -n "$OPENSTACK_SSH_KEY_FILE" ]; then
1426 ANSIBLE_VARS
+=" key_file=$OPENSTACK_SSH_KEY_FILE"
1429 if [ -n "$OPENSTACK_USERDATA_FILE" ]; then
1430 ANSIBLE_VARS
+=" userdata_file=$OPENSTACK_USERDATA_FILE"
1433 # Execute the Ansible playbook based on openrc or clouds.yaml
1434 if [ -e "$1" ]; then
1436 ansible-playbook
-e installer_args
="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
1437 $OSM_DEVOPS/installers
/openstack
/site.yml
1439 ansible-playbook
-e installer_args
="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
1440 -e cloud_name
=$1 $OSM_DEVOPS/installers
/openstack
/site.yml
1449 function install_vimemu
() {
1450 echo "\nInstalling vim-emu"
1451 EMUTEMPDIR
="$(mktemp -d -q --tmpdir "installosmvimemu.XXXXXX
")"
1452 trap 'rm -rf "${EMUTEMPDIR}"' EXIT
1453 # install prerequisites (OVS is a must for the emulator to work)
1454 sudo apt-get
install openvswitch-switch
1455 # clone vim-emu repository (attention: branch is currently master only)
1456 echo "Cloning vim-emu repository ..."
1457 git clone https
://osm.etsi.org
/gerrit
/osm
/vim-emu.git
$EMUTEMPDIR
1458 # build vim-emu docker
1459 echo "Building vim-emu Docker container..."
1461 sg docker
-c "docker build -t vim-emu-img -f $EMUTEMPDIR/Dockerfile --no-cache $EMUTEMPDIR/" || FATAL
"cannot build vim-emu-img docker image"
1462 # start vim-emu container as daemon
1463 echo "Starting vim-emu Docker container 'vim-emu' ..."
1464 if [ -n "$INSTALL_LIGHTWEIGHT" ]; then
1465 # in lightweight mode, the emulator needs to be attached to netOSM
1466 sg docker
-c "docker run --name vim-emu -t -d --restart always --privileged --pid='host' --network=net${OSM_STACK_NAME} -v /var/run/docker.sock:/var/run/docker.sock vim-emu-img python examples/osm_default_daemon_topology_2_pop.py"
1468 # classic build mode
1469 sg docker
-c "docker run --name vim-emu -t -d --restart always --privileged --pid='host' -v /var/run/docker.sock:/var/run/docker.sock vim-emu-img python examples/osm_default_daemon_topology_2_pop.py"
1471 echo "Waiting for 'vim-emu' container to start ..."
1473 export VIMEMU_HOSTNAME
=$
(sg docker
-c "docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' vim-emu")
1474 echo "vim-emu running at ${VIMEMU_HOSTNAME} ..."
1475 # print vim-emu connection info
1476 echo -e "\nYou might be interested in adding the following vim-emu env variables to your .bashrc file:"
1477 echo " export VIMEMU_HOSTNAME=${VIMEMU_HOSTNAME}"
1478 echo -e "To add the emulated VIM to OSM you should do:"
1479 echo " osm vim-create --name emu-vim1 --user username --password password --auth_url http://${VIMEMU_HOSTNAME}:6001/v2.0 --tenant tenantName --account_type openstack"
1482 function install_k8s_monitoring
() {
1483 # install OSM monitoring
1484 $WORKDIR_SUDO chmod +x
$OSM_DEVOPS/installers
/k8s
/*.sh
1485 $WORKDIR_SUDO $OSM_DEVOPS/installers
/k8s
/install_osm_k8s_monitoring.sh
1488 function uninstall_k8s_monitoring
() {
1489 # uninstall OSM monitoring
1490 $WORKDIR_SUDO $OSM_DEVOPS/installers
/k8s
/uninstall_osm_k8s_monitoring.sh
1493 function dump_vars
(){
1494 echo "DEVELOP=$DEVELOP"
1495 echo "INSTALL_FROM_SOURCE=$INSTALL_FROM_SOURCE"
1496 echo "UNINSTALL=$UNINSTALL"
1497 echo "UPDATE=$UPDATE"
1498 echo "RECONFIGURE=$RECONFIGURE"
1499 echo "TEST_INSTALLER=$TEST_INSTALLER"
1500 echo "INSTALL_VIMEMU=$INSTALL_VIMEMU"
1501 echo "INSTALL_PLA=$INSTALL_PLA"
1502 echo "INSTALL_LXD=$INSTALL_LXD"
1503 echo "INSTALL_LIGHTWEIGHT=$INSTALL_LIGHTWEIGHT"
1504 echo "INSTALL_ONLY=$INSTALL_ONLY"
1505 echo "INSTALL_ELK=$INSTALL_ELK"
1506 echo "INSTALL_NOCACHELXDIMAGES=$INSTALL_NOCACHELXDIMAGES"
1507 #echo "INSTALL_PERFMON=$INSTALL_PERFMON"
1508 echo "INSTALL_TO_OPENSTACK=$INSTALL_TO_OPENSTACK"
1509 echo "OPENSTACK_PUBLIC_NET_NAME=$OPENSTACK_PUBLIC_NET_NAME"
1510 echo "OPENSTACK_OPENRC_FILE_OR_CLOUD=$OPENSTACK_OPENRC_FILE_OR_CLOUD"
1511 echo "OPENSTACK_ATTACH_VOLUME=$OPENSTACK_ATTACH_VOLUME"
1512 echo "OPENSTACK_SSH_KEY_FILE"="$OPENSTACK_SSH_KEY_FILE"
1513 echo "OPENSTACK_USERDATA_FILE"="$OPENSTACK_USERDATA_FILE"
1514 echo "OPENSTACK_VM_NAME"="$OPENSTACK_VM_NAME"
1515 echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR"
1516 echo "TO_REBUILD=$TO_REBUILD"
1517 echo "INSTALL_NOLXD=$INSTALL_NOLXD"
1518 echo "INSTALL_NODOCKER=$INSTALL_NODOCKER"
1519 echo "INSTALL_NOJUJU=$INSTALL_NOJUJU"
1520 echo "RELEASE=$RELEASE"
1521 echo "REPOSITORY=$REPOSITORY"
1522 echo "REPOSITORY_BASE=$REPOSITORY_BASE"
1523 echo "REPOSITORY_KEY=$REPOSITORY_KEY"
1524 echo "OSM_DEVOPS=$OSM_DEVOPS"
1525 echo "OSM_VCA_HOST=$OSM_VCA_HOST"
1526 echo "OSM_VCA_SECRET=$OSM_VCA_SECRET"
1527 echo "OSM_VCA_PUBKEY=$OSM_VCA_PUBKEY"
1528 echo "NO_HOST_PORTS=$NO_HOST_PORTS"
1529 echo "DOCKER_NOBUILD=$DOCKER_NOBUILD"
1530 echo "WORKDIR_SUDO=$WORKDIR_SUDO"
1531 echo "OSM_WORK_DIR=$OSM_WORK_DIR"
1532 echo "OSM_DOCKER_TAG=$OSM_DOCKER_TAG"
1533 echo "DOCKER_USER=$DOCKER_USER"
1534 echo "OSM_STACK_NAME=$OSM_STACK_NAME"
1535 echo "PULL_IMAGES=$PULL_IMAGES"
1536 echo "KUBERNETES=$KUBERNETES"
1537 echo "DOCKER_REGISTRY_URL=$DOCKER_REGISTRY_URL"
1538 echo "DOCKER_PROXY_URL=$DOCKER_PROXY_URL"
1539 echo "SHOWOPTS=$SHOWOPTS"
1540 echo "Install from specific refspec (-b): $COMMIT_ID"
1545 duration
=$
((ctime
- SESSION_ID
))
1546 url
="http://www.woopra.com/track/ce?project=osm.etsi.org&cookie=${SESSION_ID}"
1547 #url="${url}&ce_campaign_name=${CAMPAIGN_NAME}"
1549 [ -z "$INSTALL_LIGHTWEIGHT" ] && [ -n "$INSTALL_FROM_SOURCE" ] && event_name
="binsrc"
1550 [ -z "$INSTALL_LIGHTWEIGHT" ] && [ -n "$INSTALL_FROM_LXDIMAGES" ] && event_name
="lxd"
1551 [ -n "$INSTALL_LIGHTWEIGHT" ] && event_name
="lw"
1552 event_name
="${event_name}_$1"
1553 url
="${url}&event=${event_name}&ce_duration=${duration}"
1554 wget
-q -O /dev
/null
$url
1557 function parse_docker_registry_url
() {
1558 DOCKER_REGISTRY_USER
=$
(echo "$DOCKER_REGISTRY_URL" |
awk '{split($1,a,"@"); split(a[1],b,":"); print b[1]}')
1559 DOCKER_REGISTRY_PASSWORD
=$
(echo "$DOCKER_REGISTRY_URL" |
awk '{split($1,a,"@"); split(a[1],b,":"); print b[2]}')
1560 DOCKER_REGISTRY_URL
=$
(echo "$DOCKER_REGISTRY_URL" |
awk '{split($1,a,"@"); print a[2]}')
1563 JUJU_AGENT_VERSION
=2.8.6
1573 INSTALL_FROM_SOURCE
=""
1574 RELEASE
="ReleaseNINE"
1578 LXD_REPOSITORY_BASE
="https://osm-download.etsi.org/repository/osm/lxd"
1579 LXD_REPOSITORY_PATH
=""
1580 INSTALL_LIGHTWEIGHT
="y"
1581 INSTALL_TO_OPENSTACK
=""
1582 OPENSTACK_OPENRC_FILE_OR_CLOUD
=""
1583 OPENSTACK_PUBLIC_NET_NAME
=""
1584 OPENSTACK_ATTACH_VOLUME
="false"
1585 OPENSTACK_SSH_KEY_FILE
=""
1586 OPENSTACK_USERDATA_FILE
=""
1587 OPENSTACK_VM_NAME
="server-osm"
1588 OPENSTACK_PYTHON_VENV
="$HOME/.virtual-envs/osm"
1596 INSTALL_K8S_MONITOR
=""
1597 INSTALL_NOHOSTCLIENT
=""
1598 INSTALL_NOCACHELXDIMAGES
=""
1599 SESSION_ID
=`date +%s`
1604 OSM_VCA_CLOUDNAME
="localhost"
1605 OSM_VCA_K8S_CLOUDNAME
="k8scloud"
1609 REPOSITORY_KEY
="OSM%20ETSI%20Release%20Key.gpg"
1610 REPOSITORY_BASE
="https://osm-download.etsi.org/repository/osm/debian"
1612 OSM_WORK_DIR
="/etc/osm"
1613 OSM_DOCKER_WORK_DIR
="/etc/osm/docker"
1614 OSM_K8S_WORK_DIR
="${OSM_DOCKER_WORK_DIR}/osm_pods"
1615 OSM_HOST_VOL
="/var/lib/osm"
1616 OSM_NAMESPACE_VOL
="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
1617 OSM_DOCKER_TAG
=latest
1618 DOCKER_USER
=opensourcemano
1620 KAFKA_TAG
=2.11-1.0
.2
1621 PROMETHEUS_TAG
=v2.4
.3
1623 PROMETHEUS_NODE_EXPORTER_TAG
=0.18.1
1624 PROMETHEUS_CADVISOR_TAG
=latest
1626 OSM_DATABASE_COMMONKEY
=
1627 ELASTIC_VERSION
=6.4.2
1628 ELASTIC_CURATOR_VERSION
=5.5.4
1629 POD_NETWORK_CIDR
=10.244.0.0/16
1630 K8S_MANIFEST_DIR
="/etc/kubernetes/manifests"
1631 RE_CHECK
='^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
1632 DOCKER_REGISTRY_URL
=
1636 while getopts ":b:r:c:n:k:u:R:D:o:O:m:N:H:S:s:w:t:U:P:A:l:L:K:d:p:T:f:F:-: hy" o
; do
1643 REPOSITORY
="${OPTARG}"
1644 REPO_ARGS
+=(-r "$REPOSITORY")
1647 [ "${OPTARG}" == "swarm" ] && KUBERNETES
="" && REPO_ARGS
+=(-c "${OPTARG}") && continue
1648 [ "${OPTARG}" == "k8s" ] && KUBERNETES
="y" && continue
1649 echo -e "Invalid argument for -i : ' $OPTARG'\n" >&2
1653 REPOSITORY_KEY
="${OPTARG}"
1654 REPO_ARGS
+=(-k "$REPOSITORY_KEY")
1657 REPOSITORY_BASE
="${OPTARG}"
1658 REPO_ARGS
+=(-u "$REPOSITORY_BASE")
1662 REPO_ARGS
+=(-R "$RELEASE")
1665 OSM_DEVOPS
="${OPTARG}"
1669 [ "${OPTARG}" == "vimemu" ] && INSTALL_VIMEMU
="y" && continue
1670 [ "${OPTARG}" == "elk_stack" ] && INSTALL_ELK
="y" && continue
1671 [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR
="y" && continue
1674 INSTALL_TO_OPENSTACK
="y"
1675 if [ -n "${OPTARG}" ]; then
1676 OPENSTACK_OPENRC_FILE_OR_CLOUD
="${OPTARG}"
1678 echo -e "Invalid argument for -O : ' $OPTARG'\n" >&2
1683 OPENSTACK_SSH_KEY_FILE
="${OPTARG}"
1686 OPENSTACK_USERDATA_FILE
="${OPTARG}"
1689 OPENSTACK_PUBLIC_NET_NAME
="${OPTARG}"
1692 [ "${OPTARG}" == "NG-UI" ] && TO_REBUILD
="$TO_REBUILD NG-UI" && continue
1693 [ "${OPTARG}" == "NBI" ] && TO_REBUILD
="$TO_REBUILD NBI" && continue
1694 [ "${OPTARG}" == "LCM" ] && TO_REBUILD
="$TO_REBUILD LCM" && continue
1695 [ "${OPTARG}" == "RO" ] && TO_REBUILD
="$TO_REBUILD RO" && continue
1696 [ "${OPTARG}" == "MON" ] && TO_REBUILD
="$TO_REBUILD MON" && continue
1697 [ "${OPTARG}" == "POL" ] && TO_REBUILD
="$TO_REBUILD POL" && continue
1698 [ "${OPTARG}" == "PLA" ] && TO_REBUILD
="$TO_REBUILD PLA" && continue
1699 [ "${OPTARG}" == "osmclient" ] && TO_REBUILD
="$TO_REBUILD osmclient" && continue
1700 [ "${OPTARG}" == "KAFKA" ] && TO_REBUILD
="$TO_REBUILD KAFKA" && continue
1701 [ "${OPTARG}" == "MONGO" ] && TO_REBUILD
="$TO_REBUILD MONGO" && continue
1702 [ "${OPTARG}" == "PROMETHEUS" ] && TO_REBUILD
="$TO_REBUILD PROMETHEUS" && continue
1703 [ "${OPTARG}" == "PROMETHEUS-CADVISOR" ] && TO_REBUILD
="$TO_REBUILD PROMETHEUS-CADVISOR" && continue
1704 [ "${OPTARG}" == "KEYSTONE-DB" ] && TO_REBUILD
="$TO_REBUILD KEYSTONE-DB" && continue
1705 [ "${OPTARG}" == "GRAFANA" ] && TO_REBUILD
="$TO_REBUILD GRAFANA" && continue
1706 [ "${OPTARG}" == "NONE" ] && TO_REBUILD
="$TO_REBUILD NONE" && continue
1709 OSM_VCA_HOST
="${OPTARG}"
1712 OSM_VCA_SECRET
="${OPTARG}"
1715 OSM_STACK_NAME
="${OPTARG}" && [ -n "$KUBERNETES" ] && [[ ! "${OPTARG}" =~
$RE_CHECK ]] && echo "Namespace $OPTARG is invalid. Regex used for validation is $RE_CHECK" && exit 0
1718 # when specifying workdir, do not use sudo for access
1720 OSM_WORK_DIR
="${OPTARG}"
1723 OSM_DOCKER_TAG
="${OPTARG}"
1724 REPO_ARGS
+=(-t "$OSM_DOCKER_TAG")
1727 DOCKER_USER
="${OPTARG}"
1730 OSM_VCA_PUBKEY
=$
(cat ${OPTARG})
1733 OSM_VCA_APIPROXY
="${OPTARG}"
1736 LXD_CLOUD_FILE
="${OPTARG}"
1739 LXD_CRED_FILE
="${OPTARG}"
1742 CONTROLLER_NAME
="${OPTARG}"
1745 DOCKER_REGISTRY_URL
="${OPTARG}"
1748 DOCKER_PROXY_URL
="${OPTARG}"
1751 MODULE_DOCKER_TAG
="${OPTARG}"
1754 [ "${OPTARG}" == "help" ] && usage
&& exit 0
1755 [ "${OPTARG}" == "source" ] && INSTALL_FROM_SOURCE
="y" && PULL_IMAGES
="" && continue
1756 [ "${OPTARG}" == "develop" ] && DEVELOP
="y" && continue
1757 [ "${OPTARG}" == "uninstall" ] && UNINSTALL
="y" && continue
1758 [ "${OPTARG}" == "update" ] && UPDATE
="y" && continue
1759 [ "${OPTARG}" == "reconfigure" ] && RECONFIGURE
="y" && continue
1760 [ "${OPTARG}" == "test" ] && TEST_INSTALLER
="y" && continue
1761 [ "${OPTARG}" == "lxdinstall" ] && INSTALL_LXD
="y" && continue
1762 [ "${OPTARG}" == "nolxd" ] && INSTALL_NOLXD
="y" && continue
1763 [ "${OPTARG}" == "nodocker" ] && INSTALL_NODOCKER
="y" && continue
1764 [ "${OPTARG}" == "lightweight" ] && INSTALL_LIGHTWEIGHT
="y" && continue
1765 [ "${OPTARG}" == "vimemu" ] && INSTALL_VIMEMU
="y" && continue
1766 [ "${OPTARG}" == "elk_stack" ] && INSTALL_ELK
="y" && continue
1767 [ "${OPTARG}" == "showopts" ] && SHOWOPTS
="y" && continue
1768 [ "${OPTARG}" == "nohostports" ] && NO_HOST_PORTS
="y" && continue
1769 [ "${OPTARG}" == "nojuju" ] && INSTALL_NOJUJU
="y" && continue
1770 [ "${OPTARG}" == "nodockerbuild" ] && DOCKER_NOBUILD
="y" && continue
1771 [ "${OPTARG}" == "nohostclient" ] && INSTALL_NOHOSTCLIENT
="y" && continue
1772 [ "${OPTARG}" == "pullimages" ] && continue
1773 [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR
="y" && continue
1774 [ "${OPTARG}" == "charmed" ] && CHARMED
="y" && continue
1775 [ "${OPTARG}" == "bundle" ] && continue
1776 [ "${OPTARG}" == "k8s" ] && continue
1777 [ "${OPTARG}" == "lxd" ] && continue
1778 [ "${OPTARG}" == "lxd-cred" ] && continue
1779 [ "${OPTARG}" == "microstack" ] && continue
1780 [ "${OPTARG}" == "overlay" ] && continue
1781 [ "${OPTARG}" == "only-vca" ] && continue
1782 [ "${OPTARG}" == "vca" ] && continue
1783 [ "${OPTARG}" == "ha" ] && continue
1784 [ "${OPTARG}" == "tag" ] && continue
1785 [ "${OPTARG}" == "registry" ] && continue
1786 [ "${OPTARG}" == "pla" ] && INSTALL_PLA
="y" && continue
1787 [ "${OPTARG}" == "volume" ] && OPENSTACK_ATTACH_VOLUME
="true" && continue
1788 [ "${OPTARG}" == "nocachelxdimages" ] && INSTALL_NOCACHELXDIMAGES
="y" && continue
1789 echo -e "Invalid option: '--$OPTARG'\n" >&2
1793 echo "Option -$OPTARG requires an argument" >&2
1797 echo -e "Invalid option: '-$OPTARG'\n" >&2
1812 [ -n "$DOCKER_REGISTRY_URL" ] && parse_docker_registry_url
1813 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" != " NONE" ] && echo $TO_REBUILD |
grep -q NONE
&& FATAL
"Incompatible option: -m NONE cannot be used with other -m options"
1814 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" == " PLA" ] && [ -z "$INSTALL_PLA" ] && FATAL
"Incompatible option: -m PLA cannot be used without --pla option"
1816 if [ -n "$SHOWOPTS" ]; then
1821 if [ -n "$CHARMED" ]; then
1822 if [ -n "$UNINSTALL" ]; then
1823 ${OSM_DEVOPS}/installers
/charmed_uninstall.sh
-R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D /usr
/share
/osm-devops
-t $DOCKER_TAG "$@"
1825 ${OSM_DEVOPS}/installers
/charmed_install.sh
-R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D /usr
/share
/osm-devops
-t $DOCKER_TAG "$@"
1831 # if develop, we force master
1832 [ -z "$COMMIT_ID" ] && [ -n "$DEVELOP" ] && COMMIT_ID
="master"
1834 need_packages
="git wget curl tar"
1836 [ -n "$INSTALL_TO_OPENSTACK" ] && install_to_openstack
$OPENSTACK_OPENRC_FILE_OR_CLOUD $OPENSTACK_PUBLIC_NET_NAME $OPENSTACK_ATTACH_VOLUME && echo -e "\nDONE" && exit 0
1838 echo -e "Checking required packages: $need_packages"
1839 dpkg
-l $need_packages &>/dev
/null \
1840 ||
! echo -e "One or several required packages are not installed. Updating apt cache requires root privileges." \
1841 || sudo apt-get update \
1842 || FATAL
"failed to run apt-get update"
1843 dpkg
-l $need_packages &>/dev
/null \
1844 ||
! echo -e "Installing $need_packages requires root privileges." \
1845 || sudo apt-get
install -y $need_packages \
1846 || FATAL
"failed to install $need_packages"
1847 sudo snap
install jq
1848 if [ -z "$OSM_DEVOPS" ]; then
1849 if [ -n "$TEST_INSTALLER" ]; then
1850 echo -e "\nUsing local devops repo for OSM installation"
1851 OSM_DEVOPS
="$(dirname $(realpath $(dirname $0)))"
1853 echo -e "\nCreating temporary dir for OSM installation"
1854 OSM_DEVOPS
="$(mktemp -d -q --tmpdir "installosm.XXXXXX
")"
1855 trap 'rm -rf "$OSM_DEVOPS"' EXIT
1857 git clone https
://osm.etsi.org
/gerrit
/osm
/devops.git
$OSM_DEVOPS
1859 if [ -z "$COMMIT_ID" ]; then
1860 echo -e "\nGuessing the current stable release"
1861 LATEST_STABLE_DEVOPS
=`git -C $OSM_DEVOPS tag -l v[0-9].* | sort -V | tail -n1`
1862 [ -z "$LATEST_STABLE_DEVOPS" ] && echo "Could not find the current latest stable release" && exit 0
1864 echo "Latest tag in devops repo: $LATEST_STABLE_DEVOPS"
1865 COMMIT_ID
="tags/$LATEST_STABLE_DEVOPS"
1867 echo -e "\nDEVOPS Using commit $COMMIT_ID"
1869 git
-C $OSM_DEVOPS checkout
$COMMIT_ID
1873 .
$OSM_DEVOPS/common
/all_funcs
1875 [ "${OSM_STACK_NAME}" == "osm" ] || OSM_DOCKER_WORK_DIR
="$OSM_WORK_DIR/stack/$OSM_STACK_NAME"
1876 [ -n "$KUBERNETES" ] && OSM_K8S_WORK_DIR
="$OSM_DOCKER_WORK_DIR/osm_pods" && OSM_NAMESPACE_VOL
="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
1877 [ -n "$INSTALL_LIGHTWEIGHT" ] && [ -n "$UNINSTALL" ] && uninstall_lightweight
&& echo -e "\nDONE" && exit 0
1878 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_ELK" ] && deploy_elk
1879 #[ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_PERFMON" ] && deploy_perfmon
1880 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_VIMEMU" ] && install_vimemu
1881 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_K8S_MONITOR" ] && install_k8s_monitoring
1882 [ -n "$INSTALL_ONLY" ] && echo -e "\nDONE" && exit 0
1884 #Installation starts here
1885 wget
-q -O- https
://osm-download.etsi.org
/ftp
/osm-9.0
-nine/README.txt
&> /dev
/null
1888 [ -n "$INSTALL_LIGHTWEIGHT" ] && install_lightweight
&& echo -e "\nDONE" && exit 0
1889 echo -e "\nInstalling OSM from refspec: $COMMIT_ID"
1890 if [ -n "$INSTALL_FROM_SOURCE" ] && [ -z "$ASSUME_YES" ]; then
1891 ! ask_user
"The installation will take about 75-90 minutes. Continue (Y/n)? " y
&& echo "Cancelled!" && exit 1
1894 echo -e "Checking required packages: lxd"
1895 lxd
--version &>/dev
/null || FATAL
"lxd not present, exiting."
1896 [ -n "$INSTALL_LXD" ] && echo -e "\nInstalling and configuring lxd" && install_lxd
1898 # use local devops for containers
1899 export OSM_USE_LOCAL_DEVOPS
=true
1903 #Install vim-emu (optional)
1904 [ -n "$INSTALL_VIMEMU" ] && install_docker_ce
&& install_vimemu
1906 wget
-q -O- https
://osm-download.etsi.org
/ftp
/osm-9.0
-nine/README2.txt
&> /dev
/null