Creating Dynamic VMs Infrastructure With Xen Hosts

Introdução

No mundo atual, as máquinas de infraestrutura de servidor estão em data centers locais, data centers privados ou data centers de nuvem pública. Essas máquinas são máquinas físicas bare metal, máquinas virtuais (VMs) com hipervisores ou pequenos contêineres, como contêineres docker, em cima de máquinas físicas ou virtuais. Essas máquinas podem estar fisicamente no laboratório local. Em um cenário de data center privado, em que seus próprios hosts adquiridos são colocados em um espaço físico compartilhado em um data center de terceiros e conectados remotamente. Já nos data centers públicos, como AWS, GCP, Azure e OCI, as máquinas são reservadas ou criadas sob demanda para as necessidades altamente escalonáveis que se conectam remotamente. Cada um deles tem suas próprias vantagens em termos de escalabilidade, segurança, confiabilidade, gerenciamento e custos associados a essas infraestruturas.

As equipes do ambiente de desenvolvimento de produtos podem precisar de muitos servidores durante o processo de SDLC. Digamos que alguém tenha escolhido o data center privado com suas próprias máquinas físicas e servidores Xen. Agora, o desafio é como o ciclo de vida das VMs é gerenciado para provisionamento ou encerramento, de forma semelhante aos ambientes de nuvem com processos enxutos e ágeis.

O objetivo deste documento é fornecer o modelo básico de infraestrutura, a arquitetura, as APIs mínimas e os exemplos de trechos de código para que seja possível criar facilmente ambientes de infraestrutura dinâmicos.

Benefícios

Primeiro, vamos entender a sequência típica das etapas seguidas no processo de infraestrutura desse servidor. Você pode relembrá-la da seguinte forma.

1. Aquisição de novas máquinas pela TI
2. Virtualização de host - Instalar o Xen Server e criar modelos de VM por TI
3. Solicitação de VMs estáticas pelas equipes de desenvolvimento e teste por meio de tíquetes (digamos, JIRA) para a TI
4. Mantenha os IPs de VM recebidos em um banco de dados ou em um arquivo estático ou codificados em arquivos de configuração ou ferramentas de CI, como no config.xml do Jenkins
5. Monitore as VMs quanto a verificações de integridade para garantir que elas estejam íntegras antes de usá-las para instalar os produtos
6. Limpeza ou desinstalação antes ou depois das instalações do servidor
7. O Windows pode precisar de alguma limpeza do registro antes de instalar o produto
8. A alocação fixa de VMs para uma área ou uma equipe ou dedicada a um engenheiro pode ter sido feita

Agora, como você pode tornar esse processo mais enxuto e ágil? Você pode eliminar a maioria das etapas acima com uma automação simples?

Sim. Em nosso ambiente, tínhamos mais de 1.000 VMs e tentamos alcançar e, principalmente, o seguinte.

"VMs descartáveis sob demanda, conforme necessário durante a execução dos testes. Resolva problemas de limpeza do Windows com ciclos de teste regulares."

Como você pode ver abaixo, usando o serviço de API do gerenciador de servidor de VMs dinâmicas, 6 das 8 etapas podem ser eliminadas e isso proporciona uma visão ilimitada da infraestrutura para toda a equipe de produtos. Somente as duas primeiras etapas - aquisição e virtualização de host - são necessárias. De fato, isso economiza em termos de tempo e custo!

Fluxo típico para obter infraestrutura

Modelo de infraestrutura dinâmica

A imagem abaixo mostra nossa infraestrutura proposta para um ambiente típico de produto de servidor, com 80% de contêineres do docker, 15% como VMs dinâmicas e 5% como VMs estáticas em pool para casos especiais. Essa distribuição pode ser ajustada com base no que funciona melhor em seu ambiente.

Modelo de infraestrutura

Daqui em diante, discutiremos mais sobre a parte do gerenciador do servidor de VM dinâmica.

Arquitetura do Dynamic Server Manager

No gerenciador de servidor de VMs dinâmicas, um serviço de API simples em que as APIs REST abaixo podem ser expostas e usadas em qualquer lugar no processo automatizado. Como mostra a pilha de tecnologia, as APIs Xen baseadas em python 3 e Python são usadas para a criação real de VMs com o host XenServer. O Flask está sendo usado para a criação da camada de serviço REST. O sistema operacional pode ser qualquer uma das plataformas compatíveis com seu produto, como windows2016, centos7, centos8, debian10, ubuntu18, oel8, suse15.

Arquitetura do gerenciador de servidor de VMs dinâmicas

Salve o histórico das VMs para rastrear o uso e o tempo de provisionamento ou encerramento que pode ser analisado posteriormente. Para armazenar o documento json, pode ser usado o servidor corporativo Couchbase, que é um banco de dados de documentos nosql.

APIs REST simples

*Método*	*URI(s)*	*Finalidade*
OBTER	/showall	Lista todas as VMs no formato json
OBTER	/getavailablecount/	Obtém a lista de contagem de VMs disponíveis para o fornecido
OBTER	/getservers/?os= /getservers/?os=&count= /getservers/?os=&count=&cpus=&mem= /getservers/?os=&expiresin=	Provisões dadas VMs de . contagem de cpus e tamanho de memória também podem ser suportados. parâmetro expiresin em minutos para obter a expiração (encerramento automático) das VMs.
OBTER	/releaseservers/?os= /releaseservers/?os=&count=	Encerra determinadas VMs de

Pré-requisitos para hosts Xen direcionados a VMs dinâmicas

Identificar hosts Xen de VM dinâmicos direcionados
Copiar/criar os modelos de VM
Mova esses hosts Xen para uma VLAN/sub-rede separada (trabalhe com a TI) para reciclar os IPs

Implementação

Em um nível alto -

Criar funções para cada API REST
Chame um serviço comum para executar diferentes ações REST.
Entenda a criação da sessão Xen, obtendo os registros, clonando a VM a partir do modelo, anexando o disco correto, aguardando a criação da VM e o recebimento do IP; exclusão de VMs, exclusão de discos
Iniciar um thread para expiração automática de VMs
Ler a configuração comum, como o formato .ini
Compreender o trabalho com o banco de dados Couchbase e salvar documentos
Teste todas as APIs com os sistemas operacionais e parâmetros necessários
Corrigir problemas, se houver
Executar um POC com poucos hosts Xen

Os trechos de código abaixo podem ajudá-lo a entender ainda melhor.

Criação de APIs

@app.route('/showall/<string:os>')
@app.route("/showall")
def showall_service(os=None):
    count, _ = get_all_xen_hosts_count(os)
    log.info("--> count: {}".format(count))
    all_vms = {}
    for xen_host_ref in range(1, count + 1):
        log.info("Getting xen_host_ref=" + str(xen_host_ref))
        all_vms[xen_host_ref] = perform_service(xen_host_ref, service_name='listvms', os=os)
    return json.dumps(all_vms, indent=2, sort_keys=True)


@app.route('/getavailablecount/<string:os>')
@app.route('/getavailablecount')
def getavailable_count_service(os='centos'):
    """
    Calculate the available count:
        Get Total CPUs, Total Memory
        Get Free CPUs, Free Memory
        Get all the VMs - CPUs and Memory allocated
        Get each OS template - CPUs and Memory
        Available count1 = (Free CPUs - VMs CPUs)/OS_Template_CPUs
        Available count2 = (Free Memory - VMs Memory)/OS_Template_Memory
        Return min(count1,count2)
    """
    count, available_counts, xen_hosts = get_all_available_count(os)
    log.info("{},{},{},{}".format(count, available_counts, xen_hosts, reserved_count))
    if count > reserved_count:
        count -= reserved_count
    log.info("Less reserved count: {},{},{},{}".format(count, available_counts, xen_hosts,
                                                 reserved_count))
    return str(count)


# /getservers/username?count=number&os=centos&ver=6&expiresin=30
@app.route('/getservers/<string:username>')
def getservers_service(username):
    global reserved_count
    if request.args.get('count'):
        vm_count = int(request.args.get('count'))
    else:
        vm_count = 1
    os_name = request.args.get('os')
    if request.args.get('cpus'):
        cpus_count = request.args.get('cpus')
    else:
        cpus_count = "default"

    if request.args.get('mem'):
        mem = request.args.get('mem')
    else:
        mem = "default"

    if request.args.get('expiresin'):
        exp = int(request.args.get('expiresin'))
    else:
        exp = MAX_EXPIRY_MINUTES

    if request.args.get('format'):
        output_format = request.args.get('format')
    else:
        output_format = "servermanager"

    xhostref = None
    if request.args.get('xhostref'):
        xhostref = request.args.get('xhostref')
    reserved_count += vm_count
    if xhostref:
        log.info("-->  VMs on given xenhost" + xhostref)
        vms_ips_list = perform_service(xhostref, 'createvm', os_name, username, vm_count,
                                       cpus=cpus_count, maxmemory=mem, expiry_minutes=exp,
                                       output_format=output_format)
        return json.dumps(vms_ips_list)

 ...


# /releaseservers/{username}
@app.route('/releaseservers/<string:username>/<string:available>')
@app.route('/releaseservers/<string:username>')
def releaseservers_service(username):
    if request.args.get('count'):
        vm_count = int(request.args.get('count'))
    else:
        vm_count = 1
    os_name = request.args.get('os')
    delete_vms_res = []
    for vm_index in range(vm_count):
        if vm_count > 1:
            vm_name = username + str(vm_index + 1)
        else:
            vm_name = username
        xen_host_ref = get_vm_existed_xenhost_ref(vm_name, 1, None)
        log.info("VM to be deleted from xhost_ref=" + str(xen_host_ref))
        if xen_host_ref != 0:
            delete_per_xen_res = perform_service(xen_host_ref, 'deletevm', os_name, vm_name, 1)
            for deleted_vm_res in delete_per_xen_res:
                delete_vms_res.append(deleted_vm_res)
    if len(delete_vms_res) < 1:
        return "Error: VM " + username + " doesn't exist"
    else:
        return json.dumps(delete_vms_res, indent=2, sort_keys=True)


def perform_service(xen_host_ref=1, service_name='list_vms', os="centos", vm_prefix_names="",
                    number_of_vms=1, cpus="default", maxmemory="default",
                    expiry_minutes=MAX_EXPIRY_MINUTES, output_format="servermanager",
                    start_suffix=0):
    xen_host = get_xen_host(xen_host_ref, os)
...

def main():
    # options = parse_arguments()
    set_log_level()
    app.run(host='0.0.0.0', debug=True)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

@aplicativo.rota('/showall/')

@aplicativo.rota("/showall")

def showall_service(os=Nenhum):

contagem, _ = get_all_xen_hosts_count(os)

registro.informações("--> count: {}".formato(contagem))

todos_vms = {}

para xen_host_ref em alcance(1, contagem + 1):

registro.informações("Obtendo xen_host_ref=" + str(xen_host_ref))

todos_vms[xen_host_ref] = perform_service(xen_host_ref, nome_do_serviço='listvms', os=os)

retorno json.lixeiras(todos_vms, recuo=2, sort_keys=Verdadeiro)

@aplicativo.rota('/getavailablecount/')

@aplicativo.rota('/getavailablecount')

def getavailable_count_service(os='centos'):

"""

Calcular a contagem disponível:

Obter total de CPUs, total de memória

Obtenha CPUs gratuitas, memória gratuita

Obter todas as VMs - CPUs e memória alocadas

Obter cada modelo de sistema operacional - CPUs e memória

Contagem disponível1 = (CPUs livres - CPUs de VMs)/OS_Template_CPUs

Contagem disponível2 = (Memória livre - Memória das VMs)/OS_Template_Memory

Retorna min(count1,count2)

"""

contagem, available_counts, xen_hosts = get_all_available_count(os)

registro.informações("{},{},{},{}".formato(contagem, available_counts, xen_hosts, reserved_count))

se contagem > reserved_count:

contagem -= reserved_count

registro.informações("Contagem menos reservada: {},{},{},{}".formato(contagem, available_counts, xen_hosts,

reserved_count))

retorno str(contagem)

# /getservers/username?count=number&os=centos&ver=6&expiresin=30

@aplicativo.rota('/getservers/')

def getervers_service(nome de usuário):

global reserved_count

se solicitação.argumentos.obter('count' (contagem)):

vm_count = int(solicitação.argumentos.obter('count' (contagem)))

mais:

vm_count = 1

nome_do_os = solicitação.argumentos.obter('os')

se solicitação.argumentos.obter('cpus'):

cpus_count = solicitação.argumentos.obter('cpus')

mais:

cpus_count = "default"

se solicitação.argumentos.obter('mem'):

mem = solicitação.argumentos.obter('mem')

mais:

mem = "default"

se solicitação.argumentos.obter('expiresin'):

exp = int(solicitação.argumentos.obter('expiresin'))

mais:

exp = MAX_EXPIRY_MINUTES

se solicitação.argumentos.obter('formato'):

formato de saída = solicitação.argumentos.obter('formato')

mais:

formato de saída = "gerenciador de servidor"

xhostref = Nenhum

se solicitação.argumentos.obter('xhostref'):

xhostref = solicitação.argumentos.obter('xhostref')

reserved_count += vm_count

se xhostref:

registro.informações("--> VMs em um determinado xenhost" + xhostref)

vms_ips_list = perform_service(xhostref, 'createvm', nome_do_os, nome de usuário, vm_count,

cpus=cpus_count, memória máxima=mem, expiry_minutes=exp,

formato de saída=formato de saída)

retorno json.lixeiras(vms_ips_list)

...

# /releaseservers/{username}

@aplicativo.rota('/releaseservers//')

@aplicativo.rota('/releaseservers/')

def releaseservers_service(nome de usuário):

se solicitação.argumentos.obter('count' (contagem)):

vm_count = int(solicitação.argumentos.obter('count' (contagem)))

mais:

vm_count = 1

nome_do_os = solicitação.argumentos.obter('os')

delete_vms_res = []

para vm_index em alcance(vm_count):

se vm_count > 1:

vm_name = nome de usuário + str(vm_index + 1)

mais:

vm_name = nome de usuário

xen_host_ref = get_vm_existed_xenhost_ref(vm_name, 1, Nenhum)

registro.informações("VM a ser excluída de xhost_ref=" + str(xen_host_ref))

se xen_host_ref != 0:

delete_per_xen_res = perform_service(xen_host_ref, 'deletevm', nome_do_os, vm_name, 1)

para deleted_vm_res em delete_per_xen_res:

delete_vms_res.anexar(deleted_vm_res)

se len(delete_vms_res) < 1:

retorno "Error: VM " + nome de usuário + " não existe"

mais:

retorno json.lixeiras(delete_vms_res, recuo=2, sort_keys=Verdadeiro)

def perform_service(xen_host_ref=1, nome_do_serviço='list_vms', os="centos", vm_prefix_names="",

número_de_vms=1, cpus="default", memória máxima="default",

expiry_minutes=MAX_EXPIRY_MINUTES, formato de saída="gerenciador de servidor",

sufixo inicial=0):

xen_host = get_xen_host(xen_host_ref, os)

...

def principal():

# options = parse_arguments()

set_log_level()

aplicativo.executar(hospedeiro='0.0.0.0', depurar=Verdadeiro)

Criação da sessão Xen

def get_xen_session(xen_host_ref=1, os="centos"):
    xen_host = get_xen_host(xen_host_ref, os)
    if not xen_host:
        return None
    url = "http://" + xen_host['host.name']
    log.info("\nXen Server host: " + xen_host['host.name'] + "\n")
    try:
        session = XenAPI.Session(url)
        session.xenapi.login_with_password(xen_host['host.user'], xen_host['host.password'])
    except XenAPI.Failure as f:
        error = "Failed to acquire a session: {}".format(f.details)
        log.error(error)
        return error
    return session

def get_xen_session(xen_host_ref=1, os="centos"):

xen_host = get_xen_host(xen_host_ref, os)

se não xen_host:

retorno Nenhum

url = "http://" + xen_host['host.name']

registro.informações("\nXen Server host: " + xen_host['host.name'] + "\n")

tentar:

sessão = XenAPI.Sessão(url)

sessão.xenapi.login_with_password(xen_host['host.user'], xen_host['host.password'])

exceto XenAPI.Falha como f:

erro = "Falha ao adquirir uma sessão: {}".formato(f.detalhes)

registro.erro(erro)

retorno erro

retorno sessão

Listar VMs

def list_vms(session):
    vm_count = 0
    vms = session.xenapi.VM.get_all()
    log.info("Server has {} VM objects (this includes templates):".format(len(vms)))
    log.info("-----------------------------------------------------------")
    log.info("S.No.,VMname,PowerState,Vcpus,MaxMemory,Networkinfo,Description")
    log.info("-----------------------------------------------------------")

    vm_details = []

    for vm in vms:
        network_info = 'N/A'
        record = session.xenapi.VM.get_record(vm)
        if not (record["is_a_template"]) and not (record["is_control_domain"]):
            log.debug(record)
            vm_count = vm_count + 1
            name = record["name_label"]
            name_description = record["name_description"]
            power_state = record["power_state"]
            vcpus = record["VCPUs_max"]
            memory_static_max = record["memory_static_max"]
            if record["power_state"] != 'Halted':
                ip_ref = session.xenapi.VM_guest_metrics.get_record(record['guest_metrics'])
                network_info = ','.join([str(elem) for elem in ip_ref['networks'].values()])
            else:
                continue  # Listing only Running VMs

            vm_info = {'name': name, 'power_state': power_state, 'vcpus': vcpus,
                       'memory_static_max': memory_static_max, 'networkinfo': network_info,
                       'name_description': name_description}
            vm_details.append(vm_info)
            log.info(vm_info)

    log.info("Server has {} VM objects and {} templates.".format(vm_count, len(vms) - vm_count))
    log.debug(vm_details)
    return vm_details

def list_vms(sessão):

vm_count = 0

vms = sessão.xenapi.VM.get_all()

registro.informações("O servidor tem {} objetos de VM (isso inclui modelos):".formato(len(vms)))

registro.informações("-----------------------------------------------------------")

registro.informações("S.No., VMname, PowerState, Vcpus, MaxMemory, Networkinfo, Description")

registro.informações("-----------------------------------------------------------")

vm_details = []

para vm em vms:

informação_de_rede = 'N/A'

registro = sessão.xenapi.VM.get_record(vm)

se não (registro["is_a_template"]) e não (registro["is_control_domain"]):

registro.depurar(registro)

vm_count = vm_count + 1

nome = registro["name_label"]

name_description = registro["name_description"]

power_state = registro["power_state"]

vcpus = registro["VCPUs_max"]

memory_static_max = registro["memory_static_max"]

se registro["power_state"] != "Parado:

ip_ref = sessão.xenapi.VM_guest_metrics.get_record(registro['guest_metrics'])

informação_de_rede = ','.unir-se([str(elem) para elem em ip_ref["redes].valores()])

mais:

continuar # Listando apenas VMs em execução

vm_info = {"nome: nome, 'power_state': power_state, 'vcpus': vcpus,

'memory_static_max': memory_static_max, 'networkinfo': informação_de_rede,

'name_description': name_description}

vm_details.anexar(vm_info)

registro.informações(vm_info)

registro.informações("O servidor tem {} objetos de VM e {} modelos.".formato(vm_count, len(vms) - vm_count))

registro.depurar(vm_details)

retorno vm_details

Criar VM

def create_vm(session, os_name, template, new_vm_name, cpus="default", maxmemory="default",
              expiry_minutes=MAX_EXPIRY_MINUTES):
    error = ''
    vm_os_name = ''
    vm_ip_addr = ''
    prov_start_time = time.time()
    try:
        log.info("\n--- Creating VM: " + new_vm_name + " using " + template)
        pifs = session.xenapi.PIF.get_all_records()
        lowest = None
        for pifRef in pifs.keys():
            if (lowest is None) or (pifs[pifRef]['device'] < pifs[lowest]['device']):
                lowest = pifRef
        log.debug("Choosing PIF with device: {}".format(pifs[lowest]['device']))
        ref = lowest
        mac = pifs[ref]['MAC']
        device = pifs[ref]['device']
        mode = pifs[ref]['ip_configuration_mode']
        ip_addr = pifs[ref]['IP']
        net_mask = pifs[ref]['IP']
        gateway = pifs[ref]['gateway']
        dns_server = pifs[ref]['DNS']
        log.debug("{},{},{},{},{},{},{}".format(mac, device, mode, ip_addr, net_mask, gateway,
                                                dns_server))
        # List all the VM objects
        vms = session.xenapi.VM.get_all_records()
        log.debug("Server has {} VM objects (this includes templates)".format(len(vms)))

        templates = []
        all_templates = []
        for vm in vms:
            record = vms[vm]
            res_type = "VM"
            if record["is_a_template"]:
                res_type = "Template"
                all_templates.append(vm)
                # Look for a given template
                if record["name_label"].startswith(template):
                    templates.append(vm)
                    log.debug(" Found %8s with name_label = %s" % (res_type, record["name_label"]))

        log.debug("Server has {} Templates and {} VM objects.".format(len(all_templates),
                                                                      len(vms) - len(
                                                                          all_templates)))

        log.debug("Choosing a {} template to clone".format(template))
        if not templates:
            log.error("Could not find any {} templates. Exiting.".format(template))
            sys.exit(1)

        template_ref = templates[0]
        log.debug("  Selected template: {}".format(session.xenapi.VM.get_name_label(template_ref)))

        # Retries when 169.x address received
        ipaddr_max_retries = 3
        retry_count = 1
        is_local_ip = True
        vm_ip_addr = ""
        while is_local_ip and retry_count != ipaddr_max_retries:
            log.info("Installing new VM from the template - attempt #{}".format(retry_count))
            vm = session.xenapi.VM.clone(template_ref, new_vm_name)

            network = session.xenapi.PIF.get_network(lowest)
            log.debug("Chosen PIF is connected to network: {}".format(
                session.xenapi.network.get_name_label(network)))
            vifs = session.xenapi.VIF.get_all()
            log.debug(("Number of VIFs=" + str(len(vifs))))
            for i in range(len(vifs)):
                vmref = session.xenapi.VIF.get_VM(vifs[i])
                a_vm_name = session.xenapi.VM.get_name_label(vmref)
                log.debug(str(i) + "." + session.xenapi.network.get_name_label(
                    session.xenapi.VIF.get_network(vifs[i])) + " " + a_vm_name)
                if a_vm_name == new_vm_name:
                    session.xenapi.VIF.move(vifs[i], network)

            log.debug("Adding non-interactive to the kernel commandline")
            session.xenapi.VM.set_PV_args(vm, "non-interactive")
            log.debug("Choosing an SR to instantiate the VM's disks")
            pool = session.xenapi.pool.get_all()[0]
            default_sr = session.xenapi.pool.get_default_SR(pool)
            default_sr = session.xenapi.SR.get_record(default_sr)
            log.debug("Choosing SR: {} (uuid {})".format(default_sr['name_label'], default_sr['uuid']))
            log.debug("Asking server to provision storage from the template specification")
            description = new_vm_name + " from " + template + " on " + str(datetime.datetime.utcnow())
            session.xenapi.VM.set_name_description(vm, description)
            if cpus != "default":
                log.info("Setting cpus to " + cpus)
                session.xenapi.VM.set_VCPUs_max(vm, int(cpus))
                session.xenapi.VM.set_VCPUs_at_startup(vm, int(cpus))
            if maxmemory != "default":
                log.info("Setting memory to " + maxmemory)
                session.xenapi.VM.set_memory(vm, maxmemory)  # 8GB="8589934592" or 4GB="4294967296"
            session.xenapi.VM.provision(vm)
            log.info("Starting VM")
            session.xenapi.VM.start(vm, False, True)
            log.debug("  VM is booting")

            log.debug("Waiting for the installation to complete")

            # Get the OS Name and IPs
            log.info("Getting the OS Name and IP...")
            config = read_config()
            vm_network_timeout_secs = int(config.get("common", "vm.network.timeout.secs"))
            if vm_network_timeout_secs > 0:
                TIMEOUT_SECS = vm_network_timeout_secs

            log.info("Max wait time in secs for VM OS address is {0}".format(str(TIMEOUT_SECS)))
            if "win" not in template:
                maxtime = time.time() + TIMEOUT_SECS
                while read_os_name(session, vm) is None and time.time() < maxtime:
                    time.sleep(1)
                vm_os_name = read_os_name(session, vm)
                log.info("VM OS name: {}".format(vm_os_name))
            else:
                # TBD: Wait for network to refresh on Windows VM
                time.sleep(60)

            log.info("Max wait time in secs for IP address is " + str(TIMEOUT_SECS))
            maxtime = time.time() + TIMEOUT_SECS
            # Wait until IP is not None or 169.xx (when no IPs available, this is default) and timeout
            # is not reached.
            while (read_ip_address(session, vm) is None or read_ip_address(session, vm).startswith(
                    '169')) and \
                    time.time() < maxtime:
                time.sleep(1)
            vm_ip_addr = read_ip_address(session, vm)
            log.info("VM IP: {}".format(vm_ip_addr))

            if vm_ip_addr.startswith('169'):
                log.info("No Network IP available. Deleting this VM ... ")
                record = session.xenapi.VM.get_record(vm)
                power_state = record["power_state"]
                if power_state != 'Halted':
                    session.xenapi.VM.hard_shutdown(vm)
                delete_all_disks(session, vm)
                session.xenapi.VM.destroy(vm)
                time.sleep(5)
                is_local_ip = True
                retry_count += 1
            else:
                is_local_ip = False

        log.info("Final VM IP: {}".format(vm_ip_addr))

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

def create_vm(sessão, nome_do_os, modelo, new_vm_name, cpus="default", memória máxima="default",

expiry_minutes=MAX_EXPIRY_MINUTES):

erro = ''

vm_os_name = ''

vm_ip_addr = ''

prov_start_time = tempo.tempo()

tentar:

registro.informações("\n--- Criando VM: " + new_vm_name + " usando " + modelo)

pifs = sessão.xenapi.PIF.get_all_records()

mais baixo = Nenhum

para pifRef em pifs.chaves():

se (mais baixo é Nenhum) ou (pifs[pifRef]['dispositivo'] < pifs[mais baixo]['dispositivo']):

mais baixo = pifRef

registro.depurar("Escolhendo PIF com dispositivo: {}".formato(pifs[mais baixo]['dispositivo']))

ref = mais baixo

mac = pifs[ref]['MAC']

dispositivo = pifs[ref]['dispositivo']

modo = pifs[ref]['ip_configuration_mode']

ip_addr = pifs[ref]['IP']

máscara_de_rede = pifs[ref]['IP']

portal = pifs[ref]['gateway']

dns_server = pifs[ref]['DNS']

registro.depurar("{},{},{},{},{},{},{}".formato(mac, dispositivo, modo, ip_addr, máscara_de_rede, portal,

dns_server))

# Listar todos os objetos da VM

vms = sessão.xenapi.VM.get_all_records()

registro.depurar("O servidor tem {} objetos de VM (isso inclui modelos)".formato(len(vms)))

modelos = []

todos_templates = []

para vm em vms:

registro = vms[vm]

tipo_de_res = "VM"

se registro["is_a_template"]:

tipo_de_res = "Template" (Modelo)

todos_templates.anexar(vm)

# Procurar um determinado modelo

se registro["name_label"].começa com(modelo):

modelos.anexar(vm)

registro.depurar(" Encontrados %8s com name_label = %s" % (tipo_de_res, registro["name_label"]))

registro.depurar("O servidor tem {} modelos e {} VM objects.".formato(len(todos_templates),

len(vms) - len(

todos_templates)))

registro.depurar("Escolhendo um modelo {} para clonar".formato(modelo))

se não modelos:

registro.erro("Não foi possível encontrar nenhum modelo {}. Exiting.".formato(modelo))

sistema.saída(1)

template_ref = modelos[0]

registro.depurar(" Modelo selecionado: {}".formato(sessão.xenapi.VM.get_name_label(template_ref)))

# Tenta novamente quando o endereço 169.x é recebido

ipaddr_max_retries = 3

retry_count = 1

is_local_ip = Verdadeiro

vm_ip_addr = ""

enquanto is_local_ip e retry_count != ipaddr_max_retries:

registro.informações("Instalando nova VM a partir do modelo - tentativa #{}".formato(retry_count))

vm = sessão.xenapi.VM.clone(template_ref, new_vm_name)

rede = sessão.xenapi.PIF.get_network(mais baixo)

registro.depurar("O PIF escolhido está conectado à rede: {}".formato(

sessão.xenapi.rede.get_name_label(rede)))

vifs = sessão.xenapi.VIF.get_all()

registro.depurar(("Número de VIFs=" + str(len(vifs))))

para i em alcance(len(vifs)):

vmref = sessão.xenapi.VIF.get_VM(vifs[i])

a_vm_name = sessão.xenapi.VM.get_name_label(vmref)

registro.depurar(str(i) + "." + sessão.xenapi.rede.get_name_label(

sessão.xenapi.VIF.get_network(vifs[i])) + " " + a_vm_name)

se a_vm_name == new_vm_name:

sessão.xenapi.VIF.mover(vifs[i], rede)

registro.depurar("Adição de não interativo à linha de comando do kernel")

sessão.xenapi.VM.set_PV_args(vm, "não interativo")

registro.depurar("Escolha de um SR para instanciar os discos da VM")

piscina = sessão.xenapi.piscina.get_all()[0]

default_sr = sessão.xenapi.piscina.get_default_SR(piscina)

default_sr = sessão.xenapi.SR.get_record(default_sr)

registro.depurar("Escolhendo SR: {} (uuid {})".formato(default_sr['name_label'], default_sr['uuid']))

registro.depurar("Solicitando que o servidor provisione o armazenamento a partir da especificação do modelo")

descrição = new_vm_name + " de " + modelo + " em " + str(data e hora.data e hora.utcnow())

sessão.xenapi.VM.set_name_description(vm, descrição)

se cpus != "default":

registro.informações("Configurando cpus para " + cpus)

sessão.xenapi.VM.set_VCPUs_max(vm, int(cpus))

sessão.xenapi.VM.set_VCPUs_at_startup(vm, int(cpus))

se memória máxima != "default":

registro.informações("Configurando a memória para " + memória máxima)

sessão.xenapi.VM.set_memory(vm, memória máxima) # 8GB="8589934592" ou 4GB="4294967296"

sessão.xenapi.VM.provisão(vm)

registro.informações("Iniciando VM")

sessão.xenapi.VM.iniciar(vm, Falso, Verdadeiro)

registro.depurar(" A VM está sendo inicializada")

registro.depurar("Aguardando a conclusão da instalação")

# Obtenha o nome do sistema operacional e os IPs

registro.informações("Obtendo o nome e o IP do sistema operacional...")

configuração = read_config()

vm_network_timeout_secs = int(configuração.obter("comum", "vm.network.timeout.secs"))

se vm_network_timeout_secs > 0:

TIMEOUT_SECS = vm_network_timeout_secs

registro.informações("O tempo máximo de espera em segundos para o endereço do sistema operacional da VM é {0}".formato(str(TIMEOUT_SECS)))

se "ganhar" não em modelo:

tempo máximo = tempo.tempo() + TIMEOUT_SECS

enquanto read_os_name(sessão, vm) é Nenhum e tempo.tempo() < tempo máximo:

tempo.dormir(1)

vm_os_name = read_os_name(sessão, vm)

registro.informações("Nome do sistema operacional da VM: {}".formato(vm_os_name))

mais:

# TBD: aguardar a atualização da rede na VM do Windows

tempo.dormir(60)

registro.informações("O tempo máximo de espera em segundos para o endereço IP é " + str(TIMEOUT_SECS))

tempo máximo = tempo.tempo() + TEMPO LIMITE_SCEE

# Aguarde até que o IP não seja Nenhum ou 169.xx (quando não houver IPs disponíveis, esse é o padrão) e o tempo limite

# não é acessado.

enquanto (read_ip_address(sessão, vm) é Nenhum ou read_ip_address(sessão, vm).começa com(

'169')) e \

tempo.tempo() < tempo máximo:

tempo.dormir(1)

vm_ip_addr = read_ip_address(sessão, vm)

registro.informações("VM IP: {}".formato(vm_ip_addr))

se vm_ip_addr.começa com('169'):

registro.informações("Nenhum IP de rede disponível. Excluindo esta VM ... ")

registro = sessão.xenapi.VM.get_record(vm)

power_state = registro["power_state"]

se power_state != "Parado:

sessão.xenapi.VM.hard_shutdown(vm)

delete_all_disks(sessão, vm)

sessão.xenapi.VM.destruir(vm)

tempo.dormir(5)

is_local_ip = Verdadeiro

retry_count += 1

mais:

is_local_ip = Falso

registro.informações("IP final da VM: {}".formato(vm_ip_addr))

Excluir VM

def delete_vm(session, vm_name):
    log.info("Deleting VM: " + vm_name)
    delete_start_time = time.time()
    vm = session.xenapi.VM.get_by_name_label(vm_name)
    log.info("Number of VMs found with name - " + vm_name + " : " + str(len(vm)))
    for j in range(len(vm)):
        record = session.xenapi.VM.get_record(vm[j])
        power_state = record["power_state"]
        if power_state != 'Halted':
            # session.xenapi.VM.shutdown(vm[j])
            session.xenapi.VM.hard_shutdown(vm[j])

        # print_all_disks(session, vm[j])
        delete_all_disks(session, vm[j])

        session.xenapi.VM.destroy(vm[j])

        delete_end_time = time.time()
        delete_duration = round(delete_end_time - delete_start_time)

        # delete from CB
        uuid = record["uuid"]
        doc_key = uuid
        cbdoc = CBDoc()
        doc_result = cbdoc.get_doc(doc_key)
        if doc_result:
            doc_value = doc_result.value
            doc_value["state"] = 'deleted'
            current_time = time.time()
            doc_value["deleted_time"] = current_time
            if doc_value["created_time"]:
                doc_value["live_duration_secs"] = round(current_time - doc_value["created_time"])
            doc_value["delete_duration_secs"] = delete_duration
            cbdoc.save_dynvm_doc(doc_key, doc_value)

def delete_vm(sessão, vm_name):

registro.informações("Excluindo a VM: " + vm_name)

delete_start_time = tempo.tempo()

vm = sessão.xenapi.VM.get_by_name_label(vm_name)

registro.informações("Número de VMs encontradas com o nome - " + vm_name + " : " + str(len(vm)))

para j em alcance(len(vm)):

registro = sessão.xenapi.VM.get_record(vm[j])

power_state = registro["power_state"]

se power_state != "Parado:

# session.xenapi.VM.shutdown(vm[j])

sessão.xenapi.VM.hard_shutdown(vm[j])

# print_all_disks(session, vm[j])

delete_all_disks(sessão, vm[j])

sessão.xenapi.VM.destruir(vm[j])

delete_end_time = tempo.tempo()

delete_duration = rodada(delete_end_time - delete_start_time)

# excluir do CB

uuid = registro["uuid"]

chave_documento = uuid

cbdoc = CBDoc()

resultado_doc = cbdoc.get_doc(chave_documento)

se resultado_doc:

valor_doc = resultado_doc.valor

valor_doc["estado"] = "excluído

current_time = tempo.tempo()

valor_doc["deleted_time"] = current_time

se valor_doc["created_time"]:

valor_doc["live_duration_secs"] = rodada(current_time - valor_doc["created_time"])

valor_doc["delete_duration_secs"] = delete_duration

cbdoc.salvar_dynvm_doc(chave_documento, valor_doc)

Histórico de uso de VMs

É melhor manter o histórico de todas as VMs criadas e encerradas junto com outros dados úteis. Aqui está o exemplo de um documento json armazenado no Couchbase, um banco de dados Nosql gratuito servidor. Insira um novo documento usando a chave como o uuid de referência do xen opac sempre que uma nova VM for provisionada e atualize o mesmo sempre que a VM for encerrada. Acompanhe o tempo de uso da VM e também como o provisionamento/encerramento foi feito por cada usuário.

       record = session.xenapi.VM.get_record(vm)
       uuid = record["uuid"]

       # Save as doc in CB
        state = "available"
        username = new_vm_name
        pool = "dynamicpool"
        doc_value = {"ipaddr": vm_ip_addr, "origin": xen_host_description, "os": os_name,
                     "state": state, "poolId": pool, "prevUser": "", "username": username,
                     "ver": "12", "memory": memory_static_max, "os_version": vm_os_name,
                     "name": new_vm_name, "created_time": prov_end_time,
                     "create_duration_secs": create_duration, "cpu": vcpus, "disk": disks_info}
        # doc_value["mac_address"] = mac_address
        doc_key = uuid

        cb_doc = CBDoc()
        cb_doc.save_dynvm_doc(doc_key, doc_value)

registro = sessão.xenapi.VM.get_record(vm)

uuid = registro["uuid"]

# Salvar como documento no CB

estado = "disponível"

nome de usuário = new_vm_name

piscina = "dynamicpool"

valor_doc = {"ipaddr": vm_ip_addr, "origem": xen_host_description, "os": nome_do_os,

"estado": estado, "poolId": piscina, "prevUser": "", "nome de usuário": nome de usuário,

"ver": "12", "memória": memory_static_max, "os_version": vm_os_name,

"name" (nome): new_vm_name, "created_time": prov_end_time,

"create_duration_secs": create_duration, "cpu": vcpus, "disco": informação_discos}

# doc_value["mac_address"] = mac_address

chave_documento = uuid

cb_doc = CBDoc()

cb_doc.salvar_dynvm_doc(chave_documento, valor_doc)

class CBDoc:
    def __init__(self):
        config = read_config()
        self.cb_server = config.get("couchbase", "couchbase.server")
        self.cb_bucket = config.get("couchbase", "couchbase.bucket")
        self.cb_username = config.get("couchbase", "couchbase.username")
        self.cb_userpassword = config.get("couchbase", "couchbase.userpassword")
        try:
            self.cb_cluster = Cluster('couchbase://' + self.cb_server)
            self.cb_auth = PasswordAuthenticator(self.cb_username, self.cb_userpassword)
            self.cb_cluster.authenticate(self.cb_auth)
            self.cb = self.cb_cluster.open_bucket(self.cb_bucket)
        except Exception as e:
            log.error('Connection Failed: %s ' % self.cb_server)
            log.error(e)

    def get_doc(self, doc_key):
        try:
            return self.cb.get(doc_key)
        except Exception as e:
            log.error('Error while getting doc %s !' % doc_key)
            log.error(e)

    def save_dynvm_doc(self, doc_key, doc_value):
        try:
            log.info(doc_value)
            self.cb.upsert(doc_key, doc_value)
            log.info("%s added/updated successfully" % doc_key)
        except Exception as e:
            log.error('Document with key: %s saving error' % doc_key)
            log.error(e)

classe CBDoc:

def __init__(autônomo):

configuração = read_config()

autônomo.cb_servidor = configuração.obter("couchbase", "couchbase.server")

autônomo.cb_bucket = configuração.obter("couchbase", "couchbase.bucket")

autônomo.cb_username = configuração.obter("couchbase", "couchbase.username")

autônomo.cb_userpassword = configuração.obter("couchbase", "couchbase.userpassword")

tentar:

autônomo.cb_cluster = Aglomerado('couchbase://' + autônomo.cb_servidor)

autônomo.cb_auth = PasswordAuthenticator(autônomo.cb_username, autônomo.cb_userpassword)

autônomo.cb_cluster.autenticar(autônomo.cb_auth)

autônomo.cb = autônomo.cb_cluster.open_bucket(autônomo.cb_bucket)

exceto Exceção como e:

registro.erro('Falha na conexão: %s ' % autônomo.cb_servidor)

registro.erro(e)

def get_doc(autônomo, chave_documento):

tentar:

retorno autônomo.cb.obter(chave_documento)

exceto Exceção como e:

registro.erro('Erro ao obter o documento %s! % chave_documento)

registro.erro(e)

def salvar_dynvm_doc(autônomo, chave_documento, valor_doc):

tentar:

registro.informações(valor_doc)

autônomo.cb.upsert(chave_documento, valor_doc)

registro.informações("%s adicionado/atualizado com sucesso" % chave_documento)

exceto Exceção como e:

registro.erro('Erro de salvamento do documento com chave: %s' % chave_documento)

registro.erro(e)

"dynserver-pool": {
  "cpu": "6",
  "create_duration_secs": 65,
  "created_time": 1583518463.8943903,
  "delete_duration_secs": 5,
  "deleted_time": 1583520211.8498628,
  "disk": "75161927680",
  "ipaddr": "x.x.x.x",
  "live_duration_secs": 1748,
  "memory": "6442450944",
  "name": "Win2019-Server-1node-DynVM",
  "origin": "s827",
  "os": "win16",
  "os_version": "",
  "poolId": "dynamicpool",
  "prevUser": "",
  "state": "deleted",
  "username": "Win2019-Server-1node-DynVM",
  "ver": "12"
}

"dynserver-pool": {

"cpu": "6",

"create_duration_secs": 65,

"created_time": 1583518463.8943903,

"delete_duration_secs": 5,

"deleted_time": 1583520211.8498628,

"disco": "75161927680",

"ipaddr": "x.x.x.x",

"live_duration_secs": 1748,

"memória": "6442450944",

"name" (nome): "Win2019-Server-1node-DynVM",

"origem": "s827",

"os": "win16",

"os_version": "",

"poolId": "dynamicpool",

"prevUser": "",

"estado": "excluído",

"nome de usuário": "Win2019-Server-1node-DynVM",

"ver": "12"

}

Configuração

A configuração do serviço do gerenciador de servidores Dynamic VM, como o servidor couchbase, os servidores xenhost, os detalhes do modelo, a expiração padrão e os valores de tempo limite da rede podem ser mantidos em um formato .ini simples. Qualquer novo host Xen recebido, basta adicionar como uma seção separada. A configuração é carregada dinamicamente sem reiniciar o serviço Dynamic VM SM.

Exemplo de arquivo de configuração: .dynvmservice.ini

[couchbase]
couchbase.server=<couchbase-hostIp>
couchbase.bucket=<bucket-name>
couchbase.username=<username>
couchbase.userpassword=<password>

[common]
vm.expiry.minutes=720
vm.network.timeout.secs=400

[xenhost1]
host.name=<xenhostip1>
host.user=root
host.password=xxxx
host.storage.name=Local Storage 01
centos.template=tmpl-cnt7.7
centos7.template=tmpl-cnt7.7
windows.template=tmpl-win16dc - PATCHED (1)
centos8.template=tmpl-cnt8.0
oel8.template=tmpl-oel8
deb10.template=tmpl-deb10-too
debian10.template=tmpl-deb10-too
ubuntu18.template=tmpl-ubu18-4cgb
suse15.template=tmpl-suse15

[xenhost2]
host.name=<xenhostip2>
host.user=root
host.password=xxxx
host.storage.name=ssd
centos.template=tmpl-cnt7.7
windows.template=tmpl-win16dc - PATCHED (1)
centos8.template=tmpl-cnt8.0
oel8.template=tmpl-oel8
deb10.template=tmpl-deb10-too
debian10.template=tmpl-deb10-too
ubuntu18.template=tmpl-ubu18-4cgb
suse15.template=tmpl-suse15

[xenhost3]
...


[xenhost4]
...

[couchbase]

couchbase.servidor=<couchbase-hostIp>

couchbase.balde=<balde-nome>

couchbase.nome de usuário=<nome de usuário>

couchbase.senha de usuário=<senha>

[comum]

vm.expiração.minutos=720

vm.rede.tempo limite.segundos=400

[xenhost1]

hospedeiro.nome=<xenhostip1>

hospedeiro.usuário=raiz

hospedeiro.senha=xxxx

hospedeiro.armazenamento.nome=Local Armazenamento 01

centos.modelo=tmpl-cnt7.7

centos7.modelo=tmpl-cnt7.7

janelas.modelo=tmpl-win16dc - PATCHES (1)

centos8.modelo=tmpl-cnt8.0

oel8.modelo=tmpl-oel8

deb10.modelo=tmpl-deb10-também

debian10.modelo=tmpl-deb10-também

ubuntu18.modelo=tmpl-ubu18-4cgb

suse15.modelo=tmpl-suse15

[xenhost2]

hospedeiro.nome=<xenhostip2>

hospedeiro.usuário=raiz

hospedeiro.senha=xxxx

hospedeiro.armazenamento.nome=ssd

centos.modelo=tmpl-cnt7.7

janelas.modelo=tmpl-win16dc - PATCHES (1)

centos8.modelo=tmpl-cnt8.0

oel8.modelo=tmpl-oel8

deb10.modelo=tmpl-deb10-também

debian10.modelo=tmpl-deb10-também

ubuntu18.modelo=tmpl-ubu18-4cgb

suse15.modelo=tmpl-suse15

[xenhost3]

...

[xenhost4]

...

Exemplos

Exemplo de chamadas à API REST usando curl

$ curl 'http://127.0.0.1:5000/showall'
{
  "1": [
    {
      "memory_static_max": "6442450944",
      "name": "tunable-rebalance-out-Apr-29-13:43:59-7.0.0-19021",
      "name_description": "tunable-rebalance-out-Apr-29-13:43:59-7.0.0-19021 from tmpl-win16dc - PATCHED (1) on 2020-04-29 20:43:33.785778",
      "networkinfo": "172.23.137.20,172.23.137.20,fe80:0000:0000:0000:0585:c6e8:52f9:91d1",
      "power_state": "Running",
      "vcpus": "6"
    },
    {
      "memory_static_max": "6442450944",
      "name": "nserv-nserv-rebalanceinout_P0_Set1_compression-Apr-29-06:36:12-7.0.0-19022",
      "name_description": "nserv-nserv-rebalanceinout_P0_Set1_compression-Apr-29-06:36:12-7.0.0-19022 from tmpl-win16dc - PATCHED (1) on 2020-04-29 13:36:53.717776",
      "networkinfo": "172.23.136.142,172.23.136.142,fe80:0000:0000:0000:744d:fd63:1a88:2fa8",
      "power_state": "Running",
      "vcpus": "6"
    }
  ],
  "2": [
    ..
  ]
  "3": [
    ..
  ]
  "4": [
    ..
  ]
  "5": [
    ..
  ]
  "6": [
    ..
  ]
}

$ curl 'http://127.0.0.1:5000/getavailablecount/windows'
2
$ curl 'http://127.0.0.1:5000/getavailablecount/centos'
10 
$ curl 'http://127.0.0.1:5000/getservers/demoserver?os=centos&count=3'
["172.23.137.73", "172.23.137.74", "172.23.137.75"]
$ curl 'http://127.0.0.1:5000/getavailablecount/centos'
7
$ curl 'http://127.0.0.1:5000/releaseservers/demoserver?os=centos&count=3'
[
  "demoserver1",
  "demoserver2",
  "demoserver3"
]
$ curl 'http://127.0.0.1:5000/getavailablecount/centos'
10 
$

$ enrolar 'http://127.0.0.1:5000/showall'

{

"1": [

{

"memory_static_max": "6442450944",

"name" (nome): "tunable-rebalance-out-Apr-29-13:43:59-7.0.0-19021",

"name_description": "tunable-rebalance-out-Apr-29-13:43:59-7.0.0-19021 from tmpl-win16dc - PATCHED (1) on 2020-04-29 20:43:33.785778",

"networkinfo": "172.23.137.20,172.23.137.20,fe80:0000:0000:0000:0585:c6e8:52f9:91d1",

"power_state": "Em execução",

"vcpus": "6"

{

"memory_static_max": "6442450944",

"name" (nome): "nserv-nserv-rebalanceinout_P0_Set1_compression-Apr-29-06:36:12-7.0.0-19022",

"name_description": "nserv-nserv-rebalanceinout_P0_Set1_compression-Apr-29-06:36:12-7.0.0-19022 from tmpl-win16dc - PATCHED (1) on 2020-04-29 13:36:53.717776",

"networkinfo": "172.23.136.142,172.23.136.142,fe80:0000:0000:0000:744d:fd63:1a88:2fa8",

"power_state": "Em execução",

"vcpus": "6"

}

"2": [

]

"3": [

]

"4": [

]

"5": [

]

"6": [

]

}

$ enrolar 'http://127.0.0.1:5000/getavailablecount/windows'

$ enrolar 'http://127.0.0.1:5000/getavailablecount/centos'

$ enrolar 'http://127.0.0.1:5000/getservers/demoserver?os=centos&count=3'

["172.23.137.73", "172.23.137.74", "172.23.137.75"]

$ enrolar 'http://127.0.0.1:5000/getavailablecount/centos'

$ enrolar 'http://127.0.0.1:5000/releaseservers/demoserver?os=centos&count=3'

[

"demoserver1",

"demoserver2",

"demoserver3"

]

$ enrolar 'http://127.0.0.1:5000/getavailablecount/centos'

Trabalhos Jenkins com uma única VM

curl -s -o ${BUILD_TAG}_vm.json "http://<host:port>/getservers/${BUILD_TAG}?os=windows&format=detailed"
VM_IP_ADDRESS="`cat ${BUILD_TAG}_vm.json |egrep ${BUILD_TAG}|cut -f2 -d':'|xargs`"
if [[ $VM_IP_ADDRESS =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]]; then
  echo Valid IP received
else
  echo NOT a valid IP received
  exit 1
fi

enrolar -s -o ${BUILD_TAG}_vm.json "http:///getservers/${BUILD_TAG}?os=windows&format=detailed"

ENDEREÇO IP DA VM="`cat ${BUILD_TAG}_vm.json |egrep ${BUILD_TAG}|cut -f2 -d':'|xargs`"

se [[ $ENDEREÇO IP DA VM =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]]; então

eco Válido IP recebido

mais

eco NÃO a válido IP recebido

saída 1

São necessários trabalhos Jenkins com várias VMs

curl -s -o ${BUILD_TAG}.json "${SERVER_API_URL}/getservers/${BUILD_TAG}?os=${OS}&count=${COUNT}&format=detailed"
cat ${BUILD_TAG}.json
VM_IP_ADDRESS="`cat ${BUILD_TAG}.json |egrep ${BUILD_TAG}|cut -f2 -d':'|xargs|sed 's/,//g'`"
echo $VM_IP_ADDRESS
ADDR=()
INDEX=1
for IP in `echo $VM_IP_ADDRESS`
do
  if [[ $IP =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]]; then
    echo Valid IP=$IP received
    ADDR[$INDEX]=${IP}
    INDEX=`expr ${INDEX} + 1`
  else
    echo NOT a valid IP=$IP received
    exit 1
  fi
done

echo ${ADDR[1]}
echo ${ADDR[2]}
echo ${ADDR[3]}
echo ${ADDR[4]}

enrolar -s -o ${BUILD_TAG}.json "${SERVER_API_URL}/getservers/${BUILD_TAG}?os=${OS}&count=${COUNT}&format=detailed"

gato ${BUILD_TAG}.json

ENDEREÇO IP DA VM="`cat ${BUILD_TAG}.json |egrep ${BUILD_TAG}|cut -f2 -d':'|xargs|sed 's/,//g'`"

eco $ENDEREÇO IP DA VM

ADDR=()

ÍNDICE=1

para IP em `eco $ENDEREÇO IP DA VM`

fazer

se [[ $IP =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]]; então

eco Válido IP=$IP recebido

ADDR[$ÍNDICE]=${IP}

ÍNDICE=`expr ${ÍNDICE} + 1`

mais

eco NÃO a válido IP=$IP recebido

saída 1

feito

eco ${ADDR[1]}

eco ${ADDR[2]}

eco ${ADDR[3]}

eco ${ADDR[4]}

Principais considerações

Aqui estão algumas de minhas observações feitas durante o processo e é melhor lidar com elas para torná-las mais confiáveis.

Manipular nome/ID de armazenamento diferente entre diferentes hosts Xen
- Mantenha o controle do nome do dispositivo de armazenamento da VM no arquivo de configuração de entrada do serviço.
Lidar com modelos parciais disponíveis apenas em alguns hosts Xen durante o provisionamento
Quando os IPs de rede não estão disponíveis e as APIs do Xen obtêm o padrão 169.254.xx.yy no Windows. Aguarde até obter o endereço não 169 ou o tempo limite.
Os servidores de versão devem ignorar o modelo do sistema operacional, pois alguns dos modelos podem não estar presentes Xen Hosts
Provisão em uma referência específica de um determinado Xen Host
Manipular Não há IPs disponíveis ou nnão está conseguindo obter IPs de rede para algumas das VMs criadas.
- PO Xen Hosts é uma sub-rede diferente para VMs dinâmicas direcionadas a hosts Xen. A expiração do contrato de aluguel de IP DHCP da rede padrão pode ser em dias (digamos, 7 dias) e não são fornecidos novos IPs.
Trate a verificação de capacidade para contar os IPs em andamento como IPs reservados e deve mostrar uma contagem menor do que a total no momento. Caso contrário, as solicitações em andamento e as solicitações de entrada poderão ter problemas. Uma ou duas VMs (tamanhos de cpus/memória/disco) podem estar no buffer durante a criação e a verificação de solicitações paralelas.

Referências

Algumas das principais referências que ajudam na criação do serviço de gerenciador de servidor de VM dinâmico.

Espero que você tenha tido um bom momento de leitura!

Isenção de responsabilidade: Veja isso como uma referência se estiver lidando com Xen Hosts. Sinta-se à vontade para compartilhar se tiver aprendido algo novo que possa nos ajudar. Seu feedback positivo é muito bem-vindo!

Agradecemos a Raju Suravarjjala, Ritam Sharma, Wayne Siu, Tom Thrush e James Lee por sua ajuda durante o processo.

Jagadesh Munta, engenheiro de software principal, Couchbase

Compartilhe este artigo

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Criação de infraestrutura de VMs dinâmicas com hosts Xen

Introdução

Benefícios

Modelo de infraestrutura dinâmica

Arquitetura do Dynamic Server Manager

APIs REST simples

Pré-requisitos para hosts Xen direcionados a VMs dinâmicas

Implementação

Histórico de uso de VMs

Configuração

Exemplos

Exemplo de chamadas à API REST usando curl

Trabalhos Jenkins com uma única VM

São necessários trabalhos Jenkins com várias VMs

Principais considerações

Referências

Receba atualizações do blog do Couchbase em sua caixa de entrada

Autor

Postado por Jagadesh Munta, engenheiro de software principal, Couchbase

Deixe um comentário Cancelar resposta

Pronto para começar a usar o Couchbase Capella?

Iniciar a construção

Use o Capella gratuitamente

Entre em contato