Buscar

Ya están disponibles las versiones de prueba de la primera versión (v1.0) del Sistema de Alerta y Monitorización de InterSystems (SAM, System Alerting and Monitoring). InterSystems SAM v1.0 ofrece una moderna solución de monitorización para los productos que tienen como base IRIS de InterSystems. Permite vistas de alto nivel de clústeres y visualización de métricas desglosadas de nodo único, junto con notificaciones de alertas. La primera versión ofrece visualización para más de cien métricas del kernel de InterSystems IRIS, y los usuarios pueden extender a su criterio la plantilla de Grafana ofrecida por defecto.Esta primera versión V1.0 tiene la intención de ser un punto de partida sencillo e intuitivo. Podéis ayudarnos a mejorarla si la probáis y nos transmitís vuestro feedback! SAM puede mostrar información de instancias desde la versión 2019.4. SAM solo está disponible en formato contenedor. Se necesita el contenedor del SAM Manager y un pequeño conjunto de componentes open-source adicionales (Prometheus y Grafana) que son añadidos automáticamente mediante el uso de docker-compose. Los componentes del SAM y la SAM Manager Community Edition están disponibles desde: La página de descargas para pruebas del Centro de Soporte Internacional (WRC) como “SAM Components” y “SAM Manager” Externamente en el SAM components Github repo y el SAM Manager en Docker Hub si quieres descargarlo antes de que se ejecute el docker-compose Si estás viajando o prefieres escuchar lo que es el SAM, puedes escuchar este podcast que hemos preparado (en inglés): También puedes consultar la documentación sobre el SAM aquí.

¡Hola, Comunidad!   Como ya sabéis, en Global Masters se pueden canjear los puntos por **servicios de consultoría con un experto de InterSystems**, sobre cualquiera de los productos de la compañía: InterSystems IRIS, IRIS for Health, Interoperability (Ensemble), IRIS Analytics (DeepSee), Caché, HealthShare. La buena noticia es que ahora **el servicio de consultoría ya está disponible en varios idiomas: ** inglés, portugués, ruso, alemán, francés, italiano, español, japonés ¡y chino!. La duración de la consultoría es de 1.5 horas para que se pueda profundizar en el tema. Si estáis interesados, ya podéis canjear vuestros puntos en Global Masters.    ***Nota.-*** Para darse de alta en Global Masters, hay que [unirse aquí](http://globalmasters.intersystems.com/) (hacer clic sobre el botón para iniciar sesión en InterSystems y usar las credenciales de la Comunidad de Desarrolladores). Para más información sobre Global Masters, consultar el siguiente artículo: [¿Aún no estás registrado en Global Masters, el Programa de Fidelización de InterSystems?](https://es.community.intersystems.com/post/%C2%BFa%C3%BAn-no-est%C3%A1s-registrado-en-global-masters-el-programa-de-fidelizaci%C3%B3n-de-intersystems) ¡Nos vemos por Global Masters! 🙂  

IntroducciónVarios recursos nos enseñan cómo ejecutar IRIS en un clúster de Kubernetes, como Deploying an InterSystems IRIS Solution on EKS using GitHub Actions y Deploying InterSystems IRIS solution on GKE Using GitHub Actions. Estos métodos funcionan, pero requieren la creación de manifiestos para Kubernetes y Helm charts, lo que puede requerir mucho tiempo.Para simplificar la implementación en IRIS, InterSystems desarrolló una asombrosa herramienta llamada InterSystems Kubernetes Operator (IKO). Varios recursos explican el uso de IKO, como New Video: Intersystems IRIS Kubernetes Operator e InterSystems Kubernetes Operator. En la documentación de Kubernetes se indica que los operadores sustituyen a un operador humano ya que saben cómo lidiar con los sistemas complejos en Kubernetes. Proporcionan la configuración del sistema por medio de recursos personalizados. Un operador incluye un controlador personalizado que interpreta esta configuración y lleva a cabo los pasos establecidos para configurar y mantener funcionando correctamente tu aplicación. El controlador personalizado es un contenedor sencillo que se implementó en Kubernetes. Por lo tanto, en términos generales, todo lo que necesitas hacer para que un operador funcione es implementar un contenedor para el controlador y definir su configuración en los recursos personalizados.Puede encontrar explicaciones más especializadas sobre los operadores en el artículo How to explain Kubernetes Operators in plain English. Además, hay un libro electrónico gratuito de O'Reilly, disponible para descarga.En este artículo, veremos más de cerca qué son los operadores y qué los hace funcionar. También escribiremos nuestro propio operador. Configuración y requisitos previos Para continuar, necesitarás instalar las siguientes herramientas: kind $ kind --version kind version 0.9.0 golang $ go version go version go1.13.3 linux/amd64 kubebuilder $ kubebuilder version Version: version.Version{KubeBuilderVersion:"2.3.1"… kubectl $ kubectl version Client Version: version.Info{Major:"1", Minor:"15", GitVersion:"v1.15.11"... operator-sdk $ operator-sdk version operator-sdk version: "v1.2.0"… Recursos personalizados Los recursos de la API son un concepto importante en Kubernetes. Estos recursos te permiten interactuar con Kubernetes mediante endpoints HTTP que pueden agruparse y versionarse. La API estándar puede ampliarse con los recursos personalizados, los cuales requieren que proporciones una Definición de recursos personalizados (CRD). Para más información, echa un vistazo a la página Extend the Kubernetes API with Custom Resource Definitions.Este es un ejemplo de una CRD: $ cat crd.yaml apiVersion: apiextensions.k8s.io/v1beta1 kind: CustomResourceDefinition metadata: name: irises.example.com spec: group: example.com version: v1alpha1 scope: Namespaced names: plural: irises singular: iris kind: Iris shortNames: - ir validation: openAPIV3Schema: required: ["spec"] properties: spec: required: ["replicas"] properties: replicas: type: "integer" minimum: 0 En el ejemplo anterior, definimos el recurso API GVK (Group/Version/Kind) como example.com/v1alpha1/Iris, con replicas como el único campo requerido.Ahora definiremos un recurso personalizado basado en nuestra CRD: $ cat crd-object.yaml apiVersion: example.com/v1alpha1 kind: Iris metadata: name: iris spec: test: 42 replicas: 1 En nuestro recurso personalizado, podemos definir cualquier campo además del número de replicas, lo cual es necesario para la CRD.Después de implementar los dos archivos anteriores, nuestro recurso personalizado debería ser visible para el kubectl estándar.A continuación, iniciaremos Kubernetes localmente utilizando kind, y después ejecutaremos los siguientes comandos de kubectl : $ kind create cluster $ kubectl apply -f crd.yaml $ kubectl get crd irises.example.com NAME CREATED AT irises.example.com 2020-11-14T11:48:56Z $ kubectl apply -f crd-object.yaml $ kubectl get iris NAME AGE iris 84s Aunque hemos establecido un cierto número de réplicas para nuestro IRIS, realmente no sucedió nada hasta el momento. Como se esperaba. Necesitamos implementar un controlador - la entidad que pueda leer nuestro recurso personalizado y realice algunas acciones basadas en la configuración.Por ahora, eliminaremos lo que creamos: $ kubectl delete -f crd-object.yaml $ kubectl delete -f crd.yaml Controlador Un controlador puede escribirse en cualquier lenguaje. Utilizaremos Golang por ser el lenguaje “nativo” de Kubernetes. Podríamos escribir la lógica de un controlador desde cero, pero nuestros buenos amigos de Google y RedHat se nos adelantaron. Ellos han creado dos proyectos que pueden generar el código del operador y que solo requerirán cambios mínimos - kubebuilder y operator-sdk. Ambos pueden compararse en la página kubebuilder vs operator-sdk, y también en el artículo: What is the difference between kubebuilder and operator-sdk #1758. Kubebuilder Es útil que comencemos a familiarizarnos con Kubebuilder desde la página Kubebuilder book. El video Tutorial: Zero to Operator in 90 minutes también podría ayudar. En los repositorios de sample-controller-kubebuilder y en kubebuilder-sample-controller se pueden encontrar ejemplos sobre las implementaciones del proyecto Kubebuilder. Configuremos un nuevo proyecto para el operador: $ mkdir iris $ cd iris $ go mod init iris # Creates a new module, name it iris $ kubebuilder init --domain myardyas.club # An arbitrary domain, used below as a suffix in the API group La configuración incluye muchos archivos y manifiestos. Por ejemplo, el archivo main.go es el punto de entrada del código. Importa la biblioteca controller-runtime, crea una instancia y ejecuta un administrador especial que registra la ejecución del controlador. No es necesario cambiar nada en ninguno de estos archivos. Vamos a crear la CRD: $ kubebuilder create api --group test --version v1alpha1 --kind Iris Create Resource [y/n] y Create Controller [y/n] y … De nuevo, se generan muchos archivos. Estos se describen con detallade en la página Adding a new API. Por ejemplo, puedes ver que se añade un archivo para el kind Iris en api/v1alpha1/iris_types.go. En nuestro primer ejemplo de la CRD, definimos el campo requerido replicas. Vamos a crear un campo idéntico aquí, esta vez en la estructura IrisSpec. También agregaremos el campo DeploymentName. El número de réplicas también debería ser visible en la sección Status, por lo que necesitamos hacer los siguientes cambios: $ vim api/v1alpha1/iris_types.go … type IrisSpec struct { // +kubebuilder:validation:MaxLength=64 DeploymentName string `json:"deploymentName"` // +kubebuilder:validation:Minimum=0 Replicas *int32 `json:"replicas"` } … type IrisStatus struct { ReadyReplicas int32 `json:"readyReplicas"` } … Después de editar la API, editaremos el código repetitivo del controlador. Toda la lógica debe definirse en el método Reconcile (la mayor parte de este ejemplo proviene de mykind_controller.go). También agregaremos un par de métodos auxiliares y reescribimos el método SetupWithManager. $ vim controllers/iris_controller.go … import ( ... // Leave the existing imports and add these packages apps "k8s.io/api/apps/v1" core "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/tools/record" ) // Add the Recorder field to enable Kubernetes events type IrisReconciler struct { client.Client Log logr.Logger Scheme *runtime.Scheme Recorder record.EventRecorder } … // +kubebuilder:rbac:groups=test.myardyas.club,resources=iris,verbs=get;list;watch;create;update;patch;delete // +kubebuilder:rbac:groups=test.myardyas.club,resources=iris/status,verbs=get;update;patch // +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;delete // +kubebuilder:rbac:groups="",resources=events,verbs=create;patch func (r *IrisReconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) { ctx := context.Background() log := r.Log.WithValues("iris", req.NamespacedName) // Fetch Iris objects by name log.Info("fetching Iris resource") iris := testv1alpha1.Iris{} if err := r.Get(ctx, req.NamespacedName, &iris); err != nil { log.Error(err, "unable to fetch Iris resource") return ctrl.Result{}, client.IgnoreNotFound(err) } if err := r.cleanupOwnedResources(ctx, log, &iris); err != nil { log.Error(err, "failed to clean up old Deployment resources for Iris") return ctrl.Result{}, err } log = log.WithValues("deployment_name", iris.Spec.DeploymentName) log.Info("checking if an existing Deployment exists for this resource") deployment := apps.Deployment{} err := r.Get(ctx, client.ObjectKey{Namespace: iris.Namespace, Name: iris.Spec.DeploymentName}, &deployment) if apierrors.IsNotFound(err) { log.Info("could not find existing Deployment for Iris, creating one...") deployment = *buildDeployment(iris) if err := r.Client.Create(ctx, &deployment); err != nil { log.Error(err, "failed to create Deployment resource") return ctrl.Result{}, err } r.Recorder.Eventf(&iris, core.EventTypeNormal, "Created", "Created deployment %q", deployment.Name) log.Info("created Deployment resource for Iris") return ctrl.Result{}, nil } if err != nil { log.Error(err, "failed to get Deployment for Iris resource") return ctrl.Result{}, err } log.Info("existing Deployment resource already exists for Iris, checking replica count") expectedReplicas := int32(1) if iris.Spec.Replicas != nil { expectedReplicas = *iris.Spec.Replicas } if *deployment.Spec.Replicas != expectedReplicas { log.Info("updating replica count", "old_count", *deployment.Spec.Replicas, "new_count", expectedReplicas) deployment.Spec.Replicas = &expectedReplicas if err := r.Client.Update(ctx, &deployment); err != nil { log.Error(err, "failed to Deployment update replica count") return ctrl.Result{}, err } r.Recorder.Eventf(&iris, core.EventTypeNormal, "Scaled", "Scaled deployment %q to %d replicas", deployment.Name, expectedReplicas) return ctrl.Result{}, nil } log.Info("replica count up to date", "replica_count", *deployment.Spec.Replicas) log.Info("updating Iris resource status") iris.Status.ReadyReplicas = deployment.Status.ReadyReplicas if r.Client.Status().Update(ctx, &iris); err != nil { log.Error(err, "failed to update Iris status") return ctrl.Result{}, err } log.Info("resource status synced") return ctrl.Result{}, nil } // Delete the deployment resources that no longer match the iris.spec.deploymentName field func (r *IrisReconciler) cleanupOwnedResources(ctx context.Context, log logr.Logger, iris *testv1alpha1.Iris) error { log.Info("looking for existing Deployments for Iris resource") var deployments apps.DeploymentList if err := r.List(ctx, &deployments, client.InNamespace(iris.Namespace), client.MatchingField(deploymentOwnerKey, iris.Name)); err != nil { return err } deleted := 0 for _, depl := range deployments.Items { if depl.Name == iris.Spec.DeploymentName { // Leave Deployment if its name matches the one in the Iris resource continue } if err := r.Client.Delete(ctx, &depl); err != nil { log.Error(err, "failed to delete Deployment resource") return err } r.Recorder.Eventf(iris, core.EventTypeNormal, "Deleted", "Deleted deployment %q", depl.Name) deleted++ } log.Info("finished cleaning up old Deployment resources", "number_deleted", deleted) return nil } func buildDeployment(iris testv1alpha1.Iris) *apps.Deployment { deployment := apps.Deployment{ ObjectMeta: metav1.ObjectMeta{ Name: iris.Spec.DeploymentName, Namespace: iris.Namespace, OwnerReferences: []metav1.OwnerReference{*metav1.NewControllerRef(&iris, testv1alpha1.GroupVersion.WithKind("Iris"))}, }, Spec: apps.DeploymentSpec{ Replicas: iris.Spec.Replicas, Selector: &metav1.LabelSelector{ MatchLabels: map[string]string{ "iris/deployment-name": iris.Spec.DeploymentName, }, }, Template: core.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ "iris/deployment-name": iris.Spec.DeploymentName, }, }, Spec: core.PodSpec{ Containers: []core.Container{ { Name: "iris", Image: "store/intersystems/iris-community:2020.4.0.524.0", }, }, }, }, }, } return &deployment } var ( deploymentOwnerKey = ".metadata.controller" ) // Specifies how the controller is built to watch a CR and other resources // that are owned and managed by that controller func (r *IrisReconciler) SetupWithManager(mgr ctrl.Manager) error { if err := mgr.GetFieldIndexer().IndexField(&apps.Deployment{}, deploymentOwnerKey, func(rawObj runtime.Object) []string { // grab the Deployment object, extract the owner... depl := rawObj.(*apps.Deployment) owner := metav1.GetControllerOf(depl) if owner == nil { return nil } // ...make sure it's an Iris... if owner.APIVersion != testv1alpha1.GroupVersion.String() || owner.Kind != "Iris" { return nil } // ...and if so, return it return []string{owner.Name} }); err != nil { return err } return ctrl.NewControllerManagedBy(mgr). For(&testv1alpha1.Iris{}). Owns(&apps.Deployment{}). Complete(r) } Para que el registro de eventos funcione, necesitamos agregar otra línea al archivo main.go: if err = (&controllers.IrisReconciler{ Client: mgr.GetClient(), Log: ctrl.Log.WithName("controllers").WithName("Iris"), Scheme: mgr.GetScheme(), Recorder: mgr.GetEventRecorderFor("iris-controller"), }).SetupWithManager(mgr); err != nil { Ahora todo está listo para establecer un operador.Primero vamos a instalar la CRD utilizando el destino de instalación Makefile: $ cat Makefile … # Install CRDs into a cluster install: manifests kustomize build config/crd | kubectl apply -f - ... $ make install Puedes echar un vistazo al archivo CRD YAML resultante, en el directorio config/crd/bases/. Ahora, comprueba la existencia de la CRD en el clúster: $ kubectl get crd NAME CREATED AT iris.test.myardyas.club 2020-11-17T11:02:02Z Vamos a ejecutar nuestro controlador en otro terminal, a nivel local (no en Kubernetes), solo para ver si realmente funciona: $ make run ... 2020-11-17T13:02:35.649+0200 INFO controller-runtime.metrics metrics server is starting to listen {"addr": ":8080"} 2020-11-17T13:02:35.650+0200 INFO setup starting manager 2020-11-17T13:02:35.651+0200 INFO controller-runtime.manager starting metrics server {"path": "/metrics"} 2020-11-17T13:02:35.752+0200 INFO controller-runtime.controller Starting EventSource {"controller": "iris", "source": "kind source: /, Kind="} 2020-11-17T13:02:35.852+0200 INFO controller-runtime.controller Starting EventSource {"controller": "iris", "source": "kind source: /, Kind="} 2020-11-17T13:02:35.853+0200 INFO controller-runtime.controller Starting Controller {"controller": "iris"} 2020-11-17T13:02:35.853+0200 INFO controller-runtime.controller Starting workers {"controller": "iris", "worker count": 1} … Ahora que ya tenemos la CRD y el controlador instalados, lo único que debemos hacer es crear una instancia de nuestro recurso personalizado. Es posible encontrar una plantilla en el archivo config/samples/example.com_v1alpha1_iris.yaml. En este archivo, necesitamos hacer modificaciones similares a las que se realizaron en crd-objeto.yaml: $ cat config/samples/test_v1alpha1_iris.yaml apiVersion: test.myardyas.club/v1alpha1 kind: Iris metadata: name: iris spec: deploymentName: iris replicas: 1 $ kubectl apply -f config/samples/test_v1alpha1_iris.yaml Tras un ligero retraso debido a la necesidad de extraer una imagen de IRIS, deberías ver el contenedor de IRIS en ejecución: $ kubectl get deploy NAME READY UP-TO-DATE AVAILABLE AGE iris 1/1 1 1 119s $ kubectl get pod NAME READY STATUS RESTARTS AGE iris-6b78cbb67-vk2gq 1/1 Running 0 2m42s $ kubectl logs -f -l iris/deployment-name=iris Puedes abrir el portal de IRIS usando el comando port-forward de kubectl: $ kubectl port-forward deploy/iris 52773 Ve a http://localhost:52773/csp/sys/UtilHome.csp en tu navegador. ¿Qué sucedería si cambiamos el número de replicas en la CRD? Vamos a hacerlo y aplicar este cambio: $ vi config/samples/test_v1alpha1_iris.yaml … replicas: 2 $ kubectl apply -f config/samples/test_v1alpha1_iris.yaml Ahora ser debería ver que aparece otro contenedor de Iris. $ kubectl get events … 54s Normal Scaled iris/iris Scaled deployment "iris" to 2 replicas 54s Normal ScalingReplicaSet deployment/iris Scaled up replica set iris-6b78cbb67 to 2 Esto son los mensajes, en el terminal donde el controlador está en ejecución, que informan sobre la reconciliación exitosa: 2020-11-17T13:09:04.102+0200 INFO controllers.Iris replica count up to date {"iris": "default/iris", "deployment_name": "iris", "replica_count": 2} 2020-11-17T13:09:04.102+0200 INFO controllers.Iris updating Iris resource status {"iris": "default/iris", "deployment_name": "iris"} 2020-11-17T13:09:04.104+0200 INFO controllers.Iris resource status synced {"iris": "default/iris", "deployment_name": "iris"} 2020-11-17T13:09:04.104+0200 DEBUG controller-runtime.controller Successfully Reconciled {"controller": "iris", "request": "default/iris"} Ok, parece que nuestros controladores están funcionando. Ahora, estamos listos para implementar ese controlador dentro de Kubernetes como un contenedor. Para hacerlo, necesitamos crear el controlador del contenedor Docker y llevarlo al registro. Este puede ser cualquier registro que funcione con Kubernetes: DockerHub, ECR, GCR, etc. Utilizaremos los Kubernetes locales (kind), así que vamos a implementar el controlador en el registro local mediante el script kind-with-registry.sh, disponible en la página Local Registry. Para ello, podemos simplemente eliminar el clúster actual y recrearlo: $ kind delete cluster $ ./kind_with_registry.sh $ make install $ docker build . -t localhost:5000/iris-operator:v0.1 # Dockerfile is autogenerated by kubebuilder $ docker push localhost:5000/iris-operator:v0.1 $ make deploy IMG=localhost:5000/iris-operator:v0.1 El controlador se implementará en el namespace IRIS-system. O puedes escanear todos los contenedores para encontrar un namespace como kubectl get pod -A): $ kubectl -n iris-system get po NAME READY STATUS RESTARTS AGE iris-controller-manager-bf9fd5855-kbklt 2/2 Running 0 54s Revisemos los registros: $ kubectl -n iris-system logs -f -l control-plane=controller-manager -c manager Puedes experimentar modificando el número de replicas en la CRD y observar cómo estos cambios se reflejan en el número de instancias en IRIS. Operator-SDK Otra herramienta útil para generar el código del operador es Operator SDK. Para tener una idea inicial sobre cómo funciona esta herramienta, echa un vistazo a este tutorial. Primero deberías instalar operator-sdk.Para nuestro sencillo caso de uso, el proceso será similar al que realizamos con kubebuilder (puedes eliminar/crear el clúster kind con el registro Docker antes de continuar). Ejecuta el siguiente script en otro directorio: $ mkdir iris $ cd iris $ go mod init iris $ operator-sdk init --domain=myardyas.club $ operator-sdk create api --group=test --version=v1alpha1 --kind=Iris # Answer two ‘yes’ Ahora modifica las estructuras IrisSpec e IrisStatus en el mismo archivo, api/v1alpha1/iris_types.go.Utilizaremos el mismo archivo iris_controller.go, como hicimos en kubebuilder. No olvides agregar el campo Recorder en el archivo main.go.Dado que kubebuilder y operator-sdk utilizan versiones diferentes de los paquetes Golang, debes agregar contexto en la función SetupWithManager que se encuentra en controllers/iris_controller.go: ctx := context.Background() if err := mgr.GetFieldIndexer().IndexField(ctx, &apps.Deployment{}, deploymentOwnerKey, func(rawObj runtime.Object) []string { Luego, instala la CRD y el operador (asegúrate de que el kind del clúster se está ejecutando): $ make install $ docker build . -t localhost:5000/iris-operator:v0.2 $ docker push localhost:5000/iris-operator:v0.2 $ make deploy IMG=localhost:5000/iris-operator:v0.2 Ahora debería ver la CRD, el contenedor del operador y los contenedores de IRIS de forma similar a los que vimos cuando trabajamos con kubebuilder. Conclusión Aunque un controlador incluye una gran cantidad de código, se puede ver que modificar las replicas de IRIS simplemente es cuestión de modificar una línea en un recurso personalizado. Toda la complejidad está oculta en la implementación del controlador. Hemos visto cómo se puede crear un operador simple mediante el uso de herramientas útiles para configurarlo. Nuestro operador solo necesitaba las replicas de IRIS. Ahora imagina que en realidad necesitamos que los datos de IRIS persistan en el disco - esto requeriría que utilizáramos StatefulSet y Persistent Volumes. Además, necesitaríamos un Service y, tal vez, un Ingress para acceder externamente. Deberíamos ser capaces de establecer la versión de IRIS y la contraseña del sistema, Mirroring y/o ECP, entre otras cosas. Se puede imaginar la cantidad de trabajo que InterSystems tuvo que hacer para simplificar la implementación de IRIS, ocultando toda la lógica específica de IRIS dentro del código del operador. En el próximo artículo, analizaremos el Operador de IRIS (IKO) más en detalle e investigaremos todo lo que puede hacer en escenarios más complejos.

¡Hola Comunidad! Estamos encantados de invitaros a InterSystems AI+ML Summit 2021, un encuentro virtual sobre Inteligencia Artificial y Machine Learning, que tendrá lugar del 25 de enero al 4 de febrero. Participa en dos semanas de ponencias, ofrecidas tanto por profesionales de reconocido prestigio como por técnicos de InterSystems. También habrá encuentros virtuales privados (“Ask the Expert”). Las sesiones serán en alemán e inglés. Y el evento es gratuito. Más información: Descubre nuevos puntos de vista. Da forma al futuro. Según Statista, para el final de 2021 se habrán generado 74 zettabytes de datos. Sin la ayuda de la Inteligencia artificial (AI) y el Machine learning (ML), esta inmensa cantidad de información no puede ser canalizada de forma eficiente ni transformada en valor para los procesos de negocio. Por eso no deberíais perderos el encuentro virtual "InterSystems AI + ML Summit 2021", en el que aprenderéis todo lo necesario sobre el estado actual de la IA y el ML en general, y en relación a InterSystems en particular. Los temas que se tratarán irán desde tendencias en IA de la máxima actualidad a casos de uso concretos en diferentes industrias, pasando por "workshops" interactivos. Durante la primera semana, las sesiones se centrarán en la IA y el ML aplicada a la salud y la atención sanitaria. En la segunda semana, se tratarán los temas desde el punto de vista del resto de sectores e industrias. Recordad: ⏱ 25 enero - 4 febrero, 2021 📍 Online ✅ REGISTRO >> Apuntaos y descubrid cómo utilizar con éxito las tecnologías de IA y ML con InterSystems IRIS, IRIS for Health y HealthShare, para crear valor añadido en vuestras empresas y/o vuestros clientes.

¡Hola desarrolladores!Hay un nuevo reto en Global Masters (GM), disponible para los miembros con el nivel "Advocate" o superior: graba un vídeo de 30-60 segundos, con la respuesta a esta pregunta: ➥ ¿Cuál es el valor de InterSystems IRIS para ti? 🎁 Premio: a elegir entre una tarjeta regalo de $50 (VISA/Amazon) o 12 000 puntos en GM! En este enlace al reto tenéis toda la información. Nota.- el enlace solo funciona para los miembros de Global Masters con nivel "Advocate" o superior. ¿No sabes en qué nivel de Global Masters estás? Descubre todos los niveles en esta publicación. ¡Nos encantaría escucharos! ¡Os vemos por Global Masters!

Hola Comunidad! Aprovechando la publicación de la [nueva versión IRIS 2021.1](https://es.community.intersystems.com/post/ya-están-disponibles-intersystems-iris-iris-health-y-healthshare-health-connect-20211) y también de [IAM 2.3](https://es.community.intersystems.com/post/ya-está-disponible-iam-intersystems-api-manager-23) os paso los ejercicios de un taller (*workshop*) sobre desarrollo de APIs REST y gestión de las mismas utilizando *InterSystems API Manager*. Contiene ejercicios paso a paso para: * Crear APIs REST desde sus especificaciones *OpenAPI*. * Añadir, opcionalmente, la API creada a una producción de interoperabilidad. * Gestión básica de la API en InterSystems API Manager (consumidores, limitación, autenticación). * Planteamiento de algunos escenarios más complejos en InterSystems API Manager como **balanceo de carga**, o **enrutamiento por cabecera**. Lo tenéis todo en la aplicación de Open Exchange vinculada.

¡Hola desarrolladores! Supón que tienes una clase persistente con datos y quieres tener una interfaz de usuario Angular sencilla, para ver los datos y llevar a cabo operaciones CRUD. En este [artículo](https://es.community.intersystems.com/post/ejemplo-de-aplicaci%C3%B3n-angular-intersystems-iris) describíamos cómo desarrollar una interfaz de usuario Angular para InterSystems IRIS utilizando RESTForms2. A continuación vamos a explicar cómo conseguir una interfaz de usuario Angular sencilla que permita realizar operaciones CRUD y ver automáticamente los datos de tu clase de InterSystems IRIS en menos de 5 minutos. ¡Vamos! Necesitarás: 1. InterSystems IRIS 2. [ZPM](https://openexchange.intersystems.com/package/ObjectScript-Package-Manager-2) 3. Los módulos [RESTForms2](https://openexchange.intersystems.com/package/RESTForms2) y [RESTForms2-UI](https://openexchange.intersystems.com/package/RestFormsUI2). Utilizaré como ejemplo la clase [Data.Countries](https://github.com/evshvarov/rest-angular-test/blob/master/src/Data/Countries.cls) que generé e importé a través de [csvgen](https://openexchange.intersystems.com/package/csvgen), utilizando este comando: d ##class(community.csvgen).GenerateFromURL("https://raw.githubusercontent.com/datasciencedojo/datasets/master/WorldDBTables/CountryTable.csv",",","Data.Countries" Para crear una interfaz de usuario Angular necesitamos exponer una API REST para esta clase, que dará servicio a las operaciones CRUD. Vamos a utilizar el módulo [restforms2](https://openexchange.intersystems.com/package/RESTForms2) para esto.  [Este comando en dockerfile](https://github.com/evshvarov/rest-angular-test/blob/8e98da749d06877ccdf93403718c5ebab366d8b6/Dockerfile#L23) instala restforms2 en el contenedor IRIS: zpm "install restforms2" \ Para añadir una API REST, necesitamos hacer que nuestra clase de ejemplo herede de [Form.Adaptor](https://github.com/evshvarov/rest-angular-test/blob/8e98da749d06877ccdf93403718c5ebab366d8b6/src/Data/Countries.cls#L1): Class Data.Countries Extends (%Library.Persistent, Form.Adaptor) Añade los parámetros restforms2 a la clase persistente para gestionar el comportamiento general: ordenación, visualización, etc: // Form name, not a global key so it can be anything Parameter FORMNAME = "Countries"; /// Default permissions /// Objects of this form can be Created, Read, Updated and Deleted /// Redefine this parameter to change permissions for everyone /// Redefine checkPermission method (see Form.Security) for this class  /// to add custom security based on user/roles/etc. Parameter OBJPERMISSIONS As %String = "CRUD"; /// Property used for basic information about the object /// By default getObjectDisplayName method gets its value from it Parameter DISPLAYPROPERTY As %String = "name"; Perfecto. A continuación, podemos utilizar la sintaxis de restforms2 para hacerle saber qué propiedades de la clase queremos exponer a la API CRUD. Puedes hacerlo añadiendo el atributo "DISPLAYNAME =" a las propiedades que quieras exponer en restforms2-ui. Por ejemplo: Property code As %Library.String(MAXLEN = 250) [ SqlColumnNumber = 2 ]; Property name As %Library.String(DISPLAYNAME = "Name", MAXLEN = 250) [ SqlColumnNumber = 3 ]; Property continent As %Library.String(DISPLAYNAME = "Continent", MAXLEN = 250) [ SqlColumnNumber = 4 ]; Property region As %Library.String(DISPLAYNAME = "Region", MAXLEN = 250) [ SqlColumnNumber = 5 ]; Property surfacearea As %Library.Integer(DISPLAYNAME = "Surface Area", MAXVAL = 2147483647, MINVAL = -2147483648) [ SqlColumnNumber = 6, SqlFieldName = surface_area ]; Property independenceyear As %Library.Integer(DISPLAYNAME = "Independence Year", MAXVAL = 2147483647, MINVAL = -2147483648) [ SqlColumnNumber = 7, SqlFieldName = independence_year ]; ¡Genial! Ahora vamos a introducir la capa de interfaz de usuario. [Este comando en dockerfile](https://github.com/evshvarov/rest-angular-test/blob/8e98da749d06877ccdf93403718c5ebab366d8b6/Dockerfile#L24) instala restforms2-ui, que es la interfaz de usuario Angular para Restform2: zpm "install restforms2-ui" \ ¡Y ya está! Vamos a echarle un vistazo a la interfaz de usuario de nuestra clase de ejemplo, que puedes encontrar en la URL server:port/restforms2-ui: RESTForms incluye las clases de prueba Person y Company, y se pueden utilizar para examinar las características de restfomsUI. Actualmente, puedes editar campos de cadenas de texto, numéricos, booleanos, de fecha y búsqueda. Puedes probar todo esto en tu portátil, si clonas y construyes [este repositorio:](https://github.com/evshvarov/restforms2-angularui-demo) docker-compose up -d --build Y, a continuación, abres la URL: localhost:port/restforms2-ui/index.html o si usas VSCode, selecciona este elemento del menú: ¡Happy coding! Este artículo ha sido etiquetado como "Mejores prácticas" ("Best practices"). Los artículos con la etiqueta "Mejores prácticas" incluyen recomendaciones sobre cómo desarrollar, probar, implementar y administrar mejor las soluciones de InterSystems.

Ahora que [la extensión de ObjectScript para VS Code ha alcanzado la versión 1.0](https://es.community.intersystems.com/post/la-extensi%C3%B3n-de-objectscript-para-vs-code-alcanza-la-versi%C3%B3n-10) y ha sido presentada en varias sesiones de la [Cumbre Virtual 2020](https://www.intersystems.com/virtual-summit-2020/), parece un buen momento para ofrecer algunos consejos sobre cómo reportar problemas. [InterSystems ObjectScript para VS Code](https://intersystems-community.github.io/vscode-objectscript/) se basa en tres extensiones de VS Code que colaboran entre sí. Para facilitar la instalación y la administración hay una cuarta entidad, el [paquete de extensiones de InterSystems ObjectScript](https://community.intersystems.com/post/vs-code-extension-pack-objectscript-development-now-available). Es la mejor manera de empezar con un mínimo de clics y es práctico tenerlo incluso si ya habéis instalado las otras extensiones. Esta arquitectura modular también significa que hay tres repositorios diferentes de GitHub donde se pueden crear incidencias. Afortunadamente, el propio VS Code ayuda con la tarea. A continuación, te explicamos cómo utilizarlo: 1. Desde el menú **Help** en VS Code, selecciona **Report issue**. O abre la Command Palette (normalmente hago esto presionando la tecla F1) y ejecuta **Help: report issue...** (Truco: escribe solo **hri** y comprueba lo rápido que te lleva al comando correcto). 2. Aparece un diálogo como este: .png) 3. Utiliza el primer campo para clasificar tu incidencia: * Bug report -> Reportar un error * Feature request -> Solicitar una nueva funcionalidad * Performance Issue -> Problema de rendimiento 4. En el segundo campo, selecciona "An extension". 5. El tercer menú desplegable te permite elegir una de tus extensiones instaladas. También puedes escribir algunos caracteres para encontrar la entrada correcta. Por ejemplo, **isls** selecciona rápidamente "InterSystems Language Server". ¿Cuál elegir? Esta es una guía aproximada: * **InterSystems Language Server** * code colo(u)ring -> código de colores * Intellisense * **InterSystems ObjectScript** * export, import and compile -> exportar, importar y compilar * ObjectScript Explorer (navegar por el contenido del namespace) * Edición directa del lado del servidor por medio del uso de carpetas isfs:// en un espacio de trabajo * Integración con el control de fuentes del lado del servidor, etc * **InterSystems Server Manager** * Administración de contraseñas en la cadena de claves * Definición y selección de entradas en \`intersystems.servers\` Si no puedes decidir, selecciona InterSystems ObjectScript. 6. Escribe un resumen descriptivo de una sola línea sobre tu incidencia. El diálogo puede ofrecer una lista de incidencias existentes que podrían estar duplicadas. Si no encuentras una que cubra la tuya, continúa. 7. Comienza introduciendo detalles. En esta etapa normalmente escribo un solo carácter, después hago clic en "Preview on GitHub" para iniciar una página del navegador donde puedo utilizar la conocida interfaz de usuario de incidencias GH para completar mi reporte. Consejos para utilizarlo allí: * Pega las imágenes del portapapeles directamente en el campo de informe en GH. Para incidencias difíciles de describir, un GIF animado obtiene puntos de bonificación. * Vincula a otras incidencias poniendo delante del número de destino el símbolo # * Recuerda que todo lo que publiques aquí es visible para cualquier persona en Internet. Enmascara/elimina la información confidencial. Sé amable. 8. Cuando estés satisfecho con lo que has escrito (consejo: utiliza la pestaña Preview), haz clic en "Submit new issue". Al usar **Help: report issue...** los números de tu versión se agregan automáticamente. El artículo original, escrito por John Murray, se puede encontrar [aquí](https://community.intersystems.com/post/using-intersystems-objectscript-vs-code-how-report-issues).

¡Hola Comunidad! ¿No pudistéis ver el webinar que hicimos el miércoles? Por si os lo perdisteis.. o lo queréis volver a ver, ya está disponible la grabación del mismo. Marcos Sabourdin y Laura Blázquez son dos cracks en la tecnología de InterSystems, saben mucho y tienen mucha experiencia. Además, lo explicaron todo súper bien. Así que os recomendamos encarecidamente el webinar. ¡Aprenderéis un montón! ⏯ ¿Qué necesitas para empezar con InterSystems IRIS y VS Code? Por cierto... ¿habéis entrado al Canal de YouTube de la Comunidad de Desarrolladores en español? En él podéis ver todos los webinars que hemos realizado (¡ya llevamos nueve!), varios tutoriales y otros vídeos. ¡Dadle al play! ▶️

¡Hola desarrolladores! A menudo, tenemos que implementar algunos datos junto con código de aplicación. Y para los desarrolladores de InterSystems IRIS, la pregunta podría ser: "¿Cómo puedo desplegar los datos que tengo en globals?" En este artículo, os propongo uno de los métodos - desplegar los datos de los globals utilizando el ZPM package manager. Cómo exportar datos de los globals Supongamos que tenemos un servidor de base de datos de IRIS donde está el global a desplegar. El gestor de paquetes ZPM puede desplegar ficheros, así que la solución consiste en exportar el global a un archivo y crear el paquete de despliegue con este archivo. ZPM puede desplegar globals en formato XML, así que primero tenemos que exportar un global en un fichero XML. Por ejemplo, si el global que hay que exportar tiene el nombre "DataD", el siguiente comando en el terminal IRIS exportará el global DataD en un fichero XML: d $System.OBJ.Export("DataD.GBL","/irisrun/repo/data/DataD.xml") Qué aspecto tiene el recurso Para generar el paquete con un global, debemos introducir un nuevo recurso en el fichero de definición module.xml, como sigue: <Resource Name="DataD.GBL"/> Mirar el ejemplo en la documentación. A tener en cuenta que con esta definición, se buscará el fichero DataD.XML, no DataD.GBL, como podríamos esperar. Y ZPM buscará el fichero DataD.XML en la carpeta /gbl dentro de la carpeta registrada en el elemento <SourceRoot>. Ejemplo Este es un repositorio de prueba: iris-dataset-countries, que contiene un paquete que despliega un global con los datos en diferentes países. Este es el módulo XML: <?xml version="1.0" encoding="UTF-8"?> <Export generator="Cache" version="25"> <Document name="dataset-countries.ZPM"> <Module> <Name>dataset-countries</Name> <Description>Module imports the data of Country passengers in dc.data.Titanic class</Description> <Version>1.0.0</Version> <Packaging>module</Packaging> <SourcesRoot>src</SourcesRoot> <Resource Name="dc.data.Country.CLS"/> <Resource Name="dc.data.CountryD.GBL"/> </Module> </Document> </Export> Y podemos ver el recurso: <Resource Name="dc.data.CountryD.GBL"/> Que se localiza en el fichero /src/gbl/dc.data.CountryD.XML en el repositorio. Así que, cuando ZPM carga el módulo en IRIS, importa el global según el module.xml. Podemos probar a instalar el global (y la clase para él para hacer consultas) con: USER>zpm "install dataset-countries" O podemos practicar con los conjuntos de datos de países y del Titanic.

¡Hola desarrolladores! En este nuevo vídeo en inglés, os mostramos cómo se realiza un test de velocidad para un caso de ingesta de grandes volúmenes de datos en InterSystems IRIS: ⏯ Test de velocidad de InterSystems IRIS: Ingesta de grandes volúmenes de datos Por si os resultar útil, podéis activar los subtítulos en inglés haciendo clic en el icono "Subtítulos" en la parte inferior del vídeo: Podéis ver la demo completa en https://github.com/intersystems-community/irisdemo-demo-htap Ponentes: 🗣 @Amir.Samary, InterSystems Director, Solution Architecture 🗣 @Derek.Robinson, InterSystems Senior Online Course Developer, InterSystems Y recordad que podéis suscribiros al canal de YouTube de la Comunidad de Desarrolladores en inglés para manteneros formados e informados!

**InterSystems SAM** es una gran herramienta para monitorizar tus clústeres de **InterSystems IRIS** e **InterSystems IRIS For Health** en instalaciones físicas o en un entorno de nube. En este artículo se describe cómo puedes implementar un administrador de alertas personalizado. Actualmente esta es una función no documentada y muy probablemente desconocida de InterSystems SAM. Con futuras versiones probablemente será más fácil aprovechar este útil concepto. Para ser breve, en este artículo solo mencionaré InterSystems IRIS, pero todo aplica a InterSystems IRIS e InterSystems IRIS For Health.  InterSystems SAM es un clúster de cinco contenedores y cada uno de ellos desempeña una función específica. Estos son: * **Grafana** para crear paneles de control con los que visualizar las métricas del sistema que selecciones. Es decir, tanto las métricas que InterSystems IRIS proporciona con la configuración predeterminada, como tus propias métricas (de la aplicación). * **Prometheus**, una herramienta de monitorización nativa de la nube, que recopila datos de series temporales de las instancias de destino * **Nginx** como el servidor web * **Alertmanager**, que recopila las alertas de InterSystems IRIS y de Prometheus * **SAM Manager**, que es el núcleo del SAM. Es una instancia de InterSystems IRIS en la que se almacenan todos los datos métricos InterSystems SAM activa dos diferentes clases de alertas. * **Alertas de InterSystems IRIS**, definidas por InterSystems IRIS * **Alertas definidas por el usuario**. Son alertas que se pueden especificar en las llamadas "reglas de alerta" en el portal del SAM. Para saber cómo especificar reglas de alerta, consulta la documentación ([https://docs.intersystems.com/sam/csp/docbook/Doc.View.cls?KEY=ASAM#ASAM_edit_alert](https://docs.intersystems.com/sam/csp/docbook/Doc.View.cls?KEY=ASAM#ASAM_edit_alert)) Las alertas que se activan se muestran en el portal del SAM, pero ¿qué sucedería si quieres notificar a alguien responsable del clúster InterSystems IRIS monitorizado y quieres hacerlo a través de diferentes canales de comunicación como el correo electrónico o el SMS, para que pueda hacerse cargo del clúster y solucionar el problema? Ahí es donde entra en acción un administrador de alertas personalizado.   En este artículo se describen los pasos necesarios para implementar tu propio administrador de alertas para tu instancia del SAM Manager. En este ejemplo, el administrador de alertas enviará un correo electrónico a una dirección de correo electrónico preconfigurada, junto con la información de la alerta.  La clave aquí es que hay una clase abstracta "oculta" _**%SAM.AbstractAlertsHandler**_ en la instancia del SAM Manager. Mira la referencia de la clase: .png)   Primero, tienes que extraer tu propio administrador de alertas de esta clase abstracta y después implementar el método de clase HandleAlerts. El método recibe una matriz JSON con los detalles de la alerta. Así que en mi sencillo ejemplo, el administrador de alertas es una clase _**SAM.AlertHandler**_ con subclases %SAM.AbstractAlertsHandler. La implementación del método HandleAlerts() es sencilla. Mira el código completo: .png) Delega el trabajo al método **_SendAlert_**. Asume que tienes una cuenta de correo electrónico de usuario, que puedes utilizar para las alertas. La contraseña del correo electrónico se almacena en la base de datos, pero la contraseña se encripta utilizando la función de InterSystems IRIS para el encriptado de "elementos de datos". Por lo tanto, tienes que crear una clave de encriptación en el SAM Manager y esta clave se debe cargar. De lo contrario, el administrador de alertas no podrá enviar el correo electrónico. Mi proveedor de correo electrónico requiere SSL/TLS para enviar el correo electrónico. He definido una configuración SSL _**ForMail**_ en la instancia de SAM Manager. El resto del código es sencillo. Mira el código:  .png)   En el cuerpo del correo electrónico copia la matriz JSON que recibió con los detalles de la alerta y la envía a los destinatarios.  Queda un problema pendiente. No puedes crear y editar directamente la clase de administrador de alertas en tu instancia del SAM Manager. La configuración predeterminada no permite conexiones desde tu IDE (IRIS Studio o VSCode) a la instancia del SAM Manager. Para resolver esto he creado y editado la clase del administrador de alertas en mi instancia de InterSystems IRIS, y la he importado al *namespace* del SAM proveniente de mi instancia del SAM Manager. Otra opción sería modificar el archivo docker-compose para iniciar InterSystems SAM, pero no quería tocar este tema.  Una vez que hayas cargado correctamente tu clase del administrador de alertas en tu instancia del InterSystems SAM Manager, el método **_HandleAlerts_** se ejecutará para cada alerta que se active en tu clúster de InterSystems IRIS monitorizado. ¡Espero que os resulte útil! Este artículo está etiquetado como "Mejores prácticas" ("Best practices"). Los artículos con la etiqueta "Mejores prácticas" incluyen recomendaciones sobre cómo desarrollar, probar, implementar y administrar mejor las soluciones de InterSystems.

¡Hola Comunidad! Os traemos un nuevo vídeo con subtítulos en español, ya disponible en el canal de YouTube de la Comunidad de Desarrolladores de InterSystems en español: ⏯ Python Embedido en InterSystems IRIS Python Embebido ofrece la posibilidad de cargar y ejecutar el código Python en el servidor de InterSystems IRIS. Se pueden utilizar módulos de librerías de Python instalándolos con pip, como NumPy, Pandas, etc., o podéis escribir vuestros propios módulos de Python como archivos .py independientes. Aquí tenéis otros vídeos con subtítulos en español: ⏯ Demo de IAM, el gestor de APIs de InterSystems⏯ Cómo usar Visual Studio Code y ObjectScritpt⏯ Cómo trabajar con Perfiles FHIR en InterSystems IRIS for Health⏯ Cómo crear una API Rest con InterSystems IRIS⏯ Demo de PEX (Production Extension Framework) Esperamos que os resulten útiles ¡Y recordad que podéis suscribiros al canal de YouTube de la Comunidad de Desarrolladores en español, para manteneros formados e informados!

El equipo de certificación de InterSystems está preparando un examen de certificación de Especialista en integración Intersystems IRIS (InterSystems IRIS Integration Specialist) y está buscando expertos en la materia (EEM) (SME, en inglés Subject Matter Expert) de nuestra comunidad para que le ayuden a redactar preguntas. Usted, como miembro valioso de la comunidad de InterSystems, conoce los desafíos de trabajar con nuestra tecnología y lo que se necesita para tener éxito en su trabajo. A cambio de su ayuda, se le compensará hasta con $500 por trabajo asignado. Un trabajo asignado, generalmente, implicará en escribir 20 preguntas asignadas en un periodo de dos semanas, y una vez enviadas las preguntas, ser revisadas dentro de las siguientes dos semanas posteriores a la presentación del trabajo. El tiempo estimado para la realización de estos trabajos es de 20 horas aproximadamente. Fecha de trabajos propuestos: Las asignaciones de trabajo de dos semanas serán realizarán en diferentes etapas entre el 18 de octubre y el 31 de diciembre de 2021 y serán asignadas por el equipo de certificación. Nota: La redacción de preguntas para la certificación de InterSystems es un trabajo remunerado como contrato temporal con sede en Estados Unidos. Como tal, para participar deberá de ser apto para aceptar proyectos de trabajos remunerados en los Estados Unidos. Deberás de firmar el acuerdo de proveedor de InterSystems y completar el formulario de declaración de impuestos de Estados Unidos (W-9). Estos son los detalles: Elemento de acción Detalles Perfil completo del proyecto Escribe a certification@intersystems.com para expresas tu interes en el programa de certificación de expertos en la materia (Certification Subject Matter Expert Program). Díganos que está interesado en ser una experto en la materia en la integración de InterSystems IRIS (una persona con al menos dos años de experiencia en tareas de integración de InterSystems IRIS). Un miembro del equipo le enviará un formulario de perfil para determinar si sus áreas de especialización se alinean con los proyectos abiertos. Aceptación Si es seleccionado para el desarrollo de exámenes, un miembro del equipo le enviará por correo electrónico varios formularios que requieren su firma: Una declaración de trabajo El acuerdo de proveedor de InterSystems Formulario W-9 Acuerdo de no divulgación Entrenamiento Después de recibir sus documentos firmados, y antes de empezar a escribir preguntas, se le pedirá que vea un breve video de entrenamiento sobre la redacción de preguntas y que complete un cuestionario de análisis de tareas de trabajo (ATT) (JTA, en inglés Job Task Analysis). Completar este cuestionario le tomará unos 30-45 minutos y es obligatorio. Sus respuestas nos ayudarán a validar los temas del examen y crear su tarea de redacción de preguntas. Participación Después de recibir su encuesta ATT, el equipo de certificación le enviará información sobre su primera asignación. Esto incluirá: credenciales para acceder e iniciar sesión en QuestionMark, nuestro sistema de desarrollo de redacción de artículos para EEM, y una asignación de trabajo, que generalmente consiste en la presentación de 20 preguntas basadas en escenarios. Por lo general, se le darán dos semanas para completar la tarea. Revisión El personal de InterSystems revisará su contenido. InterSystems puede aceptar, rechazar o solicitar la revisión de cualquier pregunta a su entera discreción. Es posible que se le solicite volver a enviar una pregunta si el revisor ve problemas con la pregunta y tiene una solución clara para resolverlo. Esto puede incluir: Problemas conceptuales, como un detalle técnico en la raíz de la pregunta se asume o falta O, un caso de uso particular que invalida la pregunta O, si creen que hay una razón diferente para la pregunta que la mayoría de los expertos asumirían que es la mejor manera de evaluar el elemento objetivo. Una pregunta puede ser rechazada si el revisor no está de acuerdo fundamentalmente con la justificación de la pregunta como válida, o si cree que la investigación para solucionar la pregunta requiere un trabajo poco realista. Recibir pago Al final del proyecto de redacción de preguntas, recibirá una declaración de InterSystems con las preguntas aceptadas por los revisores internos. Recibirá el pago por los artículos aceptados dentro de los 30 días posteriores al final del proyecto de redacción. Si por alguna razón, solo se ha aceptado una parte del paquete de trabajo, recibirá una cantidad prorrateada del valor del paquete de trabajo. ¿Interesado en participar? ¡Envía un email a certification@intersystems.com ahora!

AnalyzeThis es una herramienta para obtener la vista previa de tus propios datos dentro de InterSystems BI. Te permite experimentar directamente con InterSystems BI y darte cuenta de la potencia y el valor que puede aportar a tu organización. Además de obtener una visión rápida de InterSystems BI mediante la importación de un fichero CSV con tus datos, también soporta ahora Clases y Consultas SQL como fuentes de datos (a partir de la versión v1.1.0!). En el Global Summit de 2018, AnalyzeThis (enlace al artículo original) se anunció y se liberó en InterSystems Open Exchange. La versión 1.1.0 está ahora disponible a través también de InterSystems Open Exchange. Esta versión añade como Fuentes de Datos soportadas tanto clases como consultas SQL. Esto te permite instalar AnalyzeThis en cualquier namespace existente y rapidamente seleccionar cualquier clase para comenzar a analizar y ver la visión que InterSystems BI puede dar a tu organización. Este artículo está etiquetado como "Mejores prácticas" ("Best practices"). Los artículos con la etiqueta "Mejores prácticas" incluyen recomendaciones sobre cómo desarrollar, probar, implementar y administrar mejor las soluciones de InterSystems.