/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Ansible es una herramienta de código abierto que automatiza el aprovisionamiento de software y facilita el despliegue de aplicaciones, la orquestación multi-nivel y la gestión de la configuración de las infraestructuras."
      }), "\n", _jsx(_components.p, {
        children: "Su uso está muy extendido y muchos fabricantes ofrecen playbooks de Ansible para facilitar la instalación de su software."
      }), "\n", _jsx(_components.p, {
        children: "Frente a otras soluciones del mercado que requieren la puesta en marcha de agentes en las máquinas de destino, Ansible utiliza princpalmente conexiones SSH para acceder a los servidores y realizar las tareas de instalación y configuración del software, lo que lo convierte en una herramienta compatible con cualquier servidor y no requiere la realización de tareas previas para su uso (más allá de garantizar estas conexiones por SSH)."
      })]
    });
  }
}
return {
  default: MDXContent
};


Ansible

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Problamente el proveedor cloud con mayor número de servicios y, habitualmente, el primero en ofrecer servicios que todavía no están disponibles en otros proveedores."
      }), "\n", _jsx(_components.p, {
        children: "Es el más maduro del mercado, ya que existe desde el 2002 y ofrece servicios en todos los ámbitos (Iaas, PaaS y SaaS)."
      }), "\n", _jsx(_components.p, {
        children: "Está muy orientado a la automatización, con lo que ofrece tanto un cli como una API Rest completa para poder realizar cualquier acción sin utilizar el interfaz."
      }), "\n", _jsx(_components.p, {
        children: "Esto también le permite disponer del mayor ecosistema de herramientas a su alrededor, ya sea implementadas por el propio Amazon o por terceros, ya que es el cloud con mayor adopción del mundo."
      }), "\n", _jsx(_components.p, {
        children: "También ofrece servicios para optimizar el uso de los servicios y ahorrar en costes, aunque el mayor ahorro de costes en Cloud es pagar sólo cuando lo utilices."
      }), "\n", _jsx(_components.p, {
        children: "No obstante, hay ciertos puntos de mejora: como su interfaz gráfico, ya que no es homogéneo a lo largo de todos los servicios, y la cantidad de servicios que ofrece para una misma tecnología con pequeños matices que los diferencian entre sí."
      }), "\n", _jsx(_components.p, {
        children: "Esto genera la necesidad de conocer muy bien sus servicios para poder decidir el más adecuado para cada necesidad de negocio."
      }), "\n", _jsx(_components.p, {
        children: "Sin duda, si quieres innovar con las últimas tecnologías, AWS es tu proveedor."
      })]
    });
  }
}
return {
  default: MDXContent
};


/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Azure es, a día de hoy, el segundo proveedor cloud con mayor número de servicios y, debido a las herramientas que ofrece y a la integración entre sus distintos servicios, una apuesta clara y estratégica de Microsoft para convertirse en el ecosistema preferido para los desarrolladores."
      }), "\n", _jsx(_components.p, {
        children: "Al igual que AWS ofrece servicios tanto IaaS, como PaaS, como SaaS, pero su principal punto fuerte son todas las herramientas para desarrolladores como Azure DevOps."
      }), "\n", _jsx(_components.p, {
        children: "Alineado con la estrategia de Microsoft de convertirse en el ecosistema preferido para los desarrolladores está integrando Azure con todo el stack ya existente para la comunidad de desarrolladores como Github, IDEs de desarrollo (Intellij, Visual Studio Code, ...) y, en general, con todas las herramientas que forman parte del ciclo de desarrollo del software."
      }), "\n", _jsx(_components.p, {
        children: "Sin duda, los esfuerzos de Microsoft en los últimos tiempo para convertir a Azure en una alternativa real a AWS en el ámbito empresarial han dado sus frutos y sus distintas alianzas para incrementar su catálogo de servicios auto gestionados lo ha convertido en una de las opciones más sencillas para dar el salto al cloud."
      }), "\n", _jsx(_components.p, {
        children: "Si estás buscando adoptar cloud para montar entornos de desarrollo con herramientas estandarizadas o en ir migrando servicios al cloud, Azure es tu opción."
      })]
    });
  }
}
return {
  default: MDXContent
};


Azure

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "A la hora de utilizar Elasticsearch como punto central para la indexación de distintas fuentes de datos, es importante tener clara cuál ser la estrategia para la ingesta de estos datos."
      }), "\n", _jsx(_components.p, {
        children: "Como parte de Elastic Stack, se distribuyen una serie de agentes ligeros que tienen la misión de recopilar información de distintos orígines para enviarlos a otra herramienta que se encargará de su procesamiento o almacenamiento."
      }), "\n", _jsx(_components.p, {
        children: "Debido a la gran integración que estos beats ofrecen con el resto del stack, especialmente en cuanto a su integración, configuración y la provisión de dashboards para Kibana listos para usar, consideramos que son la mejor opción para la ingesta de datos siempre que exista alguno que cumpla la función que buscamos."
      }), "\n", _jsx(_components.p, {
        children: "Actualmente, el catálogo de beats que forman parte del stack es: Filebeat (ingesta de datos a partir de fichero, generalmente, de logs), Packetbeat (lectura de paquetes de datos de red), Winlogbeat (log de eventos de windows), Metricbeat (ingesta y análisis de métricas de gran cantidad de origenes diferentes), Heartbeat (control de estado de la infraestructura y healthchecks), Auditbeat (lectura de datos de auditoría de Linux), Functionbeat (envío de datos basado en una arquitectura severless), Journalbeat (análisis de logs de Systemd y Journalctl)."
      })]
    });
  }
}
return {
  default: MDXContent
};


Beats

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Blockchain es la tecnología en la que se basan conocidas criptomonedas como Bitcoin o Ethereum."
      }), "\n", _jsx(_components.p, {
        children: "Pero Blockchain es mucho mas que eso."
      }), "\n", _jsx(_components.p, {
        children: "Permite que se manejen conjuntos enormes de datos distribuidos de manera fiable, como por ejemplo, secuencias de transacciones que requieren trazabilidad."
      }), "\n", _jsx(_components.p, {
        children: "Evidentemente, el caso de uso de las transacciones económicas es de aplicación directa, pero también lo son otras aplicaciones como trazabilidad en la cadena alimentaria o incluso la aplicación de sistemas verificables de comercio justo."
      }), "\n", _jsx(_components.p, {
        children: "Pese a la apariencia de inestabilidad debido a los movimientos especulativos que han llegado a la opinión pública, la tecnología en sí está evolucionando positivamente y cada vez es mejor la base teórica y las implementaciones concretas."
      }), "\n", _jsx(_components.p, {
        children: "Sin duda, es una tecnología que está aquí para quedarse."
      }), "\n", _jsx(_components.p, {
        children: "Adicionalmente, dado el crecimiento exponecial y la gran adopción que han tenido este tipo de tecnologías, es importante destacar que ya hay muchos proyectos basados en blockchain que tratan de cubrir soluciones y casos de uso concretos para el mercado, lo que facilita mucho la adopción de esta tecnología puesto que no es necesario partir de cero."
      }), "\n", _jsx(_components.p, {
        children: "Por ejemplo, podemos encontrar proyectos basados en blockchain que cubren necesidades tan específicas como la trazabilidad de mercancías, el streaming de video, ecommerce, gestión financiera, etc."
      }), "\n", _jsx(_components.p, {
        children: "Después de varios años en el punto de mira, consideramos que blockchain es una tecnología a tener en cuenta y que podríamos ir probando en casos de uso específicos donde la descentralización de la información o la seguridad del dato sean importantes."
      })]
    });
  }
}
return {
  default: MDXContent
};


Blockchain

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Estas siglas hacen referencia a Continuous Integration y Continuous Delivery."
      }), "\n", _jsx(_components.p, {
        children: "CI: Se basa en que los desarrolladores puedan actualizar sus cambios en el código frecuentemente."
      }), "\n", _jsx(_components.p, {
        children: "Esto simplifica el proceso de fusión con el código de otros desarrolladores del equipo."
      }), "\n", _jsx(_components.p, {
        children: "Tras esta se validan los cambios y se ejecutan pruebas de manera automática con el objetivo de evitar errores tras cada evolutivo."
      }), "\n", _jsx(_components.p, {
        children: "Esto simplifica el proceso de desarrollo en equipos distribuidos y asegura la calidad del software entregado."
      }), "\n", _jsx(_components.p, {
        children: "CD: Se trata de realizar entregas automatizadas de las releases desarrolladas."
      }), "\n", _jsx(_components.p, {
        children: "Tras la ejecución de la fase de CI, el CD se encarga de automatizar el despliegue del código validado al entorno correspondiente de la infraestructura."
      }), "\n", _jsx(_components.p, {
        children: "Creemos que es muy buena práctica en el desarrollo del software, ya que automatiza las tareas relacionadas con el despliegue de una aplicación y se reduce el tiempo que transcurre desde que el código es validado hasta que es desplegado en un entorno, mejorando time to market y reduciendo posibles errores."
      }), "\n", _jsx(_components.p, {
        children: "Además, todos los procesos de CI/CD aparecen hoy en día muy ligados a la metodología DevOps, y hay gran cantidad de herramientas que nos ayudarán a poner en marcha todo este sistema a partir de una buena gestión de versionado de nuestro código."
      })]
    });
  }
}
return {
  default: MDXContent
};


CI/CD

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p",
      ul: "ul",
      li: "li"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Plataforma de streaming de eventos basada en Kafka, formada por los creadores y manteiners de Kafka, pero con visión empresarial."
      }), "\n", _jsx(_components.p, {
        children: "Su punto fuerte es complementar kafka con herramientas que ayuden al gobierno, la monitorización, las operaciones, las integraciones y faciliten la implementación de disitntos patrones sobre arquitecturas de eventos."
      }), "\n", _jsx(_components.p, {
        children: "Ofrece estas capacidades tanto con licencias Open Source, como con licencias propietarias, además de ofrecer servicios de soporte sobre kafka."
      }), "\n", _jsx(_components.p, {
        children: "De todas las herramientas con las que generar la plataforma de eventos, podemos destacar: - Automatización de Operaciones: Ofrece playbooks de ansible, helm charts, operadores de kubernetes y un SaaS completamente adminsitrado denominado Confluent Cloud."
      }), "\n", _jsxs(_components.ul, {
        children: ["\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Escalabilidad: Ofrece auto balanceo del clúster para mejorar el rendimiento, también ofrece almacenamiento 'infinito' permitiendo llevar los mensajes más antiguos a almacenamientos masivos, como s3, Google cloud Storage o Object Storage."
          }), "\n"]
        }), "\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Aceleradores de desarrollo: Ofrece clientes no java para conectar con Kafka y ksqlDB (que permite implementar aplicaciones de stremaing utilizando sintaxis SQL) - Optimización de la interoperablidad: Ofrece un repositorio de esquemas (contratos) centralizado que soporta los formatos Avro, Protobuff y Json Schema."
          }), "\n"]
        }), "\n"]
      }), "\n", _jsx(_components.p, {
        children: "También ofrece unos 100 conectores, que permiten importar datos a kafka desde distintos orígenes o exportar datos desde kafka a otros almancenamientos."
      }), "\n", _jsxs(_components.ul, {
        children: ["\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Seguridad: Habilita el uso de roles para configurar los accesos, permite el cifrado de secretos e implementa logs de auditoría para conocer los accesos que se realizan sobre los datos."
          }), "\n"]
        }), "\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Resiliencia global: Ofrece herramienta para la réplica de datos, permite la creación de clústers en múltiples Datacenters/regiones cloud y habilita la creación de clústers híbridos entre el cloud y el CPD."
          }), "\n"]
        }), "\n"]
      }), "\n", _jsx(_components.p, {
        children: "Si estás pensando en implementar casos de uso en streaming en tiempo real o que gestionen grandes volúmenes de datos, Confluent es la plataforma adecuada para ello y, por nuestra experiencia, una de las más recomendadas por su flexibilidad para adaptarse a casi todos los casos de uso y su rendimiento para la ingesta y transformación de datos en tiempo real."
      })]
    });
  }
}
return {
  default: MDXContent
};


Confluent

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Contentful es una herramienta CMS para producir, administrar y publicar contenidos de forma sencilla en cualquier web."
      }), "\n", _jsx(_components.p, {
        children: "Proporciona un conjunto de APIs REST que permiten tanto enviar contenido a través de varias plataformas (sitios web, aplicaciones móviles, etc.) como consumirlo, gestionar usuarios, etc."
      }), "\n", _jsx(_components.p, {
        children: "Además, proporciona una API GraphQL para consultar tanto contenidos publicados como los que todavía no lo están, lo que lo convierte en una herramienta muy potente."
      }), "\n", _jsx(_components.p, {
        children: "Todo esto sumado a la usabilidad de la plataforma, ya que tiene un diseño muy sencillo de utilizar, hace que sea una opción muy recomendada a la hora de gestionar diversos tipos de contenidos y documentos, donde se necesite flexibilidad y libertad para diseñar y desarrollar la interfaz de usuario."
      })]
    });
  }
}
return {
  default: MDXContent
};


Contentful

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "DevOps es un término que surge de Development y Operations."
      }), "\n", _jsx(_components.p, {
        children: "Se trata de una metodología basada en potenciar la integración entre desarrolladores de software y administradores de sistemas con el objetivo de mejorar la calidad y la velocidad de las entregas."
      }), "\n", _jsx(_components.p, {
        children: "Además de los equipos, también se combinan procesos y tecnologías utilizadas por ambos."
      }), "\n", _jsx(_components.p, {
        children: "Busca mejorar la comunicación entre estos equipos (llegando incluso a fusionarse en todo el ciclo de vida de la aplicación), ya que incrementado la comunicación, los desarrolladores pueden centrarse en su punto fuerte, la implementación de código, y a su vez poder desplegar sus versiones de la manera más ágil posible aprovechando la colaboración del equipo de operaciones."
      }), "\n", _jsx(_components.p, {
        children: "La idea final de esta metodología, es que cada equipo pueda ser autosuficiente para gestionar todo el ciclo de vida del software y, de esta manera, evitar bloqueos por depender de otros equipos, áreas o departamentos que trabajen de manera transversal para todos los equipos y que, por tanto, tengan unas prioridades diferentes."
      }), "\n", _jsx(_components.p, {
        children: "Por esta misma razón, esta metodología siempre ha estado muy ligada a la idea de automatizar todo tipo de tareas, con todos los beneficios que ello conlleva, no sólo por la velocidad que se puede ganar en cualquier tipo de proceso, sino también por la disminución del número de errores humanos."
      }), "\n", _jsx(_components.p, {
        children: "Es este sentido, es muy recomendable adoptar cuantas buenas prácticas se pueda de esta metodología."
      })]
    });
  }
}
return {
  default: MDXContent
};


DevOps

Digital Accelerator Program

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Elastic Stack es un conjunto de herramientas open source que permiten transformar, indexar, buscar y visualizar datos: Elasticsearch: motor de búsquedas distribuido construido sobre Apache Lucene."
      }), "\n", _jsx(_components.p, {
        children: "Permite indexar y recuperar documentos JSON."
      }), "\n", _jsx(_components.p, {
        children: "Está basado en Java y proporciona un interfaz RESTFUL de acceso."
      }), "\n", _jsx(_components.p, {
        children: "Destaca por su facilidad de escalado y capacidad de resolver búsquedas distribuidas."
      }), "\n", _jsx(_components.p, {
        children: "Logstash: herramienta que permite recolectar datos de distintas fuentes, normalizarlos y distribuirlos."
      }), "\n", _jsx(_components.p, {
        children: "Beats: familia de agentes muy ligeros que recolectan datos en hosts o servidores y los envían a Elasticsearch."
      }), "\n", _jsx(_components.p, {
        children: "Kibana: herramienta que permite visualizar y explorar datos que se encuentran indexados en Elasticsearch."
      }), "\n", _jsx(_components.p, {
        children: "Si bien en su nacimiento Elasticsearch se presentaba como una solución para mejorar la experiencia de los usuarios al realizar búsquedas, dada su potencia para gestionar y analizar grandes volúmenes de datos, con el tiempo se ha posicionado más como una herramienta de ingesta y analítica de datos, explotando el número de casos de uso en que puede ser incorporado: analítica de logs, SIEM, APM, Machine learning, etc."
      }), "\n", _jsx(_components.p, {
        children: "Gracias a su evolución, y al incremento en sus casos de usos, podemos considerar el stack de Elastic como como una solución muy completa que puede cubrir casi cualquier tipo de necesidad relacionada con la analítica y gestión de logs, monitorización de aplicaciones y solución de búsqueda."
      })]
    });
  }
}
return {
  default: MDXContent
};


Elastic Stack

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Elasticsearch es un motor de indexación de todo tipo de datos flexible y escalable."
      }), "\n", _jsx(_components.p, {
        children: "Tras su nacimiento, se presentó inicialmente como una solución rápida y fiable para la localización de datos, especialmente, textuales."
      }), "\n", _jsx(_components.p, {
        children: "Sin embargo, con el paso del tiempo, ha demostrado que tiene grandes capacidades para realizar analítica sobre todo tipo de datos, abriendo de manera notable los casos de uso que es capaz de cubrir: analítica de grandes volúmenes de datos, soluciones SIEM, analítica de logs, operaciones de machine learning, monitorización de hardware y software, apm y un largo etcétera."
      }), "\n", _jsx(_components.p, {
        children: "Por todo ello, consideramos que Elasticsearch es una apuesta segura en muchos ámbitos empresariales, ya que su flexibilidad y potencia hace que pueda encajar en gran catidad de casos de uso, mucho más allá de ofrecer una solución de búsqueda de datos y rivalizando en muchas ocasiones con herramientas y soluciones que están muy alejadas de las funciones que incialmente podemos atribuir a un motor de indexación."
      }), "\n", _jsx(_components.p, {
        children: "Sin duda alguna, si entre tus objetivos está la de tener un motor de búsqueda o realizar analítica de datos en tiempo real, Elasticsearch debe ser una de las opciones a tener en cuenta"
      })]
    });
  }
}
return {
  default: MDXContent
};


Elasticsearch

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "El uso de metodologías de ideación rápida está cada vez más extendido, por lo que cada vez es más habitual la realización de workshops que fomenten el uso de las mismas."
      }), "\n", _jsx(_components.p, {
        children: "Event Storming es otra de las metodologías que busca ayudarnos en estos workshops, pero focalizado en evitar silos, ayudando en la definición de modelos de datos, la identificación de los actores involucrados, los eventos que desencadenan las relaciones entre los actores y los servicios y la perioricidad de los mismos."
      }), "\n", _jsx(_components.p, {
        children: "En un momento en el que las arquitecturas orientadas a eventos cada vez están más extendidas, Event Storming trata de identificar los eventos de negocio que generan las interacciones entre los distintos departamentos de una organización y los datos que se necesitan en dichas interacciones, para ayudarnos a entender nuestros procesos de negocio y cómo se relacionan entre ellos, basado en que cada evento desencadena una serie de acciones y estas acciones afectan a ciertos actores."
      }), "\n", _jsx(_components.p, {
        children: "Por ejemplo, el evento de llegar a final de mes, desencadena la acción de pagar la nómina a todos los empleados de nuestra organización."
      }), "\n", _jsx(_components.p, {
        children: "Sin duda, la metodología de Event Storming, facilita el alineamiento entre personal técnico y no técnico al utilizar un lenguaje cotidiano para identificar las necesidades, elimina los silos al proponer sesiones en el que participen todos los departamentos involucrados y lo enfoca desde un punto de vista cotidiano, ya que son los eventos que se producen en nuestro negocio los que guían el workshop."
      }), "\n", _jsx(_components.p, {
        children: "Sin duda, si tienes silos en tu organización, dificultades para alinear al personal técnico y no técnico y estás orientando tu organización hacia arquitecturas orientadas a eventos, event storming es una de las metodologías que te ayudarán a resolver esta problemática y tener éxito en la implantación de estas soluciones."
      })]
    });
  }
}
return {
  default: MDXContent
};


Event Storming

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Flowable proporciona un conjunto básico de motores de procesos empresariales de código abierto que son compactos y altamente eficientes."
      }), "\n", _jsx(_components.p, {
        children: "Estos motores proporcionan una plataforma de flujo de trabajo y gestión de procesos empresariales (BPM) para desarrolladores, administradores de sistemas y usuarios de negocio."
      }), "\n", _jsx(_components.p, {
        children: "Su núcleo es un motor de procesos BPMN dinámico, rápido y probado."
      }), "\n", _jsx(_components.p, {
        children: "Además, cuenta con tablas de decisión DMN y un motor de gestión de casos CMMN, todo ello escrito en Java."
      }), "\n", _jsx(_components.p, {
        children: "Todo el código de los motores se distribuye como código abierto con licencia Apache 2.0, con una comunidad comprometida y en constante crecimiento."
      }), "\n", _jsx(_components.p, {
        children: "La principal ventaja que ofrece Flowable frente a productos de su mismo ámbito, es que está centrado en la automatización inteligente, lo que genera un equilibrio perfecto entre la facilidad de desarrollo e integración con prácticamente cualquier sistema y el disponer de un conjunto de herramientas orientadas a personal no técnico, que permiten modelar casos de negocio flexibles y adaptados a cualquier empresa del sector."
      }), "\n", _jsx(_components.p, {
        children: "Adicionalmente a la versión Open Source, Flowable también dispone una versión licenciada que ofrece soporte y añade la implementación de herramientas Low Code, para facilitar el modelado de los procesos y casos de negocio por personal no técnico, así como integración con los principales sistemas de mensajería (WhatsApp, WeChat, ...) para una comunicación directa con los usuarios finales."
      }), "\n", _jsx(_components.p, {
        children: "Sectores con procesos fuertemente definidos y/o que integran diferentes actores, como la banca, administraciones públicas, compañías de seguros, empresas de streaming de vídeo, ..."
      }), "\n", _jsx(_components.p, {
        children: ", están apostando por esta herramienta para la digitalización y automatización de sus procesos, reduciendo ampliamente el tiempo necesario para completarlos."
      }), "\n", _jsx(_components.p, {
        children: "Si quieres que tu informática modele tus casos de negocio, Flowbale debe ser una de las herramientas a considerar para llevar a cabo la digitalización de tu organización"
      })]
    });
  }
}
return {
  default: MDXContent
};


Flowable

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Google Cloud Vision es la solución de pago por uso que ofrece Google Cloud Platform y que permite añadir la capacidad de reconomiento visual a las aplicaciones a través de una API."
      }), "\n", _jsx(_components.p, {
        children: "Permite hacer reconocimiento de objetos, textos, etiquetar contenido explícito y detección de caras mediante el un API que se utiliza un modelo ya entrenado por Google y que es el mismo en el que se basan servicios como Google AR, por lo que se mantiene entrenado y actualizado constantemente."
      }), "\n", _jsx(_components.p, {
        children: "Nosotros lo hemos probado con casos de uso como la automatización de lectura de nóminas para validar de forma automáticamente ciertos procesos administrativos."
      }), "\n", _jsx(_components.p, {
        children: "En este punto hemos visto que el servicio de OCR funciona muy bien, pero es responsabilidad de la aplicación saber identificar cual es el importe de la nómina que queremos evaluar."
      }), "\n", _jsx(_components.p, {
        children: "Aun así nuestra valoración es que se puede empezar a probar este servicio, tal cual lo ofrece google Cloud Platform sin necesidad de disponer ded científicos de datos, para casos de uso sencillos como la automatización de la lectura de ciertos documentos, matrículas, ..."
      })]
    });
  }
}
return {
  default: MDXContent
};


Google Cloud Vision

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "La última versión del modelo de lenguaje de OpenAI, GPT-3, ha supuesto una revolución en cuanto a las capacidades de este tipo de tecnologías, ya que no sólo es capaz de entender lo que se le solicita, sino que también es capaz de crear soluciones basadas en estas peticiones: desde crear páginas web o aplicaciones en función de una descripción previa, hasta charlar sobre criptomonedas o películas."
      }), "\n", _jsx(_components.p, {
        children: "Dadas las opciones que ofrece este modelo, es recomendable mantener vigilada su evolución, tanto por las opciones que ofrece y la gran cantidad de usos en los que podría derivar, como para tener una idea clara de cómo evoluciona la tecnología en este sentido (bien sea con GPT-3 o con otros tecnologías similares)."
      }), "\n", _jsx(_components.p, {
        children: "Nuestra recomendación sería empezar a hacer algún ensayo con esta solución para ver cómo puede ayudar a mejorar a tu negocio."
      }), "\n", _jsx(_components.p, {
        children: "Tal vez en este momento, podría ser una gran herramienta de marketing y se podría integrar en tus flujos conversacionales"
      })]
    });
  }
}
return {
  default: MDXContent
};


GPT3

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "GraphQL es un lenguaje de consultas para APIs construido por Facebook que permite construir APIs rompiendo con los estándares REST en el que cada URL representa un recurso distinto."
      }), "\n", _jsx(_components.p, {
        children: "GraphQL se basa en la exposición de un único endpoint que al ser llamado con este lenguaje, es capaz de responder en una única petición con la información exacta que está siendo solicitada, evitando así tener que hacer más de una petición a distintos endpoints para obtener la misma información, u obtener más campos sobre algún recurso solicitado de los que realmente se necesitan."
      }), "\n", _jsx(_components.p, {
        children: "Por ejemplo, si queremos obtener 3 entidades distints con REST, deberíamos hacer 3 peticiones, sin embargo, GraphQL nos da la posibilidad de obtener las 3 entidades con una sola petición."
      }), "\n", _jsx(_components.p, {
        children: "Si se busca reducir el número de endpoints expuestos, y reducir el tamaño de las respuestas, sin duda GraphQL tiene ventajas frente al tradicional REST."
      }), "\n", _jsx(_components.p, {
        children: "Tabmién es mucho más flexible al no tener que ajustar el backend si una aplicación necesita más o menos campos de cierta entidad, y al ser un lenguaje fuertemente tipado ofrece una ventaja importante que es que la documentación del modelo de datos es autogenerada sobre el contrato definido."
      })]
    });
  }
}
return {
  default: MDXContent
};


GraphQL

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Tras la explosión de las arquitecturas de microservicios, empezaron a salir soluciones que cubriesen todas las necesidades que caracterizan a los sistemas distribuidos, como el Service Registry para identiifcar cuantas instancias hay de un servicio, balanceadores que permitan enrutar las peticiones a la instancia correspondiente del servicio, soluciones de circuit breaker para desacoplar los microservicios entre sí y gestionar la indisponibilida de uno de ellos, adoptar estándares para la trazabilidad distribuida, observabilidad, etc."
      }), "\n", _jsx(_components.p, {
        children: "Pero estas soluciones se implementaron a nivel de software, por lo que en un entorno de microservicios políglotas (con microservicios implementados con pyhton, otros con java, ...) cada microservicios utilizaba su propia solución, incluso para el mismo lenguaje, podían haber soluciones distintas."
      }), "\n", _jsx(_components.p, {
        children: "Una vez kubernetes se adoptó como la solución de infraestructura por excelencia de las arquitecturas de microservicios, apareció la solución de Service Mesh, que trasladaba a la infraestructura estas piezas, por lo que aligera los microservicios, al eliminar elementos software y permite aprovechar al máximo esta infraestructura."
      }), "\n", _jsx(_components.p, {
        children: "Istio es la solución más adoptada como Service Mesh, es Open Source, está implementada mayoritariamente por Google (al igual que kubernetes) y la ofrecen los principales proveedores cloud, tanto pública como privada , dentro de sus servicios gestionados de kubernetes (Azure, Google Cloud Platform, Open Shift, ...) Es una herramienta necesaria si estás implementando microservicios sobre kubernetes, combinas múltiples lenguajes de programación dentro de tu ecosistema y si buscas arquitecturas de microservicios operadas de forma híbrida, tanto en tu CPD y en Cloud."
      })]
    });
  }
}
return {
  default: MDXContent
};


Istio

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Poco a poco, Kafka se ha ido convirtienda en la solución preferida de muchos para todos los temas relacionados con el streaming de datos."
      }), "\n", _jsx(_components.p, {
        children: "Lo que inicialmente era entendido como una cola, o una implementación de un pub/sub pensado para mover grandes volúmenes de información, se ha ido convirtiendo en una solución capaz de ofrecer datos procesados en real time a múltiples fuentes de manera flexible y confiable y con unas capacidades que pocas otras tecnologías han conseguido alcanzar."
      }), "\n", _jsx(_components.p, {
        children: "Debido a estas capacidades y a la gran cantidad de herramientas satélite con las que contamos alrededor de Kafka (Kafka Streams, KSQLDB, Schema Registry, Confluent Replicator, etc.) resulta muy difícil localizar competidores en el mercado o realizar comparativas con herramientas de terceros, ya que llega donde la mayoría de herramientas no lo hacen."
      }), "\n", _jsx(_components.p, {
        children: "Por tanto, nuestra elección es clara al recomendar el uso de Kafka para todos los casos en que sea necesario realizar steaming de datos a otras plataformas, especialmente, en aquellas situaciones donde, además, sea neceario procesar, normalizar o enriquecer los datos recibidos."
      })]
    });
  }
}
return {
  default: MDXContent
};


Kafka

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Kafka Connect es el API que ofrece Kafka para implementar los patrones Source, Processor y Sink para integrar tus datos hacia y desde kafka."
      }), "\n", _jsx(_components.p, {
        children: "Además de ofrecer el API, existen un conjunto de conectores ya implementados que permiten integrar con los principales motores de almacenamiento de datos, ya sea para extraer los datos o para enviarlos."
      }), "\n", _jsx(_components.p, {
        children: "El abanico de conectores existentes es muy amplio, tanto bajo licencia Open Source como con licencias propietarias."
      }), "\n", _jsx(_components.p, {
        children: "El rápido crecimiento del número de conectores más su diseño concebido para la escalabilidad y el procesado de grandes volúmenes de datos, lo convierten en una herramienta muy utilizada para integrar Kafka en tu organización sin tener que reimplementar tus aplicaciones existentes."
      }), "\n", _jsx(_components.p, {
        children: "La solución de Kafka Connect funciona perfectamente en entornos de kubernetes como con máquinas virtuales, estando preparada para trabajar en alta disponibilidad y, por tanto, para uso en producción."
      }), "\n", _jsx(_components.p, {
        children: "Nuestra experiencia nos recomienda utilizarla, pero se debe hacer mucho foco en la resiliciencia, ya que los conectores se detienen ante cualquier error en el acceso al origen o destino de datos, lo que puede generar que dejen de integrarse datos, y dependiendo de cada caso de uso, la solución puede ser distinta."
      }), "\n", _jsx(_components.p, {
        children: "Para solucionar esta necesidad hay que implementar un buen mecanismo de monitorización, apoyado en el API que ofrece Kafka Connect, para poder implementar un mecanismo de recovery que cubra las necesidades de negocio o un alertado adecuado para actuar cuando se produzca un error."
      }), "\n", _jsx(_components.p, {
        children: "Otra de las características por las que lo ponemos en trial, es porque los conectores no permiten hacer excesivas transformaciones de los datos, sólo filtrar qué campos se cargan, qué campos forman la clave y cambios entre formatos (AVRO, json y protobuff), aunque en clases personalizadas se podrá hacer algún cambio más complejo."
      }), "\n", _jsx(_components.p, {
        children: "Desde luego, si vas a empezar un nuevo proyecto en el que quieras integrar datos existentes sobre kafka, los conectores te ayudarán a implementar más rápidamente tu solución"
      })]
    });
  }
}
return {
  default: MDXContent
};


Kafka Connect

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "La principal funcionalidad de Kibana es la de proporcional una capa visual para consultar de forma gráfica los datos almacenados en Elasticsearch."
      }), "\n", _jsx(_components.p, {
        children: "No obstante, con el paso del tiempo, esta pieza ha ido adquiriendo cada vez más valor, y se ha ido convirtiendo en el centro de control que sirve de nexo de unión entre todas las piezas del stack de Elastic y desde el que se puede, no solo consultar los datos indexados, sino también configurar y monitorizar el resto de piezas que forman Elastic Stack."
      }), "\n", _jsx(_components.p, {
        children: "Algunas de las funcionalidades que ofrece son: gestión de los índices y sus políticas, creación y mantenimiento de plantillas de índices, gestión de permisos, creación y modificación de alertas, control de los trabajar de Machine Learning, etc."
      }), "\n", _jsx(_components.p, {
        children: "Adicionalmente, se incorporan también en Kibana una serie de visualizaciones y dashboards que facilitan el acercamiento a la herramienta con soluciones ya predefinidas."
      }), "\n", _jsx(_components.p, {
        children: "Por tanto, Kibana es una pieza que se ha vuelto casi imprescindible y recomendamos su adopción para trabajar con Elastic Stack."
      })]
    });
  }
}
return {
  default: MDXContent
};


Kibana

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Kubernetes (K8s) es el sistema creado por Google y liberado como código abierto para orquestar los despliegues, escalado y gestión de aplicaciones basadas en contenedores."
      }), "\n", _jsx(_components.p, {
        children: "La dirección del proyecto está en manos de la Cloud Native Computing Foundation, una organización independiente en la que colaboran los principales gigantes de la industria."
      }), "\n", _jsx(_components.p, {
        children: "K8s ha cambiado radicalmente la forma de relacionarse con las aplicaciones."
      }), "\n", _jsx(_components.p, {
        children: "Ha supuesto un salto cualitativo en muchos sentidos: escalabilidad, estabilidad, compatibilidad, reducción de costes, etc."
      }), "\n", _jsx(_components.p, {
        children: "Debido a su gran versatilidad, aunque nació junto con las arquitecturas de microservicios, se está desarrollando dando cabida a otros tipos de arquitectura como las arquitecturas basadas en funciones."
      })]
    });
  }
}
return {
  default: MDXContent
};


Kubernetes

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p",
      ul: "ul",
      li: "li"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Liferay DXP (Digital Experience Platform) es un gestor de portales open source desarrollado en Java."
      }), "\n", _jsx(_components.p, {
        children: "Sirve para construir desde sitios pequeños hasta portales grandes y flexibles."
      }), "\n", _jsx(_components.p, {
        children: "Las principales ventajas de Liferay DXP son: * Ofrece una gestión de usuarios, roles y permisos de grano muy fino."
      }), "\n", _jsx(_components.p, {
        children: "Además, out-of-the-box tiene integración con LDAP, SAML, OpenId, OAuth, etc."
      }), "\n", _jsxs(_components.ul, {
        children: ["\n", _jsx(_components.li, {
          children: "Tiene una interfaz de usuario muy amigable que hace que la gestión de portales sea fácil e intuitiva."
        }), "\n"]
      }), "\n", _jsx(_components.p, {
        children: "Cada sitio web/portal tiene su propia gestión de contenidos, documentos, categorías, etc."
      }), "\n", _jsxs(_components.ul, {
        children: ["\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Ofrece gran variedad de componentes out-of-the-box, por tanto, podemos crear nuestros sitios web rápidamente."
          }), "\n"]
        }), "\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Muy flexible, permite integrarse con sistemas de terceros con gran facilidad."
          }), "\n"]
        }), "\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Proporciona soporte para los frameworks JavaScript más populares, como Angular, Vue.js o React y los flujos de trabajo de JavaScript modernos con npm."
          }), "\n"]
        }), "\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Ofrece una API headless que sigue la especificación OpenAPI."
          }), "\n"]
        }), "\n"]
      }), "\n", _jsx(_components.p, {
        children: "Esto nos permite consumir las APIs sin estar atado a la UI de Liferay DXP, ofreciendo gran libertad a la hora de diseñar y desarrollar las aplicaciones."
      }), "\n", _jsxs(_components.ul, {
        children: ["\n", _jsx(_components.li, {
          children: "Tiene una gran comunidad de usuarios que colaboran entre sí para aportar ideas de mejoras de productos y compartir sus experiencias."
        }), "\n"]
      }), "\n", _jsx(_components.p, {
        children: "Además, Liferay ha incrementado los productos que ofrece para abordar las necesidades de sus clientes."
      }), "\n", _jsx(_components.p, {
        children: "Entre sus productos también destacan Liferay DXP Cloud, Liferay Analytics Cloud y Liferay Commerce."
      })]
    });
  }
}
return {
  default: MDXContent
};


Liferay

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Logstash es una herramienta ETL que permite leer datos de múltiples fuentes de entrada, procesarlos y enviarlos por diversas salidas."
      }), "\n", _jsx(_components.p, {
        children: "Dentro del stack de Elastic tiene mucho potencial debido a sus integración directa con Beats (como fuente de entrada) y Elasticsearch (como destino de los datos)."
      }), "\n", _jsx(_components.p, {
        children: "No obstante, dentro del stack de Elastic, es posible que Logstash sea la pieza más prescindible de todas."
      }), "\n", _jsx(_components.p, {
        children: "Por un lado, con otras herramientas dentro del propio stack pueden realizarse algunas de las tareas que tradicionalmente se venían realizando desde Logstash: por ejemplo, el enriquecimiento de los datos directamente en los beats, o el procesamiento de los mismos a través de pipelines en nodos de ingesta de Elasticsearch."
      }), "\n", _jsx(_components.p, {
        children: "Por otro lado, hay otras herramientas ETL dentro del mercado que podrían realizar la misma función (como sería el caso de Apache NIFI)."
      }), "\n", _jsx(_components.p, {
        children: "Y, por último, porque en gran cantidad de ocasiones, debido a la alta carga de datos y a las pocas opciones que ofrece Logstash para trabajar en modo cluster, se opta por herramientas intermedias para pasar los datos entre las fuentes origen y Logstash (herramientas como Redis o Kafka)."
      }), "\n", _jsx(_components.p, {
        children: "En este tipo de arquitecturas, la necesidad de incluir Logstash se hace más dudosa, ya que, por ejemplo, se puede optar por utilizar Kafka para todo este procesamiento: a través de Kafka Streams o KSQLDB para el procesamiento de los datos, y Kafka Connect para su almacenamiento en Elasticsearch."
      }), "\n", _jsx(_components.p, {
        children: "Es por eso que, aunque Logstash ofrece una gran integración dentro del stack de Elastic, nuestra recomendación es utilizarla únicamente en aquellos casos en que las funcionalidades que aporta no puedan ser sustituidas por otras herramientas que ya formen parte de nuestra solución."
      })]
    });
  }
}
return {
  default: MDXContent
};


Logstash

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Low code es un paradigma de desarrollo de aplicaciones que se basa en desarrollo primordialmente visual."
      }), "\n", _jsx(_components.p, {
        children: "Para conseguirlo se emplean abstracciones que son entendibles por el usuario de negocio, reduciendo la brecha con los detalles de la implementación."
      }), "\n", _jsx(_components.p, {
        children: "Para manejar estas abstracciones se utilizan modelos que representan los objetos de negocio y que pueden evolucionar conforme avanza el desarrollo que se quiere llevar a cabo (model-driven development)."
      }), "\n", _jsx(_components.p, {
        children: "Low code se diferencia de 'No-code' en su falta de empeño de enmascarar la implementación subyacente."
      }), "\n", _jsx(_components.p, {
        children: "De hecho, las mejores plataformas low code permiten que los usuarios de negocio sean capaces de ir adaptando las aplicaciones mediante métodos de alto nivel y que al mismo tiempo los programadores sean capaces de 'bajar al código' e implementar cualquier funcionalidad por compleja que sea, manteniendo la estabilidad general de la solución.Este paradigma se está adoptando ampliamente en las organizaciones para acelerar la implementación de aplicaciones transversales y de negocio."
      }), "\n", _jsx(_components.p, {
        children: "Nuestra experiencia nos muestra que se empieza adoptando para reemplazar las aplicaciones desarrolladas con herramientas ofimáticas (como Access, Excel, ...) y pronto se empieza a utilizar para el desarrollo de MVPs de forma muy ágil, para validar el aporte que ofrecen a negocio."
      }), "\n", _jsx(_components.p, {
        children: "El principal inconveniente que ofrecen este tipo de herramientas, es que, habitualmente, no ofrecen flexibilidad para fuertes personalizaciones y, en caso de necesitar desarrollar código, no suelen ofrecer soluciones que faciliten la gestión del código ni la reutilización del mismo."
      }), "\n", _jsx(_components.p, {
        children: "También encontramos cierta difcultad para integrar este tipo de herramientas con las soluciones core de las organizaciones, ya sea porque los mecanismos de integración ofrecidos por las aplicaciones core no están soportados por las herramientas Low Code o bien porque hay requerimientos de seguridad no estánderes que impiden la integración."
      }), "\n", _jsx(_components.p, {
        children: "Si quieres acelerar la implementación de tus MVPs en todos tus dispositivos (Desktop, tablet y móvil) este paradigma es una gran opción."
      })]
    });
  }
}
return {
  default: MDXContent
};


Lowcode

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Si bien el concepto de Machile Learning no es algo novedoso de los últimos tiempos, sí que lo es la gran acogida y adopción que ha tenido debido a la explosión de tecnologías que hacen uso de técnicas de Machine Learning y, de manera más notable, por su incorporación en muchos procesos y tecnologías que nos acompañan día a día."
      }), "\n", _jsx(_components.p, {
        children: "Los casos de uso donde podemos encontrar incorporadas técnicas y algoritmos de machine learning a día de hoy son múltiples: procesamiento de imagen, video o audio, detección de anomalías al analizar datos, juegos, análisis del comportamiento humano, predicciones, procesamiento del lenguaje natural, vehículos inteligentes, recomendaciones, medicina y un largo etcétera."
      }), "\n", _jsx(_components.p, {
        children: "Por tanto, la pregunta que debemos hacernos hoy en día no es si debo apostar por soluciones basadas en Machine Learning, sino más bien, cómo me pueden ayudar este tipo de técnicas en el desarrollo de mis soluciones."
      }), "\n", _jsx(_components.p, {
        children: "Nuestra recomendación en este ámbito es acelerar la incorporación utilizando modelos ya entrenados por productos (como Elsaticsearch) o los principales proveedores cloud, para beneficiarse rápidamente de este tipo de soluciones y mejorar nuestro negocio de una forma ágil"
      })]
    });
  }
}
return {
  default: MDXContent
};


Machine Learning

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p",
      ul: "ul",
      li: "li"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Magnolia es un CMS (Content Management System) desarrollado en Java y open source."
      }), "\n", _jsx(_components.p, {
        children: "Magnolia destaca por las siguientes características: * Interfaz intuitiva y sencilla, orientada a que los equipos de Marketing puedan ser independientes de TI."
      }), "\n", _jsxs(_components.ul, {
        children: ["\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Permite integrar fácilmente distintas software como comercio electrónico, analítica, automatización de marketing, redes sociales, CRM y ERP."
          }), "\n"]
        }), "\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Front-end agnóstico: proporciona soporte para los frameworks JavaScript más populares."
          }), "\n"]
        }), "\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Es una empresa de “nicho” de CMS, es decir, se centra en mejorar y ampliar las necesidades del CMS."
          }), "\n"]
        }), "\n"]
      }), "\n", _jsx(_components.p, {
        children: "Algunos puntos de mejora son: * No cuenta con una gran comunidad, su comunidad es activa pero pequeña."
      }), "\n", _jsxs(_components.ul, {
        children: ["\n", _jsx(_components.li, {
          children: "No tiene un marketplace amplio que permita reutilizar desarrollos."
        }), "\n"]
      })]
    });
  }
}
return {
  default: MDXContent
};


Magnolia

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Pair programming es una metología basada en que 2 desarrolladores de software trabajen sobre el mismo código con el objetivo de reducir el número de errores y mejorar la creatividad."
      }), "\n", _jsx(_components.p, {
        children: "Esta metodología hace que uno de los programadores tome el rol de 'piloto' y que sea el que implementa el software, mientras que el otro 'copiloto' revisa el código que está siendo implementado."
      }), "\n", _jsx(_components.p, {
        children: "Estos roles deben de ir cambiando cada poco tiempo."
      }), "\n", _jsx(_components.p, {
        children: "Por normal general, los 2 desarrolladores deben de estar sentados juntos y colaborar de manera estrecha tratando de entregar código de mayor calidad."
      }), "\n", _jsx(_components.p, {
        children: "Esta metodología es a veces utilizada para compartir experiencia con desarrolladores de diferente nivel y es posible que sea en estos casos cuando muestra más potencial, aunque en ocasiones puede ser sustituida por procesos de revisiones de código."
      }), "\n", _jsx(_components.p, {
        children: "Si bien utilizar esta metodología durante todo el proceso de desarrollo puede resultar poco productivo, esta metodología es muy eficiente tanto en momentos iniciales de desarrollo de un nuevo proyecto o una nueva funcionalidad, buscando que se distribuya entre los miembros del equipo tanto la solución a implementar como una serie de buenas prácticas a seguir, como en procesos de transferencia de conocimiento, onboarding de nuevas personas al equipo, o incluso en fases de solución de errores."
      })]
    });
  }
}
return {
  default: MDXContent
};


Pair Programming

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Quarkus es un framework creado por RedHat para desarrollo de aplicaciones Java especialmente optimizado para OpenJDK, GraalVM y Kubernetes."
      }), "\n", _jsx(_components.p, {
        children: "Ofrece increíbles tiempos de arranque y un uso de memoria y tamaño de imágenes muy contenido."
      }), "\n", _jsx(_components.p, {
        children: "Mejora ostensiblemente los resultados que se pueden obtener con una aplicación Java basada en Spring Boot aunque hay que tener en cuenta sus limitaciones."
      }), "\n", _jsx(_components.p, {
        children: "La principal de ellas es la necesidad de que todos las clases y el código bytecode que se va a utilizar en tiempo de ejecución deben ser conocidos en tiempo de compilación."
      }), "\n", _jsx(_components.p, {
        children: "Esta limitación impide técnicas de reflexión o el acceso a interfaz nativa."
      }), "\n", _jsx(_components.p, {
        children: "No obstante, para la inmensa mayoría de los casos, esto no es un problema y compensa el disponer de un cold-boot time casi inexistente que facilita incluso el escalar a 0."
      }), "\n", _jsx(_components.p, {
        children: "El principal obstaculo que tiene Quarkus es que compite con Spring Boot y es necesario adaptarse a sus conceptos, muchos de ellos provenientes del mundo J2EE (afortunadamente, las partes buenas)."
      }), "\n", _jsx(_components.p, {
        children: "Sin duda una plataforma muy interesante que seguirá dando mucho que hablar."
      })]
    });
  }
}
return {
  default: MDXContent
};


Quarkus

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "React nace de la mano de Facebook como alternativa a Angular para la creación de Single Page Applications con JavaScript."
      }), "\n", _jsx(_components.p, {
        children: "La principal característica de React es que no es un framework en sí, si no una librería que renderiza componentes en el DOM."
      }), "\n", _jsx(_components.p, {
        children: "Esto tiene ventajas y desventajas: cualquier funcionalidad más allá de pintar el DOM se tiene que desarrollar a medida."
      }), "\n", _jsx(_components.p, {
        children: "La ventaja clara de esta solución es que no se introducen funcionalidades innecesarias en los proyectos que nunca van a ser utilizadas y que se tiene una flexibilidad máxima para poder implementar los desarrollos al gusto."
      }), "\n", _jsx(_components.p, {
        children: "Para los que prefieren no tener que reinventar la rueda, la extensa comunidad de desarrolladores que utilizan React, proporciona innumerables librerías para hacer prácticamente todo lo imaginable."
      }), "\n", _jsx(_components.p, {
        children: "Esto tiene la desventaja de depender siempre de que dichas librerías estén mantenidas, no puede ser todo perfecto."
      }), "\n", _jsx(_components.p, {
        children: "Apostamos claramente por React porque está muy extendido en la comunidad, hay mucha documentación oficial y de comunidad y porque proporciona una gran flexibilidad a la hora de desarrollar aplicaciones web."
      }), "\n", _jsx(_components.p, {
        children: "Además, está plenamente preparado para usarse con TypeScript, Redux y muchas otras librerías consolidadas en el desarrollo web actual."
      }), "\n", _jsx(_components.p, {
        children: "Su curva de aprendizaje es un poco dura al principio, sobre todo desde la incorporación de hooks, pero facilita mucho el separation of concerns."
      })]
    });
  }
}
return {
  default: MDXContent
};


React

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "React Native es el framework de desarrollo de aplicaciones móviles híbridas basado en React."
      }), "\n", _jsx(_components.p, {
        children: "Su principal característica es que no se basa en un DOM, si no que se utilizan componentes nativos directamente."
      }), "\n", _jsx(_components.p, {
        children: "Su principal ventaja es que de una misma base de código (y, por lo tanto, un mismo equipo de desarrollo), se podrán crear aplicaciones nativas tanto para iOS como para Android."
      }), "\n", _jsx(_components.p, {
        children: "Además, dado que el lenguaje de desarrollo es JavaScript o TypeScript, no es necesario conocer los lenguajes o frameworks de desarrollo específicos de cada plataforma móvil."
      }), "\n", _jsx(_components.p, {
        children: "Otra ventaja es que, con la utilización de componentes nativos, se consigue que la experiencia de usuario sea idéntica a la que proporcionan las aplicaciones nativas, sin limitar de ningún modo la interacción con funcionalidades específicas de los dispositivos móviles como la cámara, localización, autenticación vía FaceID/Fingerprint, etc."
      }), "\n", _jsx(_components.p, {
        children: "Adicionalmente, parece natural que, si hemos decidido apostar por el desarrollo de aplicaciones web utilizando React, también seleccionemos React Native para el desarrollo de aplicaciones móviles, dado el crecimiento de uso de este framework en la comunidad."
      })]
    });
  }
}
return {
  default: MDXContent
};


React Native

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "El framework de Spring no necesita presentación."
      }), "\n", _jsx(_components.p, {
        children: "Supuso una revolución en el desarrollo de aplicaciones empresariales dado que ponía el foco en construir sistemas basándose en patrones que ya estaban demostrando su idonéidad en el mundo real."
      }), "\n", _jsx(_components.p, {
        children: "Nos dio herramientas que venían como anillo al dedo y nos liberaba de otros modelos, más respaldados por la industria en un principio pero también mucho más encorsetados y farragosos."
      }), "\n", _jsx(_components.p, {
        children: "Al final, el tiempo le ha dado la razón en numerosas ocasiones y la industria que tanto criticó a Spring por tener cierto caracter de 'outsider', ahora ha adoptado la inmensa mayoría de sus ideas."
      }), "\n", _jsx(_components.p, {
        children: "El futuro de Spring sigue siendo prometedor porque ha sabido adaptarse a los tiempos que corren y no deja de hacernos la vida más fácil, que al final, es lo que uno busca cuando utiliza un framework de desarrollo."
      })]
    });
  }
}
return {
  default: MDXContent
};


Spring Framework

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p",
      ul: "ul",
      li: "li"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "TensorFlow es una librería de código abierto para computación numérica y aprendizaje automático."
      }), "\n", _jsx(_components.p, {
        children: "Agrupa una gran cantidad de modelos y algoritmos de aprendizaje automático y aprendizaje profundo (redes neuronales)."
      }), "\n", _jsx(_components.p, {
        children: "Está programado en C++ y Python."
      }), "\n", _jsx(_components.p, {
        children: "Fue desarrollado por el equipo de Google Brain para ser usado internamente y posteriormente fue lanzado como plataforma de código abierto en noviembre de 2015."
      }), "\n", _jsx(_components.p, {
        children: "Las principales ventajas de TensorFlow son: * Visualización de datos: proporciona una manera de visualizar los datos con un enfoque gráfico."
      }), "\n", _jsx(_components.p, {
        children: "También permite una fácil depuración de los nodos con la ayuda de TensorBoard."
      }), "\n", _jsxs(_components.ul, {
        children: ["\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Las aplicaciones TensorFlow se pueden ejecutar en una máquina local, un clúster en la nube, dispositivos iOS y Android, CPU o GPU."
          }), "\n"]
        }), "\n", _jsxs(_components.li, {
          children: ["\n", _jsx(_components.p, {
            children: "Es compatible con muchos lenguajes como C++, JavaScript, Python, C#, Ruby y Swift."
          }), "\n"]
        }), "\n"]
      }), "\n", _jsx(_components.p, {
        children: "Esto permite que un usuario trabaje en un entorno en el que se sienta cómodo."
      }), "\n", _jsxs(_components.ul, {
        children: ["\n", _jsx(_components.li, {
          children: "Con frecuencia se lanzan nuevas versiones y características."
        }), "\n"]
      }), "\n", _jsx(_components.p, {
        children: "TensorFlow cuenta con el respaldo de Google."
      }), "\n", _jsx(_components.p, {
        children: "Esto ha impulsado el rápido ritmo de desarrollo detrás del proyecto y ha realizado muchas características que facilitan la implementación y el uso."
      })]
    });
  }
}
return {
  default: MDXContent
};


Tensor Flow

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "Terraform es una herramienta open source para aprovisionar infraestructura mediante código declarativo."
      }), "\n", _jsx(_components.p, {
        children: "Permite automatizar y gestionar la infraestructura necesaria para desplegar plataformas y servicios sobre ella."
      }), "\n", _jsx(_components.p, {
        children: "También permite automatizar la gestión de estas plataformas y servicios una vez desplegados."
      }), "\n", _jsx(_components.p, {
        children: "Como punto fuerte frente a otras soluciones, es su soporte para múltiples proveedores de infraestructura, lo que lo convierte en una opción perfecta para montar entornos con independencia de dónde o cómo será la infraestructura: cloud, on prem, contenedores, máquinas virtuales, etc."
      }), "\n", _jsx(_components.p, {
        children: "La gran característica que tiene Terraform, es que te permite definir el estado en que quieres que se quede la infraestructura, permitiendo crear ejecuciones idempotentes y modificaciones incrementales de las infraestructura."
      }), "\n", _jsx(_components.p, {
        children: "Gracias a esta característica, se integra perfectamente en ciclos de Integración continua o despliegue continuo, ya que automatiza la gestión de toda la infraestructura controlando si sus plugins ya están aplicados o no."
      }), "\n", _jsx(_components.p, {
        children: "El principal inconveniente que le encontramos a Terraform es que aunque te permite definir infraesctructura para los principales proveedores cloud, entornos de virtualización, ..."
      }), "\n", _jsx(_components.p, {
        children: "hay que utilizar plugins específicos en función de donde vayas a crear tu infraestrcutura, por lo que si decides cambiar el destino de tus despliegues, en la mayoría de ocasiones, no será un cambio transparente, si no, que requerirá de pequeñas adaptaciones en tus scripts."
      }), "\n", _jsx(_components.p, {
        children: "Sin duda, si estás utilizando Infraestructura como Código (IaC), te encuentras trabajando en entornos de infraestructura variable (on prem, cloud, hosting, ...) y quieres independizarte de la infraestructura sobre la que correrás tus aplicaciones, debes valorar el uso de Terraform."
      })]
    });
  }
}
return {
  default: MDXContent
};


Terraform

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "El uso de las tecnologías inmersivas (realidad virtual y realidad aumentada) está cada vez más extendiendo y se empieza a complementar con la realidad extendida, que busca otorgar una experiencia mucho más realista y conseguir que la inmersión sea total."
      }), "\n", _jsx(_components.p, {
        children: "Cada vez más sectores empiezan a adoptar estas tecnologías para mejorar la experiencia de usuario, optimizar sus costes o para campañas de marketing."
      }), "\n", _jsx(_components.p, {
        children: "Las tecnologías inmersivas facilitan las simulaciones en entornos reales, pero es complejo tener resultados realistas, además de muy costoso."
      }), "\n", _jsx(_components.p, {
        children: "Sus capacidades espaciales nos permiten saber, con bastante precisión, si los objetos reales cabrán en un espacio determinado, utilizando elementos virtuales."
      }), "\n", _jsx(_components.p, {
        children: "La forma más sencilla de utilizarlos es a través de teléfono móviles o tabletas, ya que nos ofrecen movilidad y permiten que veamos los objetos virtuales desde cualquier ángulo, pero el inconveniente que tienen este tipo de soluciones es que requieren que una o las 2 manos, estén ocupadas sujetando el dispositivo."
      }), "\n", _jsx(_components.p, {
        children: "La otra alternativa que existe es con el uso de cascos o gafas que liberan las manos, pero no permiten actuar de una forma tan rica con el objeto virtual."
      }), "\n", _jsx(_components.p, {
        children: "Si tu caso de uso implica cambios estéticos en multitud de espacios (tiendas, almacenes, ...), requiere soporte especializado de equipos de forma global, con altos costes en desplazamientos o requiere mediciones precisas de objetos cambiantes, te recomendamos que empieces a utilizar las tecnologías inmersivas, ya que puedes obtener grandes beneficios con su uso"
      })]
    });
  }
}
return {
  default: MDXContent
};


VR/AR/XRtrial

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, {})
  })) : _createMdxContent();
  function _createMdxContent() {
    const _components = Object.assign({
      p: "p"
    }, _provideComponents(), props.components);
    return _jsxs(_Fragment, {
      children: [_jsx(_components.p, {
        children: "VueJs es un framework de JavaScript que nace de la comunidad, para hacer frente claramente a Angular y React."
      }), "\n", _jsx(_components.p, {
        children: "Se caracteriza por combinar conceptos presentes tanto en Angular como en React, de hecho para los que hayan conocido AngularJS, seguro encontrarán muchas similitudes con aquellas directivas."
      }), "\n", _jsx(_components.p, {
        children: "Su punto fuerte es que la curva de aprendizaje es mucho más suave que con otros frameworks y, si ya tienes experiencia en alguno de ellos, es todavía más sencillo."
      }), "\n", _jsx(_components.p, {
        children: "Confiamos en VueJS porque es fácil de aprender e intuitivo, acompañado de una buena documentación."
      }), "\n", _jsx(_components.p, {
        children: "Está ampliamente reconocido por la comunidad de desarrolladores y empresas como Gitlab, Xiaomi o Netflix hacen uso de esta tecnología."
      }), "\n", _jsx(_components.p, {
        children: "Además de tener un buen rendimiento, con 20KB min+gzip de tiempo de ejecución, VueJs construye una virtual DOM veloz y con coste mínimo de optimización."
      }), "\n", _jsx(_components.p, {
        children: "Por último, uno de sus puntos fuertes frente a su competencia es su versatilidad, contando con un ecosistema que escala entre una librería y un framework con todas las capacidades."
      })]
    });
  }
}
return {
  default: MDXContent
};
