Políticas de protección de MVs

Introdución

Nesta ocasión o que se pretende é realizar copias de seguridade das MVs e sacalas para un medio de almacenamento exterior.
Até a versión 6.2 de XenServer dispoñíase da utilidade VMPPR/VMPR (Virtual Machine Protection Policies & Recovery), que se amosará ao final deste apartado para ver como funcionaba e por se nalgunha versión posterior a volven incorporar.
Na versión 6.2 Citrix retirou esa funcionalidade deste versión aducindo: "Que hai outras ferramentas de backup de terceiros para facer copias das MVs: Quadric Software, SEP, e PHD Virtual.": http://support.citrix.com/article/CTX137826#deprecated_removed.

Por tanto, como non deixa de ser moi importante que polo menos unha vez ao mes (incluso por unha por semana, e se se fan moitos cambios unha por día) se faga unha copia de seguridade da MV en si: dos seus VDIs ou discos e de xeito automático é necesario implantar unha política de seguridade feita cun script na linguaxe Python (http://www.python.org/, http://gl.wikipedia.org/wiki/Python)

En calquera caso con ou sen script, precísase un recurso externo, compartido por NFS ou por SAMBA, no que realizar as copias.
Imos usar para iso a cabina (FreeNAS) lembrar que ao comezo da parte VII creouse un DataSet chamado backup
Tamén se pode podería usar calquera outro ordenador da rede que teña un recurso compartido por SMB/CIFS ou NFS.

Na imaxe seguinte obsérvase que imos montar un o mesmo recurso Backup da FreeNAS a través de SMB/CIFS e NFS. Non é preciso montar o mesmo recurso por distintos protocolos, pero así vemos toda a casuística. Co cal imos crear en XenServer 2 repositorios de almacenamento para o mesmo recurso: un por CIFS e outro por NFS.

Pero antes configuraremos ese recurso na FreeNAS.

Configuración do volume na NAS

Volumes usados da FreeNAS
Usarase o Conxunto de Datos Backup creado ao comezo do apartado V.
Indicamos que os propietarios dese volume son noa/nobody.
Configurar o recurso NFS asociado ...
Non configuramos as Redes autorizadas para ter liberdade e conectarse ao recurso compartido dende calquera Rede. Nun sistema real habería que configuralo.
Mapeamos o usuario raíz a noa, así calquera que se conecte a ese recurso vai conectarse como se fora a usuario noa. Neste caso, pasa o mesmo que no anterior, nun sistema real habería que adaptalo ás circunstancias.

Crear políticas de protección

As políticas de protección o que fan é:
- Crear Snapshots programados da/s MV/s, aínda estando acendidas..
- Opcionalmente pódese exportar ese Snapshot a un recurso externo por SAMBA ou por NFS.
- A continuación vaise expoñer como implantar políticas de protección facendo uso de comandos do CLI xe.

Políticas de protección facendo uso do CLI xe

Basicamente imos realizar os seguintes pasos:
- Comezar configurando en XenServer os repositorios de almacenamento
- Realizar un snapshot da MV (MVs) en cuestión
- Exportar o snapshot a un recurso compartido no exterior para salvagardar a MV
- Destruír/Eliminar o snapshot

Primeiramente exporase como realizar cada un dos pasos anteriores e finalmente automatizaremos o proceso cun script e programaremos a súa execución

Configurar en XenServer os repositorios de almacenamento

Unha vez que temos o recurso compartido Backup na FreeNAS e compartido por SMB/CIFS e NFS facendo uso do comando mount poderíamos montar en XenServer ese recurso tanto por SMB/CIFS ou NFS como se viu na parte IV do curso, pero ...
Imos crear eses puntos de montaxe a través de XenCenter (podería ser tamén a través do CLI xe) creando dous Repositorios de Almacenamento en XenServer apuntando ao mesmo recurso da FreeNAS (Backup) pero facendo uso de protocolos de conexión distintos en cada caso: CIFS e NFS. (O obxectivo de crear os dous Repositorios é simplemente por practicar, chegaría con crear un só).

Creación de repositorios en XenServer
Comezaremos creando un SR (Storage Repository) como se fose para unha Biblioteca de imaxes ISO tipo ...
CIFS
Poñemos un nome a ese SR.
Indicamos a ruta de acceso a ese SR e se é necesario as credenciais de autenticación.
SR creado e observar o seu UUID.
Creamos agora un SR tipo Biblioteca ISO facendo uso do protocolo NFS.
Indicamos o nome.
Indicamos a ruta ao recurso. Lembrar como debe ser o formato servidor:/ruta completa até a exportación.
SR creado e observar o seu UUID.
Con mount vemos os puntos de montaxe creados. Neste caso filtrado con grep
Có CLI xe, podemos ver/modificar/crear/borrar os SR creados no XenServer: xe sr- (Lembrar a tecla TAB)
xe sr-list podemos ver os SRs conectados ao host.
Con xe sr-param- podemos modificar/ver/establecer parámetros dun SR.
xe sr-param-list uuid=.... vemos tódolos parámetros dun SR.

Para afondar máis sobre comandos sr: http://docs.vmd.citrix.com/XenServer/6.2.0/1.0/en_gb/reference.html#cli-xe-commands_sr

Realizar snapshot e exportación dunha MV co CLI xe

A continuación imos ver os pasos básicos para crear co CLI xe un snapshot e exportalo ao exterior.
Estes pasos serán o núcleo do script que logo se amosará para programar e automatizar as medidas de proteccións das MVs.
Imos para iso usar a MV dx2go'.
Para os seguintes pasos como pode ser que haxa que copiar/pegar recomendamos conectarse ao host por ssh/putty ou a consola de XenCenter.

Crear snapshot e exportación dunha MV
Con xe vm- podemos ver tódolos comandos que podemos realizar coas MVs.
xe vm-list amosa as MVs. Observar como unha delas é a pertencente ao dom0 (Control domain on host: ...)
Có parámetro is-control-domain podemos filtrar as MVs a amosar: xe vm-list is-control-domain=false amosa as MVs menos a que é controladora de dominio.
Observar o uuid de x2go.
No seguinte enlace pódese ampliar a información sobre o comando "xe vm": http://docs.vmd.citrix.com/XenServer/6.2.0/1.0/en_gb/reference.html#cli-xe-commands_vm
Imos facer un snapshot de dx2go: xe vm-snapshot uuid= (uuid de dx2go) new-name-label="Data-hora nome MV".
Notar que se o nome vai conter espazos este debe ir entre comiñas dobres.
O nome pode ser o que se desexe, pero se usamos a data e a hora podemos clasificar as copias que imos realizando.
O comando anterior tamén se podería executar como:xe vm-snapshot vm=dx2go new-name-label="Data-hora nome MV"
Cando executamos o comando obtemos un UUID asignado a ese novo snapshot. É aconsellable copiar ese UUID.
En XenCenter podemos ver o snapshot creado para dx2go. Tamén se pode ver con xe snapshot-list
grep is-a-template.
Con xe template-param-set is-a-template=false uuid="do template" cambiamos o parámetro do snapshot indicándolle que non é un template, polo tanto é unha MV.
Neste caso hai que pegar o UUID pois non autocompleta.
Agora podemos consultar de novo ese parámetro do snapshot.
Imos agora exportar ese snapshot ao exterior.
Precisamos executar o comando no directorio a onde se vai realizar a copia.
Para iso co comando mount vemos onde está montado o recurso backup da FreeNAS e situámonos nun dos dous directorios posibles: o que nos permite acceder por NFS ou o que nos permite acceder por CIFS.
Neste caso colleuse o que nos permite acceder por NFS.
Con xe vm-export uuid="do snapshot" filename="Data-hora dx2go.xva".
Lembrar que se o nome do ficheiro contén espazos, este debe ir entre comiñas.
Ao nome do ficheiro engadíuselle a extensión .xva, que era o tipo de ficheiro que usábamos na exportación.
En XenCenter, na lapela Log do host ou da MV en cuestión pódese ver como se vai realizando o proceso de exportación.
Imaxe que amosa o remate exitoso do proceso de exportación.
Neste caso, nun cliente Windows conectámonos por CIFS ao recurso compartido Backup da FreeNAS (coas credenciais correspondentes) e vemos o ficheiro xa totalmente exportado e que podería ser importado a calquera host como MV e non como template.
Finalmente, destruímos o snapshot creado no host: xe vm-uninstall uuid="do snanpshot" force=true. Con force=true evitamos que se quede parado o proceso á espera de que respondamos se estamos seguros do que imos facer.
Mensaxe obtida tras a destrución do snapshot.
E na lapela Snapshots de dx2go xa non hai instantáneas.

Automatización e programación do proceso de backup de MVs: Script

A continuación exponse o script en Python (http://www.python.org/, http://gl.wikipedia.org/wiki/Python) que pode facer todo o anterior por nós.
O propio script ten uns comentarios que explican en liñas xerais a misión de cada función ou bloque de código.
Este script é unha adaptación do orixinal creado por Jan Sipke van der Veen (http://www.jansipke.nl/) e que está no enlace: http://www.jansipke.nl/creating-backups-of-running-vms-in-xenserver/
Incorporouselle cambiar ao directorio no que se desexa realizar o backup (a exportación) e que o nome do snapshot inclúe o nome da MV, para que cando sexa importada leve ese nome e non só a data e hora da exportación.

IMPORTANTE: en python a identación equivale noutras linguaxes as chaves {}, por tanto todo aquel código que se execute no mesmo nivel de identación pertence ao mesmo bloque de código.
Cada identación son 4 espazos, non se realiza coa tecla tabuladora.

NOTAS:
Ao copiar o script dende a Web non leva consigo os números de liña
Se o script se copia dende PDF revisar as tabulacións.

#!/usr/bin/python
# coding: utf-8

import commands, time, os


#######################################################################
# Script que realiza bakcups de MVs nun Repositorio de almacenamento #
#######################################################################



######################################################################
####################################
# Directorio onde se van realizar as copias das MVs: as exportacións
# Cambiar en función do punto de montaxe 
# Usar o comando mount para ver a identificación do punto de montaxe 
# onde se vai realizar a copia.
# O script vai cambiar de directorio para executar dende aí o proceso 
# de copia da MV (exportación)
####################################
######################################################################
directory = "/var/run/sr-mount/037eac02-ddd8-be5d-4179-a08cad518f23"
os.chdir(directory)


######################################################################
####################################
# Función que devolve un array co par (uuid e nome) das MVs que non son 
# dom0 nin un snapshot
####################################
######################################################################
def get_backup_vms():
    result = []
    


    cmd = "xe vm-list is-control-domain=false is-a-snapshot=false"

    # Se se quere facer Backup dunha sóa MV descomentar a seguinte liña e configurala
    #cmd = "xe vm-list name-label=Nome da MV"

    output = commands.getoutput(cmd)

    for vm in output.split("\n\n\n"):
        lines = vm.splitlines()
        uuid = lines[0].split(":")[1][1:]
        name = lines[1].split(":")[1][1:]
        result += [(uuid, name)]

    return result




######################################################################
####################################
# Función que é chamada dende o seguinte bucle e
# recibe:
#   o uuid de cada MV 
#   un nome de ficheiro co que se vai crear o snapshot e o ficheiro a exportar.
# Crea, exporta e elimina o snapshot. 
####################################
######################################################################
def backup_vm(uuid, filename):
    cmd = "xe vm-snapshot uuid=" + uuid + " new-name-label=" + filename
    snapshot_uuid = commands.getoutput(cmd)

    cmd = "xe template-param-set is-a-template=false ha-always-run=false uuid=" + snapshot_uuid
    commands.getoutput(cmd)

    cmd = "xe vm-export vm=" + snapshot_uuid + " filename=" + filename + ".xva"
    commands.getoutput(cmd)

    cmd = "xe vm-uninstall uuid=" + snapshot_uuid + " force=true"
    commands.getoutput(cmd)


 

######################################################################
####################################
# Bucle que procesa tódolos pares (uuid, nome) das MVs
# Chama á 1ª función get_backup_vms() para obter eses pares (uuid, nome) das MVs do host
# Crea o nome do ficheiro (filename) baseado na data-hora e o nome da MV
# Chama á 2ª función (backup_vm) para realizar o backup de cada MV. 
####################################
######################################################################
for (uuid, name) in get_backup_vms():
    timestamp = time.strftime("%Y%m%d-%H%M", time.gmtime())
    print timestamp, uuid, name
    filename = "\"" + timestamp + " " + name +"\""
    backup_vm(uuid, filename)

A continuación vaise poñer en práctica o script anterior e a súa programación en xen00.

Crear snapshot e exportación dunha MV
Copiar o script anterior a un ficheiro con extensión .py. Por exemplo, /usr/local/sbin/backupMVs.py. Adaptar o directorio (variable directory) do script a que corresponda en cada caso.
Pode ser que o proceso de copiar/pegar introduza tabulacións ao comezo de cada liña. Para iso deixamos o ficheiro con extensión .txt para ser descargado dende XenServer e só hai que cambiarlle a extensión:Media:BackupMVs.txt
Tamén se pode facer todo o anterior co seguinte comando dende XenServer:
wget http://informatica.iessanclemente.net/manuais/images/4/45/BackupMVs.txt -O /usr/local/sbin/backupMVs.py
Executamos o script: python /usr/local/sbin/backupMVs.py. Mentres se executa pódense ver as lapelas Log/Snapshot das MVs que se están copiando, como se crea e borra o snapshot e tamén como se exporta.
Vemos o resultado da copia (exportación) das 3 MVs de xen00.
Agora é o momento de crear unha tarefa programada. Por exemplo en: /etc/cron.d/backupMvs
E creamos a tarefa que se executa tódolos venres ás 00:01 h. polo usuario root e que chama ao anterior script.
Para afondar sobre as tarefas programas e cron recomendamos este enlace: Planificador de tarefas: cron e dentro deste para entender o formato do ficheiro: Planificador de tarefas: cron#Estrutura dos ficheiros crontab

Políticas de protección facendo uso de XenCenter

Como xa se indicou ao comezo deste punto, Citrix retirou a realizacións de medidas de protección dende XenCenter.
O que se expón a continuación é como se crean as medidas de protección dende XenCenter en servidores XCP ou versións de pago de XenServer 6.1 e anteriores.
O usuario, salvo por curiosidade ou porque dispoña dun servidor XCP, pode saltar este punto.

Crear unha política de protección con XenCenter
Premer en Pool: VM Protection Policies, ou ...
... en VM: Asign to VM Protection Policy.
Premer en New...
Indicar o nome da política ...
Seleccionar a/s MV/s que van participar na política de protección. Neste caso usouse a MV dbase-recén-instalada.
Neste caso indícase que se desexa realizar instantánea só do disco.
Indicar a frecuencia para realizar o Snapshot (neste caso escolleuse cada hora, para poder experimentar) e cantos Snapshots manter no histórico (neste caso 2). Os anteriores eliminaranse.
Indicar se se desexa Archivar/Exportar, en caso afirmativo en que recurso exportar. Segundo como se escriba o nome do recurso pódese usar ...
... SAMBA (neste caso contra a NAS e usando o usuario noa) ... ou
... NFS (tamén contra a NAS).
Indicar se se desexan a recepción de alertas vía email.
Rematar a creación da política, desactivando que se execute nada máis rematar.
Premendo en Propiedades pódense modificar os parámetros anteriores da política.

Realización de probas

A probar ...
Premendo en Run Now comeza a realizar o Snapshot, unha vez rematado este, amósase na parte inferior (histórico) e comeza a arquivar a copia no exterior, como indica no campo Status.
Dende calquera equipo conectarse por NFS/SAMBA ao recurso Backup da NAS e observar que se creou unha carpeta co Nome da MV+16 primeiros díxitos do uuid.
Dentro da carpeta vese que se está creando un ficheiro (XVA) con nome: aaaammdd-hhmm (UTC).
Unha vez rematada a primeira execución da política, vese que se arquivou correctamente o ficheiro...
Volver executar novamente.
Na lapela Snapshots, premer co botón dereito e seleccionar View: Schedules Snapshots (Snapshots programados).
Os 2 ficheiros da exportación. Ollo que estes non se borran automaticamente, co cal, hai que estudar ben o espazo no que se realiza a copia, a frecuencia da política, ...
Unha vez que se executaron varias veces, manual ou automaticamente ...
Snapshots ...
Ficheiros arquivados ...