Códice | Entradas sobre «servidor»

Docker LAMP

JavGuerra — Wed, 11 Sep 2024 00:00:00 GMT

Etiquetas: #bbdd, #mysql, #php, #docker, #servidor, #apache, #programación, #internet

Entre las herramientas de desarrollo web más comunes no falta el entorno de ejecución. Se hace lento desplegar los cambios al servidor con cada modificación del código que queremos probar. Para evitar esto se creó LAMP, que es una combinación de Linux, Apache, MySQL (o MariaDB) y PHP que permite que se puedan ejecutar aplicaciones web en local. Este artículo pretende mostrar cómo se puede instalar y ejecutar este entorno de desarrollo web en un sistema Linux usando Docker.

La principal ventaja de usar Docker es la de poder contar en el desarrollo con una infraestructura análoga a la del despliegue, con el mismo versionado y configuraciones de los servicios.

Los contenedores son unidades ligeras y portátiles que empaquetan el código y todas sus dependencias para ejecutarse de forma independiente en cualquier sistema que soporte Docker.

El lector debe conocer Docker para seguir correctamente este artículo, no obstante, siguiendo los pasos indicados aquí se podrá levantar un entorno de desarrollo web LAMP en un sistema Linux sin mayor inconveniente.

Instalación de Docker y Docker Compose

Será necesario tener instalado Docker en el sistema para poder ejecutar el entorno de desarrollo web.

Junto con Docker, vamos a instalar Docker Compose, una herramienta que permite ejecutar varios servicios de Docker a la vez.

Una vez tengamos ambos instalados, necesitaremos crear un fichero de configuración llamado docker-compose.yml que contendrá la configuración de los servicios que se va a desplegar, y accesoriamente, un fichero Dockerfile que contendrá las configuraciones comple,entarias necesarias.

Por último, veremos como ejecutar y parar el entorno de desarrollo web.

Docker

Para instalar Docker, necesitaremos cumplir con algunas dependencias:

sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release software-properties-common

Podemos seguir la documentación oficial o usar el meta-paquete docker-ce, la última versión de Docker:

sudo apt-get install docker-io

Posteriormente se añade nuestro usuario al grupo docker. Esto nos permitirá ejecutar comandos de Docker sin necesidad de tener permisos de superusuario:

sudo usermod -aG docker $USER

Una vez instalado, se puede comprobar que se está ejecutando Docker usando el siguiente comando:

docker --version

Docker Compose

Para instalar Docker Compose se puede usar el siguiente comando:

sudo apt install docker-compose

Luego se puede comprobar que se está ejecutando Docker Compose usando el siguiente comando:

docker-compose --version

Ya tenemos todo lo necesario para instalar el entorno de desarrollo web LAMP.

Stack LAMP con Docker

Para facilitar su despliegue, uso un fichero llamado docker-compose.yml que contiene la configuración de los servicios que se va a desplegar.

Contenido del fichero docker-compose.yml

Mediante el siguiente fichero se configuran y lanzan los diferentes contenedores, volúmenes y redes del entorno para tres servicios: www, db y phpmyadmin.

version: "3.1"
services:
    www:
        build: .
        ports: 
            - 8081:80
        volumes:
            - www:/var/www/html
        depends_on:
            - db
        networks:
            - default
    db:
        image: mysql
        ports: 
            - 3306:3306
        command: --default-authentication-plugin=mysql_native_password
        environment:
            MYSQL_ROOT_PASSWORD: example 
        volumes:
            - ./dump:/docker-entrypoint-initdb.d
            - ./conf:/etc/mysql/conf.d
            - persistent:/var/lib/mysql
        networks:
            - default
    phpmyadmin:
        image: phpmyadmin/phpmyadmin
        depends_on: 
            - db
        ports:
            - 8080:80
volumes:
    persistent:

Este fichero está escrito en formato YAML, que es un lenguaje de marcado de datos, que permite definir la estructura de un fichero de configuración de forma legible y fácil de entender. Como en Python, los espacios son importantes aquí.

El contenedor www será el encargado de gestionar el servidor web, y PHP. Por su parte, el contenedor db se ocupará de la base de datos MySQL y phpmyadmin lo hará del entorno de administración de la BBDD.

Por cada servicio, se detallan algunos valores de configuración, como los puertos o las claves de acceso. En el caso de www es destacable que se hace uso de un fichero dockerfile externo con:

build: .

El volumen (volumes) almacena y gestiona datos persistentes generados por los contenedores, permitiendo que los datos cruciales de la aplicación no se pierdan durante operaciones rutinarias, estando disponibles aunque los contenedores dejen de estar operativos, compartiendo los datos entre uno o varios contenedores.

Las redes (networks) permiten la comunicación entre contenedores y con el mundo exterior, facilitando la conexión entre contenedores en la misma red o con servicios externos, y proporcionando un entorno aislado para la red de contenedores.

Contenido del fichero Dockerfile

Para su completo despliegue, el servicio www hace uso de un fichero Dockerfile que añade las configuraciones necesarias para obtener PHP, MySQL y varios compresores:

FROM php:8.0.0-apache
ARG DEBIAN_FRONTEND=noninteractive
RUN docker-php-ext-install mysqli
RUN apt-get update \
    && apt-get install -y libzip-dev \
    && apt-get install -y zlib1g-dev \
    && rm -rf /var/lib/apt/lists/* \
    && docker-php-ext-install zip
RUN a2enmod rewrite

Lo guardo con el nombre Dockerfile. Tanto el fichero docker-compose.yml como el Dockerfile han de estar en la misma ruta.

Ejecución del entorno de desarrollo web

Para poder probar su correcto funcionamiento uso:

docker-compose up -d

Esto levantará los contenedores. Si todo ha ido bien, se habrán descargado las imágenes correspondientes y lanzado los contenedores necesarios para disponer del entorno. Se puede obtener un listado de los contenedores levantados con:

docker-compose ps

Para probar su correcto funcionamiento, podemos copiar aquello que deseemos mostrar en el navegador a la carpeta www en la carpeta actual donde están los dos scripts, o bien podemos crear un fichero index.php con sólo el código siguiente:

<?php phpinfo( ); ?>

Ahora debemos acceder al contenido mediante el navegador con la ruta:

localhost 8001

8001 es el puerto descrito en el fichero docker-compose.yml para el servidor web, pero podemos cambiarlo en el mismo fichero.

Una vez ejecutado, si podemos ver la información en el navegador, es que Apache y PHP están funcionando adecuadamente.

Para comprobar si MySQL y PHPMyAdmin están activos, accedemos a la misma dirección localhost pero por el puerto 8080:

localhost:8080

Para acceder podemos usar root como usuario y example como contraseña.

Cuando terminemos, podemos detener los contenedores mediante:

docker-compose stop

Usando Docker LAMP en nuestros desarrollos

Ahora podemos levantar y detener los contenedores mediante simples comandos y ubicar estos script y el contenido que estemos desarrollando en la carpeta www de la misma manera que lo hicimos antes, y podemos mover toda esta estructura de ficheros a donde nos resulte más conveniente, o configurar el fichero docker-compose.yml para que sepa encontrar la carpeta www allá donde se ubique.

BONUS: Portainer

Para una gestión más cómoda de los contenedores y su monitorización, se puede usar Portainer, un front end web local que se levanta como un contenedor más mediante:

sudo docker run -itd -p 9443:9443 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v /docker/portainer:/data portainer/portainer-ce

Es posible acceder a él mediante la dirección localhost y el puerto 9443:

localhost:9443

Mediante este entorno se puede hacer una gestión de los contenedores y su monitorización, como se ve en la imagen.

Saber más

Accediendo a la API de Mastodon

JavGuerra — Wed, 18 Sep 2024 00:00:00 GMT

Etiquetas: #javascript, #código, #api, #servidor

En este artículo vamos a ver cómo se puede acceder a la API de Mastodon, un servicio que nos permite, entre otras cosas, obtener las últimas publicaciones de un usuario concreto.

Recientemente la he usado para mostrar, en el apartado social de esta página, las publicaciones que escribo en la red social, empleando JavaScript del lado del cliente en Astro, es decir, que en una página .astro he incluido un script que lee y muestra las publicaciones actualizadas de mi cuenta de Mastodon.

Me centraré en la parte de JavaScript y no tanto en la integración con Astro, ya que, de esta forma, será posible aprovechar la información para que pueda ser usada en otros frameworks o aplicaciones propias.

El lector debe conocer las funciones avanzadas de JavaScript como asincronía y llamadas a APIs para seguir correctamente esta entrada.

Nota: Este artículo ha sido publicado también en IfGeekThen, el blog de NTT Data, el 18 de marzo de 2026.

API de Mastodon

Realizaré la consulta a la API de Mastodon mediante la función fetch de JavaScript.

Las consultas a la API no requieren autenticación (aunque es posible), por lo que podemos acceder a ella sin ningún tipo de token, pero voy a necesitar:

La url de la instancia de Mastodon, es decir el servidor.
El id de la cuenta de usuario que quiero consultar.
El número que indique la cantidad de publicaciones que quiero obtener.

Cuando tengamos estos datos, podremos construir el endpoint o url de la API de Mastodon, que será la siguiente:

https://<server>/api/v1/accounts/<accountId>/statuses?limit=<limit>

Donde:

<server> es el nombre de dominio de la instancia de Mastodon, por ejemplo mastodon.social o la de tu propia instancia.
<accountId> es el id de la cuenta que queremos consultar, por ejemplo 1234567890. Este id se obtendría de la url de la cuenta, ej.: https://mastodon.social/@usuario, como se verá enseguida.
<limit> es el número de publicaciones que queremos consultar, por ejemplo 10.

Para obtener el id de la cuenta, debo usar la siguiente url:

https://<server>/api/v1/accounts/lookup?acct=<username>

Donde hay que sustituir <server> por el nombre de la instancia de Mastodon y <username> por el nombre de usuario de la cuenta que queremos consultar.

Obtengo un json con el id de la cuenta, entre otros datos, como por ejemplo:

{
  "id": "1234567890",
  "username": "usuario",

  ...

}

Si queremos consultar las 10 últimas publicaciones de la cuenta ficticia @usuario, que tiene el id ficticio: 1234567890, en la instancia de Mastodon mastodon.social, tendríamos que usar la siguiente url:

https://mastodon.social/api/v1/accounts/1234567890/statuses?limit=10

Fetch

Ya tenemos formado el endpoint de la API de Mastodon, y, para llevar a cabo la consulta, usaré la función fetch de JavaScript, que permite realizar peticiones HTTP, y obtener el resultado como un objeto json.

const server = 'https://mastodon.social';
const profileId = '1234567890';
const limit = 10;

const route = `${server}/api/v1/accounts/${profileId}/statuses?limit=${limit}`;

async function getLatestPosts(route) {
  try {
    const response = await fetch(route);
    if (!response.ok) throw new Error(response.statusText);
    return await response.json();
  } catch (error) {
    console.error(error);
    return [];
  }
}

Como se aprecia, se trata de una función asíncrona con una estructura de lo más común, que se ejecutará de manera independiente, y cuando se haya terminado de ejecutar, me permitirá seguir con la ejecución del código.

Para llamar a la función, uso:

const posts = await getLatestPosts(route);

Con await, se espera a que la función getLatestPosts termine de ejecutarse, y luego es posible usar el array posts para mostrar las publicaciones en nuestra página, siempre que no se haya producido ningún error.

Mostrando las publicaciones

Allí donde vamos a mostrar las publicaciones, voy a usar un elemento <div> con el id="posts" para definir una lista de publicaciones, un <ul>, y un elemento <li> para cada publicación.

Incluyo el siguiente código HTML en la página:

<div id="posts">
  Cargando...
</div>

Y luego, mediante el script de JavaScript, sustituiré el contenido del elemento <div> con las publicaciones obtenidas y formateadas:

function displayPosts(posts) {
  const postsElement = document.getElementById('posts');

  if (!posts || posts.length === 0) {
    postsElement.innerHTML = '<p>No se encontraron posts.</p>';
    return;
  }

  postsElement.innerHTML = `
    <h2>Últimas publicaciones</h2>
    <ul>
    ${posts.map(post => {
      const isReblog = post.reblog != null;
      const originalPost = isReblog ? post.reblog : post;
      const contentIsEmpty = !originalPost.content || originalPost.content.replace(/<[^>]*>/g, '').trim() === '';
      const hasMedia = originalPost.media_attachments && originalPost.media_attachments.length > 0;
      const multimediaLink = hasMedia ? `<small>Incluye contenido multimedia <a href="${originalPost.url}">👁️ Ver en origen →</a></small><br />` : '';

      return `
        <li class="post">
          ${isReblog 
            ? `${originalPost.content} <small>♻️ Republicado </small>`
            : contentIsEmpty && hasMedia
              ? multimediaLink
              : originalPost.content + multimediaLink}

          <a href="${originalPost.url}">
            <small>
              📢 ${new Date(originalPost.created_at).toLocaleString('es-ES', {dateStyle: 'medium', timeStyle: 'short'})}
            </small>
          </a>
        </li>
        `
      }).join('')}
    </ul>
  `;
}

Vamos por partes.

Primero obtengo el elemento <div> con el id posts del DOM, y lo guardo en una variable postsElement para poder referirme a él en el script.

const postsElement = document.getElementById('posts');

Compruebo que hay publicaciones y que el array posts no esté vacío. Si no es así, defino el contenido del elemento <div> con el siguiente código:

postsElement.innerHTML = '<p>No se encontraron posts.</p>';

Si hemos obtenidos publicaciones, hago uso de la siguiente estructura:

postsElement.innerHTML = `
    <h2>Últimas publicaciones</h2>
    <ul>
    ${posts.map(post => `

        // código para mostrar cada publicación

    `).join('')}
    </ul>
  `;

Con la función map puedo iterar sobre cada elemento del objeto posts y acceder a cada una de las publicaciones, y luego puedo juntar todos los elementos formateados en una cadena de texto mediante la función join. El resultado se incluirá en el elemento <div> con el id posts mediante el método innerHTML de postElement. Es decir, obtengo cada publicación, esta se formatea, y se concatena o añade a la cadena de texto que conforma el contenido del elemento <div>; las publicaciones.

Pintando…

Para formatear las publicaciones, voy a usar una estructura de elementos <li> por cada publicación, como dije, y un elemento <a> para enlazar a la publicación original. Lo que quiero conseguir se parece a esto:

<li class="post">
  Este es un ejemplo de una publicación en Mastodon.
  <a href="https://mastodon.social/@usuario/109292343224519197">
    <small>18 sep 2024, 1:23:45</small>
  </a>
</li>

De cada publicación obtengo el contenido de la publicación, y el enlace a la publicación. Con esta información defino una serie de variables:

const isReblog = post.reblog != null;
const originalPost = isReblog ? post.reblog : post;
const contentIsEmpty = !originalPost.content || originalPost.content.replace(/<[^>]*>/g, '').trim() === '';
const hasMedia = originalPost.media_attachments && originalPost.media_attachments.length > 0;
const multimediaLink = hasMedia ? `<small>Incluye contenido multimedia <a href="${originalPost.url}">👁️ Ver en origen →</a></small><br />` : '';

Como las publicaciones pueden ser republicaciones, es decir, publicaciones compartidas de otros usuarios o propias, compruebo si este es el caso.

Si es una republicación, obtengo su contenido, sino, obtengo el contenido de la publicación original.

Compruebo si el texto de la publicación está verdaderamente vacío, es decir, si no contiene, por ejemplo, alguna etiqueta HTML.

Compruebo también si la publicación tiene contenido multimedia.

Por último, si la publicación tiene contenido multimedia, preparo el enlace a la publicación original, y si no lo tiene, dejo el aviso vacío.

Seguidamente, formateo el texto de la publicación mediante el siguiente código:

  <li class="post">
    ${isReblog 
      ? `${originalPost.content} <small>♻️ Republicado </small>`
      : contentIsEmpty && hasMedia
        ? multimediaLink
        : originalPost.content + multimediaLink}

    <a href="${originalPost.url}">
      <small>
        📢 ${new Date(originalPost.created_at).toLocaleString('es-ES', {dateStyle: 'medium', timeStyle: 'short'})}
      </small>
    </a>
  </li>

¿Se trata de una republicación?, entonces publico el texto de la republicación con el aviso de ♻️ Republicado.

En caso contrario, compruebo si el texto de la publicación está vacío y si tiene contenido multimedia.

Si ambas condiciones se cumplen, entonces publico el aviso de ver 👁️ Ver en origen → con su enlace, ya que será una publicación sin texto pero con video o imagen…

Si no se cumple alguna o ambas condiciones, entonces publico el contenido de la publicación y el aviso de ver 👁️ Ver en origen → con su enlace, pues o bien la publicación tiene contenido, tiene texto y contenido multimedia o sólo texto.

Para mostrar la fecha, uso la función toLocaleString de JavaScript, que me permite obtener la fecha en formato local.

Es posible llamar a la función displayPosts mediante:

displayPosts(posts);

Siendo posts el objeto de publicaciones en json obtenido de la API de Mastodon.

Una advertencia

Si bien las instancias de Mastodon se encargan de limpiar las publicaciones de los usuarios ante potenciales peligros, no estaría de más implementar una función propia que se ocupe de limpiar el contenido de las publicaciones antes de hacer uso de originalPost.content para evitar sorpresas por la inclusión de etiquetas o atributos dañinos que pudieran llegar de publicaciones de instancias de Mastodon poco confiables.

El código completo

El código siguiente incluye el contenido mostrado hasta ahora en el artículo:

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Publicaciones de Mastodon</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    
    <h1>Mastodon</h1>

    <div id="posts">
        Cargando...
    </div>

<script>
    // Sustituye los valores siguientes para adaptarlo a tu propio uso
    const server = 'https://mastodon.social';
    const profileId = '1234567890';
    const limit = 10;

    const route = `${server}/api/v1/accounts/${profileId}/statuses?limit=${limit}`;

    async function getLatestPosts(route) {
        try {
            const response = await fetch(route);
            if (!response.ok) throw new Error(response.statusText);
            return await response.json();
        } catch (error) {
            console.error(error);
            return [];
        }
    }

    function displayPosts(posts) {
      const postsElement = document.getElementById('posts');

      if (!posts || posts.length === 0) {
        postsElement.innerHTML = '<p>No se encontraron posts.</p>';
        return;
      }

      postsElement.innerHTML = `
        <h2>Últimas publicaciones</h2>
        <ul>
        ${posts.map(post => {
          const isReblog = post.reblog != null;
          const originalPost = isReblog ? post.reblog : post;
          const contentIsEmpty = !originalPost.content || originalPost.content.replace(/<[^>]*>/g, '').trim() === '';
          const hasMedia = originalPost.media_attachments && originalPost.media_attachments.length > 0;
          const multimediaLink = hasMedia ? `<small>Incluye contenido multimedia <a href="${originalPost.url}">👁️ Ver en origen →</a></small><br />` : '';

          return `
            <li class="post">
              ${isReblog 
                ? `${originalPost.content} <small>♻️ Republicado </small>`
                : contentIsEmpty && hasMedia
                  ? multimediaLink
                  : originalPost.content + multimediaLink}

              <a href="${originalPost.url}">
                <small>
                  📢 ${new Date(originalPost.created_at).toLocaleString('es-ES', {dateStyle: 'medium', timeStyle: 'short'})}
                </small>
              </a>
            </li>
            `
          }).join('')}
        </ul>
      `;
    }

    document.addEventListener("DOMContentLoaded", async () => {
      const posts = await getLatestPosts(route);
      displayPosts(posts);
    });
</script>

</body>
</html>

No olvides sustituir los valores de server, profileId y limit con los que correspondan a tu propio perfil de Mastodon o el del perfil que desees consultar.

Cargando las publicaciones

Aquí confluye todo. Mediante el evento asociado a la carga de la página DOMContentLoaded, que se incluye al final del script, se inicia la petición asíncrona a la API de Mastodon con getLatestPosts(route) y se muestran las publicaciones con displayPosts(posts).

Estilos

Para que el contenido se vea correctamente, es recomendable definir algunos estilos en el archivo style.css. Un ejemplo:

.invisible {
  display: inline-block;
  font-size: 0;
  height: 0;
  line-height: 0;
  position: absolute;
  width: 0;
}
.invisible img,
.invisible svg {
  border: 0 !important;
  height: 0 !important;
  margin: 0 !important;
  padding: 0 !important;
  width: 0 !important;
}
.ellipsis:after {
  content: "…";
}

Los estilos aquí mostrados son los que usa el propio Mastodon para presentar las publicaciones en su página.

La clase .invisible se aplica a los elementos que quiero que no se vean. Esto es necesario para evitar saltos de línea y espacios en blanco en el contenido de las publicaciones debido a su formateo original.

Se incluye también la clase .invisible para imágenes y vectores SVG. Si bien no se usa en este ejemplo, pueden ser de utilidad si decides mostrar el contenido multimedia de las publicaciones.

Por su parte, la clase .ellipsis se usa para mostrar puntos suspensivos … al final de los enlaces acortados.

A partir de estos estilos es posible aplicar estilos propios al contenido mostrado.

Experimenta por tu cuenta

Como has podido comprobar a lo largo de este artículo, acceder a la API de Mastodon es un proceso sencillo que nos permite integrar el contenido de una cuenta en nuestros propios proyectos mediante código JavaScript. Desde la construcción del endpoint y la gestión de la respuesta asíncrona con fetch, hasta el formateo final de los datos considerando casos como las republicaciones o el contenido multimedia, has visto los fundamentos para crear tu propio visor de publicaciones.

Te animo a que tomes el código completo, lo adaptes con tus propios datos y experimentes modificando la lógica de displayPosts y el css para personalizar aún más la presentación. Y si te surgen dudas o mejoras, no dudes en explorar la documentación oficial de la API, donde encontrarás muchas más posibilidades.

Saber más

Mastodon
Mastodon API
Ejemplo de uso: Social

Museos de computación en Londres

JavGuerra — Fri, 27 Dec 2024 00:00:00 GMT

Etiquetas: #algoritmia, #computación, #historia, #londres, #museo, #criptografía, #fotografía, #internet, #retro, #servidor, #sinclair ql, #tic, #viaje, #enigma

Recientemente he estado de viaje familiar en Londres y creo que he aprovechado bien el tiempo. En esta entrada cuento brevemente la visita a distintos museos relacionados con la informática en la ciudad.

Reino Unido es el país que vio nacer la informática como la conocemos hoy y de esto tiene mucha culpa la Segunda Guerra Mundial y Bletchley Park, la base donde Alan Turing y las mujeres de inteligencia del ejercito descifraron el código de Enigma y Lorenz. Allí pude ver estas máquinas y las que se usaron para descifrarlas.

Alan Turing

Enigma

Hablando de códigos, en el Museo Británico está la original piedra de Rosetta, que también pude ver.

Piedra de Rosetta

Justo detrás de Bletchley Park, a escasos metros, está The National Museum Of Computing. Esta es una visita que no debes perderte, pues cuenta con grandes sorpresas, como una versión operativa de The Bombe reconstruida, asi como las reconstrucciones de la máquina Tunny y del no menos famoso Colossus que ayudaron a romper los códigos del ejercito alemán en la WWII.

The Bombe

Colossus

También allí puede encontrarse la máquina WITCH, que tiene el mérito de ser el ordenador de primera generación más antiguo aún en funcionamiento, y junto a él, está el ordenador EDSAC.

Además de mainframes, un par de ordenadores CRAY’s, de una buena colección de PCs, discos, válvulas y calculadoras, encontré, como no, un Sinclair QL y sus dos hermanos, el OPD y el Merlin TONTO.

OPD

Merlin TONTO

Este museo es muy pequeño, pero tiene voluntarios que explican con pasión lo que allí se encuentra, y merece la pena dedicarle el tiempo necesario para apreciar todo lo que tiene en tan poco espacio. Salí algo desencantado de allí por estacuestión, pensando qué mejor aprovechamiento podría hacerse de la exposición con más terreno, porque uno no es conciente de las maravillas que ese museo guarda.

Se puede visitar en un tour 3D online y ver todo con detalle. Y su página web está muy bien organizada.

Antes de regresar, después de ver los dinosaurios del Museo de Historia Natural, visitamos lo poco que pudimos ver del Museo de la Ciencia, por falta de tiempo, donde además de cosas del espacio, encontramos máquinas tan interesantes como lo que queda del LEO de Lyons, el primer ordenador comercial, un PDP 10, un IBM 360 o un Control Data 6600.

LEO

Si viajáis a Londres, ya tenéis plan turístico retro.

Enlaces

Acceder a BBDD Oracle con DBeaver

JavGuerra — Wed, 10 Jun 2026 00:00:00 GMT

Etiquetas: #herramienta, #servidor, #bbdd, #software libre, #oracle

DBeaver es una herramienta de gestión de bases de datos multiplataforma y de código abierto que permite conectarse y trabajar con distintos sistemas como Oracle, MySQL, PostgreSQL o SQL Server desde una única interfaz. Ofrece funcionalidades como ejecución de consultas SQL, exploración de estructuras, edición de datos y administración de conexiones, destacando por su flexibilidad y compatibilidad con múltiples drivers. En esta te explico cómo instalar los drivers originales de Oracle en DBeaver.

Descargando DBeaver

Puedes descargar la última versión de la aplicación desde:

Download DBeaver Community

Hay disponibles versiones para Windows, macOS y Linux.

Si vas a descargar la versión de Windows, dispones también de un fichero .zip que no requiere instalación en el sistema. Tan sólo descomprimes la carpeta en el lugar que decidas y la aplicación estará lista para usarse.

El problema

Elegí esta herramienta porque, como otras, me permite acceder a la BBDD desde mi entorno local, pero empleando los drivers originales de Oracle, con lo que consigo la máxima compatibilidad, con un software versátil y abierto. Pero al seguir los pasos para descargar automáticamente los drivers:

Abrir DBeaver.
Ir a Database → Driver Manager.
Buscar Oracle en la lista y seleccionarlo.
Pulsar Edit.
Ir a la pestaña Libraries.
Y pulsar Download/Update.

Obtuve un error. Ocurre que Oracle no permite la descarga automática directa en muchos casos, así que DBeaver falla.

La alternativa

Descargar los drivers directamente desde la página de Oracle:

Oracle Database JDBC driver and Companion Jars Downloads

Deberás seleccionar los drivers adecuados. En mi caso decidí descargar el fichero ojdbc11-full.tar.gz bajo el título Zipped JDBC driver (ojdbc11.jar) and Companion Jars que viene con todos los ficheros necesarios y está certificado para las versiones JDK 11 de Java (en mi caso) y versiones superiores.

Una vea descargado, hay que descomprimir el contenido en la carpeta que desees. También puedes descomprimirlo en la carpeta pluggins dentro de la carpeta de DBeaver.

Instalando los drivers

El siguiente paso es instalar los drivers en la aplicación. Por defecto, DBeaver carga cuatro de ellos.

ojdbc11.jar (la versión para mi JDK.) Obligatorio. El driver JDBC principal de Oracle que permite la conexión a BBDD.
orai18n.jar Recomendado. Es el soporte de internacionalización (i18n) que permite manejar caracteres especiales, codificaciones (UTF-8, etc.) y distintos idiomas correctamente.
xdb.jar Opcional. Librería para XML DB de Oracle si se trabaja con XML almacenado en la base de datos y se requieren funcionalidades avanzadas tipo XMLType.
xmlparserv2.jar Opcional. Parser XML de Oracle para procesar XML internamente y dar soporte a funcionalidades de xdb.jar.

Para ello debes estar en la pestaña libraries del driver Oracle en la en la opción Driver manager del menú Database. Ver pasos para llegar más arriba. Y una vez allí:

Pulsamos Add File, seleccionamos cada fichero mencionado, y le damos a Open.
Repetimos la opción por cada fichero.
Una vez tenemos todos los drivers abiertos, ya no necesitamos los drivers que aparecen por defecto. Los quitamos con Delete para que no den problemas.

Conectar a la BBDD

Ahora ya podemos ver si todo ha ido bien.

En el menú Database, hacemos clic en la opción New connection e introducimos los datos de la conexión. La nueva conexión a BBDD aparecerá en el espacio de conexiones de la izquierda.

TIPs

Podemos arrastrar el nombre de la BBDD a Bookmarks (Favoritos) en la lista de abajo, a la izquierda, para poder acceder de forma fácil a ella.

También podemos poner DBeaver en español. Para esto iremos a Windows, luego Preferences, y en la opción User Interface elegiremos el idioma español.

Para más información sobre el uso de DBeaver, puedes consultar la documentación en el Wiki:

About DBeaver