DESARROLLO

Desde mi punto de vista, como nuevo administrador de una Base de Datos en una empresa
es fundamental, como primera actividad en mi primer día, conocer y familiarizarse con la
estructura y la forma de la base de datos.

Al no estar presente o no participar en la planeación de la base de datos desconosco las

definiciones e implementaciones de normas, procedimientos y reglas que el anterior
administrador estableció, por lo que se vuelve importante conocer dichas operaciones para
ser yo quien me adapte a los objetivos que están instituidos desde la creación de la base,
incluyendo la misma definición del esquema original y el diseño conceptual de la base.

Por otro lado, debo conocer e identificar el medio físico donde esta almacenada la base de
la empresa, el tipo de hardware que se está utilizando, como por ejemplo el tipo de disco
duro y su partición asignada en el servidor. Además, también debo conocer las políticas que
se están llevando a cabo en cuestión de la seguridad, es decir, los métodos específicos de
acceso y los estándares que se están utilizando para la definición de permisos para los
usuarios y los grupos.

Considero que debo obtener de este análisis un reporte preciso de todos los privilegios que
están establecidos, esto con el fin de garantizar la integridad de la información contenida
en la base, pues ahora como nuevo administrador es mi responsabilidad salvaguardar las
operaciones diarias de la empresa.

Dentro de este primer reporte que debo generar en cuanto a la seguridad de la base de
datos, debo determinar si el software encargado del combate al malware y las utilerías
propias del servidor para la administración de las operaciones son los ideales o debo buscar
una mejor opción para proponerla, con el fin de realizar la óptima y correcta configuración
del servidor.

Una ves analizado a detalle todos los puntos que he mencionado anteriormente, y antes de
adentrarme a las tareas de monitoreo y mantenimiento de la base de datos, considero que
existen una serie de actividades mas a realizar. Una de ellas es, en primera instancia, crear
un informe detallado dirigido a la gerencia sobre el estado en el cual estoy recibiendo la
base de datos, donde debo indicar y describir los puntos a trabajar y las propuestas que
tengo en mente para llevar a cabo mis actividades como nuevo DBA.

Otro punto a tratar, que a grandes rasgos es uno de los puntos más importantes como
nuevo responsable de la administración de una base de datos, es el entender y conocer las
necesidades de los usuarios. Aquí es importante aclarar que, como parte del área de
sistemas y tecnologías de la información, somos personas que ofrecemos un servicio a los
demás por lo que, en el aspecto personal, es fundamental ser empático con los usuarios y
con nuestros compañeros, comprender que cada uno tiene diferentes necesidades y
diferentes objetivos por cumplir.

Entonces, tomando en cuenta las necesidades, estaré en posición de asignar los accesos,
permisos y privilegios para las áreas de la empresa que así lo requieran, y a su ves evaluar
si las políticas de seguridad que encontré al llegar a la gestión de la base son idóneas y no
se compromete la integridad de los datos.

Una vez que me haya familiarizado con la estructura, funcionalidad y seguridad de la base
de datos y antes de realizar cualquier otra actividad al respecto, el paso a seguir es realizar
el respaldo correspondiente de los datos, con objeto de que no exista ningún inconveniente
cuando se implementen las nuevas disposiciones de gestión que llevare a acabo, una ves
que se hayan aprobado por la gerencia.

Respecto al respaldo de la información, debo asegurarme de realizar una copia completa

para evitar perdida de datos sensibles, pues al ser el nuevo administrador de la base
realizare cambios en la forma de gestionar los recursos, y ello me hace responsable del
cuidado de toda la información.

En estos primeros pasos debo ser minucioso y cuidadoso, pues la transición en un DBA a
otro no solo afecta una sola parte de la empresa, sino a toda la organización.

Una vez que he podido conocer la base, realizar su respaldo y después de realizar los
reportes correspondientes para implementar mi forma de gestionar la base de datos,
entonces si llego el momento de monitorear la actividad y el rendimiento de la base.

De ahora en adelante, la mayor de mis responsabilidades es monitorear la actividad y las

operacion de manipulación de la base, donde debo identificar la integridad del hardware y
el software (Sistema Operativo Linux) y del manejador que se está utilizando (en este caso
PostgreSQL), además de errores de desarrollo y de conectividad. Más adelante explicare
este proceso de monitoreo con un ejemplo, por lo pronto seguiré explicando de manera
general mis actividades como nuevo DBA.

En primer lugar, debo saber cuales son las tareas que el sistema operativo esta ejecutando,
cuantas de estas tareas realizan otros procesos en segundo plano, cual es el consumo de
memoria que estas tareas gastan para que, con base en ello, determine la prioridad entre
los procesos, con el fin de conocer el alcance y el limite de operación del servidor que estoy
administrando.
Es claro que el monitoreo empieza desde el sistema operativo, por lo que, desde la consola
de comandos del mismo, ejecuto el comando ps para conseguir información del uso del
CPU, de la memoria RAM y sobre todo de la actividad de la interacción entre los clientes y
el servidor.

También, ejecutar el comando ps -fea | grep postgres | grep -v grep me permitirá conocer
el estado de uso tanto del CPU y de la memoria RAM. Ejecutar este proceso es primordial
en mis primeros días de trabajo con el nuevo administrador, ya que puedo estar al tanto del
consumo de ambos, pues si su actividad es muy alta provocaría la inestabilidad del servidor
y podría significar un gran problema para las operaciones de las áreas que componen la
organización.

Como se puede notar, es muy importante que la memoria RAM tenga capacidad suficiente
para el buen funcionamiento del servidor, entonces, al ser minucioso en mi trabajo, debo
vigilar el rendimiento y obtener los detalles necesarios mediante la ejecución el comando
vmstat para evitar un colapso por el acceso excesivo al disco y por la saturación de la
memoria.

Otra de mis responsabilidades es estar al pendiente del estado de la conexión al servidor,

por lo que, mediante el comando netstat, conoceré el total de las conexiones en espera de
conexión, por lo que mi trabajo es evitar problemas de respuesta del servidor.

Por otro lado, es importante hacer diversas pruebas en cuanto a la importación y

exportación de datos para conocer los tiempos de respuesta de nuestro servidor. En esta
parte cobra mucha importancia la realización del respaldo de la base, así no se afectarán ni
interrumpidas las actividades. Además, podre observar la cantidad de respaldos existentes
para determinar cuales ya son obsoletos y proceder a liberar espacio en el disco.

Ahora bien, desde la perspectiva del sistema operativo conozco cual es mi labor, entonces
es momento de monitorear las actividades desde el mismo gestor de base de datos, que en
este caso es PostgreSQL, como ya había mencionado.

Oto procedimiento obligatorio que necesito realizar en mis primeros días como DBA es
saber el tamaño de la base que estoy administrando, para ello, debo ejecutar la sintaxis
correcta de la función pg_database_size (oid). Esta acción me será de utilidad para visualizar
el espacio ocupado y el espacio libre en el disco.

Entendiendo que me encuentro en una empresa donde tener acceso a la información es

importante no solo para un usuario, sino que lo es también para uno, dos, tres o varios
usuarios, es necesario que como administrador de la base de datos realice ciertos bloqueos
para evitar que varios usuarios ingresen y realicen cambios en la información que otra
persona esta ocupando en ese preciso momento.

De esta forma se garantiza, por un lado, la integridad de la información que se está

gestionando, y por el otro, el buen rendimiento y del servidor.

Anteriormente, había mencionado que era necesario entregar un reporte a la gerencia

sobre el estado en el cual recibí la administración de la base, además de las propuestas en
cuando a las mejoras en hardware y software. Pues es en este punto donde esto adquiere
una relevancia muy importante, ya que mi labor diaria es monitorear la concurrencia de
usuarios al sistema de base de datos para garantizar la fluidez en las operaciones que se
realizan.

Y aunque parte de esta fluidez depende de la conexión del servidor y del tipo de hardware
que se utiliza, también puedo revisar este flujo mediante el comando pg_stat_activity, el
cual me permite visualizar el numero total de usuarios conectados.

El día a día en la organización demanda mayor atención en los procedimientos que se

realizan en la base, por lo que tener el mayor espacio libre posible en el disco duro es muy
importe, pero no solo de la memoria común, sino también de la memoria cache, así que
para recoger la relación entre estas es necesito que ejecute el comando pg_stat_database,
el cual me permitirá visualizar el almacenamiento total y la correcta funcionalidad de la
memoria cache respecto a la memoria común.

A pesar de que mi labor demanda mucha atención de mi parte para que todo funcione
correctamente, no siempre se podrá tener todo en orden o funcionando como yo deseo,
por lo que optimizar lo mas posible el rendimiento de nuestra base es primordial, esto lo
podemos gestionar mediante el comando pg_stat_bgwriter, el cual nos permite asignar
mas espacio en los buffers a los procesos que lo demandan.

Hasta ahora, y analizándolo como he descrito mis actividades de administrador de la base

de datos, pareciera que es un trabajo muy difícil y que consume mucho tiempo de nuestro
día, incluso más allá de mi horario laboral. Pero para mi fortuna existen procedimientos que
me auxilian y son de mucha ayuda, me refiero a las tareas rutinarias y a las tareas
programadas.

Respecto a las tareas rutinarias, estas se enfocan a la limpieza y mantenimiento de los datos
contenidos en cada tabla de la base. Para la realización de este procedimiento debo utilizar
el comando vacuum, el cual me permite realizar dicha limpieza de la base. De esta manera,
podré recuperar espacio en disco perdido principalmente por las actualizaciones, actualizar
la planificación de las consultas y me brinda protección ante la pérdida de datos. Por lo que
es altamente recomendable ejecutar de forma periódica este comando para que, en caso
de algún problema, el sistema me avise que acción debo tomar.

En cuanto a las tareas programadas, estas me resultan de gran ayuda sobre todo al
momento de realizar un backup. Gracias estas tareas me es posible programar el respaldo
de la base a una cierta hora en un periodo de tiempo determinado por mí. Esta se realizará
en automático y además de guardar en forma física en el disco dicho respaldo, me puede
enviar una copia a mi correo electrónico y libera espacio eliminando antiguos respaldos.

Ahora bien, es verdad que gestores de bases de datos como SQL Server u Oracle son mucho
más populares y más utilizadas por sus estándares y robustez. Pero a pesar de ello en esta
empresa se elige trabajar con PostgreSQL por diversas razones, entre las que se encuentran
su fácil accesibilidad para usuarios avanzados o novatos y su rápido ajuste para gestionar
grandes volúmenes de información.

Además de contar con el hardware necesario y óptimo para administrar la base y ofrecer
un mejor servicio, es necesario que realice modificaciones al archivo de configuración de
postgres, el cual se encuentra ubicado en /usr/local/pgsql/data/. Pero antes de que realice
cualquier acción, es altamente recomendable la elaboración de un respaldo de este archivo
de configuración (postgres.conf).

Una vez ubicado en la edición de este archivo puedo realizar las modificaciones necesarias
para mejorar el rendimiento. Entre estas se encuentran el aumento del tamaño del buffer
sobre el total de memoria RAM disponible. Pero debo tener en cuenta que existen
parámetros del kernel que se necesitan modificar debido a los limites de la cantidad de
memoria que asigna, con el fin de evitar inconvenientes.

Dentro del mismo archivo, puedo modificar el parámetro work_mem, el cual me permitirá
tener control del total de la memoria que se utiliza en la realización de consultas complejas.

El tamaño de la memoria cache siempre será un asunto muy importante, no para los
usuarios, sino para mí, ya que de ello depende que los usuarios trabajen de la forma mas
optima posible. Para saber el total de chache que tengo disponible debo modificar el
parámetro effective_cache_size para establecer la cantidad de memoria.

Por otro lado, existe una técnica no tan compleja para ofrecer un mejor rendimiento y un
opimo servicio, esta es la partición de tablas. Su función principal es reducir los datos que
se leen en cada consulta realizada, pues se trabaja en bloques mas simples y la realización
de respaldos es mucho más rápida.
Mi trabajo parece muy complicado de llevar a cabo, ya lo había mencionado. Mis
actividades requieren un porcentaje de atención muy alto, pero es gratificante y
emocionante cuando me doy cuenta que de mi depende gran parte de los objetivos de cada
departamento y de la organización como tal.

Algunas personas podrán preguntarse: “¿Y de que sirve realizar todas esas operaciones y
actividades tan complejas? De seguro tu trabajo no se toma muy en cuenta”. Y no se podría
estar mas equivocado. El objetivo de realizar todas y cada una de las actividades descritas
en este documente es que me permiten crear estadísticas de desempeño, las cuales debo
reportar periódicamente a la gerencia y contribuir así a la adecuada toma de decisiones.

Por último, ejemplificare y enlistare una serie de actividades de restauración y monitoreo

de un servicio de base de datos, que en este caso es el siguiente:

Se me otorga la responsabilidad de la gestión base de datos “cp_cdmx”, el cual contiene

todos los códigos postales de la Ciudad de México.

1. Los datos se encuentran contenidos en una hoja de cálculo, por lo que procedo a
respaldar esta información en un archivo llamado codpost.csv en la ubicación
/usr/local/pgsql/.
2. En la terminal del sistema operativo, específicamente en la base de datos “cp_cdmx”
creo la tabla “codigos”.

create table codigos (

id_codigo serial not null,
codigo_postal int not null,
colonia varchar (100) not null,
tipo_colonia varchar (20) not null,
alcaldia varchar (30) not null,
estado varchar (20) not null,
ciudad varchar (20) not null,
cp int not null,
c_estado int not null,
oficina int not null,
c_tipo_colonia int not null,
c_alcaldia int not null,
colonia_cpcons int not null,
zona varchar (10) not null,
clave_ciudad int not null
);

3. Se restauran los datos del archivo codpost.csv en la tabla creada.

Copy codigos (codigo_postal, colonia, tipo_colonia, alcaldía,

estado, ciudad, cp, c_estado, oficina, c_tipo_colonia, c_alcaldia,
colonia_cpcons,zona,clave_ciudad)from'/usr/local/pgsql/codpost.csv
'delimiter',' csv header;

4. Se realiza una consulta para verificar que los datos se han restaurado correctamente.

cp_cdmx=# select * from codigos;

id_codigo | codigo_postal | colonia
| tipo_colonia | alcaldia | estado | ciud
ad | cp | c_estado | oficina | c_tipo_colonia | c_alcaldia
| colonia_cpcons | zona | clave_ciudad
-----------+---------------+--------------------------------------
--------------+--------------+------------------------+-----------
-------+----------
--------+-------+----------+---------+----------------+-----------
-+----------------+--------+--------------
1 | 1010 | Los Alpes
| Colonia | Álvaro Obregón | Ciudad de México | Ciudad
de
México | 1001 | 9 | 1001 | 9 | 10
| 5 | Urbano | 1
 2 | 1020 | Guadalupe Inn
| Colonia | Álvaro Obregón | Ciudad de México | Ciudad
de
México | 1001 | 9 | 1001 | 9 | 10
| 6 | Urbano | 1
3 | 1030 | Florida |
Colonia | Álvaro Obregón | Ciudad de México | Ciudad
de
México | 1001 | 9 | 1001 | 9 | 10
| 10 | Urbano | 1
4 | 1030 | Axotla |
Pueblo | Álvaro Obregón | Ciudad de México | Ciudad
de
México | 1001 | 9 | 1001 | 28 | 10
| 9 | Urbano | 1
5 | 1040 | Campestre
| Colonia | Álvaro Obregón | Ciudad de México | Ciudad
de
México | 1001 | 9 | 1001 | 9 | 10
| 12 | Urbano | 1
6 | 1049 | Tlacopac
| Pueblo | Álvaro Obregón | Ciudad de México | Ciudad
de
México | 1001 | 9 | 1001 | 28 | 10
| 14 | Urbano | 1
7 | 1050 | Ex-Hacienda de Guadalupe Chimalistac
| Colonia | Álvaro Obregón | Ciudad de México | Ciudad
de
México | 1001 | 9 | 1001 | 9 | 10
| 16 | Urbano | 1
8 | 1060 | Altavista
| Colonia | Álvaro Obregón | Ciudad de México | Ciudad
de
México | 1001 | 9 | 1001 | 9 | 10
| 17 | Urbano | 1
9 | 1060 | San Ángel Inn
| Colonia | Álvaro Obregón | Ciudad de México | Ciudad
de
México | 1001 | 9 | 1001 | 9 | 10
| 18 | Urbano | 1
10 | 1070 | Chimalistac
| Colonia | Álvaro Obregón | Ciudad de México | Ciudad
de México

5. Desde el sistema operativo, se ejecuta el comando ps.

cp_cdmx=# \q
-bash-4.2$ exit
logout
[root@localhost diplomado]# ps
PID TTY TIME CMD
9647 pts/1 00:00:00 su
9667 pts/1 00:00:00 bash
9979 pts/1 00:00:00 ps

6. Desde el sistema operativo, se ejecuta el comando ps -fea | grep postgres | grep -v

grep.

[root@localhost diplomado]# ps -fea | grep postgres | grep -v grep

postgres 7023 1 0 oct07? 00:00:04
/usr/local/pgsql/bin/postmaster -D /usr/local/pgsql/data
postgres 7148 7023 0 oct07 ? 00:00:00 postgres:
checkpointer
postgres 7149 7023 0 oct07 ? 00:00:00 postgres: background
writer
postgres 7150 7023 0 oct07 ? 00:00:00 postgres: walwriter
postgres 7151 7023 0 oct07 ? 00:00:00 postgres: autovacuum
launcher
postgres 7152 7023 0 oct07 ? 00:00:00 postgres: stats
collector
postgres 7155 7023 0 oct07 ? 00:00:00 postgres: logical
replication launcher
root 9529 9490 0 oct07 pts/0 00:00:00 su - postgres
postgres 9530 9529 0 oct07 pts/0 00:00:00 -bash
postgres 9594 9530 0 oct07 pts/0 00:00:00 psql cp_cdmx
postgres 9595 7023 0 oct07 ? 00:00:00 postgres: postgres
cp_cdmx [local] idle
postgres 9598 9594 0 oct07 pts/0 00:00:00 more
root 9913 9875 0 oct07 pts/2 00:00:00 su - postgres
postgres 9914 9913 0 oct07 pts/2 00:00:00 -bash
postgres 9958 9914 0 oct07 pts/2 00:00:00 psql cp_cdmx
postgres 9959 7023 0 oct07 ? 00:00:00 postgres: postgres
cp_cdmx [local] idle

7. Desde el sistema operative, se ejecuta el commando vmstat.

[root@localhost diplomado]# vmstat 1 10

procs -----------memory---------- ---swap-- -----io---- -system-- -
-----cpu-----
r b swpd free buff cache si so bi bo in cs
us sy id wa st
2 0 114688 69480 0 268776 1 8 230 12 93 76
2 2 96 0 0
0 0 114688 69456 0 268776 0 0 0 0 259 291
3 0 97 0 0
 0 0 114688 69456 0 268776 0 0 0 0 293 367
2 0 97 0 0
0 0 114688 69456 0 268776 0 0 0 0 303 366
3 0 97 0 0
0 0 114688 69512 0 268776 0 0 0 0 525 391
3 3 94 0 0
0 0 114688 69696 0 268784 0 0 0 0 317 362
3 0 97 0 0
0 0 114688 69696 0 268784 0 0 0 0 285 349
3 0 97 0 0
0 0 114688 69508 0 268848 0 0 0 0 367 340
3 1 96 0 0
0 0 114688 69508 0 268848 0 0 0 0 321 354
3 1 96 0 0
0 0 114688 69508 0 268848 0 0 0 0 254 296
2 0 97 0 0

8. Desde el sistema operativo se ejecuta el comando netstat.

[root@localhost diplomado]# netstat -ntu | grep «TIME_WAIT» | wc -l

0

9. De ahora en adelante se ejecutarán consultas dentro del PostgreSQL, comenzando por

pg_database.

cp_cdmx=# SELECT SUM(pg_database_size(oid)) FROM pg_database;

sum
----------
62891024
(1 row)

cp_cdmx=# SELECT pg_database_size(oid) FROM pg_database;

pg_database_size
------------------
7908351
7774723
7766531
7766531
7881219
7766531
7766531
8260607
(8 rows)

cp_cdmx=# \l
 List of databases
Name | Owner | Encoding | Collate | Ctype
| Access privileges
---------------------+----------+----------+-------------+--------
-----+-----------------------
biblioteca | postgres | UTF8 | es_MX.UTF-8 | es_MX.UTF-
8 |
cp_cdmx | postgres | UTF8 | es_MX.UTF-8 | es_MX.UTF-
8 |
postgres | postgres | UTF8 | es_MX.UTF-8 | es_MX.UTF-
8 |
prueba | postgres | UTF8 | es_MX.UTF-8 | es_MX.UTF-
8 |
respaldo_biblioteca | postgres | UTF8 | es_MX.UTF-8 | es_MX.UTF-
8 |
respaldo_prueba | postgres | UTF8 | es_MX.UTF-8 | es_MX.UTF-
8 |
template0 | postgres | UTF8 | es_MX.UTF-8 | es_MX.UTF-
8 | =c/postgres +
| | | | |
postgres=CTc/postgres
template1 | postgres | UTF8 | es_MX.UTF-8 | es_MX.UTF-
8 | =c/postgres +
| | | | |
postgres=CTc/postgres
(8 rows)

10. Se ejecuta la consulta pg_locks.

cp_cdmx=# SELECT COUNT(*) FROM pg_locks;

count
-------
2
(1 row)

cp_cdmx=# SELECT * FROM pg_locks;

locktype | database | relation | page | tuple | virtualxid |
transactionid | classid | objid | objsubid | virtualtransaction |
pid | mode
| granted | fastpath
------------+----------+----------+------+-------+------------+---
------------+---------+-------+----------+--------------------+---
----+-------------
----+---------+----------
relation | 24617 | 11645 | | | |
| | | | 4/111 | 10556 |
AccessShareL
ock | t | t
 virtualxid | | | | | 4/111 |
| | | | 4/111 | 10556 |
ExclusiveLoc
k | t | t
(2 rows)

11. Se ejecuta la consulta pg_stat_activity.

cp_cdmx=# SELECT COUNT(usename) FROM pg_stat_activity;

count
-------
4
(1 row)

cp_cdmx=# SELECT usename FROM pg_stat_activity;

usename
----------
postgres
postgres
postgres
postgres

12. Se ejecuta la consulta pg_stat_database.

cp_cdmx=# SELECT SUM(blks_hit) / SUM(blks_read) FROM

pg_stat_database;
?column?
---------------------
61.2592592592592593
(1 row)

13. Se ejecuta el comando pg_stat_bgwriter.

cp_cdmx=# SELECT maxwritten_clean FROM pg_stat_bgwriter;

maxwritten_clean
------------------
0
(1 row)

cp_cdmx=# SELECT buffers_backend FROM pg_stat_bgwriter;

buffers_backend
-----------------
157
(1 row)
14. Entrando en la programación de tareas rutinarias, se ejecuta la consulta VACUUM.

cp_cdmx=# vacuum verbose codigos;

INFO: vacuuming "public.codigos"
INFO: "codigos": found 0 removable, 1539 nonremovable row versions
in 29 out of 29 pages
DETAIL: 0 dead row versions cannot be removed yet, oldest xmin: 609
There were 0 unused item pointers.
Skipped 0 pages due to buffer pins, 0 frozen pages.
0 pages are entirely empty.
CPU: user: 0.02 s, system: 0.09 s, elapsed: 0.14 s.
VACUUM

15. Se ejecuta la consulta reindex.

cp_cdmx=# REINDEX DATABASE cp_cdmx;

REINDEX

16. En cuanto a los ajustes de la configuración del rendimiento y optimización de

consultas, se ejecuta la consulta EXPLAIN.

cp_cdmx=# EXPLAIN SELECT * FROM codigos;

QUERY PLAN
-------------------------------------------------------------
Seq Scan on codigos (cost=0.00..44.39 rows=1539 width=116)
(1 row)

cp_cdmx=# EXPLAIN ANALYZE SELECT * FROM codigos;

QUERY PLAN
------------------------------------------------------------------
----------------------------------------
Seq Scan on codigos (cost=0.00..44.39 rows=1539 width=116) (actual
time=0.038..0.696 rows=1539 loops=1)
Planning Time: 0.102 ms
Execution Time: 2.525 ms
(3 rows)

17. Se ejecuta la consulta ANALYZE VERBOSE.

cp_cdmx=# ANALYZE VERBOSE codigos;

INFO: analyzing "public.codigos"
INFO: "codigos": scanned 29 of 29 pages, containing 1539 live rows
and 0 dead rows; 1539 rows in sample, 1539 estimated total rows
ANALYZE