API sencilla para aplicaciones de red

Interfaz de programación de aplicaciones de computación en red
API sencilla para aplicaciones de red
Desarrollador(es)Centro de Computación y Tecnología de la LSU , Grupo RADICAL de la Universidad Rutgers , IN2P3 (Francia) y Vrije Universiteit (Ámsterdam, Países Bajos)
Escrito enC++ , Python , Java
PlataformaMultiplataforma
TipoComputación en red , biblioteca de computación distribuida
LicenciaLicencia de software Boost , GPL
Sitio websaga-proyecto.org

La API simple para aplicaciones de cuadrícula ( SAGA ) es una familia de estándares relacionados especificados por el Open Grid Forum para definir una interfaz de programación de aplicaciones (API) para la funcionalidad informática distribuida común .

Descripción general

La especificación SAGA para computación distribuida originalmente constaba de un único documento, GFD.90, que se publicó en 2009.

La API de SAGA no pretende reemplazar a Globus ni a sistemas de middleware de computación en red similares , y no está dirigida a desarrolladores de middleware, sino a desarrolladores de aplicaciones sin experiencia en computación en red. Estos desarrolladores normalmente desean dedicar su tiempo a sus propios objetivos y minimizar el tiempo dedicado a codificar la funcionalidad de la infraestructura. La API aísla a los desarrolladores de aplicaciones del middleware.

La especificación de los servicios y los protocolos para interactuar con ellos están fuera del alcance de SAGA. En cambio, la API busca ocultar los detalles de cualquier infraestructura de servicio que pueda o no utilizarse para implementar la funcionalidad que necesita el desarrollador de la aplicación. Sin embargo, la API se alinea con todos los estándares de middleware dentro del Open Grid Forum (OGF). [1]

La API de SAGA define un mecanismo para especificar paquetes API adicionales que amplían su alcance. La propia API SAGA Core define una serie de paquetes: gestión de trabajos, gestión de archivos, gestión de réplicas, llamadas a procedimientos remotos y flujos. SAGA cubre la funcionalidad distribuida más importante y utilizada con frecuencia y es compatible y está disponible en todos los principales sistemas de red: Extreme Science and Engineering Discovery Environment (XSEDE), EGI y FutureGrid. SAGA no solo admite una amplia gama de modelos de coordinación y programación distribuida, sino que también es fácilmente extensible para admitir middleware nuevo y emergente. [2] [3]

Normalización

La API de SAGA está estandarizada en el Grupo de Trabajo SAGA del Open Grid Forum . [4] Basada en un conjunto de casos de uso [5] , [6] la especificación SAGA Core API [1] define un conjunto de principios generales de API (el 'SAGA Look and Feel', y un conjunto de paquetes de API que representan patrones de programación Grid comúnmente utilizados (gestión de trabajos, gestión y acceso a archivos, gestión de réplicas, etc.). La especificación SAGA Core también define cómo se deben definir paquetes de API adicionales y cómo se relacionan con la API Core y con su 'Look and Feel'. Basándose en eso, se han definido varias extensiones de API y se encuentran en varios estados del proceso de estandarización. [7] [8] [9] [10]

Todas las especificaciones de SAGA están definidas en (una variante de) IDL y, por lo tanto, están orientadas a objetos, pero son independientes del lenguaje. Existen diferentes enlaces de lenguaje (Java, C++, Python), pero, en este momento, no están estandarizados. No obstante, las diferentes implementaciones de estos enlaces de lenguaje tienen una definición de API relativamente coherente (en particular, las diferentes implementaciones de Java comparten las mismas clases de API abstractas).

La parte "Apariencia y sensación" de la especificación de la API principal de SAGA cubre las siguientes áreas:

  • Seguridad y gestión de sesiones
  • Gestión de permisos
  • operaciones asincrónicas
  • escucha
  • notificaciones asincrónicas
  • gestión de atributos
  • Gestión del buffer de E/S

Arquitectura

La arquitectura SAGA C++/Python: un sistema de ejecución liviano envía llamadas API desde la aplicación al middleware a través de un conjunto de complementos o adaptadores .

SAGA está diseñado como una interfaz orientada a objetos . Encapsula la funcionalidad relacionada en un conjunto de objetos, que se agrupan en espacios de nombres funcionales , que se denominan paquetes en SAGA. La implementación principal de SAGA define los siguientes paquetes: [11]

  • saga::advert - interfaz para acceder al servicio de publicidad
  • saga::filesystem - interfaz para acceder a archivos y directorios
  • saga::job - interfaz para la definición, gestión y control de trabajos
  • saga::namespace - interfaz abstracta (usada por interfaces de publicidad, sistema de archivos y réplica)
  • saga::replica - interfaz para la gestión de réplicas
  • saga::rpc - interfaz para llamadas a procedimientos remotos de clientes y servidores
  • saga::sd - interfaz para el descubrimiento de servicios en entornos distribuidos
  • saga::stream - interfaz para clientes y servidores de flujo de datos

La arquitectura general de SAGA sigue el patrón adaptador , un patrón de diseño de software que se utiliza para traducir una interfaz a otra. En SAGA, traduce las llamadas de los paquetes API a las interfaces del middleware subyacente. El sistema de ejecución de SAGA utiliza el enlace tardío para decidir en tiempo de ejecución qué complemento ( adaptador de middleware ) cargar y enlazar. [12]

Middleware compatible

En la siguiente tabla se enumeran los sistemas de middleware distribuidos que SAGA admite actualmente. La columna denominada Adaptor Suite indica el conjunto (paquete de lanzamiento) de adaptadores de middleware (conjunto de adaptadores) que proporciona compatibilidad con el sistema de middleware.

Sistema de middlewareConjunto de adaptadores SAGAEspacio de nombres de la API de SAGA
Amazon EC2adaptadores saga awssaga::trabajo
Cóndorsaga-adaptadores-condorsaga::trabajo
Eucaliptoadaptadores saga awssaga::trabajo
Globus GRAM (2 y 5)saga-adaptadores-globussaga::trabajo
Red FTP de Globussaga-adaptadores-globussaga::sistema de archivos
Síndrome de piernas inquietas (RLS) de Globussaga-adaptadores-globussaga::réplica
Sistema de archivos HDFSadaptadores saga-hdfssaga::archivo
Sistema de archivos localparte de saga-coresaga::archivo
Bifurcación localparte de saga-coresaga::trabajo
Nimboadaptadores saga awssaga::trabajo
PBS (Profesional)adaptadores saga-pbssaga::trabajo
Plataforma LSFadaptadores saga lsfsaga::trabajo
Servicio de anuncios SQLparte de saga-coresaga::anuncio
Servicio de réplica SQLparte de saga-coresaga::réplica
SSHFSadaptadores saga-sshsaga::archivo
SSHadaptadores saga-sshsaga::trabajo
ESFUERZO DE TORSIÓNsaga-adaptadores-torquesaga::trabajo

Implementaciones

Dado que las definiciones de interfaz de SAGA no están vinculadas a ningún lenguaje de programación específico, existen varias implementaciones de los estándares SAGA en diferentes lenguajes de programación. Además del lenguaje de implementación, se diferencian entre sí en su exhaustividad en cuanto a la cobertura del estándar, así como en su compatibilidad con middleware distribuido.

SAGA C++

SAGA C++ [13] fue la primera implementación completa de la especificación SAGA Core, escrita en C++. Actualmente, la implementación en C++ no se encuentra en desarrollo activo.

RADICAL-SAGA(Python)

RADICAL-SAGA [14] es un paquete Python liviano que implementa partes de la especificación de interfaz OGF GFD.90 [1] y proporciona complementos para diferentes sistemas y servicios de middleware distribuidos. RADICAL-SAGA implementa las características más comúnmente utilizadas de GFD.90 basadas en un análisis de casos de uso extenso, y se enfoca en la usabilidad y la implementación simple en entornos informáticos distribuidos heterogéneos del mundo real y escenarios de aplicación. RADICAL-SAGA actualmente implementa las API centrales de administración de archivos y trabajos, así como la extensión de API de administración de recursos. RADICAL-SAGA proporciona complementos para diferentes sistemas y servicios de middleware distribuidos, incluido el soporte para PBS , Sun Grid Engine , SSH , SFTP y otros. RADICAL-SAGA se puede utilizar para desarrollar aplicaciones distribuidas y marcos que se ejecutan en ciberinfraestructura distribuida, incluidos XSEDE, [15] LONI y FutureGrid, [16] otras nubes y clústeres locales.

JavaSAGA

JavaSAGA es una implementación de SAGA en Java. El estado de JavaSAGA sigue siendo incierto.

importar java.util.io.* int main ( int argc , char ** argv ) { espacio de nombres sa = saga :: atributos ; espacio de nombres sja = saga :: trabajo :: atributos ;              prueba { saga :: trabajo :: descripción jd ;     jd . set_attribute ( sja :: description_executable , "/home/user/hello-mpi" ); jd . set_attribute ( sja :: description_output , "/home/user/hello.out" ); jd . set_attribute ( sja :: description_error , "/home/user/hello.err" );         // Declare esto como un trabajo de estilo MPI jd . set_attribute ( sja :: description_spmd_variation , "mpi" );    // Nombre de la cola que queremos utilizar jd.set_attribute ( sja :: description_queue , "checkpt" ); jd.set_attribute ( sja :: description_spmd_variation , " mpi" ) ; // Número de procesadores a solicitar jd.set_attribute ( sja :: description_number_of_processes , "32" ) ;           saga :: trabajo :: servicio js ( "gram://my.globus.host/jobmanager-pbs" ); saga :: trabajo :: trabajo j = js . create_job ( jd );      j . run () } catch ( saga :: excepción const & e ) { std :: cerr << "Excepción SAGA detectada: " << e . what () << std :: endl ; } }                

jSAGA

jSAGA [17] es otra implementación Java de la especificación SAGA Core. jSAGA se encuentra actualmente en desarrollo activo.

DESHL

DESHL [18] (DEISA Services for Heterogeneous management Layer) proporciona funcionalidad para el envío y la gestión de trabajos computacionales dentro de DEISA . DESHL se implementa como un conjunto de herramientas de línea de comandos sobre una API inspirada en SAGA implementada en Java. En el back-end, interactúa con HiLA, una biblioteca genérica de cliente de acceso a la red, que forma parte del sistema UNICORE .

Ejemplos

Presentación de trabajo

Una tarea típica en una aplicación distribuida es enviar un trabajo a un administrador de recursos distribuido local o remoto . SAGA proporciona una API de alto nivel denominada paquete de trabajo para esto. Los siguientes dos ejemplos simples muestran cómo se puede utilizar la API del paquete de trabajo de SAGA para enviar un trabajo de interfaz de paso de mensajes (MPI) a un administrador de recursos GRAM remoto de Globus.

C++

#include <saga/saga.hpp> int main ( int argc , char ** argv ) { espacio de nombres sa = saga :: atributos ; espacio de nombres sja = saga :: trabajo :: atributos ;              prueba { saga :: trabajo :: descripción jd ;     jd . set_attribute ( sja :: description_executable , "/home/user/hello-mpi" ); jd . set_attribute ( sja :: description_output , "/home/user/hello.out" ); jd . set_attribute ( sja :: description_error , "/home/user/hello.err" );         // Declare esto como un trabajo de estilo MPI jd . set_attribute ( sja :: description_spmd_variation , "mpi" );    // Nombre de la cola que queremos utilizar jd.set_attribute ( sja :: description_queue , "checkpt" ); jd.set_attribute ( sja :: description_spmd_variation , " mpi" ) ; // Número de procesadores a solicitar jd.set_attribute ( sja :: description_number_of_processes , "32" ) ;           saga :: trabajo :: servicio js ( "gram://my.globus.host/jobmanager-pbs" ); saga :: trabajo :: trabajo j = js . create_job ( jd );      j . run () } catch ( saga :: excepción const & e ) { std :: cerr << "Excepción SAGA detectada: " << e . what () << std :: endl ; } }                

Pitón

#!/usr/bin/env python3 import  sys import  time import  bliss.saga  como  sagadef  main ( jobno :  int ,  session ,  jobservice )  ->  None :  bfast_base_dir  =  saga.Url ( "sftp: //india.futuregrid.org/N/u/oweidner/software/bfast/ " ) Intente :  workdir  =  " %s /tmp/run/ %s "  %  ( bfast_base_dir . path ,  str ( int ( time . time ())))  basedir  =  saga . filesystem . Directory ( bfast_base_dir ,  session = session )  basedir . make_dir ( workdir ) jd  =  saga . job . description ()  jd . wall_time_limit  =  5  # tiempo de ejecución en minutos  jd . total_cpu_count  =  1  jd . environment  =  { "BFAST_DIR" :  bfast_base_dir . path }  jd . working_directory  =  workdir  jd . executable  =  "$BFAST_DIR/bin/bfast"  jd . arguments  =  [ "match" ,  "-A 1" ,  "-r $BFAST_DIR/data/small/reads_5K/reads.10.fastq" ,  "-f $BFAST_DIR/data/small/reference/hg_2122.fa" ] mitrabajo  =  js.create_job ( jd ) mitrabajo.run ( )  print ( "El trabajo n.° %s se inició con el ID ' %s ' y el directorio de trabajo: ' %s '"  %  ( jobno ,  myjob . jobid ,  workdir )) mi trabajo .espera ( ) print ( "Trabajo n.° %s con ID ' %s ' finalizado (RC: %s ). Salida disponible en: ' %s '"  %  ( jobno ,  myjob . jobid ,  myjob . exitcode ,  workdir )) basado en .close ( ) excepto  saga . Excepción ,  ej .:  print ( f "Se produjo un error durante la ejecución del trabajo : { ex } " )  sys.exit ( -1 )si  __name__  ==  "__main__" :  host_de_ejecución  =  saga.Url ( "pbs+ssh://india.futuregrid.org" ) ctx = saga.Context ( ) ctx.type = saga.Context.SSH ctx.userid = " oweidner " # como 'ssh nombre_usuario@host ... ' ctx.userkey = " /Usuarios/oweidner/.ssh/rsa_work " # como ssh -i ... '               sesión  =  saga .sesión ( ) sesión .contextos .anexar ( ctx )  js  =  saga .job .Service ( host_ejecución , sesión )  para  i  en  el rango ( 0 ,  4 ):  main ( i ,  session ,  js )

Subvenciones

El trabajo relacionado con el Proyecto SAGA está financiado por las siguientes subvenciones: NSF-CHE 1125332 (CDI), [19] NSF-EPS 1003897 (LaSIGMA), [20] NSF-OCI 1007115 (ExTENCI). [21] Las subvenciones anteriores incluyen: NSF-OCI 0710874 (HPCOPS), subvención NIH número P20RR016456 y subvención EPSRC del Reino Unido número GR/D0766171/1 a través de OMII-UK [22]

  • SAGA-Bliss: una implementación de SAGA en Python
  • jSAGA - Una implementación Java de SAGA
  • SAGA C++ - Una implementación de SAGA en C++
  • SAGA-GLib: una implementación de SAGA para GLib en Vala
  • PROYECTO SAGA
  • Sistema de archivos POSIX

Notas

  1. ^ abc T. Goodale; S. Jha; H. Káiser; T. Kielmann; P. Kleijer; A. Merzky; J. Shalf; C. Smith. "Una API simple para aplicaciones Grid (SAGA)" (PDF) . Serie de documentos OGF 90 .
  2. ^ SAGA: Una API simple para aplicaciones de red, programación de aplicaciones de alto nivel en la red Tom Goodale, Shantenu Jha, Harmut Kaiser, Thilo Kielmann, Pascal K leijer, Gregor von Laszewski, Craig Lee, Andre Merzky, Hrabri Rajic, John Shalf Métodos computacionales en ciencia y tecnología, vol. 12 n.° 1, 2006
  3. ^ Interoperabilidad de la red en el nivel de aplicación utilizando SAGA Shantenu Jha, Hartmut Kaiser, Andre Merzky, Ole Weidner E-SCIENCE '07: Actas de la Tercera Conferencia Internacional IEEE sobre e-Ciencia y Computación en Red (e-Science 2007), 2007
  4. ^ "Descripción general - SAGA WG - Foro Open Grid".
  5. ^ Shantenu Jha, Andre Merzky: "Una colección de casos de uso para una API simple para aplicaciones Grid", documento informativo OGF, GFD.70 (pdf)
  6. ^ Shantenu Jha, Andre Merzky: "Un análisis de requisitos para una API simple para aplicaciones de red", Documento informativo de OGF, GFD.71 (pdf)
  7. ^ Steve Fisher, Anthony Wilson, Arumugam Paventhan: "Extensión de API SAGA: API de descubrimiento de servicios", documento de recomendación de OGF, GFD.144 (pdf)
  8. ^ Andre Merzky: "Extensión API SAGA: API publicitaria", Documento de recomendación de OGF, GFD.177 (pdf)
  9. ^ Andre Merzky: "Extensión API SAGA: API de mensajes", Documento de recomendación de OGF, GFD.178 (pdf)
  10. ^ Steve Fisher, Anthony Wilson: "SAGA API Extension: Information System Navigator API", Documento de recomendación de OGF, GFD.195 (pdf)
  11. ^ "La API de referencia de SAGA C++ (Documentación)".
  12. ^ "SAGA: Cómo funciona". www.vimeo.com .
  13. ^ "SAGA C++".
  14. ^ "RADICAL-SAGA".
  15. ^ "Gracias por su interés en XSEDE".
  16. ^ "FutureGrid". Archivado desde el original el 25 de noviembre de 2010.
  17. ^ "jSAGA".
  18. ^ "DESHL". Archivado desde el original el 8 de junio de 2012.
  19. ^ NSF-CHE 1125332 (CDI)
  20. ^ NSF-EPS 1003897 (LaSIGMA)
  21. ^ NSF-OCI 1007115 (ExTENCI)
  22. ^ OMII-Reino Unido
Obtenido de "https://es.wikipedia.org/w/index.php?title=API_simple_para_aplicaciones_de_red&oldid=1219705401"