TripleO significa OpenStack en OpenStack y es uno de los proyectos oficiales de implementación de OpenStack. La instalación de un sistema independiente TripleO puede ser una excelente manera de crear una prueba de concepto, un laboratorio doméstico o un entorno para aprender sobre OpenStack. Sin embargo, no se recomienda para un entorno de producción.
Seguiremos los pasos necesarios para crear una implementación independiente de la versión OpenStack Victoria utilizando TripleO en CentOS 8. Luego, crearemos los componentes necesarios para iniciar y conectarse a una máquina virtual (VM) con éxito. Finalmente, escribiremos un script para limpiar la implementación.
Configuración previa a la implementación
Máquina anfitriona
Usé una máquina RHEL 8.2 para el host en este escenario. Es posible que deba ajustar ligeramente los pasos para Fedora o CentOS.
Para aprovechar Cockpit para administrar redes y máquinas virtuales, inicie y habilite el servicio, y luego instale cockpit-machines paquete:
sudo systemctl enable --now cockpit.socket
sudo yum install -y cockpit-machines
Compruebe si netfilter el módulo está cargado en el kernel:
sudo modprobe br_netfilter Habilite el reenvío de IP IPv4 si aún no está cargado:
sudo nano /etc/sysctl.conf
net.ipv4.ip_forward = 1
Vuelva a cargar sysctl.conf sin reiniciar:
sudo sysctl -p /etc/sysctl.conf [ Los lectores también disfrutaron: Introducción a las redes definidas por software ]
Redes
Antes de comenzar, cree una red independiente además de su red predeterminada. La nueva red será su red de gestión. Puede ajustar lo siguiente a sus propios entornos:
Crear la red independiente
Utilice 192.168.24.0/24 como la red independiente. Primero, crea un standalone.xml archivo:
sudo nano /tmp/standalone.xml
<network>
<name>standalone</name>
<forward mode='nat'>
<nat> <port start='1024' end='65535'/>
</nat>
</forward>
<ip address='192.168.24.0' netmask='255.255.255.0'>
</ip>
</network>
A continuación, utilice virsh para definir, habilitar e iniciar la red externa:
sudo virsh net-define /tmp/standalone.xml
sudo virsh net-autostart standalone
sudo virsh net-start standalone Creación de máquinas virtuales independientes
Dado que esta implementación utiliza una máquina virtual en lugar de hardware completo, debemos crear una máquina virtual en la que implementar nuestro entorno independiente.
Las especificaciones de la máquina virtual son:
- CentOS 8 (variante rhel8.2)
- 60GB
- 8 RAM
- 4 CPU
- Red independiente
Al instalar CentOS 8 en su VM independiente, asegúrese de no instalar libvirt-tools y usa un mínimo o servidor instalación. También deberá crear una pila usuario.
Configuración independiente
Una vez que TripleO se haya implementado como un sistema independiente, no podrá acceder a la VM mediante SSH con su contraseña. Para prepararse para eso, debe copiar su clave SSH en la pila usuario. Aquí está el comando:
ssh-copy-id -i ~/.ssh/<your ssh key> stack@<standalone>
Necesitas configurar la pila usuario para NOPASSWD en sudo :
sudo echo "stack ALL=(root) NOPASSWD:ALL" | sudo tee -a /etc/sudoers.d/stack
sudo chmod 0440 /etc/sudoers.d/stack La máquina independiente necesita un nombre de dominio completo (FQDN), que se puede configurar de la siguiente manera:
sudo hostnamectl set-hostname standalone.example.com
sudo hostnamectl set-hostname standalone.example.com --transient Actualice su sistema y reinícielo si hay cambios en el kernel:
sudo yum update -y
sudo reboot
Descargue e instale el python-tripleo-repos RPM de https://trunk.rdoproject.org/centos8/component/tripleo/current/
sudo yum install -y https://trunk.rdoproject.org/centos8/component/tripleo/current/python3-tripleo-repos-<version>.el8.noarch.rpm
sudo -E tripleo-repos -b victoria current
sudo yum install -y python3-tripleoclient Configurar e implementar
Configuración independiente
Debe crear varios archivos de configuración antes de poder implementar su entorno independiente.
El primer archivo es containers-prepare-parameters.yaml archivo, que se utilizará para extraer sus contenedores. Use el cliente TripleO para crear un archivo base:
OpenStack tripleo container image prepare default --local-push-destination --output-env-file containers-prepare-parameters.yaml A continuación, actualice el push_destination a falso y el espacio de nombres para tirar de quay.io:
nano containers-prepare-parameters.yaml
push_destination: false
namespace: quay.io/tripleovictoria A continuación, configure los ajustes de red utilizando una única configuración de NIC. Antes de continuar, debe determinar la interfaz de su red independiente Está encendido. Tenga en cuenta que es posible que la interfaz aún no esté configurada, por lo que será la interfaz sin IP.
ip addr
Para reutilizar parámetros durante la configuración de standalone_parameters.yaml y luego la instalación, exporte los parámetros al búfer de la siguiente manera:
export IP=192.168.24.2
export VIP=192.168.25.2
export NETMASK=24
export GATEWAY=192.168.24.1
export INTERFACE=<interface>
Ahora, crea el standalone_parameters.yaml archivo usando cat:
cat <<EOF > $HOME/standalone_parameters.yaml
parameter_defaults:
CloudName: $IP
# default gateway
ControlPlaneStaticRoutes:
- ip_netmask: 0.0.0.0/0
next_hop: $GATEWAY
default: true
Debug: true
DeploymentUser: $USER
DnsServers:
- 1.1.1.1
- 8.8.8.8
# needed for vip & pacemaker
KernelIpNonLocalBind: 1
DockerInsecureRegistryAddress:
- $IP:8787
NeutronPublicInterface: $INTERFACE
# domain name used by the host
CloudDomain: localdomain
NeutronDnsDomain: localdomain
# re-use ctlplane bridge for public net, defined in the standalone
# net config (do not change unless you know what you're doing)
NeutronBridgeMappings: datacentre:br-ctlplane
NeutronPhysicalBridge: br-ctlplane
# enable to force metadata for public net
#NeutronEnableForceMetadata: true
StandaloneEnableRoutedNetworks: false
StandaloneHomeDir: $HOME
InterfaceLocalMtu: 1500
# Needed if running in a VM, not needed if on baremetal
NovaComputeLibvirtType: qemu
EOF Ahora está listo para implementar el entorno independiente de TripleO con el siguiente comando:
sudo openstack tripleo deploy \
--templates \
--local-ip=$IP/$NETMASK \
--control-virtual-ip $VIP \
-e /usr/share/openstack-tripleo-heat-templates/environments/standalone/standalone-tripleo.yaml \
-r /usr/share/openstack-tripleo-heat-templates/roles/Standalone.yaml \
-e $HOME/containers-prepare-parameters.yaml \
-e $HOME/standalone_parameters.yaml \
--output-dir $HOME \
--standalone Verificación de la instalación
Ahora puede verificar la CLI de OpenStack:
export OS_CLOUD=standalone
openstack endpoint list Crear un tipo, una imagen, un par de claves, un grupo de seguridad, una red y un servidor
Ahora que ha instalado y verificado su entorno independiente, está listo para usar. Cree una pequeña instancia llamada myserver , que ejecuta Cirros y los componentes necesarios para lograrlo. Antes de comenzar, configure la línea de comando para acceder a la implementación:
export OS_CLOUD=standalone Sabor
Ahora está listo para configurar el pequeño sabor que está usando y luego verifique su creación:
openstack flavor create --ram 512 --disk 1 --vcpu 1 --public tiny
openstack flavor list Imagen
Ahora que tiene un sabor, descargue la imagen de Cirros y luego configure Glance para usarlo Verifique que se haya creado:
wget https://download.cirros-cloud.net/0.5.0/cirros-0.5.0-x86_64-disk.img
openstack image create cirros --container-format bare --disk-format qcow2 --public --file cirros-0.5.0-x86_64-disk.img
openstack image list Par de claves
Para conectarse a nuestras máquinas virtuales sin necesidad de escribir una contraseña, cree una nueva clave SSH en el sistema independiente, cárguela como un par de claves llamado predeterminado, y verifique que se haya creado:
ssh-keygen
openstack keypair create --public-key ~/.ssh/id_rsa.pub default
openstack keypair list Grupo de seguridad
La siguiente tarea es crear un grupo de seguridad llamado básico con reglas que nos permiten SSH y ping nuestra instancia:
openstack security group create basic
openstack security group rule create basic --protocol tcp --dst-port 22:22 --remote-ip 0.0.0.0/0
openstack security group rule create --protocol icmp basic
openstack security group rule create --protocol udp --dst-port 53:53 basic
openstack security group list
openstack security group show default Red
Antes de crear la red, exporte los siguientes parámetros para la máquina independiente, así como para el público red, una privada red, y una subred que crearemos:
export GATEWAY=192.168.24.1
export STANDALONE_HOST=192.168.24.2
export PUBLIC_NETWORK_CIDR=192.168.24.0/24
export PRIVATE_NETWORK_CIDR=192.168.100.0/24
export PUBLIC_NET_START=192.168.24.4
export PUBLIC_NET_END=192.168.24.5
export DNS_SERVER=1.1.1.1 La red pública que crearemos es una externa red que utiliza el centro de datos red física:
openstack network create --external --provider-physical-network datacentre --provider-network-type flat public
openstack network list Ahora crearemos un interno red llamada privada y construye una subred llamada private-net :
openstack network create --internal private
openstack network list
openstack subnet create public-net --subnet-range $PUBLIC_NETWORK_CIDR --no-dhcp --gateway $GATEWAY --allocation-pool start=$PUBLIC_NET_START,end=$PUBLIC_NET_END --network public
openstack subnet create private-net --subnet-range $PRIVATE_NETWORK_CIDR --network private
openstack subnet list Los últimos pasos son crear un enrutador llamado vrouter y conectarlo al público red, así como agregarlo a la private-net subred:
openstack router create vrouter
openstack router list
openstack router set vrouter --external-gateway public
openstack router add subnet vrouter private-net
openstack router show vrouter Servidor
Ahora estamos listos para crear un servidor llamado myserver utilizando el tipo, la imagen, el par de claves y la red privada que creamos:
openstack server create --flavor tiny --image cirros --key-name default --security-group basic --network private myserver
Utilice el server show comando centrado en el estado columna para determinar cuando nuestro servidor está ACTIVO o en ERROR :
openstack server show -c status myserver Antes de que podamos conectarnos al servidor, necesitamos crear una IP flotante y agregarla a nuestro servidor:
openstack floating ip create public
openstack server add floating ip myserver <IP> Como adjuntamos un par de claves a nuestra instancia y abrimos el puerto SSH en el grupo de seguridad del servidor, podemos simplemente usar SSH en el servidor como cirros usuario a probar:
ssh cirros@<IP> Limpieza de implementación
Si necesita limpiar su entorno, elimine los servicios y archivos instalados para la implementación independiente. Para hacer esto, cree un script llamado standalone-cleanup.sh :
cat <<EOF > $HOME/standalone-cleanup.sh
#!/bin/bash
echo "Tearing down TripleO environment"
if type pcs &> /dev/null; then
sudo pcs cluster destroy
fi
if type podman &> /dev/null; then
echo "Removing podman containers and images (takes times...)"
sudo podman rm -af
sudo podman rmi -af
fi
sudo rm -rf \
/var/lib/tripleo-config \
/var/lib/config-data /var/lib/container-config-scripts \
/var/lib/container-puppet \
/var/lib/heat-config \
/var/lib/image-serve \
/var/lib/containers \
/etc/systemd/system/tripleo* \
/var/lib/mysql/*
sudo systemctl daemon-reload
EOF Haga que el script sea ejecutable:
chmod u+x standalone-cleanup.sh Use el siguiente comando para ejecutar la limpieza:
./standalone-cleanup.sh [ Aprenda los aspectos básicos del uso de Kubernetes en esta hoja de trucos gratuita. ]
Resumir
TripleO puede ser útil para crear un entorno de laboratorio o demostración. Hay algunas trampas de las que debe tener cuidado para que funcione. Este artículo cubrió los pasos necesarios para implementar, configurar y limpiar TripleO utilizando un entorno basado en RHEL.