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