Cómo iniciar Instan en OpenStack
Servidor API: gestiona las solicitudes de los clientes y las reenvía al control de la nube.
Control de la nube: maneja las conexiones intermedias entre nodos informáticos, nodos de control de red, servidores API y programadores.
Programador: Selecciona el host en el que ejecutar el comando.
Trabajadores informáticos: iniciar y detener instancias, adjuntar y eliminar volúmenes, etc.
Controlador de red: gestiona los recursos de la red, asigna IP fijas y configura VLAN.
Proceso de Openstack para crear una instancia
1. El servidor API envía el mensaje al controlador de la nube.
2. La autenticación garantiza que el usuario tiene permiso y luego el controlador de la nube envía el mensaje al programador.
3.Scheduler caste envía un mensaje al host seleccionado, pidiéndole que inicie una instancia.
4. El trabajador informático (host seleccionado) recibe el mensaje.
5.6.7.8 Computeworker necesita una IP fija para iniciar una instancia, por lo que envía un mensaje al controlador de red.
Permítanme explicarlo en detalle a continuación:
Interfaz de programación de aplicaciones
1. Esto se puede hacer en la página del panel.
2. Puede utilizar la línea de comando euca-add-key par euca-run-instances.
La solicitud del usuario se envía a nova-api de dos maneras.
El primer método: crear un método a través de la API de OpenStack (controlador de clase (objeto) nova/API/servers.py)create).
Definición create(self, request, principal):
"""Crear un nuevo servidor para el usuario dado"""
Si hay "server " en el cuerpo ":
cuerpo['servidor']['nombre clave'] = self. _get_key_name(solicitud, cuerpo)
valores_extra = Ninguno
valores_extra, instancias = self helper . crear)
Segundo: a través de la API EC2 (como CloudController en nova/API/Cloud.py).
Llame a def run_instances (self, contexto, * * kwargs):
(instancia, resv_id) = self .compute_API .create(context,
InstanceType = tipo de instancia. Obtener el nombre del tipo de instancia (
kwargs.get('instance_type ', Ninguno)),
…
Calcular Llamada final a API create():
Comprueba si se ha alcanzado el número máximo de instancias de este tipo.
Si el grupo de seguridad no existe, crea uno.
Genere la dirección MAC y el nombre de host
Envíe un mensaje al programador para ejecutar esta instancia
Por supuesto, cuando maxCount Cuando es 1 (el valor predeterminado es 1). , se llama al método RPC.cast para enviar el mensaje de la instancia en ejecución al programador
El proceso de Openstack que crea la instancia
En Openstack, el mensaje pasa. Se envía el elenco y el mensaje se distribuye a través de RabbitMQ.
Los remitentes de mensajes (Compute API)
Los intercambios de temas (temas del programador) envían mensajes y los consumidores de mensajes (trabajadores del programador) reciben mensajes de la cola.
La llamada de conversión no requiere un valor de retorno.
[python]Ver texto sin formato
def _schedule_run_instance(self,
<…
Devolver rpc_method(context,
FLAGS.scheduler_topic,
{ "method": "ejecutar instancia",
" args": { "topic": flags.compute_topic,
"Solicitar especificaciones": Solicitar especificaciones,
"Contraseña de administrador": Contraseña de administrador,
"Archivo inyectado": Archivo inyectado,
"red solicitada": red solicitada,
"is_first_time": true,
" filtro _ propiedades ": filtro _ propiedades } })
Programador
El programador recibe el mensaje y luego selecciona el host de destino a través de la política del programador establecida (como el programador de zona).
Finalmente, selecciona un host en una zona disponible específica. /p>
[python]Ver texto sin formato
def cast_to_compute_host(context, host, método, update_db=True, **kwargs):
"""Enviar solicitud a calcular la cola del host" " "
if update_db:
#Si uuid no existe, confíe en id
instance_id = kwargs.get('instance_id', Ninguno)
instance_uuid = kwargs.get('instance_uuid',instance_id)
Si instancia_uuid no es Ninguno:
now = utils.utcnow()
db.instance_update(context, instancia_uuid,
{'host': host, 'scheduled_at': ahora})
rpc.cast(context,
db.queue_get_for(context, 'calcular', host),
{"method": método, " args": kwargs})
log . _(" Casted ' (métodos) ' para calcular ' (host)s ' " locales())
Calcular
El proceso de trabajo informático recibe mensajes y ejecuta métodos (nova/ calcular/manager.py).
[python]Ver texto sin formato
def _run_instance(self, context,stance_uuid,
requested_networks = Ninguno,
inyección files=[],
admin_password=Ninguno,
is_first_time=False,
* *Cuarto):
" " "Iniciar una nueva instancia con las opciones especificadas."""
context = context . elevado()
Prueba:
instance = self . db . instancia_get_by_uuid(context , instancia_uuid)
self. _ comprobar _ instancia _ no _ ya _ creada (contexto, instancia)
image_meta = self. _check_image_size(contexto, instancia)
self. _start_building(contexto, instancia)
self. _ notificar _ sobre el uso de la instancia ( instancia , " create.start " )
network_info = self . _allocate_network(contexto, instancia,
request_network)
Prueba:
block_device_info = self . _prep_block_device(contexto, instancia)
Instancia = self. _spawn(contexto, instancia, image_meta,
Información de red, información del dispositivo de bloqueo,
Archivo inyectado, contraseña de administrador)
Compruebe si la instancia ya se está ejecutando.
Asigne una dirección IP fija
Si VLAN y Bridge no están configurados, configúrelos.
Finalmente, a través de una instancia virtualizada de driversspawn.
NetworkController
NetworkInfo = self. _allocate_network(contexto, instancia,
Request_network)
Llame al método allocate_for_instance de la API de red.
[python]Ver texto sin formato
def allocate_for_instance(self, context,stance, **kwargs):
" ""Asignar todas las estructuras de red al instancia .
: Devuelve: la siguiente información de red en get_instance_nw_info()
"""
args = kwargs
args[' instancia _ id ']= instancia[' id ']
args[' instancia _ uuid ']= instancia[' uuid ']
args[' proyecto _ id ']= instancia[ 'proyecto_id']
args['host'] = instancia['host']
args['rxtx_factor']= instancia['instancia_tipo'] [' rxtx _ factor ']
nw_info = rpc.call(context, FLAGS.network_topic,
{ 'Método': 'allocate_for_instance',
args ': args})
La mayor diferencia entre RPC.call y RPC.cast es que el método de llamada requiere una respuesta
El proceso Openstack de creación de una instancia
.Instancia derivada.
A continuación, quiero hablar sobre la instancia de generación del controlador de virtualización. Usamos lib virt(nova/virt/lib virt/l connect.py)
. [. python] Ver texto sin formato
def spawn(self, contexto, instancia, elemento de imagen, información de red,
Información del dispositivo de bloqueo = Ninguno):
xml = self.to_xml(instancia, información de red, elemento de imagen, falso,
información del dispositivo de bloqueo = información del dispositivo de bloqueo)
self . instancia, network_info)
self.firewall_driver. prepare_instance_filter(instancia, network_info)
self._create_image(contexto, instancia, xml, network_info = network_info,
Bloque información del dispositivo = bloquear información del dispositivo)
self._create_new_domain(xml)
LOG.debug(_("La instancia se está ejecutando"), instancia=instancia. )
Yo. _ enable _ hairpin(instancia)
self . firewall _ driver aplicar _ instancia _ filtro (instancia, información de red)
def _wait_for_boot():
" " "Se llama de vez en cuando antes de que se ejecute la máquina virtual."""
Pruebe:
state = get_info(instance)[' state ']
Con excepciones. No encontrado:
LOG.error(_("Durante el reinicio, la instancia desapareció."),
instancia=instancia)
Mejorar la utilidad. Llamada de bucle completa
if state == power_state.
Ejecutando:
LOG.info(_("Instancia generada exitosamente."),
instancia=instancia)
Mejorar la utilidad. Llamada de bucle completa
timer = utils. Llamada de bucle (_wait_for_boot)
Devuelve timer.start(interval=0.5, now=True)
Pase el archivo xml libvirt y luego genere una instancia basada en el archivo xml.
Prepare el filtro de red. El controlador de firewall predeterminado es iptables.
Crear imagen (los detalles se presentarán más adelante)
def _create_image(self, contexto, instancia, libvirt_xml, suffix= ",
disk_images=None, network_info = Ninguno,
Bloquear información del dispositivo = Ninguno):
Finalmente, el método spawn() del controlador de virtualización llama al creatXML() del controlador.