GNU Linux Turnkey 14.

Download PDF

GNU Linux Turnkey 14.

GNU Linux Turnkey LAPP 14 es una distribución pensada para instalar-y-usar con un buen conjunto de aplicaciones (LAPP abreviatura de Linux, Apache, Postgresql y PHP) sin descuidar la seguridad (instala claves SSH inmediatamente –algo que deberíamos hacer nosotros mismos-) y un conjunto de valores predefinidos que agilizan nuestro trabajo al montar servidores para la producción, todo esto con las características intrínsecas del Software Libre. CUENTA ADEMÁS (servicio que hay que pagar, eso sí) con DNS y respaldos «en la nube» ya que de algo tienen -tenemos- que vivir los programadores.


Yo sigo la cuenta Twitter del sr. S. Vaughan-Nichols quien siempre tiene interesantes reportajes (y abundantes críticas) sobre el mundo de la informática, muy especialmente en los temas de servidores y lo que está de moda ahora: «la nuuuuuuube» (imaginen tamborileo en paralelo). Él siempre alega la SIMPLICIDAD (muchos lo llamamos «K.I.S.S. principle«) y no sólo critica por criticar sino que ÉL TAMBIÉN APORTA SOLUCIONES.

Es por tanto que me llamó poderosamente la atención el siguiente «trino (tweet)»:

Sigo el enlace, leo el artículo, sigo el otro enlace hacia los creadores de la distribución TURNKEY, noto que en cada artículo colocan el enlace para descargar la imagen ISO con la «distro» más la aplicación deseada -amd64, por supuesto, estamos hablando de servidores-, todo muy bien explicado y detallado (en idioma inglés) y en 5 minutos la descargo y en 2 minutos más la ejecuto en un ambiente VirtualBox y listo, tengo corriendo un servidor LAPP en modo live CD y casi listo para producción. ¿NO ME CREEN? Veánlo «con sus propios ojos»:

La genial idea de los programadores de Turnkey estriba en adaptar una distribución Linux para que, siguiendo los preceptos de la licencia GNU, sea libre y sin embargo si uno desea seguir adelante con un servidor DNS y respaldo de datos en los servidores Turnkey de manera paga y con una genial API KEY en poco tiempo estemos en línea y produciendo dinero.

Esas cosas las admiro profudamente: simplicidad, apoyo inicial y si quieres CRECER allí están para convertirse en socios de manera instantánea. Además  observo que Turnkey no trabaja sola, también vende servicios Amazon para alojamiento, si es que uno no tiene máquina propia para montar lo requerido.


Instalación de Turnkey.

En otras publicaciones he descrito cómo instalar un servidor PostgreSQL y cómo administrarlo con phpPgAdmin paso a paso. Siempre es bueno saber hacerlo todo uno mismo y luego que uno ya haya aprendido no está mal que obtener ayuda extra como la concebida en esta maravillosa distribución Linux Turnkey. A pesar que en los enlaces anteriores describo en detalle el entorno que utilizo, describo un resumen: uso VirtualBox en Ubuntu 64 bits, le asigné 512 megabytes en RAM, 1 CPU, 12 megabytes para vídeo y la única tarjeta de red virtual la configuro como «puente» para que la máquina virtual Turnkey se comunique con mi enrutador inalambrico (y de allí a la internet) quien se encarga del trabajo DHCP y le asigna la dirección 192.168.1.131 con los Norton DNS.

La instalación en sí la vieron arriba en el video que subí -alojamiento cortesía de Youtube- y el detalle adicional es que RECUERDEN BIEN que la distribución del teclado es en inglés [yo hace años que dejé de usarlos, ni siquiera en español tengo ya, sólo distribución Latinoamericano, ojito al meter las contraseñas 😉 ]


Primera vista a Turnkey.

Para el sr. S. Vaughan-Nichols, quien lleva años trabajando con PhpMyAdmin, probó el Adminer y le resultó agradable; en mi caso veo una sencilla interfaz que va directo al grano y sin complicación alguna: yo la recomendaría para aprendizaje previo al PhpMyAdmin y/o PhpPgAdmin.

La primera diferencia que hallo es que para poderme conectar por el explorador de internet (en mi caso Mozilla) debo utilizar el prefijo https. Como les comenté, la seguridad no ha sido descuidadada en esta distribución, ya que genera sus propias claves al instalar la distro Turnkey (en nuestro caso «correr» live CD). Si quieren conocer al detalle los de las claves SSH y su administración recomiendo leer el siguiente post del Maestro Twitter @Phenobarbital Sr. Jesús Lara.

Como dichas claves SSH no están avaladas por un tercero de confianza el navegador hace la debida advertencia de seguridad a la cual le estableceremos unas indicaciones para nuestras pruebas en el servidor virtual Turnkey (si adquirimos una llave API tipo TKLBAM con Turnkey NADA de lo siguiente que explico haría falta hacer).

Turnkey 01
Conectando por primera vez para administrar Turnkey en una máquina VirtualBox.

Como ven el en gráfico anterior haremos click en «comprendo los riesgos» y luego «agregar excepción». Esto sólo lo haremos con nuestras máquinas que corren en nuestra propia red de área local, jamás ni nunca lo haremos con otros sitios web en internet (sigamos los consejos de seguridad de SUSCERTE).

Turnkey 02
NO agregaremos como permanente la excepción de seguridad.

NO agregaremos como permanente la excepción de seguridad ya que sólo hacemos esto con propósitos didácticos, recuerden que corremos el servidor en RAM -live CD- y cada vez que lo reiniciemos imagino genera nuevas claves SSH así que no embasuremos nuestro querido navegador web ADEMÁS que si hacemos pruebas con otras máquinas virtuales y el enrutador les asigna la misma dirección IP local nos saldrán otros mensajes de advertencia de seguridad, OSEA no nos embaserumos nosotros mismos a la hora de aprender a programar.

Turnkey 03
Portada principal para administrar Turnkey.

Lo primero que vamos a ver es el Adminer LAS FLECHAS ROJAS en las imágenes son de mi autoría para guiarnos paso a paso, hacemos click a donde ellas apuntan.

Turnkey 04
Usando Adminer,
login «posgres».

El usuario -o «login»- es la palabra «posgres» y la contraseña la que hallamos colocado al instalar -o correr- el Turnkey.

Turnkey 05
Administrando PostgreSQL con Adminer.

En fin, hagan uso de su albedrío y creen bases de datos, agreguen tablas y/o índices, clonen, jueguen y aprendan. Recuerden que como estamos ejecutando un live CD al reiniciar la máquina se perderán todos los datos. Mi imaginación vuela en este caso: si adquirimos una API key que nos permita respaldar con los servidores de Turnkey y una vez hecho eso, apagamos y pudieramos levantar otro servidor virtual en cualquier otro sitio restaurando los datos desde Turnkey, aunque imagino que eso tendrá su costo adicional, respaldar y restaurar con frecuencia. No soy el único en Venezuela que conoce TurNkey ya hay varios usuarios «corriéndolo» en Venezuela: Maracaibo, Barquisimeto, Araure [ ¿? ], Valencia, Puerto Cabello, Maracay, Cumaná y, ¡cómo no!, Caracas.

Turnkey 10
Servidores (al día de hoy 27sep2015) corriendo Turnkey en Venezuela.

Mi imaginación va mucho más allá: la manera como programaron a Turnkey se puede prestar para montar servidores maliciosos. El pequeño detalle es que deben pagarle a Turnkey con una tarjeta de crédito cuyo dueño es localizable por los bancos de manera rápida y si usan una tarjeta robada o extraviada igual es delito federal en los EE.UU. así que esa opción, como ven, queda descartada.


Administrando a Turnkey.

Turnkey 00
Pantalla de bienvenida a Turnkey.

En esta pantalla de bievenida que veremos por cónsola nos muestra un resúmen sobre cómo conectarnos vía remota y ya analizamos como entrar en el apartado anterior. Hago hincapié en la publicidad: si adquirimos una API key TKLBAM la debemos introducir en el cuadro de diálogo anterior y esperar que se realicen las actualizacions y/o instalaciones para montar BIEN EN SERIO UN SERVIDOR PARA PRODUCIR DINERO. Ese tema, por ahora ni lo tocaremos ni lo revisaremos.

Turnkey corriendo en VirtualBox.
Turnkey corriendo en VirtualBox.

Lo que si que vamos a hacer es echar un ojo a las opciones para administrar nuestro futuro servidor:

Turnkey 03
Portada principal para administrar Turnkey.

¿Recuerdan la portada principal? PUES ESTA VEZ HACEMOS CLICK EN EL ÍCONO QUE DICE WEBMIN, olvídense por un momento de la flecha roja [qué pichirre soy con el alojamiento web, NO voy a subir otra imagen nada más que para apuntar con otra flecha roja ja ja ja 😉 ]

Turnkey 06
Entrando a Webmin como usuario «root».

Usaremos las credenciales de usuario raíz -«root»- y si éste fuera un servidor para producción lo primero que haríamos es crear los usuarios correspondientes y no volver a tocar la dichosa cuenta. Acá como estamos aprendiendo y jugando pues no haremos nada de eso. La contraseña pues, halá, la que introdujimos al instalar -o correr-:

Turnkey 07
Menú principal Webmin.

Sinceramente quedé abrumado por la cantidad de opciones del Webmin lo único que se me ocurre para describirles la aplicación es que es como si estuvieramos sentados en la cónsola del servidor, pero con una interfaz gráfica de la cual carece -excepto de esta manera remota-. Podemos agregar los usuarios que les dije, reiniciar o apagar el equipo (partimos de que estamos conectados por https o SSH y bien seguros), instalar o quitar aplicaciones, configurar la red (ojito con desconectarnos nosotros mismos) y cualquier otra cantidad de cosas. Incluso para nuestro aprendizaje (nunca para un servidor en producción) podemos instalar «Google Gears» -un proyecto que aunque abandonado desde marzo de 2011 seguirá existiendo por SVN – e incluso lo podemos exportar y mantenerlo en nuestro propio espacio GitHub (nada malo ha pasado con el alojamiento de proyectos de código abierto ofrecidos por este gigante, sólamente reconocen que GitHub es mucho mejor e incluso ellos se mudaron también; YO DIGO QUE ES OTRA VICTORIA PARA LINUS TORVALDS Y RICHARD STALLMAN, un proyecto abandonado de software libre puede ser mantenido perfectamente por otros que aún lo consideren importante):

Turnkey + Webmin + Google Gears
Turnkey + Webmin + Google Gears.

Como son muchas las opciones que tiene el Webmin sólamente les mostraré las capturas de pantallas de las opciones del menú:

Webmin opción principal
Webmin opción principal
Webmin opción "system".
Webmin opción «system».
Webmin opción "servers".
Webmin opción «servers».
Webmin opción "tools".
Webmin opción «tools».

 

Webmin opción "networking".
Webmin opción «networking».
Webmin opción "hardware".
Webmin opción «hardware».

Apagado de Turnkey virtual.

Espero hayan disfrutado de este post tanto como yo, hoy aprendimos algo nuevo y sólo queda apagar la máquina virtual por (faltaba más faltaba menos) por medio de Webmin:

Apagado de servidores remotos por Webmin.
Apagado de servidores remotos por Webmin.

 

<Eso es todo, ¡por ahora!>.

Download PDF

PostgreSQL 9.1: su uso con psql.

Download PDF

Y seguimos aprovechando el receso de Carnaval para continuar nuestro estudio del poderoso motor de base de datos relacional PostgreSQL 9.1.

Nuestra miniserie comienza acá y en la última entrada tocamos el tema de las consultas con uniones las cuales utilizaremos aquí también pero con ayuda del programa psql y tal como lo prometimos vamos a trabajar en profundidad por línea de comandos.

Como recordarán ya habíamos utilizado anteriormente a psql para garantizarle al usuario adminsql acceso íntegro a todas las bases de datos en el servidor PostgreSQL que instalamos.

Breve pausa para hablar sobre seguridad básica.

Normalmente lo que hicimos en el párrafo anterior sólamente se hace si hay un solo usuario y una sola base de datos, un sistema pequeño, tal como era a finales del siglo pasado. Pero ahora con computadoras con procesadores multinúcleo (e incluso hasta computadoras con multiprocesador ) un servidor PostgreSQL puede, tranquilamente, atender muchos usuarios a la vez. Imaginemos que en nuestra Academia de Software Libre de ejemplo cada alumno debe acceder a este recurso único pero debemos de cuidar que cada quien trabaje en su propia base de datos y no toque las ajenas, ya sea por error o a propósito (que se ven casos así). Pues bien PostgreSQL soporta usuarios y grupos internamente, tal como si fuera una computadora con un sistema operativo moderno.

Un usuario pudiera ser cada alumno en clase con su base de datos propia para desarrollar su trabajo y aprobar el curso.

Un grupo, por ejemplo, pudiera ser un sección o curso en determinada aula de clase con derechos de sólo lectura sobre una base de datos perteneciente al instructor de clases y además independiente de otros instructores en otras seccionesde clase; eso nos facilita el trabajo al crear usuarios pues se le asigna al grupo y «hereda» la configuración.

Trabajando con psql.

Lo comentado en la sección anterior lo veremos ahora de forma práctica y de la manera más sencilla posible. En la máquina Debian que corre nuestro PostgresSQL seleccionamos «Aplicaciones->Accesorios->Terminal»:

postgresql_blog01Abrimos así una ventana terminal donde procederemos a ingresar el comando psql pero en esta oportunidad lo haremos acompañado de opciones adicionales:

psql --username=adminsql --password --dbname=GNU_academy

Dichas opciones son:

  • «–username=nombre_de_usuario» permite colocar a continuación el nombre del usuario que se va a conectar; la forma abreviada es «-U nombre_de_usuario» con un espacio entre ambos (y tened en cuenta las mayúsculas y minúsculas, tal cual se escriben).
  • «–password» para que nos pregunte la contraseña («–no-password» será útil en trabajos de procesos por lotes); la forma abreviada es «-W» (notad que las formas largas son con doble guión y las cortas con un solo guión).
  • «–dbname=nombre_de_la_base_de_datos» nos conecta de una vez a donde vamos a trabajar; la forma abreviada es «-d nombre_de_la_base_de_datos» con un espacio entre ambos.

Por ahora ésas son las opciones que utilizaremos por la terminal interactiva pero en realidad psql tiene gran cantidad de agregados los cuales en otras entradas le daremos uso, pero no a todos. Si queréis echar un ojo a la lista completa, pincha aquí.

Una vez hayamos presionado intro y haber tecleado nuestra consabida contraseña al cabo de otro intro nos aparece el siguiente mensaje de error:

psql: FATAL: Peer authentication failed for user «adminsql»

Y no, no es porque hayamos ingresado mal la contraseña, que es harta sencilla sino por el asunto de seguridad que describí hace poco. Para que podamos conectarnos debemos crear un usuario llamado adminsql con su correspondiente contraseña en el sistema operativo Debian (o GNU/Linux que usemos). Esto no sería deseable, ya que los usuarios tendrían acceso al sistema operativo en sí, amén que también si son muchos usuarios recarga inncesariamente el sistema de archivos (que aunque tengamos poderosas computadoras siempre la frugalidad es bienvenida), y no, no necesitamos ése esquema de trabajo.

Es por ello que contamos con la opción peer por defecto, apoyada por el sistema operativo y contamos con la opción md5 que encripta la contraseña para mayor seguridad, así que sólo registraremos usuarios dentro de PostgreSQL. Para ello ganaremos acceso como superusuario y luego usaremos el programa editor de texto nano para editar la configuración. Por favor observen la imagen para que tengan el panorama completo:

postgresql_blog02

nano /etc/postgresql/9.1/main/pg_hba.conf

y buscaremos la sección «is for Unix domain sockets connections only» donde cambiaremos «peer» por «md5» tal como aparece en la siguiente figura:

postgresql_blog03lo siguiente será (recuerden, estamos usando nano) CTRL+X -> «y» -> intro osea guardar y salir en el editor de textos que hayan utilizado ustedes. Una vez hecho esto, necesitamos que el servidor tome la nueva configuración, en realidad el servicio o demonio debemos reiniciarlo, no la máquina en si:

service postgresql restart

y si hicimos bien nuestro trabajo veremos más o menos lo siguiente:

postgresql_blog04De nuevo introducimos el comando descrito para conectarnos a la base de datos pero esta vez si que tenemos éxito en nuestra tarea:

postgresql_blog05Y allí estamos, a la espera de la primera consulta, usaremos entonces la última de la entrada anterior:

SELECT students.name, phone_numbers.number
FROM students
INNER JOIN phone_numbers
ON students.id=phone_numbers.idstudent
WHERE LOWER(students.email) ~ ‘hotmail.com’;

¿Recuerdan la utilidad del punto y coma para indicar el final de la consulta? Acá nos viene como anillo al dedo pues estas terminales son un tanto incómodas al estar generalmente limitadas a 80 columnas, así que presionamos intro y notad que el prompt cambia de «=#» a «-=» para indicarnos que estamos en una sola sentencia a pesar que son varias lineas:

postgresql_blog06¡Y listo! hemos hecho nuestra primera consulta por terminal interactiva, ya sólo queda salir de psql y luego de nuestra terminal para ello bastará con teclear:

/quit

exit

En la próxima entrada seguiremos trabajando por línea de comandos para la creación de tablas e insertado de datos en las mismas y ampliaremos el estudio de consultas por uniones JOIN.

<Eso es todo, por ahora>.

Download PDF
INNER JOIN y LEFT JOIN.

PostgreSQL 9.1: integridad referencial y consultas por uniones.

Download PDF

Esta vez realizaremos unas consultas por uniones no sin antes dar una breve explicación de la integridad referencial, una característica de las bases de datos relacionales, siempre de la manera más sencilla posible.

Para los que el orden es importante esta serie de artículos sobre PostgreSQL 9.1 comienzan acá y la manera de conectarnos al servidor vía phpPgAdmin se describe aquí.

Pues bien, comenzemos ya: tenemos creadas dos tablas llamadas students y phone_numbers y como bien lo describe sus nombres en inglés, sirven para almacenar datos de estudiantes y sus números telefónicos. Como cada persona puede tener varios teléfonos (casa, trabajo, móvil, fax, etc.) y a su vez cada una de esas ubicaciones hoy en día pueden tener varios números diferentes (en mi caso tengo 2 en casa, 3 en el trabajo y uno celular) no tiene sentido crear campos para cada uno de ellos en la tabla students porque no sabemos cuántos va a tener cada inviduo. Cualquiera me puede rebatir diciendo que aunque sea debería suministrar un número de teléfono para alguna emergencia en clase (desde el punto de vista de este ejercicio donde somos una Academia de Software Libre) pero ni con eso contaría yo, es decir, puede darse el caso que no tenga ningún teléfono (hermosa es la película «Enemy of the State» ojalá la disfruten tanto como yo la disfruté en 1999). Es por tanto que en la tabla students no dejamos ningún campo para almacenar el o los que nos suministren y los guardaremos en la tabla phone_numbers teniendo cuidado de guardar de quién es cada cual.

Observemos que al seleccionar la tabla phone_numbers desde phpPgAdmin haciendo click en «constraints» («restricciones») descubriremos el trabajo que hizo Visual Paradigm traduciendo nuestro organigrama a la base de datos:

Postgresql_2015-02-04 09:20:28Como en la entrada anterior agregamos algunos datos de los estudiantes tenemos dicha tabla de ejemplos de la siguiente manera:

Postgresql_2015-02-04 09:22:25De nuevo hacemos click en la tabla phone_numbers e insertamos un registro tal como lo hicimos en la entrada anterior, sólo que en este caso y cuando lleguemos al campo idstudent automáticamente aparecerá una lista de los estudiantes que ya tenemos registrados, en este caso identificados del 1 al 4:

Postgresql_2015-02-04 09:23:06Para probar si la base de datos funciona correctamente en su integridad referencial colocaremos el idstudent = 5 (que aún no está registrado) y le damos click a «insert»:

Postgresql_2015-02-04 09:31:18¡Oh, sorpresa! nos devuelve un mensaje de error y no es para menos ¿para qué querríamos guardar un número de teléfono si no sabemos quién es su propietario? (a menos que trabajeís como detective, hay «caso de casos»).

Desistimos pues en nuestro intento de «embasurar» nuestra base de datos y procedemos a colocarles a los tres números telefónicos que insertemos un idstudent cualquiera entre 1 y 4 y al poco rato tenemos una bonita matrícula lista para clases (aunque falta agregar cursos, aulas, profesores, horarios… «Roma no se construyó en un solo día» reza el refrán, vamos poco a poco).

Una vez hecho esto ya estamos listos para hacer unas consultas entre ambas tablas y con propósitos didácticos ejecutamos la primera consulta (y de manera similar a nuestra entrada anterior):

SELECT students.name, phone_numbers.number

FROM students, phone_numbers

WHERE students.id = phone_numbers.idstudent;

Postgresql_2015-02-04 09:44:09La consulta está en escrita en tres líneas pero la base de datos «sabe» que la misma termina cuando alcanza el punto y coma «;» y dicha manera de escribirla nos proporciona legibilidad para desglosarla y explicarla, línea por línea:

  • La primera línea ordena que seleccione «SELECT» los campos «name» de la tabla «students» (de allí el punto como unión) e igual con «number» que pertenece a la tabla «phone_numbers». Esta sintaxis permite que, por ejemplo, dos campos con el mismo nombre en diferentes tablas sean identificados sin ambigüedad alguna.
  • La segunda línea «FROM» instruye de cuáles tablas sacarán los datos.
  • La tercera línea «WHERE» está el condicional: para cada estudiante que devuelva el o los números telefónico(s) registrado(s) relacionados entre sí por el identificador numérico.

Como sólo insertamos tres números telefónicos pues sólo tres estudiantes con teléfonos será lo que veremos (en este caso para cada estudiante un solo número telefónico que sería el caso más común). ¿Pero y si queremos visualizar TODOS los estudiantes, tengan o no número telefónico registrado?

Uniones o «JOIN»:

En el lenguaje SQL existe el comando JOIN con sus prefijos INNER, LEFT y RIGHT haciendo la salvedad que «JOIN» = «INNER JOIN» y será el primero que veremos para realizar la misma consulta que hicimos con el condicional WHERE:

SELECT students.name, phone_numbers.number

FROM students

INNER JOIN phone_numbers

ON students.id=phone_numbers.idstudent;

Postgresql_2015-02-04 09:44:49

De nuevo desglosamos y analizamos línea por línea (recordad el para qué sirve el punto y coma al final de la consulta):

  • La primera línea solicitamos los campos que nos interesan de ambas tablas, cada uno con su espacio de nombres para evitar confusiones.
  • La segunda línea específicamos la tabla «principal» (esto tendrá sentido más adelante) es decir los estudiantes, ya que ellos son los propietarios de cada número de teléfono.
  • La tercera línea indica hacia cual tabla se hará la unión, osea con cual se combinará.
  • La última linea establece cómo relacionar los datos, en este caso una sola condición posible de relación entre ambas tablas (pudieran haber otras relaciones posibles pero por ahora no complicaremos las cosas).
INNER JOIN
INNER JOIN

Hasta aquí todo bien pero volvamos a la pregunta:

¿Pero y si queremos visualizar TODOS los estudiantes -y su(s) número(s) telefónico(s)-, tengan o no número telefónico registrado?

Es aquí que utilizaremos LEFT JOIN en vez de INNER JOIN, simplemente ese cambio, una sola palabra por otra:

Postgresql_2015-02-04 09:45:02

SELECT students.name, phone_numbers.number

FROM students

LEFT JOIN phone_numbers

ON students.id=phone_numbers.idstudent;

Y AHORA SÍ que observamos que el estudiante Pedro aparece pero en donde va el número telefónico muestra NULL el cual es una palabra que encierra un concepto que en base de datos trae aún hoy en día candentes discusiones pero que en este caso práctico muestra su utilidad: «NO TIENE NÚMERO TELEFÓNICO REGISTRADO Y NO SABEMOS SI REALMENTE LO TIENE YA QUE SIMPLEMENTE O SE NEGÓ A SUMINISTRARLO O EL INSCRIPTOR OLVIDÓ REGISTRARLO». Todo eso encierra el concepto de NULL.


Actualizado el martes 12 de enero de 2016: me hacen la sugerencia que pudieramos colocar un campo lógico (verdadero o falso) para saber a ciencia cierta si la persona posee algún teléfono. No veo mala esa idea pero recomiendo que le coloquen NULL como valor predeterminado pero que sea obligatorio ese dato -y por ende no permitirá guardar con NULL-. A nivel de la interfaz del usuario, el formulario que introduce datos para agregar personas deberá utilizarse un RADIO BUTTON sin valor preseleccionado en ninguno de los dos. Ejemplo:

¿Posee teléfono?
Sí.
No.

LEFT JOIN
LEFT JOIN

Ya cerrando la entrada podemos  acotar la consulta JOIN con un simple WHERE tal como ejercitamos en otra entrada:

SELECT students.name, phone_numbers.number
FROM students
LEFT JOIN phone_numbers
ON students.id=phone_numbers.idstudent
WHERE LOWER(students.email) ~ ‘hotmail.com’;

sólo que esta vez veremos sólamente los estudiantes que posean correo electrónico en «hotmail.com» (hoy día «outlook.com») y que tengan al menos un número telefónico registrado.

En la próxima entrada veremos y estudiaremos cuáles otras opciones existen sobre JOIN, tan importante es que en Wikipedia en castellano tiene su propia entrada completa.

<Eso es todo, por ahora>.

Download PDF

PostgreSQL 9.1: consultas SQL sencillas con phpPgAdmin.

Download PDF

Aprovecho el breve receso de estas fechas carnestolendas de 2015 para continuar con esta miniserie de artículos sobre PostgreSQL 9.1. Para aquellos que quieran llevar la secuencia correcta del tema éste se inicia acá .

La fotografía que veís y que encabeza esta entrada es la del Doctor Donald Chamberlin, investigador de la IBM quien junto al Doctor Raymond Boyce (quien falleció en 1974 y muy poquísimas fotografías dejó) ambos idearon (y nos legaron) el «Structured Query Language» (SQL).

Lo que haremos hoy son unas consultas sencillas en SQL no sin antes haber agregado unos cuantos datos de prueba (cualquier semejanza con personas reales es pura y casual coincidencia).

Utilizando el navegador web predeterminado en Debian, el Iceweasel (que cada día aprecio más por su economía de recursos y por ende rapidez) nos vamos a la consabida dirección IP de nuestro servidor virtual:

Postgresql_2015-02-02 19:52:43

Introducimos el «login» y la contraseña (si no lo recuerdan ir a esta entrada ) y una vez hayamos logrado acceso hacemos click («o vamos») a la tabla students (aunque soy fanático del castellano, debo reconocer que el inglés es hoy en día lo que fue el latín en el mundo entero) y observamos su estructura de datos más sin embargo nos interesa, por ahora, el enlace «insert» para dar algunas altas en la tabla:

Postgresql_2015-02-02 19:53:20

Tras lo cual se nos abre el siguiente cuadro de diálogo el cual procedemos a llenar sin cortapisa:

Postgresql_2015-02-02 19:54:05Observen que dejé el campo «id» intencionalmente en blanco: nuestro primer valor será, naturalmente, el 1 pero en los siguientes registros que insertemos intenten guardar ese valor de nuevo y observarán una de las restricciones de la tabla: los valores no pueden repetirse para ese campo en particular. A la final verán algo parecido a esto, ya con los registros insertados:

Postgresql_2015-02-02 19:54:30 Postgresql_2015-02-02 19:58:16

Vuelvo a repetir: cualquier parecido con los datos personales en la realidad es simple y feliz coincidencia. Ahora que tenemos unos cuantos registros insertados podemos hacer unas consultas sencillas, para ello bastará con hacer click en el enlace «SQL» que está en el borde superior derecho de la web, cerquita de

«SQL | History |Find | Logout»

¿lo vieron? en el cuadro de diálogo que se abre escribimos la siguiente sentencia para visualizar los correos electrónicos de los estudiantes:

select email from students;

Antes que hagan click en «execute» («ejecutar -sentencia-«) observen atentamente que estamos trabajando con la base de datos «GNU_academy» y que nuestro vía de búsqueda de esquema está apuntada a «public» (ésto último permite que al ejecutar una sentencia SQL los nombres de tablas y campos sean buscados y verificados primero antes de comenzar a buscar datos, e incluso es útil para asuntos de seguridad y privilegios pero ese tema es más avanzado; si luego quieren aprender más sobre ello aquí el enlace introductorio al asunto ).

Así pues, sin más, ejecutamos la sentencia tras lo cual veremos algo parecido a esto:

Postgresql_2015-02-02 19:59:41

La explicación breve de la sentencia SQL es traducirla del inglés:

«select»->»selecciona»

«from»->»desde (la tabla)»

«;»-> indica fin de la sentencia, no es obligatorio pero es útil si vamos a introducir varias sentencias que deben ir en un orden específico (por ejemplo insertar más datos de estudiantes y luego mostrarlos en un listado para asistencia -ya le vamos dando utilidad en la vida real a esto de las bases de datos-).

Como hay comandos específicos del lenguaje SQL yo opto (y hay varias personas que lo hacen) por escribir dichos comandos en mayúsculas y los nombres de tablas (y/o variables y/o constantes) en minúsculas y como pueden ver se ejecutan sin ningún problema, el asunto es de legibilidad para nosotros los humanos:

SELECT email FROM students;

Importante: los nombres de campos y tablas han escribirse tal cual fueron creados en la base de datos correspondiente, de no ser así nos devuelve error; es por ello que desde un principio en estos tutoriales los creamos todos en minúsculas -y en inglés, de paso-.

Volviendo al tema de la realidad, supongamos que por cualquier razón necesitamos saber cúales (y cuántos) estudiantes utilizan correo hotmail pues simplemente introducimos la siguiente sentencia SQL

SELECT email FROM students WHERE email ~ ‘hotmail.com’;

Observen el nuevo comando

«WHERE»->»donde (satisfazga la condición)»

y el uso de la virgulilla como comparador lógico indicando que dicha condición tenga la cadena de texto ‘hotmail.com’. Otros detalles a considerar es el uso de las comillas simples y el uso de mayúsculas: si usamos comillas dobles se interpreta como nombre de columna y si usamos mayúsculas NO devuelve los correos electrónicos ya que «hoTMail.com» NO ES IGUAL A «hotmail.com»:

«hoTMail.com» <> «hotmail.com»

Sobre nomenclatura del correo electrónico:

Esto nos plantea desde ya nuevos retos: si vamos a desarrollar una aplicación seria es deber que los usuarios ingresen direcciones de correo válidos (sintaxis usuario@dominio ):

  • El nombre del usuario NO debe llevar espacios a menos que estén precedidos por una barra inversa y entrecomillado.
  • El dominio NUNCA debe llevar espacios (ni arrobas, claro está).
  • No pueden haber espacios antes o después de una dirección válida.
  • No pueden llevar dobles puntos «..», así estén entrecomillados.
  • El nombre del usuario no pueden contener dobles arrobas a menos que estén debidamente entrecomillados.

Y son sólo algunas de las reglas que aplican a la sintaxis de una dirección de correo electrónico, para mayor información (en inglés, ¡cuando no!) en RFC 822 y dirección de correo electrónico . La buena noticia es que PosgreSQL admite varios lenguajes de programación que junto con triggers o «disparadores» nos permitirán capturar y revisar los correos electrónicos antes de agregarlos a la base de datos (serán tratados a futuro en una entrada aparte). Y aunque nos hemos salido un poco de las consultas sencillas era necesario ir abonando el terreno hacia temas más avanzados (oh idioma castellano, qué poético eres, nunca cambies 😉 ).

Os ruego hagan la prueba escribiendo las sentencias en sus múltiples variantes, como ayuda os dejo el comando LIKE cuyo uso tiene una sintaxis más elaborada:

SELECT email FROM students WHERE email LIKE ‘%hotmail.com%’;

Produciendo el mismo resultado que con la virgulilla; vale destacar que al colocar el símbolo de porcentaje como comodín le estamos ordenando que nos busque cualquier dirección de correo electrónico registrado en nuestra tabla students que contenga la cadena de caracteres «hotmail.com» (obsérvese que si algún bromista registrara la dirección de correo electrónico «hotmail.com@gmail.com» sería devuelta también en la consulta, os animo a probarla -aunque dudo que alguien en verdad tenga ésa dirección-) pero eso aún no resuelve nuestro problema de mayúsculas y minúsculas.

Una solución sería utilizar una función integrada por defecto en nuestra base de datos, es decir, una serie de programas ya registrados y de propósito general; dicha función para este caso es LOWER() aplicado al campo email (ojo que si es así lo que entrecomillamos como condición debe ir todo en minúsculas):

SELECT email FROM students WHERE LOWER(email) LIKE ‘%hotmail.com%’;

o también podemos usar, como al principio, la virgulilla que nos ahorra el uso de comodines:

SELECT email FROM students WHERE LOWER(email) ~ ‘hotmail.com’;

Si quereís ver el resto de funciones de cadena, haced click aquí.

Por último, si quiséramos el caso contrario, listar los estudiantes que no tienen correo «hotmail» registrado:

SELECT email FROM students WHERE LOWER(email) !~ ‘hotmail.com’;

y lo único que hicimos fue agregarle el operador lógico «!» que indica negación «NOT», el cual si que lo podemos usar con LIKE:

SELECT email FROM students WHERE LOWER(email) NOT LIKE ‘%hotmail.com%’;

Y entonces nos desconectamos de la base de datos como es debido:

Postgresql_2015-02-02 20:01:21

<Eso es todo, por ahora>.

Download PDF

PostgreSQL 9.1: su uso con Visual Paradigm.

Download PDF

En la entrada anterior explicamos cómo instalar y configurar el phpPgAdmin y creamos nuestra primera base de datos (basados en el usuario «adminsql» de la primera entrada de esta mini serie de artículos), y esta entrada estará dedicada a la poderosa herramienta Visual Paradigm (que puede descargar para GNU/Linux en este enlace ) con la cual podremos crear tablas y sus relaciones de una manera gráfica y hasta amena (si se quiere) en comparación a los comandos por cónsola. Para mí es una novedad esta herramienta, y creo que es representativa del nivel de calidad de software que contamos hoy en día no obstante dedicaremos una entrada a las órdenes por cónsola, por aquello de la nostalgia. 😉

Pues bien, empecemos: de primero ya descargamos el archivo llamado Visual_Paradigm_12_0_20150106_Linux32.sh que no es más que un archivo de procesamiento por lotes (o shell script en idioma inglés) en este caso MUY GRANDE que ocupa 253,3 megabytes y al cual hay que dedicarle al menos mil megabytes de espacio en disco para ser instalado. Es grande.

Abrimos una terminal con derechos de usuario root y nos vamos a la carpeta de descargas de nuestro navegador web (o a la carpeta donde realmente los guardamos) y ejecutamos:

./Visual_Paradigm_12_0_20150106_Linux32.sh

Postgresql_2015-02-02 18:45:03Hacemos click en «next» y veremos lo siguiente:

Postgresql_2015-02-02 18:46:09Pueden leer completo (en inglés) la el acuerdo de licencia completo haciendo click aquí. Seleccionamos «I accept the agreement» y hacemos click en «next»:

Postgresql_2015-02-02 18:46:16En nuestro caso dejamos el directorio por defecto (si hacen click en «browse» pueden seleccionar otra ubicación) y hacemos click en «next»:

Postgresql_2015-02-02 18:46:23Dejamos los «symlinks» o «symbolic link» (o «enlace simbólico«) en su directorio por defecto (dichos enlaces simbólicos son archivos que apunta hacia la ubicación real de los archivos y ayudan, por ejemplo, dar nombres cortos a los programas que nos ahorran trabajo cuando escribimos por cónsola). Hacemos click en «next» y comienza realmente la instalación en sí:

Postgresql_2015-02-02 18:47:30 Postgresql_2015-02-02 18:47:39Como queda seleccionada por defecto la opción de ejecutar (o «correr») el programa hacemos click en «next» para seleccionar la opción de uso, en nuestro caso seleccionamos los 30 días de prueba:

Postgresql_2015-02-02 18:47:59Recuerden que «Thus, ‘free software’ is a matter of liberty, not price.» («software libre es cuestión de libertad, no de precio») para nuestros propósitos didácticos la versiónde prueba es más que suficiente:

Postgresql_2015-02-02 18:48:09 Postgresql_2015-02-02 18:48:13Hasta acá queda instalado la herramienta de software, ahora a trabajar en la creación de las tablas y sus relaciones.

Creación de tablas y relaciones.

Nos proponemos crear dos tablas sencillas, una para contener los datos básicos de los estudiantes y otra con los números de teléfonos (teniendo en cuenta que cada persona puede tener un celular o móvil, el teléfono de casa, el de oficina u otro(s) números) relacionados por una «foreign key» que apunta a una «primary key» y en su debida oportunidad veremos las ventajas (y desventajas) de dicha forma de trabajar, todo bajo la «Normalización de base de datos«; por ahora basta con saber que ésos son los conceptos que nos basaremos para modelar.

Una vez que arranca el programa seleccionamos «Database modeling»:

Postgresql_2015-02-02 18:48:56 Postgresql_2015-02-02 18:49:29y luego hacemos click en «Entity Relationship Diagram» y le asignamos el nombre «pupils» al nuevo proyecto:

Postgresql_2015-02-02 19:04:55y procedemos primero que nada a configurar con cuál motor de base de datos vamos a trabajar, PostgreSQL para lo cual nos vamos a la pestaña «tools» y luego «Database Configuration«:

Postgresql_2015-02-02 19:05:06Hacemos click y se abre un cuadro de diálogo para que seleccionemos «PostgreSQL» no sin antes indicar dónde tenemos el «driver file» o «archivo controlador» que servirá para que Visual Paradigm pueda «hablar» con nuestro servidor recién instalado. Si nos fijamos bien en el mismo cuadro de diálogo nos indica de dónde podemos descargarlo:

Postgresql_2015-02-02 19:38:16si hacemos click en «Download link» y tenemos paciencia se abre nuestro navegador web predeterminado con la siguiente página:

Postgresql_2015-02-02 19:09:31 Postgresql_2015-02-02 19:10:00procedemos a descargar el identificado como «postgresql-9.1-903.jdbc4.jar» (observen que para cada versión de PostgreSQL hay su correspondiente controlador, sean cuidadosos al elegir por favor):

Postgresql_2015-02-02 19:11:48Este último cuadro de diálogo para elegir el controlador aparece al hacer click en el botón que muestra 3 puntitos en la misma línea de «Driver file». Al clickear en «Open» procedemos a llenar el resto de los valores que configuramos en las dos entradas anteriores, que en un papelito debemos haber anotado y puesto al alcance de la mano para ganar tiempo:

Postgresql_2015-02-02 19:38:16Luego hacemos click en «Test Connection» y si hemos realizado bien nuestro trabajo veremos algo como esto:

Postgresql_2015-02-02 19:38:23Le damos click a «OK» para entonces agregar la primera futura tabla al hacer click en «Entity -a table-» en el icono que se ve en la siguiente imagen (me disculpan el errorcito de nombre de proyecto, si se fijan) y acto seguido «dibujamos» un rectángulo con tamaño a nuestra apetencia en el área de trabajo:

Postgresql_2015-02-02 18:49:49Lo que viene a continuacón es largo de describir en palabras, pero como decimos en farmacia «hágase según arte» y siendo así manipulamos dicho objeto colocandole los nombres siguientes (no se preocupen, más adelante especificaremos los tipos de datos):

Postgresql_2015-02-02 19:40:05Tal como lo hicimos, de buenas a primera, los tipos de datos son «integer» de allí la letra «N» gorda rellena de blanco en cada renglón. Repetimos el procedimiento pero esta vez debe quedar de esta manera:

Postgresql_2015-02-02 19:40:24

Postgresql_2015-02-02 19:40:55

Ahora si hacemos «click derecho» – click con el botón secundario del ratón- para que en el cuadro de diálogo de cada linea (campo de la tabla) nos permita modificarlo; EJEMPLO seleccionamos el «id» de «students» y lo marcamos como «Primary Key» y un «Id Generator-> Increment»:

Postgresql_2015-02-02 19:42:47Hacemos click en «Ok» y repetimos el procedimiento para el campo «name» PERO lo colocamos para que sea tipo «varchar» (cadena de texto) y acepte hasta 255 letras -toda una exageración- pero vuelvo a repetir «con propósitos didácticos»:

Postgresql_2015-02-02 19:43:25A la final (TÓMENSE SU TIEMPO) las dos tablas han de quedar de la siguiente manera:

Postgresql_2015-02-02 19:48:28Luego procedemos a simplemente hacer click sobre la tabla «students» y al mover el puntero del ratón hacia el borde superior aprecerá rápidamente unos iconos con descripción rápida de uso para cada uno de ellos:

Postgresql_2015-02-02 19:49:03Escogemos «One-to-Many Relationship» (un estudiante puede tener varios números de telefonos distintos -o ninguno-) y arrastramos la línea hasta la tabla «phone_numbers» como aprecian en figura:

Postgresql_2015-02-02 19:49:23A continuación soltamos y se abre menú para escoger detalladamente la relación que queremos:

Postgresql_2015-02-02 19:50:02 Postgresql_2015-02-02 19:50:30Y listo, ya tenemos definida la estructura de datos, sólo que falta el pequeño detalle de «enviarla» al servidor PostgreSQL, para ello de nuevo nos vamos la pestaña «Tools» y luego en «DB»->»Generate Database» (no se preocupen NO vamos a generar base de datos, aunque se puede hacer ya nosotros la creamos cuando instalamos phpPgAdmin ¿se recuerdan?) sólo es cuestión de seleccionar «Update Database» y marcar «Export to database», observen bien:

Postgresql_2015-02-02 19:51:48Recordemos que habíamos configurado previamente las propiedades de conexión, una vez pulsado «OK» (y sin seleccionar «Close dialog…») y si ampliamos y ajustamos el tamaño de ventana detallaremos el maravillos trabajo que nos ahorramos (sí, todas esas líneas de comandos que para este ejemplo son pocas pero imagínense que trabajamos en una empresa que manufactura clavos y nos piden hacer una aplicación que lleve el inventario de materia prima y productos terminados… ufff y eso sin meter las ventas, pedidos, despachos, comisiones de vendedores…):

Postgresql_2015-02-02 19:52:26Ya para finalizar esta entrada, y sólo por desconfianza inherente a nuestra naturaleza humana, verificamos con phpPgAdmin cómo quedaron nuestras tablas (cómo navegar e ingresar están descritos en la entrada anterior) :

Postgresql_2015-02-02 19:52:43En nuestra próxima entrada veremos cómo añadir unos cuantos datos (registros) y los primeros comandos básicos de SQL.

<Eso es todo, por ahora>.

Download PDF

PostgreSQL 9.1: su uso con phpPgAdmin.

Download PDF

En la entrada anterior  dejamos listo el servidor de base de datos PostgreSQL 9.1 y ahora vamos a utilizar software de administración basado en web phpPgAdmin para lo cual echamos mano de una cónsola con derechos (aquí utilizamos root de una buena vez) y luego usamos apt (también pueden utilizar  aptitude-install si gustan y lo tienen configurado):

apt-get install phppgadmin

Recordad que aunque nos referimos como «phpPgAdmin» para el apt debemos escribirlo todo en letras minúsculas para que pueda haber coincidencia con los repositorios, ojito con eso que en GNU/Linux es motivo de frustración en muchas personas (eso y el NUMLOCK encendido). La buena noticia es que, si no lo tenemos instalado, la orden de manera tácita instala el servidor web Apache y el lenguaje de programación PHP a nuestra máquina (los módulos necesarios sólamente, ni más ni menos):

Postgresql_2015-02-02 19:20:34

Una vez que pulsamos la letra «Y» y presionamos «Enter» («S» e «Intro» para los que hablamos castellano):

Postgresql_2015-02-02 19:21:59 Postgresql_2015-02-02 19:22:08

Al finalizar la instalación podemos configurar el phpPgAdmin para que admita conexiones desde cualquier computadora, por seguridad viene sólo para sea administrado directa y únicamente por cónsola de la máquina, así que:

cd /etc/apache2.d

nano phppgadmin

Postgresql_2015-02-02 19:22:50

Así descomentamos (eliminamos «# » del inicio de línea) justo la que está debajo de «allow from 127.0.0. (..)», veréis algo así como esto:

Postgresql_2015-02-02 19:29:38

Guardamos y salimos para luego reiniciar el servidor Apache y que acepte así la nueva configuración que necesitamos:

/etc/init.d/apache2 restart

Postgresql_2015-02-02 19:31:04

Ahora desde cualquier otra máquina en la misma red de área local (recordáis que les dije que anotaran ése valor) podemos proceder a verificar primero si el servidor web funciona:

Postgresql_2015-02-02 19:31:47Esta última captura de pantalla, tal y como se los describí en la entrada origen a este trabajo, es la máquina real que contiene a la máquina virtual en la cual está alojada la máquina virtual cuyo nuestro enrutador de red inalámbrico le asignó la dirección 192.168.1.27 y utilizamos Iceweasel que es el navegador web predeterminado en Debian. Luego procedemos a verificar si el phpPgAdmin está corriendo al introducir en la barra de direcciones el siguiente comando:

http://192.168.1.27/phppgadmin

Postgresql_2015-02-02 19:32:03Hacemos click en el panel izquierdo en donde dice «Servers->PostgreSQL» y nos aparece la pantalla para iniciar sesión:

Postgresql_2015-02-02 19:32:19Para nuestro caso el usuario que le colocamos: «adminsql» y contraseña «12345», entramos y podemos observar que la única base de datos es postgres la cual es utilizada para almacenar valores del PostgreSQL y permitir su funcionamiento, la dejamos tranquilita, si queréis podeís ver sus valor sin modificar nada (por ahora):

Postgresql_2015-02-02 19:32:40Fijad la mirada en el enlace «Create database» allí mismo hacemos click para comenzar a trabajar (¡por fin!) en el proyecto en sí:

Postgresql_2015-02-02 19:37:56Le colocamos el nombre «GNU_academy» en el «encoding» seleccionamos «UTF8» para que acepte nuestros caracteres castellanos («ñÑáÁéÉíÍóÓúUüÜ») y no se preocupen por «Collation» que automáticamente toma la configuración regional del sistema.

Hasta aquí finaliza el tema de phpPgAdmin en la próxima entrada comenzaremos con la poderosa herramienta Visual Paradigm.

<Eso es todo, por ahora>.

Download PDF
Postgresql logo

PostgreSQL 9.1: primeros pasos.

Download PDF

Por motivos de trabajo y estudio hemos descuidado un poco nuestro blog pero antes que termine el mes de enero de 2015 traemos a caso de análisis el potente motor  para bases de datos PostgreSQL y aunque al momento de escribir esto ya van por la versión 9.4 (diciembre de 2014) utilizaremos para nuestro estudio la versión 9.1 (ojito con estos numeritos de la versión que lo usaremos bastante).

En esta entrada haremos un trabajo eminentemente práctico, las teorías y detalles serán tradadas en entradas posterios, dado el tamaño del tema en cuestión. Mi reconocimiento especial a @phenobarbital por su blog que sirve como preciada guía para este nuestro proceso de aprendizaje.

A manera de resumen enumeramos lo siguiente:

  1. Con VirtualBox haremos una máquina virtual Debian 32 bits para hacer allí las pruebas necesarias sin comprometer nuestra máquina real (uso y creación de máquinas virtuales merece una entrada completa aparte a futuro).
  2. Una vez instalada y configurada con sus repositorios instalaremos PostgreSQL y la configuraremos para aceptar conexiones de usuarios de la red de área local (no obstante los comandos los introduciremos directamente por cónsola, las sesiones ssh y Tmux merecen entrada aparte en el blog -a futuro-).
  3. Una vez tengamos el terreno abonado usaremos Visual Paradigm para linux 32 bits en modo demostrativo ya que con esta herramienta definiremos las tablas de una base de datos sencilla, manejo de inscripción de personas en cursos, haciendo una abstracción generalizada de dicho proceso.
  4. Instalaremos phpPgAdmin como herramienta para administrar la base de datos vía web, verificar las tablas e incluso agregar y/o modificar datos.
  5. Con datos agregados (y esperamos agregar unos cuantos millones de usuarios) realizaremos algunas sentencias SQL, uniones y consultas.

 

Pues bien, manos a la obra.


Instalación de PostgreSQL.

Con la máquina virtual corriendo  (512 megabytes RAM, 1 CPU y 1 NIC 100 mbps asignados virtualmente) abrimos una terminal y nos registramos como super usuario, recuerden que debemos tener configurados ya nuestros repositorios y una buena conexión a internet. Para nuestro caso es específico tenemos a la máquina virtual alojada en una red de área local cuyo enrutador asigna direcciones IP internas con DHCP basado en la dirección MAC de la tarjeta de red virtual que está en puente «bridge» con la máquina real así que al arrancar automáticamente ya la tenemos en la dirección 192.168.1.27 y con  5 mbps de velocidad al internet asignada a ella solita para no molestar a los demás usuarios, si no hacemos esto monopolizaremos al modem y no es la idea (de nuevo, todo esto merece una entrada aparte en nuestro blog, a futuro lo haremos).

Ejecutamos en la cónsola:

apt-get update (intro).

apt-get install postgresql-9.1

Recordando siempre que estamos como super usuario, aquí una captura de pantalla de los procesos que más o menos vereís sobre el proceso de instalación.

Postgresql_2015-01-30 07_36_26Postgresql_2015-01-30 07_36_35Postgresql_2015-01-30 07_37_28

Configuración de PostgreSQL.

Una vez finalizada la instalación es que comienza en realidad nuestro trabajo, verificamos si la instalación agregó un usuario llamado «postgres» con el comando:

cat /etc/shadow | egrep «postgres»

a lo cual devuelve algo parecido a esto (si está está agregado el usuario):

postgres:*:16465:0:99999:7:::

Postgresql_2015-01-30 08_30_29

Si es positivo procedemos a conectarnos como usuario «postgres»:

su postgres

y el indicador se convierte en «postgres@postgresql:/home/jimmy$» y esto quiere decir que estamos conectados como usuario «postgres» en la máquina «postgresql» y ubicados en la carpeta «home» del usuario «jimmy». Si queremos ver cual es nuestra carpeta «home», osea el «home» del usuario «postgre» escribimos:

echo $HOME

lo cual devuelve «/var/lib/postgresql».

Postgresql_2015-01-30 08_42_26

La idea es crear un nuevo usuario utilizando la sencilla nomenclatura para nombres y contraseñas (que para propósitos didácticos es excelente PERO para la vida real NO cuidadito con dejar un servidor PostgreSQL configurado así 😯 ).

createuser -sPl adminsql

y nos pregunta contraseña a lo cual introducimos «12345» y confirmamos nuestra elección.

Postgresql_2015-01-30 09_00_52

Ahora si es que vamos a entrar al propio PostgreSQL, escribimos:

psql

lo cual nos devuelve algo parecido a esto (imagen):

Postgresql_2015-01-30 09_04_17

y acto seguido garantizamos que el usuario que acabamos de agregar tenga acceso libre a las bases de datos:

grant all on database postgres to adminsql;

y si nos acepta el comando nos devuelve «GRANT» y listo, salimos de la cónsola con

\quit

Postgresql_2015-01-30 09_08_48

Acceso remoto a PostgreSQL.

No obstante que estamos trabajando en cónsola directamente a la máquina virtual lo más probable es que tengamos que acceder a ella remotamente así que agregamos el usuario que acabamos de agregar al archivo siguiente:

nano /etc/postgresql/9.1/main/pg_hba.conf

y quiere decir que utilizamos el editor de texto «nano» para editar el archivo pg_hba.conf (o utilicen su editor de texto favorito, muy populares son «vi» y pueden instalar «vim» o «gedit», el que gusten). Editamos el archivo donde especifican las direcciones IPv4:

#IPv4 local conections:

host   all   127.0.0.1/32   md5

host    all   192.168.1.0/24   md5

Teniendo cuidado de insertar sólo espacios en blanco entre las palabras (que si usaís la tecla TAB configurar para que la misma inserte espacios y no el caracter mismo tabulador) y recordemos hacer esto cada vez que agreguemos un usuario a la base de datos y así permitirle conectarse de manera remota en una red de área local con su respectiva submáscara de red (en notación CIDR:  «192.168.1.0/24»), me disculpan el error al colocar 255:

Postgresql_2015-01-30 09_18_58

Guardamos y salimos a la linea de comando para ejecutar:

nano /etc/postgresql/9.1/main/postgresql.conf

y modificamos y agregamos los siguientes datos (todo lo que esté escrito a la derecha del símbolo «#» son comentarios que no toma en cuenta el servidor PostgreSQL pero que para nosotros los humanos son importantes):


# – Connection settings –

listen_addresses = ‘*’     #valor por defecto ‘localhost’

max_connections = 50     # valor por defecto 100

# – Memory –

shared_buffers = 16MB   #valor por defecto 24 se requiere «fórmula» para hallar el mejor valor para nuestro servidor según nuestro hardware -nunca más del 40% de la memoria instalada o virtualizada-.

temp_buffers = 8MB   #8 por defecto la subimos a 16 pero eso depende de las consultes que pensemos ejecutar, hay que tantear este valor.

work-men = 16MB    #para las INSERT, DELETE para cada usuario por cada segundo

# – Background Writer –

bgwriter_delay = 500ms #cada medio segundo escribe al disco duro y así evitamos sobrecargar al hardware.

En las siguientes imágenes sólo falta el valor de acceso al disco duro descrito poco antes, observen que coloco una estrella para resaltar los valores que necesitan reiniciar al servidor PostgreSQL (dado el caso que tengamos usuarios conectados utilizamos reload en vez de restart):

Postgresql_2015-01-30 09_43_22


 

Observen escribir cuidadosamente cada uno de los valores antes de guardar (si yo tengo algún error o sugerencia COMENTAR esta entrada) así que si todo está correcto guardamos y salimos a la cónsola de entrada y una vez hecho esto procedemos a reiniciar el servidor de base de datos con la orden:

/etc/init.d/postgresql restart

y si hemos colocado bien las modificaciones devolverá lo siguiente (imagen):

Postgresql_2015-01-30 09_52_09

De no ser así volvemos sobre nuestros pasos hasta que se reinicie el servidor postgresql y avanzar hacia la siguiente etapa de configuración.

En este punto debemos advertir que tocaremos variables de configuración del sistem Debian por lo tanto debemos ser cuidadosos con lo que escribimos, vericar 3 veces lo ingresado; ya que estamos como usuario «postgres» debemos teclear «exit» y presionar la tecla intro y ganar acceso como «root» para así poder ejecutar en cónsola:

nano /etc/sysctl.conf

y agregamos al final los siguientes valores (que por ahora no sabemos qué significan pero en una futura entrada le dedicaremos su correspondiente espacio bien explicado):


kernel.sem = 100 32000 100 128
kernel.shmall = 3279547
kernel.shmmax = 289128448
kernel.shmmni = 8192
fs.file-max = 287573
vm.dirty_bytes = 67108864
vm.dirty_background_bytes = 134217728



 

Revisamos bien los valores guardamos y salimos para ejecutar:

sysctl -p

a lo cual nos devuelve por pantalla precisamente los guarismos que introdujimos:

Postgresql_2015-01-30 10_16_19

Acto seguido comprobamos que el servidor PostgreSQL acepte la nueva configuración pormedio de la orden que ya sabemos:

/etc/init.d/postgresql restart

y si todo va bien veremos lo siguiente:

Postgresql_2015-01-30 10_17_41

Ahora  vamos a instalar el Visual Paradigm 12  phpPgAdmin  desde el enlace que colocamos al inicio de esta entrada y para no resultar tediosa y larga esta entrada continuaremos en otra en el siguente enlace.

<Eso es todo, por ahora>.

Enlaces relacionados.

En castellano:

En inglés:

Download PDF