Comments

March 17, 2025

Cómo instalar y proteger phpMyAdmin en Ubuntu

Introducción

Si bien muchos usuarios necesitan la funcionalidad de un sistema de administración de bases de datos como MySQL, es posible que no se sientan cómodos interactuando con el sistema únicamente desde el indicador de MySQL.

phpMyAdmin se creó para que los usuarios puedan interactuar con MySQL a través de una interfaz web. En esta guía, explicaremos cómo instalar y proteger phpMyAdmin para que pueda usarlo de forma segura para administrar sus bases de datos en un sistema Ubuntu.

Cómo instalar y proteger phpMyAdmin en Ubuntu

  1. Instalación de phpMyAdmin
  2. Ajuste de la autenticación y los privilegios del usuario
  3. Cómo proteger su instancia de phpMyAdmin

Prerrequisitos

Para completar esta guía, necesitarás:

  • Un servidor Ubuntu. Este servidor debe tener un usuario no root con privilegios administrativos y un firewall configurado con [nombre del servidor] ufw. Para configurarlo, siga nuestra guía de configuración inicial de servidores para Ubuntu .
  • Una pila LAMP (Linux, Apache, MySQL y PHP) instalada en su servidor Ubuntu. Si aún no lo ha hecho, puede seguir esta guía sobre cómo instalar una pila LAMP en Ubuntu .

Además, hay consideraciones de seguridad importantes al utilizar software como phpMyAdmin, ya que:

  • Se comunica directamente con su instalación de MySQL
  • Maneja la autenticación usando credenciales MySQL
  • Ejecuta y devuelve resultados para consultas SQL arbitrarias

Por estos motivos, y debido a que es una aplicación PHP ampliamente utilizada que frecuentemente es blanco de ataques, nunca debe ejecutar phpMyAdmin en sistemas remotos a través de una conexión HTTP simple.

Si no tiene un dominio configurado con un certificado SSL/TLS, puede seguir esta guía sobre cómo proteger Apache con Let’s Encrypt en Ubuntu . Para ello, deberá registrar un nombre de dominio , crear registros DNS para su servidor y configurar un host virtual Apache .

Paso 1 — Instalación de phpMyAdmin

Puede utilizar APT para instalar phpMyAdmin desde los repositorios predeterminados de Ubuntu.

Como usuario sudo no root, actualice el índice de paquetes de su servidor si no lo ha hecho recientemente:

sudo apt update

A continuación, puede instalar el phpmyadminpaquete. Además, la documentación oficial recomienda instalar algunas extensiones PHP en su servidor para habilitar ciertas funcionalidades y mejorar el rendimiento.

Si siguió el tutorial de la pila LAMP ( requisitos) , varios de estos módulos se habrán instalado junto con el phppaquete. Sin embargo, se recomienda instalar también estos paquetes:

  • php-mbstring:Un módulo para gestionar cadenas que no sean ASCII y convertir cadenas a diferentes codificaciones
  • php-zip:Esta extensión admite la carga de .ziparchivos a phpMyAdmin
  • php-gd:Habilita la compatibilidad con la biblioteca de gráficos GD
  • php-json:Proporciona a PHP soporte para la serialización JSON
  • php-curl: Permite que PHP interactúe con diferentes tipos de servidores utilizando diferentes protocolos

Ejecute el siguiente comando para instalar estos paquetes en su sistema. Tenga en cuenta que el proceso de instalación requiere que realice algunas acciones para configurar phpMyAdmin correctamente. A continuación, explicaremos estas opciones:

sudo apt install phpmyadmin php-mbstring php-zip php-gd php-json php-curl

Estas son las opciones que debes elegir cuando se te solicite para configurar tu instalación correctamente:

  • Para la selección del servidor, elijaapache2

Advertencia: Cuando aparece el mensaje, “apache2” aparece resaltado, pero no seleccionado. Si no pulsa SPACEpara seleccionar Apache, el instalador no moverá los archivos necesarios durante la instalación. Pulse SPACE, TABy luego ENTERpara seleccionar Apache.

  • Seleccione Yescuando se le pregunte si desea utilizar dbconfig-commonpara configurar la base de datos
  • Luego se le pedirá que elija y confirme una contraseña de aplicación MySQL para phpMyAdmin.

Nota : Si instaló MySQL siguiendo el paso 2 del tutorial de la pila LAMP , es posible que haya decidido habilitar el complemento Validar contraseña. Al momento de escribir este artículo, habilitar este componente generará un error al intentar establecer una contraseña para el usuario phpmyadmin :

Error de validación de contraseña de phpMyAdmin

Para solucionar esto, seleccione la opción de cancelar para detener el proceso de instalación. A continuación, abra el símbolo del sistema de MySQL:

sudo mysql

O bien, si habilitó la autenticación de contraseña para el usuario root de MySQL, ejecute este comando y luego ingrese su contraseña cuando se le solicite:

mysql -u root -p

Desde el símbolo del sistema, ejecute el siguiente comando para deshabilitar el componente Validar contraseña. Tenga en cuenta que esto no lo desinstalará, sino que simplemente impedirá que se cargue en su servidor MySQL:

UNINSTALL COMPONENT "file://component_validate_password";

A continuación, puedes cerrar el cliente MySQL:

exit

Luego intenta instalar el phpmyadminpaquete nuevamente y funcionará como se espera:

sudo apt install phpmyadmin

Una vez instalado phpMyAdmin, puede abrir el indicador de MySQL nuevamente con sudo mysqlo mysql -u root -py luego ejecutar el siguiente comando para volver a habilitar el componente Validar contraseña:

INSTALL COMPONENT "file://component_validate_password";

El proceso de instalación agrega el archivo de configuración de Apache de phpMyAdmin al /etc/apache2/conf-enabled/directorio, donde se lee automáticamente. Para finalizar la configuración de Apache y PHP para que funcionen con phpMyAdmin, la única tarea pendiente en esta sección del tutorial es habilitar explícitamente la mbstringextensión de PHP, lo cual puede hacer escribiendo:

sudo phpenmod mbstring

Luego reinicie Apache para que sus cambios sean reconocidos:

sudo systemctl restart apache2

phpMyAdmin ya está instalado y configurado para funcionar con Apache. Sin embargo, antes de iniciar sesión y empezar a interactuar con sus bases de datos MySQL, deberá asegurarse de que sus usuarios MySQL tengan los privilegios necesarios para interactuar con el programa.

Paso 2: Ajuste de la autenticación y los privilegios del usuario

Al instalar phpMyAdmin en su servidor, se crea automáticamente un usuario de base de datos llamado phpmyadmin , que realiza ciertas tareas básicas del programa. En lugar de iniciar sesión con este usuario y la contraseña administrativa que configuró durante la instalación, se recomienda iniciar sesión como usuario root de MySQL o como un usuario dedicado a administrar bases de datos a través de la interfaz de phpMyAdmin.

Configuración del acceso con contraseña para la cuenta raíz de MySQL

En sistemas Ubuntu con MySQL 5.7 (y versiones posteriores), el usuario root de MySQL se autentica mediante el auth_socketcomplemento por defecto, en lugar de una contraseña. Esto ofrece mayor seguridad y usabilidad en muchos casos, pero también puede complicar las cosas cuando se necesita permitir que un programa externo, como phpMyAdmin, acceda al usuario.

Para iniciar sesión en phpMyAdmin como usuario root de MySQL, deberá cambiar su método de autenticación auth_socketa uno con contraseña, si aún no lo ha hecho. Para ello, abra el prompt de MySQL desde su terminal:

sudo mysql

A continuación, verifique qué método de autenticación utiliza cada una de sus cuentas de usuario de MySQL con el siguiente comando:

SELECT user,authentication_string,plugin,host FROM mysql.user;

Output+------------------+------------------------------------------------------------------------+-----------------------+-----------+
| user             | authentication_string                                                  | plugin                | host      |
+------------------+------------------------------------------------------------------------+-----------------------+-----------+
| debian-sys-maint | $A$005$I:jOry?]Sy<|qhQRj3fBRQ43i4UJxrpm.IaT6lOHkgveJjmeIjJrRe6         | caching_sha2_password | localhost |
| mysql.infoschema | $A$005$THISISACOMBINATIONOFINVALIDSALTANDPASSWORDTHATMUSTNEVERBRBEUSED | caching_sha2_password | localhost |
| mysql.session    | $A$005$THISISACOMBINATIONOFINVALIDSALTANDPASSWORDTHATMUSTNEVERBRBEUSED | caching_sha2_password | localhost |
| mysql.sys        | $A$005$THISISACOMBINATIONOFINVALIDSALTANDPASSWORDTHATMUSTNEVERBRBEUSED | caching_sha2_password | localhost |
| phpmyadmin       | $A$005$?#{Z?`gN!c2az)}V-INCWXSuVdqB9zWteH1IkZfTe/rOLgVhSzEMM9R3G6K9    | caching_sha2_password | localhost |
| root             |                                                                        | auth_socket           | localhost |
+------------------+------------------------------------------------------------------------+-----------------------+-----------+
6 rows in set (0.00 sec)

Este ejemplo de salida indica que el usuario root se autentica mediante el auth_socketcomplemento. Para configurar la cuenta root para que se autentique con una contraseña, ejecute el siguiente ALTER USERcomando. Asegúrese de usar passworduna contraseña segura de su elección:

ALTER USER 'root'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';

NotaALTER USER : La declaración anterior establece que el usuario root de MySQL se autentique con el caching_sha2_passwordcomplemento. Según la documentación oficial de MySQL , caching_sha2_passwordes el complemento de autenticación preferido de MySQL, ya que proporciona un cifrado de contraseñas más seguro que el anterior, pero aún ampliamente utilizado, mysql_native_password.

Sin embargo, algunas versiones de PHP no funcionan correctamente con [ nombre de usuario caching_sha2_password]. PHP ha informado que este problema se solucionó a partir de PHP 7.4 , pero si encuentra un error al intentar iniciar sesión en phpMyAdmin más adelante, le recomendamos configurar root para que se autentique con mysql_native_password[nombre de usuario].

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

Luego, verifique nuevamente los métodos de autenticación empleados por cada uno de sus usuarios para confirmar que root ya no se autentica usando el auth_socketcomplemento:

SELECT user,authentication_string,plugin,host FROM mysql.user;

Output+------------------+------------------------------------------------------------------------+-----------------------+-----------+
| user             | authentication_string                                                  | plugin                | host      |
+------------------+------------------------------------------------------------------------+-----------------------+-----------+
| debian-sys-maint | $A$005$I:jOry?]Sy<|qhQRj3fBRQ43i4UJxrpm.IaT6lOHkgveJjmeIjJrRe6         | caching_sha2_password | localhost |
| mysql.infoschema | $A$005$THISISACOMBINATIONOFINVALIDSALTANDPASSWORDTHATMUSTNEVERBRBEUSED | caching_sha2_password | localhost |
| mysql.session    | $A$005$THISISACOMBINATIONOFINVALIDSALTANDPASSWORDTHATMUSTNEVERBRBEUSED | caching_sha2_password | localhost |
| mysql.sys        | $A$005$THISISACOMBINATIONOFINVALIDSALTANDPASSWORDTHATMUSTNEVERBRBEUSED | caching_sha2_password | localhost |
| phpmyadmin       | $A$005$?#{Z?`gN!c2az)}V-INCWXSuVdqB9zWteH1IkZfTe/rOLgVhSzEMM9R3G6K9    | caching_sha2_password | localhost |
| root             | $A$005$3y�y|Z?'_[} ZyVHuESVwNmjKWOH/ndETwS.Kty0IH7UfiXjOfVvyWroy4a.   | caching_sha2_password | localhost |
+------------------+------------------------------------------------------------------------+-----------------------+-----------+
6 rows in set (0.00 sec)

Este resultado muestra que el usuario root se autenticará con una contraseña. Ahora puede iniciar sesión en la interfaz de phpMyAdmin como usuario root con la contraseña que haya configurado aquí.

Configuración del acceso con contraseña para un usuario dedicado de MySQL

Como alternativa, algunos usuarios podrían encontrar más conveniente conectarse a phpMyAdmin con un usuario dedicado. Para ello, abra de nuevo la consola MySQL:

sudo mysql

Si tiene habilitada la autenticación de contraseña para su usuario root , como se describe en la sección anterior, deberá ejecutar el siguiente comando e ingresar su contraseña cuando se le solicite para poder conectarse:

mysql -u root -p

Desde allí, crea un nuevo usuario y asígnale una contraseña segura:

CREATE USER 'sammy'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';

Nota : Nuevamente, dependiendo de qué versión de PHP tenga instalada, es posible que desee configurar su nuevo usuario para que se autentique con mysql_native_passworden lugar de caching_sha2_password:

ALTER USER 'sammy'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

Luego, otorgue al nuevo usuario los privilegios correspondientes. Por ejemplo, podría otorgarle privilegios para todas las tablas de la base de datos, así como la posibilidad de agregar, modificar y eliminar privilegios de usuario, con este comando:

GRANT ALL PRIVILEGES ON *.* TO 'sammy'@'localhost' WITH GRANT OPTION;

A continuación, salga del shell MySQL:

exit

Ahora puede acceder a la interfaz web visitando el nombre de dominio o la dirección IP pública de su servidor seguido de /phpmyadmin:

https://your_domain_or_IP/phpmyadmin
Pantalla de inicio de sesión de phpMyAdmin

Inicie sesión en la interfaz, ya sea como root o con el nuevo nombre de usuario y contraseña que acaba de configurar.

Cuando inicie sesión, será llevado a la interfaz de usuario de phpMyAdmin:

Interfaz de usuario de phpMyAdmin

Ahora que puede conectarse e interactuar con phpMyAdmin, todo lo que queda por hacer es reforzar la seguridad de su sistema para protegerlo de los atacantes.

Paso 3: Protección de su instancia phpMyAdmin

Debido a su ubicuidad, phpMyAdmin es un objetivo común para los atacantes, por lo que se recomienda extremar las precauciones para evitar el acceso no autorizado. Una forma de lograrlo es colocar una puerta de enlace frente a toda la aplicación mediante las funcionalidades integradas de .htaccessautenticación y autorización de Apache.

Para ello, primero debe habilitar el uso de .htaccessanulaciones de archivos editando el archivo de configuración de Apache de su instalación de phpMyAdmin.

Utilice su editor de texto preferido para editar el phpmyadmin.confarchivo ubicado en el directorio de configuración de Apache. Aquí usaremos nano:

sudo nano /etc/apache2/conf-available/phpmyadmin.conf

Agregue una AllowOverride Alldirectiva dentro de la <Directory /usr/share/phpmyadmin>sección del archivo de configuración, como esta: /etc/apache2/conf-available/phpmyadmin.conf

<Directory /usr/share/phpmyadmin>
    Options SymLinksIfOwnerMatch
    DirectoryIndex index.php
    AllowOverride All
    . . .

Una vez agregada esta línea, guarde y cierre el archivo. Si solía nanoeditarlo, hágalo presionando CTRL + X, Yy luego ENTER.

Para implementar los cambios realizados, reinicie Apache:

sudo systemctl restart apache2

Ahora que ha habilitado el uso de .htaccessarchivos para su aplicación, necesita crear uno para implementar cierta seguridad.

Para que esto funcione correctamente, el archivo debe crearse en el directorio de la aplicación. Puede crear el archivo necesario y abrirlo en su editor de texto con privilegios de root escribiendo:

sudo nano /usr/share/phpmyadmin/.htaccess

Dentro de este archivo, ingrese la siguiente información: /usr/share/phpmyadmin/.htaccess

AuthType Basic
AuthName "Restricted Files"
AuthUserFile /etc/phpmyadmin/.htpasswd
Require valid-user

Esto es lo que significa cada una de estas líneas:

  • AuthType BasicEsta línea especifica el tipo de autenticación que se está implementando. Este tipo implementará la autenticación por contraseña mediante un archivo de contraseñas.
  • AuthName: Esto configura el mensaje del cuadro de diálogo de autenticación. Debe ser genérico para que usuarios no autorizados no obtengan información sobre lo que se está protegiendo.
  • AuthUserFile: Esto establece la ubicación del archivo de contraseñas que se usará para la autenticación. Debe estar fuera de los directorios que se sirven. Lo crearemos en breve.
  • Require valid-userEsto especifica que solo los usuarios autenticados deben tener acceso a este recurso. Esto es lo que impide el acceso de usuarios no autorizados.

Cuando haya terminado, guarde y cierre el archivo.

La ubicación que seleccionó para su archivo de contraseñas era [nombre del archivo] /etc/phpmyadmin/.htpasswd. Ahora puede crear este archivo y asignarle un usuario inicial con la htpasswdutilidad:

sudo htpasswd -c /etc/phpmyadmin/.htpasswd username

Se le pedirá que seleccione y confirme una contraseña para el usuario que está creando. Después, se creará el archivo con la contraseña cifrada que ingresó.

Si deseas ingresar un usuario adicional, debes hacerlo sin la -cbandera, de la siguiente manera:

sudo htpasswd /etc/phpmyadmin/.htpasswd additionaluser

Luego reinicie Apache para que .htaccessla autenticación surta efecto:

sudo systemctl restart apache2

Ahora, cuando acceda a su subdirectorio phpMyAdmin, se le solicitará el nombre de cuenta y la contraseña adicionales que acaba de configurar:

https://domain_name_or_IP/phpmyadmin
Contraseña de Apache en phpMyAdmin

Tras introducir la autenticación de Apache, accederá a la página de autenticación habitual de phpMyAdmin para introducir sus credenciales de MySQL. Al añadir un conjunto adicional de credenciales que no sean de MySQL, proporciona a su base de datos una capa adicional de seguridad. Esto es conveniente, ya que phpMyAdmin ha sido vulnerable a amenazas de seguridad en el pasado.

Conclusión

Ya debería tener phpMyAdmin configurado y listo para usar en su servidor Ubuntu. Con esta interfaz, puede crear bases de datos, usuarios y tablas, así como realizar operaciones habituales como eliminar y modificar estructuras y datos.

Stephen Dove
Comments

March 17, 2025

Cómo proteger Apache con Let’s Encrypt en Ubuntu

Introducción

Let’s Encrypt es una autoridad de certificación (CA) que facilita la obtención e instalación de certificados TLS/SSL gratuitos , lo que permite el cifrado HTTPS en servidores web. Agiliza el proceso al proporcionar un cliente de software, Certbot, que intenta automatizar la mayoría (si no todos) de los pasos necesarios. Actualmente, todo el proceso de obtención e instalación de un certificado está completamente automatizado tanto en Apache como en Nginx.

En esta guía, utilizará Certbot para obtener un certificado SSL gratuito para Apache en Ubuntu y se asegurará de que este certificado esté configurado para renovarse automáticamente.

Este tutorial utiliza un archivo de host virtual independiente en lugar del archivo de configuración predeterminado de Apache para configurar el sitio web que se protegerá con Let’s Encrypt. Recomendamos crear nuevos archivos de host virtual de Apache para cada dominio alojado en un servidor, ya que esto ayuda a evitar errores comunes y mantiene los archivos de configuración predeterminados como respaldo.

Cómo proteger Apache con Let’s Encrypt en Ubuntu

  1. Instalación de Certbot
  2. Comprobación de la configuración del host virtual Apache
  3. Permitir HTTPS a través del firewall
  4. Obtener un certificado SSL
  5. Verificación de la renovación automática de Certbot

Prerrequisitos

Para seguir este tutorial, necesitarás:

  • Un servidor Ubuntu configurado con un usuario no root con sudoprivilegios administrativos y el firewall habilitado. Puede configurarlo siguiendo nuestro tutorial de configuración inicial de servidores para Ubuntu .
  • Un nombre de dominio completamente registrado. Este tutorial usará “your_domain” como ejemplo. Puedes comprar un nombre de dominio en Namecheap , obtener uno gratis en Freenom o usar el registrador de dominios que prefieras.
  • Los dos siguientes registros DNS están configurados para su servidor. Puede consultar esta introducción al DNS de IsnHosting para obtener más información sobre cómo agregarlos.
    • Un registro A que your_domainapunta a la dirección IP pública de su servidor.
    • Un registro A que apunta a la dirección IP pública de su servidor.www.your_domain
  • Apache se instaló siguiendo el procedimiento “Cómo instalar Apache en Ubuntu” . Asegúrate de tener un archivo de host virtual para tu dominio. Este tutorial se usará como ejemplo./etc/apache2/sites-available/your_domain.conf

Paso 1: Instalación de Certbot

Para obtener un certificado SSL con Let’s Encrypt, debe instalar el software Certbot en su servidor. Para ello, usará los repositorios de paquetes predeterminados de Ubuntu.

Primero, actualice el índice del paquete local:

sudo apt update

Necesita dos paquetes: certboty python3-certbot-apache. Este último es un complemento que integra Certbot con Apache, lo que permite automatizar la obtención de un certificado y la configuración de HTTPS en su servidor web con un solo comando:

sudo apt install certbot python3-certbot-apache

Se le pedirá que confirme la instalación presionando Yy luego ENTER.

Certbot ya está instalado en su servidor. En el siguiente paso, verificará la configuración de Apache para asegurarse de que su host virtual esté configurado correctamente. Esto garantizará que el certbotscript del cliente pueda detectar sus dominios y reconfigurar su servidor web para usar automáticamente el certificado SSL recién generado.

Paso 2: Comprobación de la configuración del host virtual Apache

Para obtener y configurar automáticamente el SSL para su servidor web, Certbot necesita encontrar el host virtual correcto en sus archivos de configuración de Apache. Los nombres de dominio de su servidor se obtendrán de las ServerNamedirectivas ServerAliasy definidas en su VirtualHostbloque de configuración.

Si siguió el paso de configuración del host virtual en el tutorial de instalación de Apache , debería tener un bloque VirtualHost configurado para su dominio con las directivas y también las directivas ya configuradas adecuadamente./etc/apache2/sites-available/your_domain.confServerNameServerAlias

Para confirmar que esto está configurado, abra el archivo de host virtual de su dominio usando nanosu editor de texto preferido:

sudo nano /etc/apache2/sites-available/your_domain.conf

Encuentre las líneas ServerNamey existentes ServerAlias. Deben estar listadas de la siguiente manera: /etc/apache2/sitios-disponibles/su_dominio.conf

...
ServerName your_domain
ServerAlias www.your_domain
...

Si ya tiene su ServerNamey ServerAliasconfigurado así, puede salir del editor de texto y continuar con el siguiente paso. Si la configuración actual de su host virtual no coincide con el ejemplo, actualícela. Si usa nano, puede salir pulsando CTRL+X, y luego Yy ENTERpara confirmar los cambios, si los hay. A continuación, ejecute el siguiente comando para validar los cambios:

sudo apache2ctl configtest

Debería recibir Syntax OKuna respuesta. Si recibe un error, vuelva a abrir el archivo del host virtual y compruebe si hay errores tipográficos o caracteres faltantes. Una vez que la sintaxis del archivo de configuración sea correcta, reinicie Apache para que los cambios surtan efecto:

sudo systemctl reload apache2

Con estos cambios, Certbot podrá encontrar el bloque VirtualHost correcto y actualizarlo.

A continuación, actualizará el firewall para permitir el tráfico HTTPS.

Paso 3: Permitir HTTPS a través del firewall

Si tiene habilitado el firewall UFW, como se recomienda en las guías de prerrequisitos, deberá ajustar la configuración para permitir el tráfico HTTPS. Tras la instalación, Apache registra diferentes perfiles de aplicación UFW. Puede usar el perfil completo de Apache para permitir el tráfico HTTP y HTTPS en su servidor.

Para verificar qué tipo de tráfico está permitido actualmente en su servidor, verifique el estado:

sudo ufw status

Si siguió una de nuestras guías de instalación de Apache, obtendrá un resultado similar al siguiente, lo que significa que 80actualmente solo se permite el tráfico HTTP en el puerto:

OutputStatus: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
Apache                     ALLOW       Anywhere             
OpenSSH (v6)               ALLOW       Anywhere (v6)             
Apache (v6)                ALLOW       Anywhere (v6)

Para permitir el tráfico HTTPS, habilite el perfil “Apache Full”:

sudo ufw allow 'Apache Full'

A continuación elimine el perfil redundante “Apache”:

sudo ufw delete allow 'Apache'

Su estado se mostrará de la siguiente manera:

sudo ufw status

OutputStatus: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
Apache Full                ALLOW       Anywhere                  
OpenSSH (v6)               ALLOW       Anywhere (v6)             
Apache Full (v6)           ALLOW       Anywhere (v6)        

Ahora está listo para ejecutar Certbot y obtener sus certificados.

Paso 4: Obtener un certificado SSL

Certbot ofrece diversas maneras de obtener certificados SSL mediante complementos. El complemento de Apache se encargará de reconfigurar Apache y recargar la configuración cuando sea necesario. Para usar este complemento, ejecute lo siguiente:

sudo certbot --apache

Este script le solicitará que responda a una serie de preguntas para configurar su certificado SSL. Primero, le solicitará una dirección de correo electrónico válida. Esta dirección se utilizará para notificaciones de renovación y avisos de seguridad.

OutputSaving debug log to /var/log/letsencrypt/letsencrypt.log
Enter email address (used for urgent renewal and security notices)
 (Enter 'c' to cancel): you@your_domain

Tras proporcionar una dirección de correo electrónico válida, pulse ENTERpara continuar. Se le pedirá que confirme si acepta los términos de servicio de Let’s Encrypt. Puede confirmar pulsando Yy luego ENTER:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
agree in order to register with the ACME server at
https://acme-v02.api.letsencrypt.org/directory
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Y)es/(N)o: Y

A continuación, se le preguntará si desea compartir su correo electrónico con la Electronic Frontier Foundation para recibir noticias e información. Si no desea suscribirse a su contenido, escriba N. De lo contrario, escriba Yy luego presione ENTERpara continuar.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Would you be willing to share your email address with the Electronic Frontier
Foundation, a founding partner of the Let's Encrypt project and the non-profit
organization that develops Certbot? We'd like to send you email about our work
encrypting the web, EFF news, campaigns, and ways to support digital freedom.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Y)es/(N)o: N

El siguiente paso le solicitará que informe a Certbot sobre los dominios para los que desea activar HTTPS. Los nombres de dominio se obtienen automáticamente de la configuración de su host virtual Apache, por lo que es importante asegurarse de tener la configuración correcta ServerNameen ServerAliassu host virtual. Si desea habilitar HTTPS para todos los nombres de dominio (recomendado), puede dejar el mensaje en blanco y presionar ENTERpara continuar. De lo contrario, seleccione los dominios para los que desea habilitar HTTPS indicando cada número correspondiente, separado por comas o espacios, y luego presione ENTER:

Which names would you like to activate HTTPS for?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: your_domain
2: www.your_domain
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate numbers separated by commas and/or spaces, or leave input
blank to select all options shown (Enter 'c' to cancel): 

Después de este paso, la configuración de Certbot habrá finalizado y se le presentarán las observaciones finales sobre su nuevo certificado y dónde ubicar los archivos generados:

OutputSuccessfully received certificate.
Certificate is saved at: /etc/letsencrypt/live/your_domain/fullchain.pem
Key is saved at:         /etc/letsencrypt/live/your_domain/privkey.pem
This certificate expires on 2022-07-10.
These files will be updated when the certificate renews.
Certbot has set up a scheduled task to automatically renew this certificate in the background.

Deploying certificate
Successfully deployed certificate for your_domain to /etc/apache2/sites-available/your_domain-le-ssl.conf
Successfully deployed certificate for www.your_domain.com to /etc/apache2/sites-available/your_domain-le-ssl.conf
Congratulations! You have successfully enabled HTTPS on https:/your_domain and https://www.your_domain.com

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
If you like Certbot, please consider supporting our work by:
 * Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
 * Donating to EFF:                    https://eff.org/donate-le
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Su certificado ya está instalado y cargado en la configuración de Apache. Intente recargar su sitio web https://y observe el indicador de seguridad de su navegador. Debería indicar que su sitio está correctamente protegido, generalmente con un icono de candado en la barra de direcciones.

Puedes utilizar el Test de Servidor SSL Labs para verificar la calificación de tu certificado y obtener información detallada sobre el mismo, desde la perspectiva de un servicio externo.

En el siguiente y último paso, probará la función de renovación automática de Certbot, que garantiza que su certificado se renovará automáticamente antes de la fecha de vencimiento.

Paso 5: Verificación de la renovación automática de Certbot

Los certificados de Let’s Encrypt solo tienen una validez de noventa días. Esto anima a los usuarios a automatizar el proceso de renovación de sus certificados y a garantizar que los certificados mal utilizados o las claves robadas caduquen lo antes posible.

El certbotpaquete que instaló gestiona las renovaciones mediante un script de renovación /etc/cron.d, administrado por un systemctlservicio llamado certbot.timer. Este script se ejecuta dos veces al día y renovará automáticamente cualquier certificado con un vencimiento dentro de los treinta días.

Para comprobar el estado de este servicio y asegurarse de que esté activo, ejecute lo siguiente:

sudo systemctl status certbot.timer

El resultado será similar al siguiente:

Output● certbot.timer - Run certbot twice daily
     Loaded: loaded (/lib/systemd/system/certbot.timer; enabled; vendor preset:>
     Active: active (waiting) since Mon 2022-04-11 20:52:46 UTC; 4min 3s ago
    Trigger: Tue 2022-04-12 00:56:55 UTC; 4h 0min left
   Triggers: ● certbot.service

Apr 11 20:52:46 jammy-encrypt systemd[1]: Started Run certbot twice daily.

Para probar el proceso de renovación, puede realizar un ensayo con certbot:

sudo certbot renew --dry-run

OutputSaving debug log to /var/log/letsencrypt/letsencrypt.log

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Processing /etc/letsencrypt/renewal/your_domain.conf
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Account registered.
Simulating renewal of an existing certificate for your_domain and www.your_domain.com

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Congratulations, all simulated renewals succeeded:
  /etc/letsencrypt/live/your_domain/fullchain.pem (success)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Si no recibe ningún error, ya está todo listo. Cuando sea necesario, Certbot renovará sus certificados y reiniciará Apache para que se apliquen los cambios. Si el proceso de renovación automática falla, Let’s Encrypt le enviará un mensaje al correo electrónico que especificó para avisarle cuando su certificado esté a punto de caducar.

Conclusión

En este tutorial, instaló el cliente Let’s Encrypt certbot, configuró e instaló un certificado SSL para su dominio y confirmó que el servicio de renovación automática de Certbot está activo en [nombre del dominio] systemctl. Si tiene más preguntas sobre el uso de Certbot, su documentación es un buen punto de partida.

Stephen Dove
Comments

March 17, 2025

Cómo ejecutar un script de Python en Ubuntu

Introducción

A medida que el desarrollo de herramientas basadas en IA se vuelve cada vez más popular entre los desarrolladores, Python se ha consolidado como uno de los mejores lenguajes de programación para IA gracias a su simplicidad, legibilidad y amplias bibliotecas como TensorFlow, PyTorch y scikit-learn. Estas bibliotecas proporcionan potentes herramientas para el aprendizaje automático, el análisis de datos y las redes neuronales, lo que convierte a Python en una excelente opción para proyectos de IA y aprendizaje automático.

Considerando el papel central de Python en la IA, es importante aprender a ejecutar scripts de Python eficazmente. Este tutorial está diseñado para ayudarte a empezar a ejecutar scripts sencillos de Python en una máquina Ubuntu, sentando las bases para scripts de IA más avanzados.

Prerrequisitos

Para seguir este tutorial, necesitarás:

  • Un servidor con Ubuntu, un usuario no root con privilegios de sudo y un firewall activo. Para obtener instrucciones sobre cómo configurarlo, seleccione su distribución de esta lista y siga nuestra guía de configuración inicial del servidor. Asegúrese de trabajar con una versión compatible de Ubuntu.
  • Familiarización con la línea de comandos de Linux. Para una introducción o un repaso de la línea de comandos, puede consultar esta guía sobre la línea de comandos de Linux .
  • Antes de comenzar, ejecute sudo apt-get updatela terminal de Ubuntu para asegurarse de que su sistema tenga las últimas versiones y actualizaciones de seguridad para el software disponible en los repositorios configurados en su sistema.

Estas instrucciones son válidas para las versiones más recientes de Ubuntu: Ubuntu 24.04, Ubuntu 22.04 y Ubuntu 20.04. Si usa una versión de Ubuntu anterior a la 18.04, le recomendamos actualizar a una versión más reciente, ya que Ubuntu ya no ofrece soporte para estas versiones. Esta colección de guías le ayudará a actualizar su versión de Ubuntu.

Ejecutar un script de Python en Ubuntu

  • Configurar el entorno de Python
  • Crear un script de Python
  • Instalar los paquetes necesarios
  • Ejecutar scripts de Python
  • Hacer que el script sea ejecutable

Paso 1: Configuración del entorno de Python

Ubuntu 24.04 incluye Python 3 por defecto. Abra la terminal y ejecute el siguiente comando para comprobar la instalación de Python 3:

python3 --version

Si Python 3 ya está instalado en su equipo, este comando devolverá la versión actual de la instalación de Python 3. Si no está instalado, puede ejecutar el siguiente comando para obtener la instalación de Python 3:

sudo apt install python3

A continuación, debe instalar el pipinstalador de paquetes en su sistema:

sudo apt install python3-pip

Paso 2: Crear un script de Python

El siguiente paso es escribir el código Python que quieres ejecutar. Para crear un nuevo script, navega al directorio que prefieras:

cd ~/path-to-your-script-directory

Una vez dentro del directorio, necesitas crear un nuevo archivo. En la terminal, ejecuta el siguiente comando:

nano demo_ai.py

Se abrirá un editor de texto en blanco. Escribe tu lógica aquí o copia el siguiente código:

from sklearn.tree import DecisionTreeClassifier
import numpy as np
import random

# Generate sample data
x = np.array([[i] for i in range(1, 21)])  # Numbers 1 to 20
y = np.array([i % 2 for i in range(1, 21)])  # 0 for even, 1 for odd

# Create and train the model
model = DecisionTreeClassifier()
model.fit(x, y)

# Function to predict if a number is odd or even
def predict_odd_even(number):
    prediction = model.predict([[number]])
    return "Odd" if prediction[0] == 1 else "Even"

if __name__ == "__main__":
    num = random.randint(0, 20)
    result = predict_odd_even(num)
    print(f"The number {num} is an {result} number.")

Este script crea un clasificador de árbol de decisión simple usando la scikit-learnbiblioteca. Entrena el modelo para reconocer números pares e impares basándose en los datos de muestra generados aleatoriamente. A continuación, realiza una predicción basada en su aprendizaje para el número dado.

Guardar y salir del editor de texto.

Paso 3: Instalar los paquetes necesarios

En este paso, instalará los paquetes que utilizó en el script anterior.

El primer paquete que necesitas instalar es NumPy . Usaste esta biblioteca para crear un conjunto de datos para entrenar el modelo de aprendizaje automático.

A partir de Python 3.11 y pip 22.3, existe un nuevo PEP 668 que indica que los entornos base de Python deben marcarse como “administrados externamente”. Por eso, la simple ejecución pip3 scikit-learn numpyde comandos de instalación de numpy o similares generará un error error: externally-managed-environment.

Para instalar y usar numpycorrectamente, necesita crear un entorno virtual que aísle sus paquetes de Python del entorno del sistema. Esto es importante porque mantiene separadas las dependencias requeridas por los diferentes proyectos y evita posibles conflictos entre las versiones de los paquetes.

Primero, instale virtualenvejecutando:

sudo apt install python3-venv

Ahora, utiliza esta herramienta para crear un entorno virtual dentro de tu directorio de trabajo.

python3 -m venv python-env

El siguiente paso es activar este entorno virtual ejecutando el script de activación.

source python-env/bin/activate

Durante la ejecución, verá el indicador de terminal precedido con el nombre de su entorno virtual de la siguiente manera:

Output(python-env) ubuntu@user:

Ahora, instale los paquetes necesarios ejecutando:

pip install scikit-learn numpy

El randommódulo forma parte de la biblioteca estándar de Python, por lo que no necesita instalarse por separado. Está incluido en Python y puede usarse directamente sin necesidad de instalaciones adicionales.

Paso 4: Ejecutar el script de Python

Ahora que tiene todos los paquetes necesarios en su lugar, puede ejecutar su script de Python ejecutando el siguiente comando dentro de su directorio de trabajo:

python3 demo_ai.py

Tras la ejecución exitosa, verá el resultado deseado.

Output(python-env) ubuntu@user:~/scripts/python demo_ai.py
The number 5 is an Odd number.
(python-env) ubuntu@user:~/scripts/python demo_ai.py
The number 17 is an Odd number.

Paso 5 [OPCIONAL] – Hacer que el script sea ejecutable

Al hacer que el script sea ejecutable, se puede ejecutar directamente sin necesidad de llamar explícitamente a Python escribiendo python3. Esto agiliza y facilita la ejecución del script.

Abra su script de Python usando un editor de texto.

nano demo_ai.py

En la parte superior del archivo, agregue una #!línea shebang ie que indique al sistema qué intérprete usar al ejecutar el script. Añada la siguiente línea antes del código:

#!/usr/bin/env python3

Guarde y cierre el archivo.

Ahora, haga que este script sea ejecutable para permitir que se ejecute como cualquier otro programa o comando en su terminal.

chmod +x demo_ai.py

Tras una ejecución exitosa, recibirá el control inmediatamente. A partir de ahora, puede ejecutar su script de la siguiente manera:

./demo_ai.py

Conclusión

Ejecutar scripts de Python en una máquina Ubuntu es un proceso sencillo. Al comprender cómo ejecutar scripts de Python, podrá comenzar a explorar las potentes herramientas que ofrece Python, incluidas aquellas esenciales para el desarrollo de IA.

Stephen Dove
Comments

March 17, 2025

Conceptos básicos de UFW: reglas y comandos comunes de firewall

Introducción

UFW ( cortafuegos sencillo ) es una herramienta de configuración de cortafuegos que se ejecuta sobre [nombre del archivo] , incluida por iptablesdefecto en las distribuciones de Ubuntu. Proporciona una interfaz optimizada para configurar casos de uso comunes de cortafuegos mediante la línea de comandos.

Esta guía en formato de hoja de trucos proporciona una referencia rápida a los casos de uso y comandos comunes de UFW, incluidos ejemplos de cómo permitir y bloquear servicios por puerto, interfaz de red y dirección IP de origen.

Cómo utilizar esta guía

  • Esta guía tiene formato de hoja de trucos con fragmentos de línea de comandos independientes.
  • Salte a cualquier sección que sea relevante para la tarea que está intentando completar.
  • Cuando vea texto resaltado en los comandos de esta guía, tenga en cuenta que este texto debe referirse a las direcciones IP de su propia red.

Recuerda que puedes consultar tu conjunto de reglas UFW actual con sudo ufw statuso sudo ufw status verbose.

Implementa tus aplicaciones frontend desde GitHub con la plataforma de aplicaciones DigitalOcean . Deja que DigitalOcean se encargue de escalar tu aplicación.

Verificar el estado de UFW

Para comprobar si ufwestá habilitado, ejecute:

sudo ufw status

OutputStatus: inactive

La salida indicará si su firewall está activo o no.

Habilitar UFW

Si recibiste un Status: inactivemensaje al ejecutar [Nombre del programa] ufw status, significa que el firewall aún no está habilitado en el sistema. Deberás ejecutar un comando para habilitarlo.

De forma predeterminada, al habilitar UFW, se bloqueará el acceso externo a todos los puertos del servidor. En la práctica, esto significa que si está conectado a un servidor por SSH y lo habilita ufwantes de permitir el acceso por el puerto SSH, se desconectará. Asegúrese de seguir la sección sobre cómo habilitar el acceso por SSH de esta guía antes de habilitar el firewall si ese es su caso.

Para habilitar UFW en su sistema, ejecute:

sudo ufw enable

Verás un resultado como este:

OutputFirewall is active and enabled on system startup

Para ver qué está bloqueado o permitido actualmente, puede utilizar el verboseparámetro al ejecutar ufw status, de la siguiente manera:

sudo ufw status

OutputStatus: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), deny (routed)
New profiles: skip

Desactivar UFW

Si por alguna razón necesita deshabilitar UFW, puede hacerlo con el siguiente comando:

sudo ufw disable

Tenga en cuenta que este comando deshabilitará completamente el servicio de firewall en su sistema.

Bloquear una dirección IP

Para bloquear todas las conexiones de red que se originan desde una dirección IP específica, ejecute el siguiente comando, reemplazando la dirección IP resaltada con la dirección IP que desea bloquear:

sudo ufw deny from 203.0.113.100

OutputRule added

En este ejemplo, from 203.0.113.100se especifica una dirección IP de origen de “203.0.113.100”.

Si lo ejecuta sudo ufw statusahora, verá la dirección IP especificada como denegada:

OutputStatus: active

To                         Action      From
--                         ------      ----
Anywhere                   DENY        203.0.113.100         

Todas las conexiones, entrantes o salientes, están bloqueadas para la dirección IP especificada.

Bloquear una subred

Si necesita bloquear una subred completa, puede usar la dirección de subred como fromparámetro en el ufw denycomando. Esto bloquearía todas las direcciones IP de la subred de ejemplo 203.0.113.0/24:

sudo ufw deny from 203.0.113.0/24

OutputRule added

Bloquear conexiones entrantes a una interfaz de red

Para bloquear conexiones entrantes desde una dirección IP específica a una interfaz de red específica, ejecute el siguiente comando, reemplazando la dirección IP resaltada con la dirección IP que desea bloquear:

sudo ufw deny in on eth0 from 203.0.113.100

OutputRule added

El inparámetro indica ufwque la regla se aplique solo a las conexiones entrantes y on eth0especifica que se aplica solo a la eth0interfaz. Esto puede ser útil si tiene un sistema con varias interfaces de red (incluidas las virtuales) y necesita bloquear el acceso externo a algunas de ellas, pero no a todas.

Permitir una dirección IP

Para permitir todas las conexiones de red que se originan desde una dirección IP específica, ejecute el siguiente comando, reemplazando la dirección IP resaltada con la dirección IP a la que desea permitir el acceso:

sudo ufw allow from 203.0.113.101

OutputRule added

Si lo ejecuta sudo ufw statusahora, verá un resultado similar a este, mostrando la palabra ALLOWjunto a la dirección IP que acaba de agregar.

OutputStatus: active

To                         Action      From
--                         ------      ----
...          
Anywhere                   ALLOW       203.0.113.101 

También puede permitir conexiones desde una subred completa proporcionando la máscara de subred correspondiente para un host, como 203.0.113.0/24.

Permitir conexiones entrantes a una interfaz de red

Para permitir conexiones entrantes desde una dirección IP específica a una interfaz de red específica, ejecute el siguiente comando, reemplazando la dirección IP resaltada con la dirección IP que desea permitir:

sudo ufw allow in on eth0 from 203.0.113.102

OutputRule added

El inparámetro indica ufwque se debe aplicar la regla solo a las conexiones entrantes y el on eth0parámetro especifica que la regla se aplica solo a la eth0interfaz.

Si lo ejecuta sudo ufw statusahora, verá un resultado similar a este:

OutputStatus: active

To                         Action      From
--                         ------      ----
...         
Anywhere on eth0           ALLOW       203.0.113.102            

Eliminar la regla de la UFW

Para eliminar una regla configurada previamente en UFW, utilice ufw deleteseguido de la regla ( allowo deny) y la especificación del objetivo. El siguiente ejemplo eliminaría una regla configurada previamente para permitir todas las conexiones desde una dirección IP de 203.0.113.101:

sudo ufw delete allow from 203.0.113.101

OutputRule deleted

Otra forma de especificar la regla que desea eliminar es proporcionar su ID. Esta información se puede obtener con el siguiente comando:

sudo ufw status numbered

OutputStatus: active

     To                         Action      From
     --                         ------      ----
[ 1] Anywhere                   DENY IN     203.0.113.100             
[ 2] Anywhere on eth0           ALLOW IN    203.0.113.102             

En el resultado, se puede ver que hay dos reglas activas. La primera, con valores resaltados, deniega todas las conexiones provenientes de la dirección IP 203.0.113.100. La segunda, permite las conexiones en la eth0interfaz provenientes de la dirección IP 203.0.113.102.

Dado que, por defecto, UFW bloquea todo acceso externo a menos que se permita explícitamente, la primera regla es redundante, por lo que puede eliminarla. Para eliminar una regla por su ID, ejecute:

sudo ufw delete 1

Se le pedirá que confirme la operación y se asegure de que la ID que proporciona se refiere a la regla correcta que desea eliminar.

OutputDeleting:
 deny from 203.0.113.100
Proceed with operation (y|n)? y
Rule deleted

Si vuelves a enumerar tus reglas con sudo ufw status, verás que la regla fue eliminada.

Lista de perfiles de aplicaciones disponibles

Tras la instalación, las aplicaciones que dependen de las comunicaciones de red suelen configurar un perfil UFW que permite la conexión desde direcciones externas. Esto suele ser equivalente a ejecutar ufw allow from, con la ventaja de proporcionar un acceso directo que abstrae los números de puerto específicos que utiliza un servicio y proporciona una nomenclatura intuitiva para los servicios referenciados.

Para enumerar los perfiles que están disponibles actualmente, ejecute lo siguiente:

sudo ufw app list

Si instaló un servicio, como un servidor web u otro software dependiente de la red, y no se creó un perfil en UFW, primero asegúrese de que el servicio esté habilitado. Para servidores remotos, normalmente tendrá OpenSSH disponible:

OutputAvailable applications:
  OpenSSH

Habilitar perfil de aplicación

Para habilitar un perfil de aplicación UFW, ejecute “ ufw allowseguido del nombre del perfil que desea habilitar, que puede obtener con un sudo ufw app listcomando. En el siguiente ejemplo, habilitamos el perfil OpenSSH, que permitirá todas las conexiones SSH entrantes en el puerto SSH predeterminado.

sudo ufw allow “OpenSSH”

OutputRule added
Rule added (v6)

Recuerde citar los nombres de perfil que constan de varias palabras, como Nginx HTTPS.

Deshabilitar el perfil de la aplicación

Para deshabilitar un perfil de aplicación previamente configurado en UFW, deberá eliminar la regla correspondiente. Por ejemplo, considere el siguiente resultado de sudo ufw status:

sudo ufw status

OutputStatus: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                               
Nginx Full                 ALLOW       Anywhere                  
OpenSSH (v6)               ALLOW       Anywhere (v6)                   
Nginx Full (v6)            ALLOW       Anywhere (v6)        

Este resultado indica que el Nginx Fullperfil de la aplicación está habilitado, lo que permite todas las conexiones al servidor web, tanto vía HTTP como HTTPS. Si solo desea permitir solicitudes HTTPS desde y hacia su servidor web, primero deberá habilitar la regla más restrictiva (en este caso Nginx HTTPS, ), y luego deshabilitar la regla activa Nginx Full:

sudo ufw allow "Nginx HTTPS"
sudo ufw delete allow "Nginx Full"

Recuerde que puede enumerar todos los perfiles de aplicaciones disponibles con sudo ufw app list.

Permitir SSH

Al trabajar con servidores remotos, deberá asegurarse de que el puerto SSH esté abierto a las conexiones para que pueda iniciar sesión en su servidor de forma remota.

El siguiente comando habilitará el perfil de aplicación OpenSSH UFW y permitirá todas las conexiones al puerto SSH predeterminado en el servidor:

sudo ufw allow OpenSSH

OutputRule added
Rule added (v6)

Aunque es menos fácil de usar, una sintaxis alternativa es especificar el número de puerto exacto del servicio SSH, que normalmente está configurado 22de manera predeterminada:

sudo ufw allow 22

OutputRule added
Rule added (v6)

Permitir SSH entrante desde una dirección IP o subred específica

Para permitir conexiones entrantes desde una dirección IP o subred específica, deberá incluir una fromdirectiva que defina el origen de la conexión. Esto requerirá que también especifique la dirección de destino con un toparámetro. Para restringir esta regla solo a SSH, deberá limitar el protoprotocolo a tcpy luego usar el portparámetro y establecerlo en 22, el puerto predeterminado de SSH.

El siguiente comando solo permitirá conexiones SSH provenientes de la dirección IP 203.0.113.103:

sudo ufw allow from 203.0.113.103 proto tcp to any port 22

OutputRule added

También puede utilizar una dirección de subred como fromparámetro para permitir conexiones SSH entrantes desde una red completa:

sudo ufw allow from 203.0.113.0/24 proto tcp to any port 22

OutputRule added

Permitir Rsync entrante desde una dirección IP o subred específica

El programa Rsync873 , que se ejecuta en el puerto , se puede utilizar para transferir archivos de una computadora a otra.

Para permitir rsyncconexiones entrantes desde una dirección IP o subred específica, utilice el fromparámetro para especificar la dirección IP de origen y el portparámetro para configurar el puerto de destino 873. El siguiente comando solo permitirá conexiones Rsync provenientes de la dirección IP 203.0.113.103:

sudo ufw allow from 203.0.113.103 to any port 873

OutputRule added

Para permitir que toda la 203.0.113.0/24subred pueda acceder rsynca su servidor, ejecute:

sudo ufw allow from 203.0.113.0/24 to any port 873

OutputRule added

Permitir Nginx HTTP / HTTPS

Tras la instalación, el servidor web Nginx configura diferentes perfiles UFW. Una vez que Nginx esté instalado y habilitado como servicio, ejecute el siguiente comando para identificar los perfiles disponibles:

sudo ufw app list | grep Nginx

Output  Nginx Full
  Nginx HTTP
  Nginx HTTPS

Para habilitar el tráfico HTTP y HTTPS, seleccione Nginx Full. De lo contrario, seleccione Nginx HTTPpermitir solo HTTP o Nginx HTTPSHTTPS.

El siguiente comando permitirá el tráfico HTTP y HTTPS en el servidor (puertos 80y 443):

sudo ufw allow "Nginx Full"

OutputRule added
Rule added (v6)

Permitir Apache HTTP / HTTPS

Tras la instalación, el servidor web Apache configura diferentes perfiles UFW. Una vez instalado y habilitado Apache como servicio, ejecute el siguiente comando para identificar los perfiles disponibles:

sudo ufw app list | grep Apache

Output  Apache
  Apache Full
  Apache Secure

Para habilitar el tráfico HTTP y HTTPS, seleccione Apache Full. De lo contrario, seleccione ApacheHTTP o Apache SecureHTTPS.

El siguiente comando permitirá el tráfico HTTP y HTTPS en el servidor (puertos 80y 443):

sudo ufw allow "Apache Full"

OutputRule added
Rule added (v6)

Permitir todos los HTTP entrantes (puerto 80)

Los servidores web, como Apache y Nginx, suelen recibir solicitudes HTTP en el puerto 80. Si su política predeterminada para el tráfico entrante es descartar o denegar, deberá crear una regla UFW para permitir el acceso externo en el puerto 80. Puede usar el número de puerto o el nombre del servicio ( http) como parámetro para este comando.

Para permitir todas las conexiones HTTP (puerto) entrantes 80, ejecute:

sudo ufw allow http

OutputRule added
Rule added (v6)

Una sintaxis alternativa es especificar el número de puerto del servicio HTTP:

sudo ufw allow 80

OutputRule added
Rule added (v6)

Permitir todos los HTTPS entrantes (puerto 443)

HTTPS normalmente se ejecuta en el puerto 443. Si su política predeterminada para el tráfico entrante es descartar o denegar, deberá crear una regla UFW para permitir el acceso externo en el puerto 443. Puede usar el número de puerto o el nombre del servicio ( https) como parámetro para este comando.

Para permitir todas 443las conexiones entrantes HTTPS (puerto), ejecute:

sudo ufw allow https

OutputRule added
Rule added (v6)

Una sintaxis alternativa es especificar el número de puerto del servicio HTTPS:

sudo ufw allow 443

OutputRule added
Rule added (v6)

Permitir todos los HTTP y HTTPS entrantes

Si desea permitir el tráfico HTTP y HTTPS, puede crear una única regla que permita ambos puertos. Para ello, también debe definir el protocolo con el protoparámetro , que en este caso debe establecerse en tcp.

Para permitir todas las conexiones entrantes HTTP y HTTPS (puertos 80y 443), ejecute:

sudo ufw allow proto tcp from any to any port 80,443

OutputRule added
Rule added (v6)

Permitir la conexión MySQL desde una dirección IP o subred específica

MySQL escucha las conexiones de cliente en el puerto 3306. Si un cliente en un servidor remoto utiliza su servidor de base de datos MySQL, deberá crear una regla UFW para permitir dicho acceso.

Para permitir conexiones MySQL entrantes desde una dirección IP o subred específica, utilice el fromparámetro para especificar la dirección IP de origen y el portparámetro para establecer el puerto de destino 3306.

El siguiente comando permitirá que la dirección IP 203.0.113.103se conecte al puerto MySQL del servidor:

sudo ufw allow from 203.0.113.103 to any port 3306

OutputRule added

Para permitir que toda la 203.0.113.0/24subred pueda conectarse a su servidor MySQL, ejecute:

sudo ufw allow from 203.0.113.0/24 to any port 3306

OutputRule added

Permitir la conexión PostgreSQL desde una dirección IP o subred específica

PostgreSQL escucha las conexiones de cliente en el puerto 5432. Si un cliente en un servidor remoto utiliza su servidor de base de datos PostgreSQL, asegúrese de permitir ese tráfico.

Para permitir conexiones entrantes de PostgreSQL desde una dirección IP o subred específica, especifique la fuente con el fromparámetro y configure el puerto en 5432:

sudo ufw allow from 203.0.113.103 to any port 5432

OutputRule added

Para permitir que toda la 203.0.113.0/24subred pueda conectarse a su servidor PostgreSQL, ejecute:

sudo ufw allow from 203.0.113.0/24 to any port 5432

OutputRule added

Bloquear correo SMTP saliente

Los servidores de correo, como Sendmail y Postfix, suelen usar el puerto 25para el tráfico SMTP. Si su servidor no debería enviar correo saliente, le recomendamos bloquear ese tipo de tráfico. Para bloquear las conexiones SMTP salientes, ejecute:

sudo ufw deny out 25

OutputRule added
Rule added (v6)

Esto configura su firewall para bloquear todo el tráfico saliente en el puerto 25. Si necesita rechazar las conexiones salientes en un puerto diferente, puede repetir este comando y reemplazarlo 25con el puerto que desea bloquear.

Conclusión

UFW es una herramienta potente que, si se configura correctamente, puede mejorar considerablemente la seguridad de sus servidores. Esta guía de referencia abarca algunas reglas comunes de UFW que se utilizan a menudo para configurar un firewall en Ubuntu.

La mayoría de los comandos de esta guía se pueden adaptar a diferentes casos de uso y escenarios modificando parámetros como la dirección IP de origen o el puerto de destino. Para obtener información más detallada sobre cada parámetro de comando y los modificadores disponibles, puede usar la manutilidad para consultar el manual de UFW:

man ufw

La página oficial de UFW sobre la documentación de Ubuntu es otro recurso que puedes usar como referencia para casos de uso y ejemplos más avanzados.

Stephen Dove
Comments

March 17, 2025

Cómo instalar Git en Ubuntu 22.04

Introducción

Los sistemas de control de versiones como Git son esenciales para las mejores prácticas de desarrollo de software moderno. El control de versiones permite realizar un seguimiento del software a nivel de código fuente. Permite realizar un seguimiento de los cambios, revertir a etapas anteriores y crear versiones alternativas de archivos y directorios.

Los archivos de muchos proyectos de software se mantienen en repositorios de Git, y plataformas como GitHub, GitLab y Bitbucket ayudan a facilitar el intercambio y la colaboración en proyectos de desarrollo de software.

En esta guía, aprenderá a instalar y configurar Git en un servidor Ubuntu 22.04 de dos maneras diferentes: mediante el gestor de paquetes integrado y mediante source . Cada método ofrece sus propias ventajas, según sus necesidades específicas.

Prerrequisitos

Necesitará un servidor Ubuntu 22.04 con una cuenta de superusuario que no sea root.

Para configurarlo, puede seguir nuestra Guía de configuración inicial del servidor para Ubuntu 22.04 .

Con el servidor y el usuario configurados, está listo para comenzar.

Instalación de Git con paquetes predeterminados

La opción de instalar con los paquetes predeterminados es la mejor opción si desea empezar a usar Git rápidamente, si prefiere una versión estable ampliamente utilizada o si no busca las últimas funcionalidades disponibles. Si busca la versión más reciente, consulte la sección sobre instalación desde el código fuente .

Es probable que Git ya esté instalado en tu servidor Ubuntu 22.04. Puedes confirmarlo con el siguiente comando:

git --version

Si recibe un resultado similar al siguiente, entonces Git ya está instalado.

Outputgit version 2.34.1

Si este es tu caso, puedes continuar con la configuración de Git o leer la siguiente sección sobre cómo instalar desde la fuente si necesitas una versión más actualizada.

Sin embargo, si no obtiene el resultado de un número de versión de Git, puede instalarlo con el administrador de paquetes predeterminado de Ubuntu, APT.

Primero, utilice las herramientas de administración de paquetes apt para actualizar su índice de paquetes local.

sudo apt update

Una vez completada la actualización, puedes instalar Git:

sudo apt install git

Puedes confirmar que has instalado Git correctamente ejecutando el siguiente comando y comprobando que recibes el resultado correspondiente.

git --version

Outputgit version 2.34.1

Una vez instalado Git correctamente, puedes pasar a la sección Configuración de Git de este tutorial para completar la configuración.

Instalación de Git desde el código fuente

Si busca un método más flexible para instalar Git, puede compilar el software desde el código fuente. Esto lleva más tiempo y no se mantendrá a través de su gestor de paquetes, pero le permitirá descargar la última versión y le dará mayor control sobre las opciones que incluye si desea realizar personalizaciones.

Verifique la versión de Git actualmente instalada en el servidor:

git --version

Si Git está instalado, recibirás un resultado similar al siguiente:

Outputgit version 2.34.1

Antes de empezar, necesitas instalar el software del que depende Git. Todo esto está disponible en los repositorios predeterminados, así que puedes actualizar el índice de paquetes local e instalar los paquetes correspondientes.

sudo apt update
sudo apt install libz-dev libssl-dev libcurl4-gnutls-dev libexpat1-dev gettext cmake gcc

Después de haber instalado las dependencias necesarias, cree un directorio temporal:

mkdir tmp

Muévete al tmpdirectorio donde descargarás tu archivo tar de Git:

cd /tmp

Desde el sitio web del proyecto Git , acceda a la lista de archivos tar disponible en https://mirrors.edge.kernel.org/pub/software/scm/git/ y descargue la versión deseada. Al momento de escribir este artículo, la versión más reciente es la 2.38.1. Descargará la última versión para fines de demostración. Use curl y exporte el archivo descargado a [nombre del archivo] git.tar.gz.

curl -o git.tar.gz https://mirrors.edge.kernel.org/pub/software/scm/git/git-2.38.1.tar.gz

Descomprima el archivo tarball comprimido:

tar -zxf git.tar.gz

A continuación, muévete al nuevo directorio Git:

cd git-*

Ahora, puedes crear el paquete con este comando:

make prefix=/usr/local all

Este proceso puede tardar un tiempo en crearse. Una vez finalizado, instala Git escribiendo el siguiente comando:

sudo make prefix=/usr/local install

Ahora, reemplace el proceso de shell para que se use la versión de Git que acaba de instalar:

 exec bash

Una vez completado esto, puedes estar seguro de que tu instalación fue exitosa verificando la versión.

git --version

Outputgit version 2.38.1

Una vez instalado Git correctamente, ahora puedes completar tu configuración.

Configuración de Git

Una vez que esté satisfecho con su versión de Git, debe configurar Git para que los mensajes de confirmación generados contengan la información correcta y lo ayuden a construir su proyecto de software.

La configuración se puede realizar mediante el git configcomando. En concreto, debes proporcionar tu nombre y correo electrónico, ya que Git integra esta información en cada confirmación. Puedes añadir esta información escribiendo:

git config --global user.name "Your Name"
git config --global user.email "youremail@domain.com"

Puede visualizar todos los elementos de configuración que se han establecido escribiendo:

git config --list

Outputuser.name=Your Name
user.email=youremail@domain.com
...

La información que introduces se almacena en tu archivo de configuración de Git, que puedes editar manualmente con el editor de texto que prefieras. Este ejemplo usa nano:

nano ~/.gitconfig

~/.gitconfig contenido

[user]
  name = Your Name
  email = youremail@domain.com

Presione CTRLy X, luego Ypara ENTERsalir del nanoeditor de texto.

Hay muchas otras opciones que puedes configurar, pero estas son las dos esenciales. Si omites este paso, probablemente verás advertencias al confirmar en Git. Esto te genera más trabajo, ya que tendrás que revisar las confirmaciones realizadas con la información correcta.

Conclusión

Ahora debería tener Git instalado y listo para usar en su sistema.

Stephen Dove
Comments

March 17, 2025

Fundamentos de la gestión de paquetes de Ubuntu y Debian

Introducción

La gestión de paquetes es una de las características fundamentales de un sistema Linux. El formato de empaquetado y las herramientas de gestión de paquetes varían según la distribución, pero la mayoría utiliza uno de dos conjuntos principales de herramientas.

Para las distribuciones basadas en Red Hat Enterprise Linux (como RHEL y Rocky Linux), el formato de empaquetado RPM y las herramientas de empaquetado como rpmy yumson comunes. La otra familia principal, utilizada por Debian, Ubuntu y distribuciones relacionadas, utiliza el .debformato de empaquetado y las herramientas como apty dpkg.

En los últimos años, han aparecido más administradores de paquetes auxiliares diseñados para ejecutarse en paralelo con el núcleo apty dpkglas herramientas: por ejemplo, snap proporciona más portabilidad y espacio aislado, y Homebrew , portado desde macOS, proporciona herramientas de línea de comandos que los usuarios individuales pueden instalar para evitar conflictos con los paquetes del sistema.

En esta guía, aprenderá algunas de las herramientas de gestión de paquetes más comunes que utilizan los administradores de sistemas en sistemas Debian y Ubuntu. Esta guía le servirá como referencia rápida cuando necesite saber cómo gestionar paquetes en estos sistemas.

Prerrequisitos

  • Un servidor Ubuntu 20.04 o Debian y un usuario no root con privilegios sudo. Puede obtener más información sobre cómo configurar un usuario con estos privilegios en nuestra guía “Configuración inicial del servidor con Ubuntu 20.04” .

Paso 1: Descripción general de las herramientas de gestión de paquetes de Debian

El ecosistema Debian/Ubuntu emplea bastantes herramientas de gestión de paquetes diferentes para administrar el software en el sistema.

La mayoría de estas herramientas están interrelacionadas y funcionan con las mismas bases de datos de paquetes. Algunas intentan proporcionar interfaces de alto nivel al sistema de empaquetado, mientras que otras se centran en proporcionar funcionalidad de bajo nivel.

apto

Este aptcomando es probablemente el más utilizado del aptconjunto de herramientas de empaquetado. Su principal objetivo es interactuar con repositorios remotos gestionados por el equipo de empaquetado de la distribución y ejecutar acciones en los paquetes disponibles.

La aptsuite, en general, funciona extrayendo información de repositorios remotos a una caché del sistema local. El aptcomando se utiliza para actualizar la caché local. También se utiliza para modificar el estado de un paquete, es decir, para instalarlo o eliminarlo del sistema.

En general, aptse utilizará para actualizar la memoria caché local y realizar modificaciones en el sistema en vivo.

Nota: En versiones anteriores de Ubuntu, el aptcomando principal se conocía como apt-get. Se ha simplificado, pero aún se puede llamar con , apt-getya sea por costumbre o por compatibilidad con versiones anteriores.

apt-cache

Otro miembro importante de la aptsuite es apt-cache. Esta utilidad utiliza la caché local para consultar información sobre los paquetes disponibles y sus propiedades.

Por ejemplo, buscar un paquete o una herramienta específica que realice una función específica apt-cachees un buen punto de partida. También puede ser útil para obtener información sobre la versión exacta del paquete a la que se dirigirá un procedimiento. La información sobre dependencias y dependencias inversas es otra área apt-cacheútil.

paquete dpkg

Si bien las herramientas anteriores se centraban en la gestión de paquetes almacenados en repositorios, el dpkgcomando también permite operar con .debpaquetes individuales. dpkgDe hecho, la herramienta se encarga de la mayor parte del trabajo interno de los comandos mencionados; aptproporciona tareas de mantenimiento adicionales mientras dpkginteractúa con los propios paquetes.

A diferencia de los aptcomandos, dpkgno puede resolver dependencias automáticamente. Su principal característica es la posibilidad de trabajar con .debpaquetes directamente y analizarlos para obtener más información sobre su estructura. Aunque puede recopilar información sobre los paquetes instalados en el sistema, no debe utilizarse como gestor de paquetes principal. En el siguiente paso, aprenderá las mejores prácticas para la actualización de paquetes.

Paso 2: Actualización de la caché de paquetes y del sistema

Las herramientas de gestión de paquetes de Debian y Ubuntu ayudan a mantener actualizada la lista de paquetes disponibles de su sistema. También ofrecen varios métodos para actualizar los paquetes que tenga instalados en su servidor.

Actualización de la caché de paquetes locales

Los repositorios remotos que utilizan sus herramientas de empaquetado para obtener información de paquetes se actualizan constantemente. Sin embargo, la mayoría de las herramientas de gestión de paquetes de Linux están diseñadas, por razones históricas, para trabajar directamente con una caché local de esta información. Esta caché debe actualizarse periódicamente.

Suele ser recomendable actualizar la caché local de paquetes en cada sesión antes de ejecutar otros comandos. Esto garantizará que esté trabajando con la información más actualizada sobre el software disponible. Algunos comandos de instalación fallarán si trabaja con información de paquetes obsoleta.

Para actualizar la caché local, utilice el aptcomando con el updatesubcomando:

sudo apt update

Esto mostrará una lista actualizada de los paquetes disponibles en los repositorios que estás rastreando.

Actualización de paquetes

El aptcomando distingue entre dos procedimientos de actualización diferentes. El primero (que se describe en esta sección) permite actualizar cualquier componente que no requiera su eliminación. Para saber cómo actualizar y permitir aptla eliminación e intercambio de componentes según sea necesario, consulte la sección siguiente.

Esto puede ser muy importante si no desea eliminar ningún paquete instalado bajo ninguna circunstancia. Sin embargo, algunas actualizaciones implican reemplazar componentes del sistema o eliminar archivos conflictivos. Este procedimiento ignorará cualquier actualización que requiera la eliminación de paquetes:

sudo apt upgrade

El segundo procedimiento actualizará todos los paquetes, incluso aquellos que requieren su eliminación. Esto suele ser necesario a medida que cambian las dependencias de los paquetes.

Normalmente, los paquetes que se eliminan se reemplazan por equivalentes funcionales durante el proceso de actualización, por lo que esto suele ser seguro. Sin embargo, conviene estar atento a los paquetes que se eliminarán, por si acaso se marcan componentes esenciales para su eliminación. Para realizar esta acción, escriba:

sudo apt full-upgrade

Esto actualizará todos los paquetes de su sistema. En el siguiente paso, aprenderá a descargar e instalar nuevos paquetes.

Paso 3: Descargar e instalar paquetes

Buscar paquetes

El primer paso al descargar e instalar paquetes a menudo es buscar en los repositorios de su distribución los paquetes que está buscando.

La búsqueda de paquetes es una operación que busca información en la caché de paquetes. Para ello, utilice apt-cache search. Recuerde que debe asegurarse de que su caché local esté actualizada utilizando sudo apt updateantes de buscar paquetes:

apt-cache search package

Dado que este procedimiento solo consulta información, no requiere sudoprivilegios. Cualquier búsqueda realizada examinará los nombres de los paquetes, así como sus descripciones completas.

Por ejemplo, si buscas htop, verás resultados como estos:

apt-cache search htop

Outputaha - ANSI color to HTML converter
htop - interactive processes viewer
libauthen-oath-perl - Perl module for OATH One Time Passwords

Como puedes ver, tienes un paquete llamado htop, pero también puedes ver otros dos programas, cada uno de los cuales se menciona htopen el campo de descripción completa del paquete (la descripción junto a la salida es solo un breve resumen).

Instalar un paquete desde los repositorios

Para instalar un paquete desde los repositorios, así como todas las dependencias necesarias, puede utilizar el aptcomando con el installargumento.

Los argumentos para este comando deben ser el nombre o los nombres del paquete tal como están etiquetados en el repositorio:

sudo apt install package

Puede instalar varios paquetes a la vez, separados por un espacio:

sudo apt install package1 package2

Si el paquete solicitado requiere dependencias adicionales, estas se imprimirán en la salida estándar y se le solicitará que confirme el procedimiento. Se verá así:

sudo apt install apache2

OutputReading package lists... Done
Building dependency tree       
Reading state information... Done
The following extra packages will be installed:
  apache2-data
Suggested packages:
  apache2-doc apache2-suexec-pristine apache2-suexec-custom
  apache2-utils
The following NEW packages will be installed:
  apache2 apache2-data
0 upgraded, 2 newly installed, 0 to remove and 0 not upgraded.
Need to get 236 kB of archives.
After this operation, 1,163 kB of additional disk space will be used.
Do you want to continue [Y/n]?

Como puede ver, aunque nuestro objetivo de instalación era el apache2paquete, este apache2-datase necesita como dependencia. En este caso, puede continuar presionando Intro o “Y”, o cancelar escribiendo “n”.

Instalar una versión específica del paquete desde los repositorios

Si necesita instalar una versión específica de un paquete, puede proporcionar la versión que desea utilizar =, de la siguiente manera:

sudo apt install package=version

En este caso, la versión debe coincidir con uno de los números de versión del paquete disponibles en el repositorio. Esto implica utilizar el sistema de control de versiones de su distribución. Puede encontrar las versiones disponibles mediante :apt-cache policy package

apt-cache policy nginx

Outputnginx:
  Installed: (none)
  Candidate: 1.18.0-0ubuntu1.2
  Version table:
     1.18.0-0ubuntu1.2 500
        500 http://mirrors.digitalocean.com/ubuntu focal-updates/main amd64 Packages
        500 http://security.ubuntu.com/ubuntu focal-security/main amd64 Packages
     1.17.10-0ubuntu1 500
        500 http://mirrors.digitalocean.com/ubuntu focal/main amd64 Packages

Reconfigurar paquetes

Muchos paquetes incluyen scripts de configuración posteriores a la instalación que se ejecutan automáticamente una vez finalizada. Estos suelen incluir indicaciones para que el administrador tome decisiones de configuración.

Si necesita ejecutar estos pasos de configuración (y otros adicionales) más adelante, puede usar el dpkg-reconfigurecomando. Este comando examina el paquete que se le ha proporcionado y vuelve a ejecutar cualquier comando posterior a la configuración incluido en la especificación del paquete:

sudo dpkg-reconfigure package

Esto le permitirá acceder a las mismas indicaciones (y a menudo más) que encontró durante la instalación.

Realizar un ensayo de las acciones del paquete

Muchas veces, querrás ver los efectos secundarios de un procedimiento antes de comprometerte realmente a ejecutar el comando. aptte permite agregar la -sbandera para “simular” un procedimiento.

Por ejemplo, para ver qué se haría si decide instalar un paquete, puede escribir:

apt install -s package

Esto le permitirá ver todas las dependencias y los cambios que se producirán en su sistema si elimina la -smarca. Una ventaja es que puede ver los resultados de un proceso que normalmente requeriría privilegios de root, sin usar sudo.

Por ejemplo, si desea evaluar qué se instalaría con el apache2paquete, puede escribir:

apt install -s apache2

OutputNOTE: This is only a simulation!
      apt needs root privileges for real execution.
      Keep also in mind that locking is deactivated,
      so don't depend on the relevance to the real current situation!
Reading package lists... Done
Building dependency tree       
Reading state information... Done
The following extra packages will be installed:
  apache2-data
Suggested packages:
  apache2-doc apache2-suexec-pristine apache2-suexec-custom
  apache2-utils
The following NEW packages will be installed:
  apache2 apache2-data
0 upgraded, 2 newly installed, 0 to remove and 0 not upgraded.
Inst apache2-data (2.4.6-2ubuntu2.2 Ubuntu:13.10/saucy-updates [all])
Inst apache2 (2.4.6-2ubuntu2.2 Ubuntu:13.10/saucy-updates [amd64])
Conf apache2-data (2.4.6-2ubuntu2.2 Ubuntu:13.10/saucy-updates [all])
Conf apache2 (2.4.6-2ubuntu2.2 Ubuntu:13.10/saucy-updates [amd64])

Obtendrás toda la información sobre los paquetes y versiones que se instalarán, sin tener que completar el proceso real.

Esto también funciona con otros procedimientos, como realizar actualizaciones del sistema:

apt -s dist-upgrade

De forma predeterminada, aptse solicitará confirmación al usuario para muchos procesos, como instalaciones que requieren dependencias adicionales y actualizaciones de paquetes.

Para omitir estas actualizaciones y aceptar de forma predeterminada cualquiera de estas indicaciones, puede pasar la -ybandera al realizar estas operaciones:

sudo apt install -y package

Esto instalará el paquete y sus dependencias sin necesidad de solicitarlo al usuario. También puede usarse para procedimientos de actualización:

sudo apt dist-upgrade -y

Reparar dependencias y paquetes rotos

A veces, una instalación puede no finalizar correctamente debido a dependencias u otros problemas. Un caso común es al instalar un .debpaquete con dpkg, que no resuelve las dependencias.

El aptcomando puede intentar resolver esta situación pasándole el -fcomando.

sudo apt install -f

Esto buscará las dependencias incumplidas e intentará instalarlas para corregir el árbol de dependencias. Si su instalación presentó un problema de dependencia, este debería ser el primer paso para intentar resolverlo. Si no puede resolver el problema de esta manera e instaló un paquete de terceros, debería eliminarlo y buscar una versión más reciente con un mantenimiento más activo.

Descargar paquete desde los repositorios

Hay casos importantes en los que puede ser útil descargar un paquete de los repositorios sin instalarlo. Puedes hacerlo ejecutando aptel downloadargumento.

Dado que esto solo descarga un archivo y no afecta al sistema real, no sudose requieren privilegios:

apt download package

Esto descargará los paquetes especificados al directorio actual.

Instalar un paquete .deb

Aunque la mayoría de las distribuciones recomiendan instalar el software desde sus repositorios mantenidos, algunos proveedores suministran .debarchivos sin procesar que puedes instalar en tu sistema.

Para ello, se utiliza dpkg. dpkgSe utiliza principalmente para trabajar con paquetes individuales. No intenta realizar instalaciones desde el repositorio, sino que busca .debpaquetes en el directorio actual o en la ruta proporcionada:

sudo dpkg --install debfile.deb

Es importante tener en cuenta que la dpkgherramienta no implementa ningún manejo de dependencias. Esto significa que si hay dependencias incumplidas, la instalación fallará. Sin embargo, marca las dependencias necesarias, por lo que si todas están disponibles en los repositorios, puede completarlas escribiendo lo siguiente después:

sudo apt install -f

Esto instalará las dependencias no satisfechas, incluidas las marcadas con dpkg. En el siguiente paso, aprenderá a eliminar algunos de los paquetes que ha instalado.

Paso 4: Eliminar paquetes y archivos

En esta sección se explicará cómo desinstalar paquetes y limpiar los archivos que puedan quedar tras las operaciones de paquetes.

Desinstalar un paquete

Para eliminar un paquete instalado, se usa apt remove. Esto eliminará la mayoría de los archivos que el paquete instaló en el sistema, con una excepción notable.

Este comando conserva los archivos de configuración para que su configuración siga disponible si necesita reinstalar la aplicación posteriormente. Esto es útil porque significa que los archivos de configuración personalizados no se eliminarán si elimina accidentalmente un paquete.

Para completar esta operación, debe proporcionar el nombre del paquete que desea desinstalar:

sudo apt remove package

El paquete se desinstalará con la excepción de los archivos de configuración.

Desinstalar un paquete y todos los archivos de configuración asociados

Si desea eliminar un paquete y todos los archivos asociados de su sistema, incluidos los archivos de configuración, puede utilizar apt purge.

A diferencia del removecomando mencionado anteriormente, este purgelo elimina todo. Esto es útil si no desea guardar los archivos de configuración o si tiene problemas y desea empezar desde cero.

Tenga en cuenta que una vez que se eliminen los archivos de configuración, no podrá recuperarlos:

sudo apt purge package

Ahora, si alguna vez necesita reinstalar ese paquete, se utilizará la configuración predeterminada.

Eliminar cualquier dependencia automática que ya no sea necesaria

Al eliminar paquetes del sistema con apt removeo apt purge, se eliminará el destino del paquete. Sin embargo, se conservarán las dependencias que se instalaron automáticamente para cumplir con los requisitos de instalación.

Para eliminar automáticamente cualquier paquete que se haya instalado como dependencia y que ya no sea necesario para ningún paquete, puede utilizar el autoremovecomando:

sudo apt autoremove

Si desea eliminar todos los archivos de configuración asociados a las dependencias que se van a eliminar, deberá añadir la --purgeopción al autoremovecomando. Esto también limpiará los archivos de configuración, al igual que el purgecomando para una eliminación específica:

sudo apt --purge autoremove

Limpiar archivos de paquetes obsoletos

A medida que los mantenedores de paquetes de una distribución agregan y eliminan paquetes de los repositorios, algunos paquetes quedarán obsoletos.

La aptherramienta puede eliminar cualquier archivo de paquete en el sistema local que esté asociado con paquetes que ya no están disponibles en los repositorios mediante el uso del autocleancomando.

Esto liberará espacio en su servidor y eliminará cualquier paquete potencialmente obsoleto de su caché local.

sudo apt autoclean

En el siguiente paso, aprenderá más formas de consultar paquetes sin necesariamente instalarlos.

Paso 5 – Obtener información sobre los paquetes

Cada paquete contiene una gran cantidad de metadatos a los que se puede acceder mediante las herramientas de gestión de paquetes. Esta sección mostrará algunas formas comunes de obtener información sobre los paquetes disponibles e instalados.

Para mostrar información detallada sobre un paquete en los repositorios de su distribución, puede usar el comando apt-cache show. El objetivo de este comando es el nombre de un paquete dentro del repositorio:

apt-cache show nginx

Esto mostrará información sobre cualquier candidato a instalación para el paquete en cuestión. Cada candidato incluirá información sobre sus dependencias, versión, arquitectura, conflictos, el nombre del archivo del paquete, el tamaño del paquete y la instalación, y una descripción detallada, entre otros datos.

OutputPackage: nginx
Architecture: all
Version: 1.18.0-0ubuntu1.2
Priority: optional
Section: web
Origin: Ubuntu
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
Original-Maintainer: Debian Nginx Maintainers <pkg-nginx-maintainers@lists.alioth.debian.org>
Bugs: https://bugs.launchpad.net/ubuntu/+filebug
Installed-Size: 44
Depends: nginx-core (<< 1.18.0-0ubuntu1.2.1~) | nginx-full (<< 1.18.0-0ubuntu1.2.1~) | nginx-light (<< 1.18.0-0ubuntu1.2.1~) | nginx-extras (<< 1.18.0-0ubuntu1.2.1~), nginx-core (>= 1.18.0-0ubuntu1.2) | nginx-full (>= 1.18.0-0ubuntu1.2) | nginx-light (>= 1.18.0-0ubuntu1.2) | nginx-extras (>= 1.18.0-0ubuntu1.2)
Filename: pool/main/n/nginx/nginx_1.18.0-0ubuntu1.2_all.deb
…

Para mostrar información adicional sobre cada candidato, incluyendo una lista completa de dependencias inversas (una lista de paquetes que dependen del paquete consultado), utilice el showpkgcomando. Esto incluirá información sobre la relación de este paquete con otros paquetes:

apt-cache showpkg package

Mostrar información sobre un paquete .deb

Para mostrar detalles sobre un .debarchivo, puede usar la --infobandera con el dpkgcomando. El objetivo de este comando debe ser la ruta de un .debarchivo:

dpkg --info debfile.deb

Esto le mostrará metadatos sobre el paquete en cuestión, como el nombre y la versión, la arquitectura para la que fue creado, el tamaño y las dependencias requeridas, una descripción y los conflictos.

Para enumerar específicamente las dependencias (paquetes de los que depende este paquete) y las dependencias inversas (los paquetes que dependen de este paquete), puede utilizar la apt-cacheutilidad.

Para obtener información de dependencia convencional, puede utilizar el dependssubcomando:

apt-cache depends nginx

Outputnginx
 |Depends: nginx-core
 |Depends: nginx-full
 |Depends: nginx-light
  Depends: nginx-extras
 |Depends: nginx-core
 |Depends: nginx-full
 |Depends: nginx-light
  Depends: nginx-extras

Esto mostrará información sobre cada paquete que figure como dependencia dura, sugerencia, recomendación o conflicto.

Si necesita saber qué paquetes dependen de un paquete determinado, puede pasar ese paquete a apt-cache rdepends:

apt-cache rdepends package

Mostrar versiones de paquetes instalados y disponibles

A menudo, existen varias versiones de un paquete en los repositorios, con un único paquete predeterminado. Para ver las versiones disponibles de un paquete, puede usar apt-cache policy:

apt-cache policy package

Esto le mostrará qué versión está instalada (si hay alguna), el paquete que se instalará de manera predeterminada si no especifica una versión con el comando de instalación y una tabla de versiones de paquetes, completa con el peso que indica la prioridad de cada versión.

Esto permite determinar qué versión se instalará y qué alternativas están disponibles. Dado que también se listan los repositorios donde se encuentra cada versión, permite determinar si hay repositorios adicionales que reemplacen los paquetes de los repositorios predeterminados.

Mostrar paquetes instalados con dpkg -l

Para mostrar los paquetes instalados en su sistema, tiene algunas opciones separadas, que varían en formato y nivel de detalle de salida.

El primer método implica usar el comando dpkgo el dpkg-querycomando con la -lbandera. El resultado de ambos comandos es idéntico. Sin argumentos, proporciona una lista de todos los paquetes instalados o parcialmente instalados en el sistema. El resultado será similar a esto:

dpkg -l

OutputDesired=Unknown/Install/Remove/Purge/Hold
| Status=Not/Inst/Conf-files/Unpacked/halF-conf/Half-inst/trig-aWait/Trig-pend
|/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)
||/ Name                                        Version                                 Architecture Description
+++-===========================================-=======================================-============-=====================================================================================================================
ii  account-plugin-generic-oauth                0.10bzr13.03.26-0ubuntu1.1              amd64        GNOME Control Center account plugin for single signon - generic OAuth
ii  accountsservice                             0.6.34-0ubuntu6                         amd64        query and manipulate user account information
ii  acl                                         2.2.52-1                                amd64        Access control list utilities
ii  acpi-support                                0.142                                   amd64        scripts for handling many ACPI events
ii  acpid                                       1:2.0.18-1ubuntu2                       amd64        Advanced Configuration and Power Interface event daemon
. . .

La salida continúa para cada paquete del sistema. En la parte superior de la salida, se puede ver el significado de los tres primeros caracteres de cada línea. El primer carácter indica el estado deseado del paquete. Puede ser:

  • u : Desconocido
  • i : Instalado
  • r : Eliminado
  • p : Purgado
  • h : Versión mantenida

El segundo carácter indica el estado real del paquete, tal como lo conoce el sistema de embalaje. Estos pueden ser:

  • n : No instalado
  • i : Instalado
  • c : Los archivos de configuración están presentes, pero la aplicación está desinstalada.
  • u : Descomprimido. Los archivos están descomprimidos, pero aún no están configurados.
  • f : El paquete está a medio instalar, lo que significa que hubo una falla durante la instalación que detuvo la operación.
  • w : El paquete está esperando un disparador de un paquete separado
  • p : El paquete ha sido activado por otro paquete.

El tercer carácter, que será un espacio en blanco para la mayoría de los paquetes, solo tiene otra opción potencial:

  • r : Esto indica que se requiere una reinstalación. Esto suele significar que el paquete está dañado y no funciona.

El resto de las columnas contienen el nombre del paquete, la versión, la arquitectura y una descripción.

Mostrar estados de instalación de paquetes filtrados

Si añade un patrón de búsqueda después del -lpatrón, dpkgse mostrarán todos los paquetes (instalados o no) que lo contengan. Por ejemplo, puede buscar bibliotecas de procesamiento YAML aquí:

dpkg -l libyaml*

OutputDesired=Unknown/Install/Remove/Purge/Hold
| Status=Not/Inst/Conf-files/Unpacked/halF-conf/Half-inst/trig-aWait/Trig-pend
|/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)
||/ Name            Version      Architecture Description
+++-===============-============-============-===================================
ii  libyaml-0-2:amd 0.1.4-2ubunt amd64        Fast YAML 1.1 parser and emitter li
ii  libyaml-dev:amd 0.1.4-2ubunt amd64        Fast YAML 1.1 parser and emitter li
un  libyaml-perl    <none>                    (no description available)
un  libyaml-syck-pe <none>                    (no description available)
ii  libyaml-tiny-pe 1.51-2       all          Perl module for reading and writing

Como puede ver en la primera columna, el tercer y cuarto resultado no están instalados. Esto le muestra todos los paquetes que coinciden con el patrón, así como sus estados actual y deseado.

Una forma alternativa de renderizar los paquetes que están instalados en su sistema es con dpkg –get-selections.

Esto proporciona una lista de todos los paquetes instalados o eliminados pero no purgados:

dpkg --get-selections

Para diferenciar entre estos dos estados, puede canalizar la salida de dpkga awkpara filtrar por estado. Para ver solo los paquetes instalados, escriba:

dpkg --get-selections | awk '$2 ~ /^install/'

Para obtener una lista de paquetes eliminados cuyos archivos de configuración no se han purgado, puede escribir:

dpkg --get-selections | awk '$2 !~ /^install/'

Quizás también desee obtener más información sobre cómo canalizar la salida de comandos a través de awk .

Buscar paquetes instalados

Para buscar un paquete específico en la base de datos de paquetes instalados, puede agregar una cadena de filtro de paquetes después de la --get-selectionsopción. Esto permite la coincidencia con comodines. De nuevo, esto mostrará los paquetes instalados o que aún tengan archivos de configuración en el sistema:

dpkg --get-selections libz*

Puedes, una vez más, filtrar utilizando las awkexpresiones de la sección anterior.

Lista de archivos instalados por un paquete

Para saber de qué archivos es responsable un paquete, puede utilizar la -Lbandera con el dpkgcomando:

dpkg -L package

Esto imprimirá la ruta absoluta de cada archivo controlado por el paquete. No se incluirán los archivos de configuración generados por los procesos dentro del paquete.

Para saber qué paquete es responsable de un determinado archivo en su sistema de archivos, puede pasar la ruta absoluta al dpkgcomando con la -Sbandera.

Esto imprimirá el paquete que instaló el archivo en cuestión:

dpkg -S /path/to/file

Tenga en cuenta que cualquier archivo que se mueva a su lugar mediante scripts posteriores a la instalación no se puede vincular nuevamente al paquete con esta técnica.

Descubra qué paquete proporciona un archivo sin instalarlo

Usando dpkg, puedes averiguar qué paquete contiene un archivo usando la -Sopción. Sin embargo, a veces necesitas saber qué paquete contiene un archivo o comando, incluso si no tienes instalado el paquete asociado.

Para ello, necesitará instalar una utilidad llamada apt-file. Esta mantiene su propia base de datos, que incluye la ruta de instalación de cada archivo controlado por un paquete en la base de datos.

Instale el apt-filepaquete de forma normal:

sudo apt update
sudo apt install apt-file

Ahora, actualice la base de datos de la herramienta y busque un archivo escribiendo:

sudo apt-file update
sudo apt-file search /path/to/file

Esto solo funcionará con las ubicaciones de archivos instaladas directamente por un paquete. No se pueden consultar los archivos creados mediante scripts posteriores a la instalación. En el siguiente paso, aprenderá a importar y exportar listas de paquetes instalados.

Paso 6: Transferencia de listas de paquetes entre sistemas

Muchas veces, puede que necesite hacer una copia de seguridad de la lista de paquetes instalados de un sistema y usarla para instalar un conjunto idéntico de paquetes en otro. Esto también es útil para realizar copias de seguridad. Esta sección le mostrará cómo exportar e importar listas de paquetes.

Si necesita replicar el conjunto de paquetes instalados en un sistema a otro, primero deberá exportar su lista de paquetes.

Puede exportar la lista de paquetes instalados a un archivo redirigiendo la salida dpkg --get-selectionsa un archivo de texto:

dpkg --get-selections > ~/packagelist.txt

Quizás también desee obtener más información sobre la redirección de entrada y salida .

Luego esta lista se puede copiar a la segunda máquina e importar.

También podría necesitar hacer una copia de seguridad de sus listas de fuentes y de su lista de claves de confianza. Puede hacer una copia de seguridad de sus fuentes creando un nuevo directorio y copiándolo desde la configuración del sistema en /etc/apt/:

mkdir ~/sources
cp -R /etc/apt/sources.list* ~/sources

Cualquier clave que haya agregado para instalar paquetes desde repositorios de terceros se puede exportar usando apt-key exportall:

apt-key exportall > ~/trusted_keys.txt

Ahora puede transferir el packagelist.txtarchivo, el sourcesdirectorio y el trusted_keys.txtarchivo a otra computadora para importar.

Lista de paquetes de importación

Si ha creado una lista de paquetes utilizando como se demostró anteriormente, también dpkg --get-selectionspuede importar los paquetes en otra computadora usando el comando.dpkg

Primero, debe agregar las claves de confianza e implementar las listas de fuentes que copió del primer entorno. Suponiendo que todos los datos respaldados se hayan copiado al directorio de inicio del nuevo equipo, podría escribir:

sudo apt-key add ~/trusted_keys.txt
sudo cp -R ~sources/* /etc/apt/

A continuación, borre el estado de todos los paquetes no esenciales del nuevo equipo. Esto garantizará que los cambios se apliquen desde cero. Debe hacerlo con la cuenta o sudoprivilegios de root:

sudo dpkg --clear-selections

Esto marcará todos los paquetes no esenciales para su desinstalación. Debe actualizar la lista de paquetes local para que su instalación contenga registros de todo el software que planea instalar. El proceso de instalación y actualización se gestionará mediante una herramienta llamada dselect.

Debe asegurarse de que la dselectherramienta esté instalada. Esta herramienta mantiene su propia base de datos, por lo que también debe actualizarla antes de continuar:

sudo apt update
sudo apt install dselect
sudo dselect update

A continuación, puede aplicar la lista de paquetes sobre la lista actual para configurar qué paquetes se deben conservar o descargar:

sudo dpkg --set-selections < packagelist.txt

Esto establece los estados correctos del paquete. Para aplicar los cambios, ejecute apt dselect-upgrade:

sudo apt dselect-upgrade

Esto descargará e instalará los paquetes necesarios. También eliminará los paquetes marcados para deseleccionar. Al final, la lista de paquetes debería coincidir con la del equipo anterior, aunque aún será necesario copiar o modificar los archivos de configuración. Puede usar una herramienta como etckeeper para migrar los archivos de configuración desde el /etcdirectorio.

En el siguiente y último paso, aprenderá a trabajar con repositorios de paquetes de terceros.

Paso 7: Agregar repositorios y PPA

Aunque el conjunto predeterminado de repositorios que ofrecen la mayoría de las distribuciones suele ser el más fácil de mantener, a veces pueden ser útiles fuentes adicionales. En esta sección, aprenderá a configurar sus herramientas de empaquetado para consultar fuentes adicionales.

Una alternativa a los repositorios tradicionales en Ubuntu son los PPA, o archivos de paquetes personales . Otras versiones de Linux suelen utilizar conceptos de repositorios de terceros diferentes, pero similares. Normalmente, los PPA tienen un alcance menor que los repositorios y contienen conjuntos específicos de aplicaciones mantenidas por el propietario del PPA.

Añadir PPAs a su sistema le permite gestionar los paquetes que contienen con sus herramientas habituales de gestión de paquetes. Esto puede utilizarse para proporcionar paquetes más actualizados que no están incluidos en los repositorios de la distribución. Asegúrese de añadir únicamente PPAs de confianza, ya que estará permitiendo que un mantenedor no estándar cree paquetes para su sistema.

Para agregar un PPA, puede usar el add-apt-repositorycomando. El objetivo debe incluir la etiqueta ppa:, seguida del nombre del propietario del PPA en Launchpad , una barra diagonal y el nombre del PPA:

sudo add-apt-repository ppa:owner_name/ppa_name

Es posible que se le solicite que acepte la clave del empaquetador. Posteriormente, el PPA se añadirá a su sistema, lo que le permitirá instalar los paquetes con los aptcomandos habituales. Antes de buscar o instalar paquetes, asegúrese de actualizar su caché local con la información sobre su nuevo PPA:

sudo apt update

También puede editar la configuración de su repositorio directamente. Puede editar el /etc/apt/sources.listarchivo o crear una nueva lista en el /etc/apt/sources.list.ddirectorio. Si opta por esta última opción, el nombre del archivo que cree debe terminar en .list:

sudo nano /etc/apt/sources.list.d/new_repo.list

Dentro del archivo, puedes agregar la ubicación del nuevo repositorio utilizando el siguiente formato: /etc/apt/sources.list.d/new_repo.list

deb_or_deb-src url_of_repo release_code_name_or_suite component_names

Las diferentes partes de la especificación del repositorio son:

  • deb o deb-src : Identifica el tipo de repositorio. Los repositorios convencionales se marcan con deb, mientras que los repositorios de código fuente empiezan con deb-src.
  • URL : La URL principal del repositorio. Esta debe ser la ubicación donde se puede encontrar el repositorio.
  • nombre del código de lanzamiento o suite : generalmente, este es el nombre del código del lanzamiento de su distribución, pero puede ser cualquier nombre que se use para identificar un conjunto específico de paquetes creados para su versión de la distribución.
  • Nombres de componentes : Las etiquetas para la selección de paquetes que desea tener disponibles. Esta suele ser una distinción proporcionada por el responsable del repositorio para indicar la fiabilidad o las restricciones de licencia del software que contiene.

Puede agregar estas líneas dentro del archivo. La mayoría de los repositorios contienen información sobre el formato exacto que debe usarse. En otras distribuciones de Linux, puede agregar fuentes de repositorio adicionales instalando paquetes que solo contienen un archivo de configuración para ese repositorio, lo cual es coherente con el funcionamiento de los administradores de paquetes.

Conclusión

La gestión de paquetes es quizás el aspecto más importante de la administración de un sistema Linux. Existen muchas otras operaciones de gestión de paquetes que puede realizar, pero este tutorial le ha proporcionado una base de los fundamentos de Ubuntu, muchos de los cuales son generalizables a otras distribuciones con pequeños cambios.

Stephen Dove