Cómo instalar PostgreSQL en Ubuntu

Introducción

PostgreSQL, a menudo simplemente conocido como Postgres, es un potente sistema de base de datos relacional orientado a objetos de código abierto. Con más de 30 años de desarrollo activo, PostgreSQL ha ganado una sólida reputación por su fiabilidad, robustez de características y rendimiento.

Instalar PostgreSQL en Ubuntu es una elección popular para muchos desarrolladores y administradores de bases de datos debido a varias razones convincentes:

Compatibilidad: Ubuntu, siendo una de las distribuciones de Linux más utilizadas, ofrece una excelente compatibilidad con PostgreSQL.
Rendimiento: La combinación de la eficiencia de Ubuntu y la robusta arquitectura de PostgreSQL resulta en operaciones de base de datos de alto rendimiento.
Seguridad: Tanto Ubuntu como PostgreSQL son conocidos por sus sólidas características de seguridad, lo que hace que esta combinación sea ideal para manejar datos sensibles.
Soporte de la comunidad: Tanto Ubuntu como PostgreSQL tienen grandes comunidades activas, lo que garantiza que la ayuda esté fácilmente disponible cuando se necesite.
Gratuito y de código abierto: Ambos sistemas son gratuitos y de código abierto, lo que permite una implementación rentable y la posibilidad de personalizar si es necesario.

Esta guía te llevará a través del proceso de instalación de PostgreSQL en tu sistema Ubuntu, desde la preparación hasta el uso básico. Ya sea que estés configurando un entorno de desarrollo o preparando un servidor de producción, este tutorial te proporcionará los pasos necesarios para poner en marcha PostgreSQL en Ubuntu.

Requisitos previos

Antes de comenzar el proceso de instalación, es importante asegurarse de que tu sistema cumpla con los requisitos necesarios y que tengas los permisos apropiados. Repasemos los requisitos previos:

Requisitos del sistema Ubuntu

Versión de Ubuntu: Esta guía es aplicable para Ubuntu 20.04 LTS (Focal Fossa) y versiones más recientes. Sin embargo, siempre se recomienda utilizar la última versión de soporte a largo plazo (LTS) para mayor estabilidad.
Recursos del sistema: PostgreSQL puede funcionar en sistemas con recursos limitados, pero para un rendimiento óptimo, considera las siguientes recomendaciones:
- CPU: Procesador de 1 GHz o más rápido
- RAM: Al menos 1 GB (se recomiendan 4 GB o más para uso en producción)
- Almacenamiento: 512 MB para la instalación de PostgreSQL, más espacio adicional para tus bases de datos
Conexión a Internet: Necesitarás una conexión a Internet activa para descargar PostgreSQL y sus dependencias.

Permisos de usuario

Para instalar PostgreSQL, necesitarás privilegios de sudo en tu sistema Ubuntu. Esto significa que debes iniciar sesión como usuario root o tener una cuenta que pueda usar sudo para ejecutar comandos con privilegios de root.

Para comprobar si tu usuario tiene privilegios de sudo, puedes ejecutar el siguiente comando en la terminal:

sudo -v

Si se te solicita una contraseña y el comando se ejecuta sin errores, tu usuario tiene privilegios de sudo.

Acceso a la terminal

Debes sentirte cómodo utilizando la interfaz de línea de comandos (CLI) ya que usaremos la terminal para la mayor parte del proceso de instalación y configuración.

Respalda tus datos

Si estás instalando PostgreSQL en un sistema que ya tiene datos importantes, siempre es una buena práctica hacer una copia de seguridad de tus datos antes de proceder con cualquier instalación de software importante.

Actualizando el sistema

Antes de instalar PostgreSQL, es crucial asegurarse de que tu sistema Ubuntu esté actualizado. Este paso es importante por varias razones:

Seguridad: Las actualizaciones a menudo incluyen parches de seguridad importantes.
Estabilidad: Las últimas actualizaciones pueden corregir errores y mejorar la estabilidad del sistema.
Compatibilidad: Tener los paquetes más recientes puede prevenir posibles problemas de compatibilidad durante la instalación de PostgreSQL.

Pasos para actualizar Ubuntu

Para actualizar tu sistema Ubuntu, sigue estos pasos:

Abre tu terminal. Puedes hacerlo presionando Ctrl + Alt + T o buscando "Terminal" en el tablero de Ubuntu.
Primero, actualiza las listas de paquetes para actualizaciones y nuevas instalaciones de paquetes. Ejecuta el siguiente comando:
```
sudo apt update
```
Este comando actualiza la lista de paquetes disponibles y sus versiones, pero no instala ni actualiza ningún paquete.
Después de que se complete la actualización, actualiza los paquetes instalados a sus últimas versiones:
```
sudo apt upgrade
```
Este comando te mostrará una lista de paquetes que están a punto de ser actualizados. Presiona 'Y' y luego 'Enter' para confirmar y proceder con la actualización.
Opcionalmente, puedes ejecutar una actualización completa del sistema, que también manejará de manera inteligente los cambios en las dependencias con las nuevas versiones de los paquetes:
```
sudo apt full-upgrade
```
Ten cuidado con este comando, ya que puede eliminar algunos paquetes si es necesario para actualizar otros.
Después de que se complete el proceso de actualización, es una buena idea reiniciar tu sistema para asegurarte de que todas las actualizaciones se apliquen correctamente:
```
sudo reboot
```

Verificando la actualización

Después de que tu sistema se reinicie, puedes verificar que la actualización fue exitosa comprobando la versión de Ubuntu:

lsb_release -a

Este comando mostrará información sobre tu distribución Ubuntu, incluyendo el número de versión.

Añadiendo el repositorio de PostgreSQL

Aunque PostgreSQL está disponible en los repositorios predeterminados de Ubuntu, a menudo no es la versión más reciente. Para asegurarnos de instalar la versión estable más reciente de PostgreSQL, añadiremos el repositorio oficial de PostgreSQL a nuestro sistema.

¿Por qué añadir el repositorio oficial de PostgreSQL?

Versiones más recientes: El repositorio oficial proporciona las versiones más actualizadas de PostgreSQL.
Actualizaciones oportunas: Los parches de seguridad y correcciones de errores están disponibles más rápidamente a través del repositorio oficial.
Consistencia: Usar el repositorio oficial asegura la compatibilidad entre PostgreSQL y sus extensiones.

Pasos para añadir el repositorio de PostgreSQL

Sigue estos pasos para añadir el repositorio de PostgreSQL a tu sistema Ubuntu:

Primero, necesitamos añadir la clave de firma de PostgreSQL. Esta clave se utiliza para verificar que los paquetes que vamos a instalar son auténticos. Ejecuta el siguiente comando:
```
sudo apt-get install wget ca-certificates
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
```
A continuación, necesitamos añadir el repositorio de PostgreSQL a la lista de fuentes de nuestro sistema. Crea un nuevo archivo llamado pgdg.list en el directorio /etc/apt/sources.list.d/:
```
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
```
Este comando crea un nuevo archivo con la información del repositorio. La parte $(lsb_release -cs) detecta automáticamente tu versión de Ubuntu e inserta el nombre de código correcto.
Después de añadir el repositorio, actualiza las listas de paquetes nuevamente para incluir el repositorio de PostgreSQL recién añadido:
```
sudo apt update
```

Verificando la adición del repositorio

Para verificar que el repositorio de PostgreSQL se ha añadido correctamente, puedes comprobar el contenido del archivo pgdg.list:

cat /etc/apt/sources.list.d/pgdg.list

Deberías ver una línea similar a:

deb http://apt.postgresql.org/pub/repos/apt focal-pgdg main

(Nota: "focal" podría ser reemplazado por el nombre de código de tu versión de Ubuntu)

Instalando PostgreSQL

Ahora que hemos añadido el repositorio de PostgreSQL y actualizado nuestro sistema, estamos listos para instalar PostgreSQL. Este proceso es sencillo y se puede completar con unos pocos comandos simples.

Comando para instalar PostgreSQL

Para instalar PostgreSQL, usaremos el gestor de paquetes apt. Aquí está el comando para instalar la última versión de PostgreSQL junto con una extensión comúnmente utilizada:

sudo apt install postgresql postgresql-contrib

Desglosemos este comando:

postgresql: Este es el paquete principal de PostgreSQL.
postgresql-contrib: Este paquete contiene utilidades adicionales y funcionalidades que no son parte del sistema principal de PostgreSQL pero que a menudo son útiles.

Durante el proceso de instalación, es posible que se te solicite confirmar la instalación. Si es así, escribe 'Y' y presiona Enter para continuar.

Verificando la instalación

Después de que se complete la instalación, es importante verificar que PostgreSQL se haya instalado correctamente y esté en funcionamiento. Aquí hay algunas formas de hacerlo:

Comprueba la versión de PostgreSQL:
```
psql --version
```
Esto debería mostrar la versión de PostgreSQL que se instaló.
Comprueba el estado del servicio PostgreSQL:
```
sudo systemctl status postgresql
```
Deberías ver una salida que indique que el servicio está activo (en ejecución).
Verifica que PostgreSQL esté escuchando conexiones:
```
sudo ss -tunelp | grep 5432
```
Este comando comprueba si PostgreSQL está escuchando en su puerto predeterminado (5432). Deberías ver una salida si PostgreSQL está funcionando correctamente.

Configuración inicial de PostgreSQL

Cuando instalas PostgreSQL en Ubuntu, automáticamente crea una nueva cuenta de usuario llamada postgres. Esta cuenta está asociada con el rol predeterminado de Postgres. Para interactuar con PostgreSQL usando esta cuenta, puedes cambiar a ella de la siguiente manera:

sudo -i -u postgres

Luego, puedes acceder al prompt de PostgreSQL escribiendo:

psql

Esto te conectará al prompt de PostgreSQL, y verás algo como:

psql (13.x)
Escribe "help" para obtener ayuda.

postgres=#

Para salir del prompt de PostgreSQL, escribe:

\q

Y para volver a tu cuenta de usuario regular, simplemente escribe:

exit

¡Enhorabuena! Has instalado PostgreSQL con éxito en tu sistema Ubuntu. En la siguiente sección, cubriremos cómo configurar PostgreSQL según tus necesidades.

Configurando PostgreSQL

Después de instalar PostgreSQL, es importante configurarlo adecuadamente para tus necesidades. Esta sección cubrirá la creación de una nueva base de datos, la configuración de un nuevo usuario y la configuración de métodos de autenticación.

Creando una nueva base de datos

Por defecto, PostgreSQL crea una base de datos llamada postgres. Sin embargo, es una buena práctica crear bases de datos separadas para tus proyectos. Así es cómo crear una nueva base de datos:

Cambia al usuario postgres:
```
sudo -i -u postgres
```
Accede al prompt de PostgreSQL:
```
psql
```
Crea una nueva base de datos usando el comando CREATE DATABASE:
```
CREATE DATABASE miproyecto;
```
Reemplaza miproyecto con el nombre deseado para tu base de datos.
Puedes verificar la creación de la base de datos con:
```
\l
```
Esto listará todas las bases de datos.

Configurando un nuevo usuario

Se recomienda crear un nuevo usuario para cada aplicación en lugar de usar el superusuario postgres por defecto. Así es cómo:

Mientras aún estás en el prompt de psql, crea un nuevo usuario:
```
CREATE USER miusuario WITH PASSWORD 'micontraseña';
```
Reemplaza miusuario y micontraseña con el nombre de usuario y contraseña deseados.

Otorga privilegios al nuevo usuario en la nueva base de datos:

GRANT ALL PRIVILEGES ON DATABASE miproyecto TO miusuario;

Puedes verificar la creación del usuario con:
```
\du
```
Esto listará todos los usuarios y sus roles.

Configurando métodos de autenticación

PostgreSQL utiliza diferentes métodos de autenticación que se configuran en el archivo pg_hba.conf. Así es cómo modificarlo:

Sal del prompt de PostgreSQL:
```
\q
```
Abre el archivo pg_hba.conf con un editor de texto (es posible que necesites privilegios sudo):
```
sudo nano /etc/postgresql/13/main/pg_hba.conf
```
Nota: Reemplaza 13 con tu número de versión de PostgreSQL si es diferente.
El archivo contiene líneas que determinan cómo los usuarios pueden autenticarse. Una configuración típica podría verse así:
```
# TYPE  DATABASE        USER            ADDRESS                 METHOD
local   all             postgres                                peer
local   all             all                                     md5
host    all             all             127.0.0.1/32            md5
host    all             all             ::1/128                 md5
```
- local significa conectarse a través de sockets de dominio Unix
- host significa conectarse a través de TCP/IP
- md5 significa autenticación por contraseña
- peer significa que el nombre de usuario del sistema se mapea directamente a un nombre de usuario de PostgreSQL
Después de hacer cambios, guarda el archivo y sal del editor.
Reinicia PostgreSQL para que los cambios surtan efecto:
```
sudo systemctl restart postgresql
```

Recuerda, estas son configuraciones básicas. Dependiendo de tus necesidades específicas, es posible que necesites ajustar la configuración más a fondo, especialmente para entornos de producción donde la seguridad es crucial.

Comandos básicos de PostgreSQL

Ahora que tenemos PostgreSQL instalado y configurado, exploremos algunos comandos básicos que te ayudarán a interactuar con tus bases de datos. Estos comandos son esenciales para gestionar bases de datos, tablas y realizar operaciones básicas.

Conectando a PostgreSQL

Conéctate como el usuario postgres:
```
sudo -i -u postgres
```
Inicia el terminal interactivo de PostgreSQL:
```
psql
```
Para conectarte a una base de datos específica:
```
psql -d miproyecto
```
Reemplaza miproyecto con el nombre de tu base de datos.

Operaciones con bases de datos

Listar todas las bases de datos:
```
\l
```
Conectarse a una base de datos específica:
```
\c miproyecto
```
Crear una nueva base de datos:
```
CREATE DATABASE nuevadb;
```
Eliminar una base de datos:
```
DROP DATABASE nuevadb;
```

Operaciones con tablas

Listar tablas en la base de datos actual:
```
\dt
```

Crear una nueva tabla:

CREATE TABLE usuarios (
    id SERIAL PRIMARY KEY,
    nombre VARCHAR(100),
    email VARCHAR(100) UNIQUE NOT NULL
);

Describir la estructura de una tabla:
```
\d usuarios
```
Eliminar una tabla:
```
DROP TABLE usuarios;
```

Ejemplos de consultas básicas

Insertar datos en una tabla:

INSERT INTO usuarios (nombre, email) VALUES ('Juan Pérez', '[email protected]');

Seleccionar todos los datos de una tabla:
```
SELECT * FROM usuarios;
```

Actualizar datos en una tabla:

UPDATE usuarios SET nombre = 'Ana García' WHERE id = 1;

Eliminar datos de una tabla:
```
DELETE FROM usuarios WHERE id = 1;
```

Otros comandos útiles

Mostrar la versión de PostgreSQL:
```
SELECT version();
```
Listar todos los usuarios y sus roles:
```
\du
```
Mostrar el usuario y la base de datos actual:
```
\conninfo
```
Ejecutar comandos desde un archivo:
```
\i nombre_archivo.sql
```
Salir de psql:
```
\q
```

Recuerda, estos son solo comandos básicos para empezar. PostgreSQL ofrece una amplia gama de características y comandos avanzados para operaciones más complejas y optimizaciones.

Mantenimiento de PostgreSQL

El mantenimiento adecuado de tu instalación de PostgreSQL es crucial para garantizar un rendimiento óptimo, la integridad de los datos y la seguridad. Esta sección cubre algunas tareas de mantenimiento esenciales que deberías conocer.

Iniciar y detener el servicio PostgreSQL

Para iniciar el servicio PostgreSQL:
```
sudo systemctl start postgresql
```
Para detener el servicio PostgreSQL:
```
sudo systemctl stop postgresql
```
Para reiniciar el servicio PostgreSQL:
```
sudo systemctl restart postgresql
```
Para comprobar el estado del servicio PostgreSQL:
```
sudo systemctl status postgresql
```

Respaldando y restaurando bases de datos

Hacer copias de seguridad regulares de tus bases de datos es crucial para la protección de datos. PostgreSQL proporciona varios métodos para hacer copias de seguridad y restauración.

Creando una copia de seguridad

Para hacer una copia de seguridad de una sola base de datos:
```
pg_dump nombredb > nombredb.sql
```
Para hacer una copia de seguridad de todas las bases de datos:
```
pg_dumpall > todas_las_bases_de_datos.sql
```

Restaurando desde una copia de seguridad

Para restaurar una sola base de datos:
```
psql nombredb < nombredb.sql
```

Para restaurar todas las bases de datos:

psql -f todas_las_bases_de_datos.sql postgres

Actualizando PostgreSQL

Mantener PostgreSQL actualizado es importante para la seguridad y el rendimiento. Así es cómo actualizar:

Actualiza la lista de paquetes:
```
sudo apt update
```

Actualiza PostgreSQL:

sudo apt upgrade postgresql postgresql-contrib

Monitorizando PostgreSQL

Comprobar conexiones activas:
```
SELECT * FROM pg_stat_activity;
```

Monitorizar el tamaño de la base de datos:

SELECT pg_size_pretty(pg_database_size('nombredb'));

Comprobar tamaños de tablas:

SELECT relname, pg_size_pretty(pg_total_relation_size(relid))
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC;

Vacuum y Analyze

PostgreSQL utiliza MVCC (Control de Concurrencia Multiversión), lo que puede llevar a un aumento en el tamaño de tablas e índices. El comando VACUUM ayuda a gestionar esto:

Para hacer vacuum a una tabla específica:
```
VACUUM nombretabla;
```
Para hacer vacuum y analyze (actualiza estadísticas) a una base de datos:
```
VACUUM ANALYZE;
```
Para el vacuum automático, asegúrate de que autovacuum esté habilitado en tu archivo postgresql.conf:
```
autovacuum = on
```

Gestión de logs

Los logs de PostgreSQL pueden proporcionar información valiosa para la resolución de problemas y la optimización del rendimiento:

Encuentra la ubicación del archivo de log:
```
SHOW log_directory;
SHOW log_filename;
```
Puedes modificar la configuración de logging en el archivo postgresql.conf para ajustar qué se registra y cómo.

Recuerda, estas son tareas de mantenimiento básicas. Para entornos de producción, es posible que necesites estrategias más avanzadas, incluyendo la configuración de replicación, balanceo de carga y la implementación de soluciones de copia de seguridad y monitorización más sofisticadas.

Solución de problemas comunes

Incluso con una configuración y mantenimiento cuidadosos, es posible que encuentres problemas con tu instalación de PostgreSQL. Aquí tienes algunos problemas comunes y sus soluciones:

Problemas de permisos

Problema: Errores de "Permiso denegado" al intentar acceder a PostgreSQL.

Solución:
- Asegúrate de que el usuario tenga los permisos necesarios:
```
sudo -i -u postgres
createuser --interactive
```
- Otorga los privilegios necesarios al usuario:
```
GRANT ALL PRIVILEGES ON DATABASE midb TO miusuario;
```
Problema: No puedes acceder a PostgreSQL con tu usuario de Ubuntu.

Solución:
- Crea un rol de PostgreSQL con el mismo nombre que tu usuario de Ubuntu:
```
sudo -u postgres createuser --interactive
```

Problemas de conexión

Problema: Error de "Conexión rechazada".

Solución:
- Comprueba si PostgreSQL está en ejecución:
```
sudo systemctl status postgresql
```
- Si no está en ejecución, inícialo:
```
sudo systemctl start postgresql
```
- Asegúrate de que PostgreSQL esté escuchando en la dirección correcta en postgresql.conf:
```
listen_addresses = 'localhost'  # o '*' para todas las interfaces
```
Problema: No puedes conectarte remotamente.

Solución:
- Modifica pg_hba.conf para permitir conexiones remotas:
```
host    all    all    0.0.0.0/0    md5
```
- Actualiza postgresql.conf:
```
listen_addresses = '*'
```
- Reinicia PostgreSQL:
```
sudo systemctl restart postgresql
```

Conflictos de versiones

Problema: Incompatibilidad entre la versión de PostgreSQL y las extensiones instaladas.

Solución:
- Comprueba la versión de PostgreSQL:
```
psql --version
```
- Asegúrate de que las extensiones sean compatibles. Es posible que necesites actualizar las extensiones:
```
ALTER EXTENSION nombre_extension UPDATE TO 'nueva_version';
```

Problemas de rendimiento

Problema: Consultas lentas o rendimiento general deficiente.

Solución:
- Usa EXPLAIN ANALYZE para entender la ejecución de la consulta:
```
EXPLAIN ANALYZE SELECT * FROM tabla_grande WHERE condicion;
```
- Asegúrate de tener una indexación adecuada:
```
CREATE INDEX idx_nombre ON nombre_tabla (nombre_columna);
```
- Ajusta los parámetros de configuración de PostgreSQL en postgresql.conf:
```
shared_buffers = 256MB
effective_cache_size = 768MB
```
Problema: Hinchazón de la base de datos causando degradación del rendimiento.

Solución:
- Ejecuta VACUUM y ANALYZE regularmente:
```
VACUUM ANALYZE;
```
- Considera configurar autovacuum para mantenimiento automático.

Problemas de espacio en disco

Problema: Quedarse sin espacio en disco.

Solución:
- Identifica tablas e índices grandes:
```
SELECT relname, pg_size_pretty(pg_total_relation_size(relid))
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC;
```
- Elimina datos innecesarios o archiva datos antiguos.
- Considera la partición de tablas para tablas muy grandes.

Recuerda, estas son soluciones generales. Los pasos exactos pueden variar dependiendo de tu versión específica de PostgreSQL y la configuración del sistema. Siempre haz una copia de seguridad de tus datos antes de hacer cambios significativos en tu base de datos o su configuración.

Instalar PostgreSQL en Ubuntu

Preguntas frecuentes (FAQ)

P: ¿Cómo puedo saber qué versión de PostgreSQL estoy ejecutando?

R: Puedes usar el siguiente comando en la terminal:

psql --version

O, si ya estás en el prompt de psql:

SELECT version();

P: ¿Puedo tener múltiples versiones de PostgreSQL instaladas en el mismo sistema Ubuntu?

R: Sí, es posible tener múltiples versiones instaladas. Sin embargo, necesitas gestionar cuidadosamente los puertos y directorios de datos para evitar conflictos.

P: ¿Cómo cambio la contraseña del usuario de PostgreSQL?

R: Puedes cambiar la contraseña usando el siguiente comando SQL:

ALTER USER nombreusuario WITH PASSWORD 'nueva_contraseña';

P: ¿Cómo puedo habilitar el acceso remoto a mi servidor PostgreSQL?

R: Necesitas modificar los archivos postgresql.conf y pg_hba.conf. En postgresql.conf, establece listen_addresses = '*', y en pg_hba.conf, añade una línea como host all all 0.0.0.0/0 md5. Recuerda reiniciar PostgreSQL después de hacer estos cambios.

P: ¿Cuál es la diferencia entre TRUNCATE y DELETE en PostgreSQL?

R: TRUNCATE es más rápido ya que elimina todas las filas en una tabla sin escanearlas individualmente. DELETE elimina las filas una por una y registra las eliminaciones en el log de transacciones. TRUNCATE también reinicia las secuencias y no activa los triggers de DELETE.

P: ¿Cómo puedo mejorar el rendimiento de PostgreSQL?

R: Algunas formas de mejorar el rendimiento incluyen:

Indexación adecuada
VACUUM y ANALYZE regulares
Optimización de consultas
Ajuste de los parámetros de configuración de PostgreSQL
Actualización del hardware (especialmente añadir más RAM)