Implementación de un sistema OpenStack independiente Virtual TripleO

TripleO significa OpenStack en OpenStack y es uno de los proyectos oficiales de implementación de OpenStack. La instalación de un sistema TripleO independiente puede ser una excelente manera de crear una prueba de concepto, un laboratorio doméstico o un entorno de aprendizaje para pila abierta. Sin embargo, no se recomienda para un entorno de producción.

Recorreremos los pasos necesarios para crear una implementación independiente de la versión de OpenStack Victoria mediante TripleO en CentOS 8. A continuación, crearemos los componentes necesarios para iniciar y conectarse con éxito a una máquina virtual (VM). Finalmente, escribiremos un script para limpiar la implementación.

Índice

Configuración previa a la implementación

El ordenador anfitrión

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 active el servicio, luego instale el cockpit-machines paquete:

sudo systemctl enable --now cockpit.socket
sudo yum install -y cockpit-machines

Compruebe si el netfilter El módulo se carga en el núcleo:

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

Recargar sysctl.conf sin reiniciar:

sudo sysctl -p /etc/sysctl.conf

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:

Establezca una red de administración para TripleO en la red 192.168.24.0/24.
Crear la red autónoma

Usar 192.168.24.0/24 como una red independiente. Primero, crea un standalone.xml archivar:

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>

Entonces usa virsh para definir, activar 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 VM independiente

Dado que esta implementación utiliza una máquina virtual en lugar de un sistema completo, necesitamos crear una máquina virtual para implementar nuestro entorno independiente.

Las especificaciones de la máquina virtual son:

  • CentOS 8 (variante rhel8.2)
  • 60 GB
  • 8 RAM
  • 4 procesadores
  • Red autónoma

Al instalar CentOS 8 en su máquina virtual independiente, asegúrese de que libvirt-tools y usa un mínimo Donde servidor instalación. También tendrá que crear un apilar usuario.

Configuración independiente

Una vez que TripleO se haya implementado como un sistema independiente, ya no podrá iniciar sesión SSH en la máquina virtual con su contraseña. Para prepararse para esto, necesita copiar su clave SSH al apilar usuario. Aquí está el comando:

ssh-copy-id -i ~/.ssh/<your ssh key> [email protected]<standalone>

Debes configurar el apilar usuario para SIN CONTRASEÑA dentro 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 definir 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 algún cambio 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 el Contenedores-prepare-parameters.yaml archivo, que se utilizará para extraer sus contenedores. Utilice el cliente TripleO para crear un archivo base:

OpenStack tripleo container image prepare default --local-push-destination --output-env-file Contenedores-prepare-parameters.yaml

Luego actualice el empujar_destino hacia y desde el espacio de nombres quay.io:

nano Contenedores-prepare-parameters.yaml
push_destination: false
namespace: quay.io/tripleovictoria

Luego configure los ajustes de red usando una configuración de adaptador de red única. Antes de continuar, debe determinar la interfaz en la que se encuentra. 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 los ajustes al configurar el standalone_parameters.yaml luego la instalación, exportar los parámetros en el 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/Contenedores-prepare-parameters.yaml 
  -e $HOME/standalone_parameters.yaml 
  --output-dir $HOME 
  --standalone

Verificación de la instalación

Ahora puede consultar la CLI de OpenStack:

export OS_CLOUD=standalone
openstack endpoint list

Cree una versión, 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. Crear una pequeña instancia con nombre monserver, que ejecuta Cirros y los componentes necesarios para hacerlo realidad. 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ñito sabor que está usando, luego verifique su creación:

openstack flavor create --ram 512 --disk 1 --vcpu 1 --public tiny
openstack flavor list

Imagen

Ahora que tienes una idea, descarga el Cirros imagen y luego configurar Vistazo para usarlo Comprueba 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 llaves

Para conectarse a nuestras máquinas virtuales sin necesidad de ingresar una contraseña, cree una nueva clave SSH en el sistema independiente, descárguela como un par de claves con nombre culpa, y verificar que se crea:

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 nuestro ejemplo:

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 la siguiente configuración para la máquina independiente, así como la Público red, uno privado red, y una subred que vamos a crear:

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 vamos a crear es una 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 nombrada privado y crear una subred llamada red privada:

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 pasos finales son crear un enrutador con nombre enrutador y conectarlo a Público red, así como añadirlo a la red privada 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 nombrado monserver usando 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

Utilizar el server show comando centrándonos en la columna para determinar cuando nuestro servidor está o en:

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, solo podemos SSH en el servidor como cirros usuario para probar:

ssh [email protected]<IP>

Limpiar la 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 Contenedores 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/Contenedores 
    /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

Conclusión

TripleO puede ser útil para crear un entorno de laboratorio o demostración. Hay algunas trampas que debe tener en cuenta para que esto funcione. Este artículo cubrió los pasos necesarios para implementar, configurar y limpiar TripleO usando un entorno basado en RHEL.

Artículos de interés

Subir