Conteúdo


Ajuste de Escala Automático de Instâncias de Padrão de Sistema Virtual no IBM PureApplication System

Uma técnica para criar tipos de padrão de gerenciador do ajuste de escala do sistema virtual

Comments

O padrão de sistema virtual (VSP) define uma carga de trabalho de nuvem como uma topologia de imagens de middleware. A topologia de carga de trabalho de middleware do VSP pode ter uma imagem virtual ou mais, que são conhecidas como "partes". Cada parte da carga de trabalho pode ser configurada para o ajuste de escala estático. No momento da implementação, o IBM Pure Application System (daqui em diante denominado PureApplication System) cria uma instância do VSP composta por várias máquinas virtuais (nós de VM da instância do VSP) com base nas configurações de ajuste de escala da parte. O modelo VSP não suporta o ajuste de escala automático com base na política de ajuste de escala.

Este artigo explica como desenvolver um padrão de aplicativo virtual (VAP) que atua como gerenciador do ajuste de escala para acrescentar e remover automaticamente nós de VM da instância de VSP com base na política definida pelo usuário. Este artigo pressupõe que você sabe usar o VAP Plug-in Development Toolkit (VAP PDK) para desenvolver um padrão do tipo VAP e plug-ins e está familiarizado com a estrutura de ajuste de escala do VAP. Para obter mais informações sobre a estrutura de ajuste de escala do VAP, consulte Escalabilidade e elasticidade para padrões de aplicativo virtual no IBM PureApplication System (em inglês).

Crie um padrão do tipo VAP para fazer o ajuste automático de escala das instâncias do VSP

As seções a seguir explicam como criar o tipo de padrão VAP "VSP Scaling Manager". Esse tipo de padrão VAP atua como gerenciador e aciona o ajuste de escala automático dos nós de VM da instância de VSP. Essa técnica usa a estrutura de monitoramento e política de VAP e a API VSP Clone. O desenvolvimento desse tipo de padrão envolve as seguintes etapas:

  1. Criar os metadados do modelo do aplicativo VAP para capturar os detalhes da instância de VSP.
  2. Criar um objeto de política para definir uma política de ajuste de escala.
  3. Criar um modelo de topologia para converter o modelo de aplicativo para um documento de topologia.
  4. Criar um modelo de monitoramento e scripts de monitoramento para monitorar a instância de VSP.
  5. Criar uma instância de VSP dos scripts de ajuste de escala dos nós de VM.

Caso de uso

Neste artigo, usaremos o VSP do cluster do WebSphere como o VSP de destino para o ajuste automático de escala. Como mostra a Figura 1, o VSP do cluster do WebSphere consiste em uma parte de gerenciador de desempenho , uma parte de nó customizado e uma parte de servidor IBM HTTP . Na seção a seguir, você verá como ajustar automaticamente a escala da parte do nó customizado, com base no uso da CPU no sistema. É possível usar essa técnica para ajustar a escala de qualquer parte do VSP com base em qualquer métrica de ajuste de escala definida pelo usuário.

Figura 1. VSP do cluster do WebSphere

Etapa 1: Criar metadados do modelo de aplicativo do VAP

Para ajustar a escala dos nós de VM de uma instância do VSP, as entradas do usuário a seguir são necessárias:

  • nome da instância do VSP
  • nome da parte do nó do VSP
  • Credenciais de usuário necessárias para acessar a instância em execução
  • Credenciais de usuário necessárias para executar as APIs de linha de comando do VSP (API de linha de comando do implementador)

O nome da instância do VSP e a parte do nó do VSP são necessários para identificar de forma exclusiva o ativo cuja escala deve ser ajustada. No caso de uso do VSP do cluster do WebSphere, o valor da parte do nó do VSP é "custom nodes" e o valor do nome da instância do VSP é o nome da instância do VSP do cluster do WebSphere implementado. As credenciais do usuário da instância são necessárias para executar os scripts de monitoramento (usando o ssh) na VM cuja escala deve ser ajustada. As credenciais de usuário do implementador são necessárias para executar as APIs para incluir ou remover a VM com base no valor monitorado.

É possível obter a entrada do usuário que é necessária usando os atributos do objeto de componente do VAP. Os atributos de objeto de componente são modelados usando os metadados do modelo de aplicativo do VAP. A Listagem 1 mostra os metadados do modelo de aplicativo. A Figura 2 mostra esses atributos da forma que eles são exibidos no construtor do aplicativo virtual.

Listagem 1. Metamodelo de atributos do VSP Scaling Manager (metadata.json)
{
      "id": "vsyscloning",
      "type": "component",
      "label": "VSys Scaling Manager",
      "description": "Example for cloning a virtual system",
      "image": "appmodel\/images\/demoapp.png",
      "thumbnail": "appmodel\/images\/thumbnail\/demoappl.png",
      "attributes": [
         {
            "id": "CLONENODE",
            "type": "string",
            "required": true,
            "label": "Virtual System Node",
         },
         {
            "id": "CLONEVSYS",
            "type": "string",
            "required": true,
            "label": "Virtual System Instance Name",
         },
         {
            "id": "VSYSPASS",
            "type": "string",
            "required": true,
            "label": "Virtual System password",
            "displayType": "password"
         },         
         {
            "id": "DEPHOST",
            "type": "string",
            "required": true,
            "label": "Deployer Host Name",
          },
         {
            "id": "DEPUSER",
            "type": "string",
            "required": true,
            "label": "Deployer User Id",
          },
         {
            "id": "DEPPASS",
            "type": "string",
            "required": true,
            "label": "Deployer password",
            "displayType": "password"
         }
      ]
   }
Figura 2. Atributos do VSP Scaling Manager

Etapa 2: Criar um objeto de política para definir uma política de ajuste de escala

Você usará a estrutura de política do VAP para criar uma política de ajuste automático de escala do VSP. A estrutura de política do VAP permite definir um objeto de política usando os metadados do modelo de aplicativo do VAP. Consulte Escalabilidade e elasticidade para padrões de aplicativo virtual no IBM PureApplication System (em inglês) para ver mais detalhes de como definir a política usando os metadados do modelo de aplicativo do VAP.

A Listagem 2 mostra a definição do objeto de política referente ao ajuste de escala baseado na CPU. A Figura 3 mostra a política da forma que ela é exibida no construtor de aplicativo virtual. Usando a interface de política mostrada na Figura 3, o usuário pode criar uma política de ajuste de escala para os nós de VM da instância do VSP com base no uso da CPU da VM. A definição de política padrão, mostrada na Figura 3, instrui o sistema a aumentar a escala caso o uso da CPU seja superior a 80% e reduzi-la caso o uso da CPU seja inferior a 10%.

No caso de uso do VSP do cluster do WebSphere, essa política de ajuste de escala aumenta a VM dos nós customizados se o uso da CPU de todas as VMs de nós customizados e superior a 80%. Ela reduz o uso da CPU se o uso da CPU de todas as VMs de nós customizados é inferior a 10%.

Listagem 2. Metamodelo do objeto de política de ajuste de escala da CPU do VSP Scaling Manager (metadata.json)
{	
        "id": "ScalingPolicyofVSys",
        "label": "VSys Scaling Policy",
        "type": "policy",
        "applicableTo": [
            "vsyscloning"
        ],
        "thumbnail": "appmodel/images/thumbnail/ClusterPolicy.png",
        "image": "appmodel/images/ClusterPolicy.png",        
        "description": "VSys scaling policy",
        "groups": [
			{
			   "category":"Scaling Type",
			   "id":"CPUVsys",
			   "label":"CPU Based",
			   "defaultValue":true,
			   "attributes":[
			      "cpuVsys",
			      "scaleInstanceRange1",
			      "triggerTime1",
                             ...
			   ],
			}                                    
        ],
        "attributes": [
            {
                "id": "triggerTime1",
                "label": "Minimum time (sec) to trigger add/remove",
                "type": "number",
                "max": 1800,
                "min": 30,
                "required": true,
                "sampleValue": 120,
                ...
            },
            {
                "id": "scaleInstanceRange1",
                "label": "Instance number range of scaling in/out",
                "type": "range",
                "min": 1,
                "max": 10,
                "required": true,
                "sampleValue": [
                    1,
                    10
                ],
                ...
            },
	    {
		 "id":"cpuVsys",
		 "label":"Scaling in/out when average CPU usage of clustered members is out 
           of threshold range(#)",
		 "type":"range",
                "displayType": "percentage",			   
		 "required":true,
		 "max":100,
		 "min":1,
		 "sampleValue":[
		      10,
		      80
		 ],
                ...
	     }     
        ]
}
Figura 3. Política de ajuste de escala da CPU do VSP Scaling Manager

Etapa 3: Criar um modelo de topologia para converter o modelo de aplicativo para um documento de topologia

A camada de IaaS do PureApplication System usa o documento de topologia para criar instâncias do VAP. O documento de topologia é construído a partir do modelo de aplicativo. Esse modelo é criado nos bastidores pelo PureApplication System durante a criação de um VAP usando o construtor de aplicativo virtual. Você usará o modelo de velocidade mostrado na Listagem 3 para converter o modelo de aplicativo do VAP "VSP Scaling Manager" para um documento de topologia. O modelo mostrado na Listagem 3 cria uma função chamada "clone" com os seguintes valores de parâmetro: detalhes da instância do VSP (capturados por meio da Etapa 1) e a definição de política (capturada por meio da Etapa 2). Os valores de parâmetros serão usados nos scripts do ciclo de vida do VAP "VSP Scaling Manager" para acionar o ajuste de escala da instância do VSP.

Listagem 3. Modelo de topologia do VSP Scaling Manager (vsyscloning.vm)
{
  #set($spattrs = $provider.getPolicyAttributes($component, 
   "ScalingPolicyofVSys"))		
  "vm-templates": [
   {
   "persistent":false,                 
    "name": "${prefix}-clone",
    "roles": [
    {
      "parms": {
	"DEPHOST":"$attributes.DEPHOST",
	"DEPUSER":"$attributes.DEPUSER",
	"DEPPASS":"$attributes.DEPPASS",						
	"CLONENODE":"$attributes.CLONENODE",	
	"CLONEVSYS":"$attributes.CLONEVSYS",
	"VSYSPASS":"$attributes.VSYSPASS",
	#if_value( $spattrs, "scaleInstanceRange1", '"MININST": 
    	$spattrs.scaleInstanceRange1.get(0),')
	#if_value( $spattrs, "scaleInstanceRange1", '"MAXINST": 							
        $spattrs.scaleInstanceRange1.get(1),')
	#if_value( $spattrs, "cpuVsys", '"MINCPU": $spattrs.cpuVsys.get(0),')
	#if_value( $spattrs, "cpuVsys", '"MAXCPU": $spattrs.cpuVsys.get(1),')		
    #if_value( $spattrs, "triggerTime1", '"triggerTime": 							
        $spattrs.triggerTime1,')
	"isCloned": "FALSE"
     },		            		                
     "type": "SClone",
     "name": "clone"                 
   }
  ],
  "packages": ["SClone"]
  }        		        
 ]
}

Etapa 4: Criar o metamodelo e os scripts de monitoramento

Nesta etapa, você irá criar os ativos necessários para monitorar os nós da VM da instância do VSP. Com base nos valores monitorados, você irá acionar o ajuste de escala do nó da VM da instância do VSP conforme o definido na política de ajuste de escala. Você usará a estrutura de monitoramento do VAP para monitorar os nós de VM da instância do VSP. A estrutura de monitoramento do VAP aciona a coleta de métricas monitoradas e exibe essas métricas no console do VAP. Para fazer isso, a estrutura de monitor do VAP espera que o plug-in do VAP forneça o seguinte:

  • Metadados de métricas para definir os dados de métrica (a Listagem 4 mostra os metadados referentes à métrica de uso da CPU).
  • Um script (consulte cpuutil.sh na amostra de código fornecida) para coletar a métrica a partir dos nós de VM da instância do VSP.
  • Metadados de métrica e código de registro do script de coleta. A Listagem 5 mostra a chamada da API maestro para registrar os ativos na estrutura.
  • Metadados de exibição de métricas para apresentar graficamente as métricas coletadas. A Listagem 6 mostra os metadados de exibição usados para exibir a métrica da CPU do nó da VM da instância do VSP.
Listagem 4. Metadados da métrica da CPU do VSP (cpuvsyscollector.json)
{
   "version":1,
   "update_interval": 60,   
   "category":[
      "cpuvsys"
   ],
   "metadata":[
      {
         "cpuvsys":{
   			"update_interval":60,         
            "metrics":[
               {
                  "attribute_name":"cpuVsys",
                  "metric_name":"cpuVsys",
                  "metric_type":"COUNTER"
               }
            ]
         }
      }
   ]
}
Listagem 5. Registro do coletor de métricas (configure.py)
#Register cpu vsys collector
maestro.monitorAgent.register('{\
"node":"%s",\
"role":"%s",\
"collector":"com.ibm.maestro.monitor.collector.script",\
"config":{\
"metafile":"/home/virtuser/collectors/cpuvsyscollector.json",\
"executable":"/home/virtuser/collectors/cpuutil.sh",\
"arguments":"%s",\
"validRC":"0",\
"workdir":"/tmp",\
"timeout":"120"}}' % (nodeName,roleName,arguments));
Listagem 6. Monitoramento dos metadados de exibição de métricas (monitoring_ui.json)
[
   {
      "version":2,
      "category":"cpuvsys",
      "label":"CPU Usage",
      "displayRoles": ["SClone"],
      "displays":[
         {
            "label":"CPU Usage of Virtual System Instance Node",
            "monitorType":"HistoricalNumber",
            "chartType":"Lines",
            "metrics":[
               {
                  "attributeName":"cpuVsys",
                  "label":"Used Percentage"
               }
            ]
         }
      ]
   }
]

Scripts de ajuste de escala e monitoramento

Nesta seção, iremos nos aprofundar no script de monitoramento e ajuste de escala (consulte o cpuutil.sh na amostra de código fornecida). O script realiza as tarefas a seguir:

  • O script recupera a utilização da CPU dos nós da VM da instância do VSP. No nosso caso de uso, o script obtém a utilização da CPU das instâncias dos nós customizados do VSP do WebSphere.
  • Se o valor recuperado é superior ao valor especificado na política, um novo nó da VM da instância é criado, até que se atinja o valor máximo definido na política. No nosso caso de uso, se o uso da CPU das instâncias dos nós customizados for superior a 80, novos nós customizados do VSP do WebSphere serão criados até que existam 10 nós desse tipo.
  • Se o valor recuperado é inferior ao valor especificado na política, todos os nós — com exceção do número mínimo especificado na política — são excluídos. No nosso caso de uso, se o uso da CPU das instâncias dos nós customizados for inferior a 10, todos os nós customizados serão removidos, com exceção de dois, nós customizados do VSP do WebSphere.
  • Por fim, o script retorna os dados de métrica para a estrutura de monitoramento do VAP, para serem exibidos no console de implementação.

Esse script é acionado pela estrutura de monitoramento em intervalos regulares. O intervalo de acionamento é baseado no valor de parâmetro update_interval definido nos metadados de monitor (consulte a Listagem 4). Nesse script, basicamente provocamos um curto-circuito na estrutura de monitoramento do VAP para acionar o ajuste de escala nos nós da VM da instância do VSP. Na próxima seção, você verá como usar o clone do VSP e excluir APIs para acrescentar ou remover um nó da VM da instância do VSP.

Etapa 5: Criar scripts de ajuste de escala do nó da VM da instância do VSP

Você usará scripts Python para acrescentar ou remover nós da VM da instância do VSP. O script Python é acionado pelo script de monitoramento, cpuutil.sh, usando o utilitário de linha de comando do implementador do PureApplication System. As Listagem 7 e 8 mostram o script Python para incluir ou excluir um nó de VM da instância do VSP. Esses scripts usam os objetos do sistema virtual do VSP, os objetos de máquina virtual e seus clones. Também excluem os métodos para aumentar e diminuir a escala do nó de VM da instância do VSP.

Listagem 7. Script para incluir uma nova VM de parte do VSP
#This python script is used to clone one new node (of type cloneNode)
#belonging to Vsys instance cloneVSys.
#No new node will be created if max is reached.
import os
import sys
cloneNode=sys.argv[1]
cloneVSys=sys.argv[2]
max=sys.argv[3]

#function to check if the maximum clone limit is reached
def isMax(max, system, cloneNode):
    current=0
    vms=system.virtualmachines
    for vm in vms:
        vmpartname= vm.patternpart.partCaption
        vmstatus = vm.currentstatus
        if(vmpartname == cloneNode and vmstatus == "RM01006"):            
             current+=1
    if(current < max):
        return "False"
    else:
        return "True"

#Get the input virtual system instance.  
allsystems=deployer.virtualsystems.list({'name':cloneVSys})
found='False'
for system in allsystems:
    vsysname=system.name
    vsysstatus = system.currentstatus
    print "SysName:" + vsysname + " SysStatus:" + vsysstatus
    if(vsysstatus == "RM01006" or vsysstatus == "RM01070"):
        #Get all the running virtual machines
        vms=system.virtualmachines
        for vm in vms:
            vmpartname= vm.patternpart.partCaption
            vmstatus = vm.currentstatus
            print "VMName:" + vmpartname + " VMStatus:" + vmstatus
            if(vmpartname == cloneNode and vmstatus == "RM01006"):
                found='True'
                #If max limit not reached then clone.
                isMaximum = isMax(int(max), system, cloneNode)
                if(isMaximum == 'False'):
                    print "Clone started"
                    vm.clone()
                break
        if(found=='True'):
            break
Listagem 8. Script para excluir a VM de parte do VSP
#This python script is used to release all the nodes (of type cloneNode)
#belonging to Vsys instance cloneVSys.
#No nodes are released if min specified is reached.

import os
import sys
cloneNode=sys.argv[1]
cloneVSys=sys.argv[2]
min=int(sys.argv[3])

#Check if minimum number of nodes reached.
def isMin(min, system, cloneNode):
    current=0
    vms=system.virtualmachines
    for vm in vms:
        vmpartname= vm.patternpart.partCaption
        vmstatus = vm.currentstatus
        if(vmpartname == cloneNode and vmstatus == "RM01006"):
             current+=1
    if(current > min):
        return "False"
    else:
        return "True"

#Get the input virtual system instance.
allsystems=deployer.virtualsystems.list({'name':cloneVSys})
found='False'
for system in allsystems:
    vsysname=system.name
    vsysstatus = system.currentstatus
    print "SysName:" + vsysname + " SysStatus:" + vsysstatus
    if(vsysstatus == "RM01006" or vsysstatus == "RM01070"):
        #Get all the running virtual machines
        vms=system.virtualmachines
        for vm in vms:
            vmpartname= vm.patternpart.partCaption
            vmstatus = vm.currentstatus
            print "VMName:" + vmpartname + " VMStatus:" + vmstatus
            if(vmpartname == cloneNode and vmstatus == "RM01006"):
                found='True'          
                #Delete till minimum specified is reached.      
                isMinimum = isMin(int(min), system, cloneNode)
                if(isMinimum == 'True'):
                    break
                else:
                    print "delete started"
                    vm.delete()
        if(found=='True'):
            break

Nas cinco etapas acima, você fez basicamente o seguinte:

  • Usou o objeto de política do VAP para definir a política de ajuste de escala definida pelo usuário.
  • Usou a estrutura de monitoramento do VAP para acionar o monitoramento da VM da instância do VSP e, com base na métrica monitorada, acionou o ajuste automático e dinâmico da escala da VM da instância do VSP.
  • Usou os métodos de clonar e remover fornecidos pela API de comandos do VSP para criar um novo nó da VM na instância do VSP ou excluir um nó existente na VM da instância.

Testando o caso de uso

Nesta seção, você verá como testar o caso de uso de ajuste da escala dos nós customizados do cluster do WebSphere. Para testar o caso de uso, primeiro é necessário criar uma instância do VSP do cluster do WebSphere. A Figura 4 mostra uma instância de VSP do cluster do WebSphere. Também é necessário criar um padrão do tipo VAP para acionar o ajuste de escala do VSP. O código de amostra fornecido com este artigo tem um padrão do tipo VAP (vsysscalingmgr) que pode ser importado para o ambiente do PureApplication System para acionar o ajuste de escala do VSP. Após a importação, é possível criar um novo VAP usando o construtor de aplicativos virtuais e implementar o VAP recém-criado.

Figura 4. Instância do VSP do cluster do WebSphere

A Figura 5 mostra o VAP do WebSphere Cluster Scaling Manager no construtor de aplicativos virtuais.

Figure 5. Padrão do Scaling Manager do cluster do WebSphere

Após a implementação do padrão, é possível simular o ajuste de escala realizando as etapas a seguir:

  1. Efetuar login no console do Deployment Manager . Criar novos servidores nos nós existentes e realizar uma ressincronização total ou outra operação no nó que aumente a utilização da CPU nos nós customizados.
  2. Como alternativa, é possível fazer o teste de unidade do ajuste de escala dos nós customizados da instância do VSP removendo os comentários das linhas mostradas na Listagem 9, no script de monitoramento — o cpuutil.sh. Essa ação alimenta um valor simulado de 85 referente ao uso da CPU para as tarefas subsequentes no script. Para reduzir a escala, é possível comentar as linhas cujos comentários você removeu.
    Listagem 9. Linhas cujos comentários devem ser removidos para testar o padrão do VSP Scaling Manager
    cpuval=$(ssh -i $DIR_NAME/key -o StrictHostKeyChecking=no $ADMIN_NAME@$i "top -b -d1 -n2
    | grep -i \"Cpu(s)\" | cut -d ',' -f1  | awk '{print \$2}' | cut -d '%' -f1 | sed -n 2p")
    #To unit test clone un-comment the following line. After cloning to unit-test delete
    #comment this line.
    #cpuval=85
    #end unit test un-comment	   
    echo "cpu value is "$cpuval  >> /home/virtuser/collectors/scaling.log

A Figura 6 mostra a interface com o usuário para monitoramento do console do VAP. Ela mostra o uso da CPU dos nós customizados do nó da instância do VSP. Observe que, quando você faz o teste de unidade do tipo de padrão usando o método descrito na Listagem 9, o gráfico mostra um pico de 85% e, em seguida, volta para 2%.

Figura 6. Uso da CPU do nó da instância do sistema virtual

A Figura 7 mostra o acréscimo da instância dos nós customizados. Quando o uso da CPU passa de 80% em todas as instâncias de nós customizados, são criados novos nós customizados do VSP do WebSphere até que se atinja o máximo de 10 nós. Quando o uso da CPU fica abaixo de 10% em todas as instâncias de nós customizados, todas as instâncias de nós customizados serão removidas, com exceção de duas.

Figura 7. Ajuste de escala dos nós customizados do VSP do WebSphere

Conclusão

Neste artigo, você aprendeu a criar um tipo de padrão de VAP para acionar o ajuste automático de escala no nó da VM da instância do VAP definido pelo usuário. Usando essa técnica, é possível ajustar automaticamente a escala de um nó da VM da instância do VSP usando uma política de ajuste de escala definida pelo usuário, com pouca ou nenhuma mudança no VSP. Além disso, é possível monitorar as métricas da instância do VSP usando o painel do VAP. Essa técnica tem as seguintes desvantagens: o usuário tem que inserir credenciais para a VM da instância do VSP, e somente os usuários do PureApplication System que têm acesso para trabalhar com a instância do VSP podem implementar a instância do VAP Scaling Manager. Do contrário, a CLI do implementador não terá acesso para acrescentar ou remover os nós.


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Cloud computing
ArticleID=953576
ArticleTitle=Ajuste de Escala Automático de Instâncias de Padrão de Sistema Virtual no IBM PureApplication System
publish-date=11192013