Servicios compartidos

1. Cree los metadatos de propiedad y el modelo de aplicación predefinidos.
   El archivo appmodel.json representa la serialización del modelo definido en la interfaz de usuario del Creador de patrones para una aplicación virtual normal. Se representan los componentes (nodos) y enlaces, junto con los valores de propiedad especificados de usuario. Para los servicios compartidos, las propiedades deben estar predefinidas. Además de los nodos, enlaces y otros atributos de un modelo de aplicación, serán necesarios los siguientes atributos para un servicio compartido:

   app_type

   Se establece en "service".

   serviceversion

   Versión del modelo de aplicación de servicio compartido y único en formato VRMF. Por ejemplo, 1.0.0.0.

   servicesupportedclients

   Lista de las versiones de cliente admitidas que pueden utilizar este servicio compartido.

   Los patrones de ejemplo son:

   • *: coincide con todas las versiones
   • [a,b]: coincide con todas las versiones entre a y b, incluyendo a y b
   • (a,b): coincide con todas las versiones entre a y b, excluyendo a y b
   • [*,b]: coincide con todas las versiones hasta b, incluyendo b
   • [a,*]: coincide con todas las versiones de a y posteriores

   servicedisplayname

   Muestra el nombre de los servicios que se agrupan de forma parecida.

   servicename

   Nombre del servicio. Utilizado como el nombre del registro de servicios de los documentos.

   id

   Se establece en "sharedservice". Este atributo es un atributo que está en un nodo.

   type

   Es el ID exclusivo que enlaza los metadatos transformer y appmodel al nodo.

   servicetype

   Se establece External en appmodel.json para identificar un servicio como compartido y externo.

   En el ejemplo siguiente se muestra el uso de estos atributos:

   {
      "model":{
   		"name":"Shared Service",
   		"app_type":"service",
   		"patterntype":"foundation",
   		"version":"1.0",
   		"serviceversion":"1.0.0.0",
   		"servicesupportedclients":"[0.0,1.0]",
   		"servicedisplayname":"servicegroup",
   		"servicename":"service",
   		"description":"comments",
   		"nodes":[{
   			 "attributes":{...},
   			"id":"sharedservice",
   			"type":"uniqueComponentOSGIID"
   		}],
   		"links":[]
   	}
   }

   El archivo appmodel/metadata.json describe los componentes, enlaces y políticas implementadas por el plugin. Los servicios compartidos utilizan el mismo diseño que el del atributo. Se pueden establecer los atributos predeterminados mediante el atributo especificado en el campo predefinido appmodel o el campo sampleValue en metadata.json.

2. Defina un tipo de proveedor de registro.

   El registro del servicio compartido contiene la información que pueden buscar los clientes y así encontrar la información necesaria que está compartida con el servicio. La infraestructura proporciona una capacidad mediante una determinada implementación del servicio compartido de la clase com.ibm.maestro.iaas.RegistryProvider. El siguiente método permite al servicio compartido devolver información al cliente basándose en su modelo y la configuración del despliegue.

   public JSONArtifact getRegistry(String ClientVersion, Map<String, JSONObject> deploymentInfo throws HttpException;

   deploymentInfo contiene los documentos appmodel (appmodel.json), de despliegue (deployment.json), de topología (topology.json) y de registro (registry.json).

3. Cree la plantilla de topología para appmodel.
   Los transformadores con servicios que convierten el modelo de aplicación de una descripción lógica en un documento de topología que se utiliza para desplegar la aplicación virtual. Los servicios compartidos, como otros plugins, pueden definir una plantilla de un documento de topología y transformadores que convierten la plantilla a un documento de topología real durante el despliegue. Se debe proporcionar el siguiente atributo mediante un servicio compartido para hacer referencia al tipo de proveedor de registro del servicio compartido:

    "service-registry": [{
           "type": "<RegistryProvider implementation>"
       
   }],

   No incluya la sección del atributo vm-templates para una plantilla de topología de servicio compartido y externo hasta que no apunte a la implementación de recurso externo del servicio compartido.

4. Cree scripts de ciclo vital de servicio compartido.

   Para obtener más información sobre cómo desarrollar scripts de ciclo de vida, consulte la sección Desarrollo de scripts de ciclo de vida que hay en la guía de desarrollo del plugin. Al desarrollar scripts de ciclo de vida para servicios compartidos, debe tener en cuenta funciones que puedan soportar y recuperar anomalías, proporcionando operaciones administrativas para el servicio, la escalabilidad y otras funciones parecidas.

5. Opcional. Realice un certificado público de servicio compartido disponible para el acceso al cliente.

   La infraestructura proporciona una ubicación central para certificados. Un servicio compartido deberá hacer disponible de forma segura los certificados para que los despliegues actúen como clientes. Se pueden llamar las siguientes API com.ibm.maestro.iaas.RegistryService mediante el servicio compartido para que gestionen sus certificados:

   public void putCertificate(RestClient restClient, String putObj, String cloudGroup, String sharedServiceName, String sharedServiceVersion) throws CredentialExpiredException, MaestroSecurityException, HttpException;

   public void deleteCertificate(RestClient restClient, String cloudGroup, String sharedServiceName, String sharedServiceVersion) throws CredentialExpiredException, MaestroSecurityException, HttpException;

6. Muestre llamadas administrativas HTTP para que los clientes interactúen con el servicio.

   Todos los servicios compartidos deben mostrar una interfaz administrativa HTTP a los clientes para que puedan registrarse e interactuar con el servicio (reservar recursos en el servicio). A continuación, se puede personalizar el uso del servicio utilizando los recursos reservados en una interacción que no sea HTTP. Este paso es donde la versión del cliente le ayuda a determinar el contrato de cliente para la interacción administrativo HTTP antes de que utilice el servicio.

   El entorno Infraestructura del servicio compartido proporciona una característica de ayuda para poder crear fácilmente la interfaz administrativa HTTP si el servicio compartido desea utilizar dicha interfaz. Para obtener más información, consulte la sección "Interacción de cliente y soporte de la API REST del servicio compartido genérico".

• Por la exposición directa de un recurso mediante el modelador de aplicación virtual (un ejemplo sería la política de direccionamiento que permite a un despliegue ser un cliente de servicio compartido de equilibrador de carga basado en direccionador a demanda).
• Utilizar de manera indirecta una configuración que implique el uso de un servicio compartido. La política de escalado implica el almacenamiento en memoria caché de sesiones HTTP y permite que un despliegue sea un cliente en el servicio compartido de almacenamiento en memoria caché.
• Uso del proceso de transformación de appmodel que inyecta el cliente. El proceso añade paquetes, parámetros, referencias de servicio y otros elementos de plugin del cliente mientras el proceso crea el documento de topología.

• El cliente puede indicar a los servicios a los que hace referencia y si el servicio puede determinar si continúa el despliegue. La etiqueta siguiente en el documento de topología de cliente indica que este cliente requiere que el servicio compartido al que hace referencia para dar soporte a una versión de cliente de 3.0 esté disponible en el grupo de nubes en el que se está desplegando. Si no es así, el despliegue del cliente fallará.

     "service-templates": [
  		{
  			"sharedservice": {
  				"client-version": "3.0", 
  				"name": "shared service name>", 
  				"required": true
  			}
  		}
      ]

• El cliente puede definir ServiceProvisioner para proporcionar los recursos necesarios. Puede comunicarse con el servicio compartido recuperando su información de registro y proporcionando la información de entrada del documento de topología para poderlo utilizar más tarde. El despliegue puede fallar en esta etapa, así como el cliente. El cliente obtiene información sobre el servicio compartido llamando a la interfaz com.ibm.maestro.iaas.RegistryService y el método getRegistry: public JSONArtifact getRegistry(RestClient restClient, String sharedServiceName, String clientCloudGroup, String clientVersion, String clientDeploymentId) throws HttpException;

  Para obtener información sobre ServiceProvisioner, consulte la documentación de Javadoc en el Kit de desarrollo de plug-ins.

import maestro
parms=maestro.registry.getRegistry(shared_service_name, shared_service_client_version)
masterIP = parms['<registry parm name>']

import maestro
maestro.registry.removeRegistryRef(shared_service_name, shared_service_client_version)

import maestro 
maestro.registry.getCertificate(shared_service_name, shared_service_client_version, temp_cert_file)

import maestro

service_name = "caching"
client_version = "2.0"

# get registry information
registry_info = maestro.registry.getRegistry(service_name, client_version)
ip_address = registry_info['cache-ip']

print "Caching service found at " + ip_address


# this is where the certificate will be stored
certificate_location = "/tmp/caching_certificate"

# download certificate
maestro.registry.getCertificate(service_name, client_version, certificate_location)

# signal the service that we have finished interacting with it
maestro.registry.removeRegistryRef(service_name, client_version)

"service-registry": [{
        "type": "<RegistryProvider implementation>"
        "trackclientusage":true
        
}],

public StateAndDescription deleteService(String serviceReferenceName,
			JSONObject serviceDescription, RestClient restClient)
			throws Exception {
        final String METHOD_NAME = "deleteService";
        if (logger.isLoggable(Level.FINE)) {
            logger.logp(Level.FINE, CLASS_NAME, METHOD_NAME, "deleteService: " + serviceReferenceName + "/" + serviceDescription);
            logger.logp(Level.FINE, CLASS_NAME, METHOD_NAME, "Calling the disconnect operation on shared service clients");
        }
        
        JSONObject operationParms = new JSONObject();
        operationParms.put("role","<role_name>");
        operationParms.put("type", "<type_name>");
        operationParms.put("script", "<scriptname>");
        operationParms.put("method", "<method_name>");
        operationParms.put("parameters", new JSONObject());
        this.registrySvc.callOperationOnSSClients(restClient, serviceDescription, operationParms);

"service-registry": [{
        "type": "<RegistryProvider implementation>"
        "trackclientusage":true,,
        "supportslinking":true
        
}],

1. Se deben y proporcionar los metadatos del servicio en un archivo JSON y empaquetados en datos nodepart del servicio compartido. Por ejemplo: plugin/nodeparts/cachingrestapi/cachingrestapi/properties/cachingrestapi.json.
   El objeto JSON en los metadatos debe contener los siguientes atributos:

   servicename

   El nombre del servicio compartido: "caching".

   operations

   El servicio muestra la matriz JSON de operaciones. Todos los objetos que hay en la matriz definen los siguientes atributos:

   type

   Tipo de operación HTTP: GET, PUT, POST, o DELETE.

   parms

   La matriz JSON de los objetos que representa los parámetros de cada llamada de ese tipo. El objeto debe definir los siguientes atributos:

   resource

   Recurso en el que se lleva a cabo la operación. Correlaciona el segmento URL después de servicename en el URL de REST.

   role

   El rol se ejecuta en esta operación.

   script

   < nombre_script > < nombre_método >. The Python script that defines the operation and the method that starts.

   clientdeploymentexposure

   Opcional. Determina si la llamada se puede originar desde las máquinas virtuales desplegadas del cliente y desde el proceso KernelServices. El valor predeterminado es false.

   timeOut

   Opcional. Se ha excedido el tiempo de espera de la operación. El valor predeterminado es 60000. Si este atributo es 0, la operación se ejecuta de forma síncrona sin tiempo de espera. Si este atributo es mayor que 0, la operación espera durante el período de tiempo especificado, en milisegundos, para devolver la llamada. La operación responde con 202 HTTP si se produce un tiempo de espera excedido.

   pattern

   Este atributo se puede utilizar para que coincida con más segmentos del URL y parms en la operación. Una entrada envuelta en corchetes coincide como un par nombre-valor en el URL de entrada y pasa a la operación como parms. Por ejemplo, considere un URL de REST con el formato: https://<host>:<port>/sharedservices/caching/sessiongrid/gridA y un patrón {gridName}. El par nombre-valor gridName=gridA proporciona la operación como un argumento adicional.

   A continuación se muestra un ejemplo metadata json:

   {
   	"servicename": "caching", 
   	"operations": [
   		{
   			"type": "PUT", 
   			"parms": [
   				{
   					"resource": "sessionGrid", 
   					"role": "Caching-Master.Caching", 
   					"script": "restapi.py createSession",
   					"timeout": 1200000
   				},
   				{
   					"resource": "simpleGrid", 
   					"role": "Caching-Master.Caching", 
   					"script": "restapi.py createSimple"
   				},
   				{
   					"resource": "dynamicGrid", 
   					"role": "Caching-Master.Caching", 
   					"script": "restapi.py createDynamic"
   				}
   			]
   		}, 
   		{
   			"type":"DELETE",
   			"parms":[
   				{
   					"resource": "sessionGrid", 
   					"role": "Caching-Master.Caching", 
   					"script": "restapi.py deleteSession",
   					"pattern": "{gridname}"
   				}, 
   				{
   					"resource": "simpleGrid", 
   					"role": "Caching-Master.Caching", 
   					"script": "restapi.py deleteSimple",
   					"pattern": "{gridname}"
   				},
   				{
   					"resource": "dynamicGrid", 
   					"role": "Caching-Master.Caching", 
   					"script": "restapi.py deleteDynamic",
   					"pattern": "{gridname}"
   				}
   			]
   		},
   		{
   			"type":"GET",
   			"parms":[
   				{
   					"resource": "sessionGrid", 
   					"clientdeploymentexposure":true,
   					"role": "Caching-Master.Caching", 
   					"script": "restapi.py gridExists",
   					"pattern": "{gridname}"
   				},
   				{
   					"resource": "publicCert", 
   					"clientdeploymentexposure":true,
   					"role": "Caching-Master.Caching", 
   					"script": "restapi.py downloadCert",
   					"responseType": "zipFile"
   				}
   			]
   		}
   	]
   }

2. Cuando la máquina virtual inicia el despliegue del servicio compartido, se deben copiar los metadatos en la siguiente ubicación de la máquina virtual: /0config/sharedservices/restmetadata/. Los metadatos se pueden copiar si se proporciona un script de instalación nodepart que se ejecute durante el despliegue. Por ejemplo: /plugin/nodeparts/cachingrestapi/common/install/7_cachingrestapi.py que contenga

   restapidir = '/0config/sharedservices/restmetadata'
   restapifile = '/cachingrestapi.json'
   restapi = '../../cachingrestapi/properties/cachingrestapi.json'
   
   os.popen('mkdir -p ' + restapidir)
   os.popen("mv " + restapi+ " "+ restapidir + restapifile)

3. Proporcione la implementación de los métodos en un script Python. Defina operaciones que ejecuten parms desde diferentes recursos, el objeto JSON de entrada a la llamada de REST o la coincidencia de patrón de un URL. Por ejemplo: parts/caching.scripts/scripts/CachingMaster/restapi.py. El cliente pueden llamar a las API a través de los siguientes métodos prácticos:
   • Si llama operaciones en el servicio desde el proceso KernelServices, mediante un Suministrador de servicios, utilice el siguiente método que se define en com.ibm.maestro.iaas.RegistryService

     public OperationResponse callOperationOnSharedService(String serviceName, String clientCloudGroup, String clientVersion, 
     String serviceIP, String resourceUrl, String operationType, JSONObject operationParms) throws HttpException;

     Por ejemplo:

     JSONObject clientJSON = new JSONObject();
         	clientJSON.put("user", user);
         	clientJSON.put("password", password);
         	clientJSON.put("gridname", grid);
         	clientJSON.put("gridcap", cachingCap);
     
           OperationResponse response = this.registrySvc.callOperationOnSharedService("caching", (String)serviceDescription.get("cloud_group"), "3.0", ip,
           "sessionGrid", "PUT", clientJSON);
           int status = response.getStatusCode();
           JSONObject result = response.getOperationResponse();

   • Para despliegues de aplicación virtual, la infraestructura de servicios compartidos proporciona un programa de utilidad para interactuar con los servicios compartidos. Se puede acceder al programa de utilidad desde scripts de ciclo de vida.

     El script de programa de utilidad sólo proporciona un método, callSSrestapi: sharedservices.callSSrestapi(url, method, data=None, filepath_input=None, filepath_output=None). Este método realiza una llamada de API REST al URL especificado con el método especificado. La función devuelve un código de estado HTTP de la llamada y del documento JSON, si se han proporcionado.

     El interlocutor puede definir un parámetro filepath_input para que almacene el archivo devuelto en una determinada ubicación, si existe el directorio. Se espera el parámetro si el servicio compartido devuelve un archivo comprimido de la llamada. Nota: si no se establece filepath_input, se suprimirá cualquier respuesta del servicio compartido después de analizarla.

     Si el interlocutor envía un archivo al servicio compartido, se puede definir el parámetro filepath_output en la ubicación del archivo, pero el argumento method debe ser PUT o POST para enviar el archivo. Si se utilizan los métodos PUT o POST, aunque se esperan los argumentos data o filepath_output.

     Para acceder a esta función, debe incluir el siguiente código en el script de ciclo de vida:

     import sys
     ss_path = '/0config/nodepkgs/helper/scripts'
     if not ss_path in sys.path:
         sys.path.append(ss_path)
     import sharedservices

     Este script de ejemplo utiliza las funciones de programa de utilidad para comunicarse con el servicio compartido de almacenamiento en memoria caché. Recupera el certificado público y comprueba si existe una cuadrícula de almacenamiento en memoria caché.

     import sys
     
     ss_path = '/0config/nodepkgs/helper/scripts'
     if not ss_path in sys.path:
         sys.path.append(ss_path)
     import sharedservices
     
     service = "caching"
     version = "2.0"
     
     regInfo = maestro.registry.getRegistry(service, version)
     try:
         ipAddr = regInfo['cache-ip']
         print "caching service found at " + ipAddr
     except KeyError:
         print "caching service not found"
         sys.exit(1)
     
     
     cert_zip_location = "cert.zip"
     
     # download zip (that contains the certificate)
     cert_response = sharedservices.callSSrestapi("https://" + ipAddr + ":9999/sharedservice/caching/publicCert", 
     "GET", filepath_input=cert_zip_location)
     
     
     # check if a grid exists
     grid_name = "SomeGrid"
     
     http_code, grid_response = sharedservices.callSSrestapi("https://" + ipAddr + ":9999/sharedservice/caching/gridExists/", "GET")
     ret =  grid_response['OperationResults'][0]['return_value']
     
     if (ret.find(grid_name + ' does not exist') >= 0):
         print grid_name + " does not exist"
     else:
         print grid_name + " exists"
     
     # inform the caching service that we have finished interacting with it
     maestro.registry.removeRegistryRef(service, version)

   Se puede hacer una prueba manual de la API con el siguiente argumento en la máquina virtual desplegada:

   cd /0config  
   export $(./get_userdata.sh)  
   export header=$(/opt/python-2.6.4/bin/python create_security_header.py)
   curl -H "X-IWD-Authorization : $header" -kv -H Content-Type:application/json -X PUT -d '{"input":"hi"}' 
   https://<shared service IP:9999/sharedservice/<servicename>/<resourcename>

1. Pulse Catálogo > Plug-ins del sistema. desde el panel de control.
2. Seleccione el tipo de patrón Foundation.
3. Seleccione el plugin virtualsystem.
4. Pulse Configurar.
5. Establezca los Plug-ins para sistemas virtuales en enabled.

import sys
ss_path = '/0config/nodepkgs/helper/scripts'
if not ss_path in sys.path:
    sys.path.append(ss_path)
import sharedserviceclient

sharedserviceclient.getRegistry(service_name, client_version)

La función devuelve información de registro del servicio compartido si se admite la versión de cliente. A diferencia de maestro.registry.getRegistry, la función devolverá la respuesta como una serie de texto.

sharedserviceclient.removeRegistryRef(service_name, client_version)

Se llama a la función cuando un cliente finaliza la interacción con el servicio compartido y señala que el servicio debe limpiar cualquier recurso obsoleto. Si esta operación es correcta, el valor de retorno será 0.

sharedserviceclient.restapi(url, method, data=None)

La función llama al método de la API REST, utilizando corchetes, para comunicarse con el servicio compartido en el URL proporcionado. Los métodos aceptados son GET, DELETE, PUTy POST. Si el método es PUT o POST, el parámetro data será necesario.

El argumento de datos debe tener una serie de texto. De la misma manera, la función devolverá la respuesta del servicio como una serie de texto.

import sys
ss_path = '/0config/nodepkgs/helper/scripts'
if not ss_path in sys.path:
    sys.path.append(ss_path)
import sharedserviceclient


def find_cache_IP(reg_info):
    """
Finds the Caching Shared Service IP address in the registry information.
    """
    str_info = str(reg_info)
    
    start = 'cache-ip":"'
    end = '",'
    
    start_cip = str_info.find(start)
    end_cip = str_info.find(end, start_cip)
    
    return str_info[start_cip+len(start):end_cip]

def does_grid_exist(grid_name, caching_ip):
    """
Queries the Caching Shared Service to see if a grid exists.
Returns '1' if the grid exists, '0' otherwise.
    """
    str_reply = str(sharedserviceclient.restapi("https://" + cip + ":9999/sharedservice/caching/gridExists/" + grid_name, "GET", ""))
    
    if (str_reply.find(grid_name + ' does not exist') >= 0):
        return 0
    else:
        return 1


# figure out the caching service's IP address
reg = sharedserviceclient.getRegistry("caching", "2.0")
cip = find_cache_IP(reg)

# grid to read data from
grid_name = "WAS_GRID"

# ensure the grid exists
if (does_grid_exist(grid_name, cip)):
    print "Reading data from grid..."
    # read data from it
else:
    print "Grid '" + grid_name + "' doesn't exist"
    # ask somebody to create it

# done with caching server
sharedserviceclient.removeRegistryRef("caching", "2.0")