GUIA PARA SYSADMINS POSTGRESQL
Vamos a plasmar en este pequeno tutorial los conocimientos basicos para poder trabajar en POSTGRESQL. Vamos a abarcar desde la instalacion, configuracion hasta el disenar una sencilla base de datos para una veterinaria con varios campos y con esta vamos a jugar un poco para descubrir el potencial de POSTGRESQL.
Que es una base de datos?
Una base de datos o banco de datos (en ocasiones abreviada con la sigla BD o con la abreviatura DB) es un conjunto de datos pertenecientes a un mismo contexto y almacenados sistemáticamente para su posterior uso
Una base de datos esta compuesta por tablas.
Las tablas es una estructura de datos que esta organiaza en columnas y filas.
Cada columna es un campo o atributo
Cada fia es un registro.
Cuando una columna y una fila se unen en una interseccion solo se puede tener el valor de un dato.
Cada registro contiene un dato por cada columna en la tabla
Cada campo (columna) debe tener un nombre. El nombre del campo hace referencia a la información que almacenará.
Cada campo (columna) también debe definir el tipo de dato que almacenará.
== INSTALACION ==
++ REQUERIMIENTOS D DISCO ++
vemos nuestro espacio disponible
#df-k
nota:
50mb para el codigo fuente
60mb para compilar
30mb para probar el codigofuente compilado.
ya finaliazada la instalacion opcupa de 8 a 15mb instalado.
++ INSTALACION DE LOS REPOSITORIOS ++
#yum install -y make gcc tar gzip readline zlib zlib-devel libtermcap-devel readline-devel vim
notas:
a) la version de gmake 4.76.1 o superior para el 8.4
b) si no se encuentran estas librerias:
-readline: no permite el interprete de comandos, el history
-zlib: no permite pg_dump and pg_restore.
++ FUENTES ++
http://ftp.postgresql.org/pub/source/v8.2.23/postgresql-8.2.23.tar.gz
http://ftp.postgresql.org/pub/source/v8.4.9/postgresql-8.4.9.tar.gz
http://ftp.postgresql.org/pub/source/v9.0.2/postgresql-9.0.2.tar.gz
http://ftp.postgresql.org/pub/source/v9.0.3/postgresql-9.0.3.tar.gz
http://ftp.postgresql.org/pub/source/v9.1.0/postgresql-9.1.0.tar.gz
http://ftp.postgresql.org/pub/source/v9.2.0/postgresql-9.2.0.tar.gz
++ INICIO DE LA INSTALACION ++
1) #./configure
Antes de compilar la instalacion debemos configurar el entorno, seleccionar las opciones y verificar las dependencias.
opciones:
–with-openssl build with OpenSSL support
–without-readline do not use GNU Readline nor BSD Libedit for editing
–with-ldap build with LDAP support
–prefix=/usr/local/.. install architecture-independent files in PREFIX. Default installation location is /usr/local/pgsql
-with-gnu-ld assume the C compiler uses GNU ld [default=no]
–with-pgport=PORTNUM change default port number [5432]
–with-docdir=DIR install the documentation in DIR [PREFIX/doc]
–without-docdir do not install the documentation
nota:
si ocurre este error: configure: error: readline library not found
yum instal libtermcap-devel readline-devel
2) #make
Despues de configurar la instalacion estamos listos para compilar el postgres. Este proceso puede durar desde 10 min hasta mas de una hora, dependiendo del equipo.
3) #make check
Podemos verificar que la compilacion esta correcta antes de instalarla. nos mostrara un reporte.
el archivo del reporte esta en: #/usr/local/src/postgresql-[version]/src/test/regress.
Si no lo deseas pasa al siguente paso.
4) #su
Cambiamos hacia root.
5) #make install
instalamos el sistema ya configurado y compilado.
6) #adduser postgres
creamos el usuario postgres que de ahora en adelante sera el dueno del POSTGRESQL.
7) #ls /usr/local/pgsql/
#mkdir /usr/local/pgsql/data
creamos el directorio data
8) #ls -l /usr/local/pgsql/
verificamos que esta creado el directorio
9) #chown -R postgres.postgres /usr/local/pgsql/
cambiamos los permisos de grupo y usuario a postgres de todos los directorios.
10) #ls -ld /usr/local/pgsql/data
vemos que se efectuaron los cambios
11) #su - postgres
nos cambiamos al usuario postgres
12) #/usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data/
creamos la estructura de base de datos: directoriosy archivos.
13) #/usr/local/pgsql/bin/postgres -D /usr/local/pgsql/data >logfile 2>&1 &
iniciamos el postgres de manera manual
14) #/usr/local/pgsql/bin/createdb test
creamos una base llamada test
15) #/usr/local/pgsql/bin/psql test
entramos al postgres y selecionamos la base test
16) >ALTER USER postgres with password '4009';
le cambiamos el pass al usuario postgres.
\q para salir
17) #vim /usr/local/pgsql/data/pg_hba.conf
modifiamos el archivo de permisos de conexiones.
# IPv4 local connections:
host all all 127.0.0.1/32 md5
host all all 0.0.0.0/0 md5
18) #vim /usr/local/pgsql/data/postgresql.conf
modificamos el archivo postgres y descomentamos y configuramos los siguentes parametros
listen_addresses = '*'
ports = 5432
password_encryption = on
autovacuum = on --leer el texto que esta al lado
19) agregamos estos parametros al bash_profile para ejecutar normal los comandos postgres:
#vi .bash_profile
PATH=$PATH:$HOME/bin:/usr/local/pgsql/bin
20) para agregar a bash_profile las paginas man de postgres
MANPATH=/usr/local/pgsql/man:$MANPATH
export MANPATH
salimos del usuario postgres y volvemos a ingresar y ya esta listo
demonio
#cp /home/usuario/download/instalacion/contrib/start-scripts/linux /etc/rc.d/init.d/postgres
#chmod a+x /etc/rc.d/init.d/postgres
#chkconfig postgres 345 on
== CONFIGURACION ==
shared_buffers = 1/4 ram de 1gb en adelante
effective_cache_size = 3/4 del swap
checkpoint_segments aqui postgres escribe las nuevas transacciones, WALL que son de 16mb > 16 para altos serv concurridos > 10 cuando son servidores peq.
Para sistemas masivos 512mb - 128gb
checkpoint_completion_target =< 0.9 o 90%
autovacuum, max_fsm_pages y max_fsm_relations
mientras mas concurrido este el server mas vacuums deben de ser ejecutados.
max_fsm_page Y max_fsm_relations deben de ser aumentados > 1000 si es un lugar concurrido
work_mem y maintainance_work_mem
maintainance_work_mem < 256 para lugares concurridos
work_mem hayque calcularlo
wal_sync_method debe de ser analizado y calculado
wal_buffers < unos cuantos kbytes
constraint_exclusion solo se usa en el particionado de tablas default = off
max_prepared_transactions = 0 standar y 100 para lugares concurridos
synchronous_commit solo activar si tienes ups o algo de respaldo.
random_page_cost es lo ultimo que se debe tocar para eficientizar. < 1.0 para discos rapidos si es scsi o raid << 1.0. normal entre 2.0 y 3.0.
Usage Approximate shared memory bytes required (as of 8.3)
Connections (1800 + 270 * max_locks_per_transaction) * max_connections
Autovacuum workers (1800 + 270 * max_locks_per_transaction) * autovacuum_max_workers
Prepared transactions (770 + 270 * max_locks_per_transaction) * max_prepared_transactions
Shared disk buffers (block_size + 208) * shared_buffers
WAL buffers (wal_block_size + 8) * wal_buffers
Fixed space requirements 770 kB
==ADMINISTRACION POSTGRESQL==
++ MANEJO DE BASE DE DATOS ++
-ingresamos a la consola postgres por:
/usr/local/pgsql/bin/psql
listamos todas las base de datos existentens:
\l
para usar una base de datos
\c nombre-base
para crear una base de datos por linux
en linux vamos al /bin
./createdb nombre-base;
para borrar una abse de datos por linux
en linux vamos al /bin
./dropdb nombre-base;
seleccionamos la base de datos con un usuario dif
\c base user \password;
++ COMANDOS INTERNOS PSQL ++
-ingresamos a la consola postgres por:
/usr/local/pgsql/bin/psql
-para facilidad le cambiamos el pass a postgres
>ALTER USER postgres with password '123456';
\h ayuda sobre ordenes de sql
\? para ordenes postgres
notas:
funciona tab para auto completar
todo comando al finalizar debe llever ';', sino de la consola (=) para a (-) advirtiendonos que falta finalizar el comando.
si deseamos usar el sistema operativo sin salir de postgres
\!; \! ls;
vemos la version de la base de datos
select version();
ver la fecha actual del sistemas
select current_date;
las contrasenas encriptadas. solo los super users pueden verla
/d pg_shadow;
ayuda en comandos sql
\h ;
ayuda en comandos psql
\?;
++ CREACION, ELIMINACION Y MANEJO DE BASE DE DATOS ++
-listamos todas las bases de datos existentes
postgres=# \l
List of databases
Name | Owner | Encoding | Collation | Ctype | Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
postgres | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 |
template0 | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
template1 | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
test | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 |
(4 rows)
-creamos una base de datos
prueba=# CREATE DATABASE prueba;
CREATE DATABASE
-listamos todas las bases de datos observamos que ya tenemos creada la base prueba.
postgres=# \l
List of databases
Name | Owner | Encoding | Collation | Ctype | Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
postgres | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 |
prueba | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 |
template0 | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
template1 | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
test | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 |
(5 rows)
-tambien podemos borrarla
postgres=# DROP DATABASE prueba;
-ahora nos conectaremos a la base prueba para trabajar con ella
postgres=# \c prueba
You are now connected to database "prueba".
++ CREACION DE TABLAS (create table) ++
La sintaxis basica y general para crear una tabla es:
create table nombre-tabla(nombre-campo1 tipo-dato1, nombre-campo2 tipo-dato2, nombre-campoN tipo-datoN);
ojo:
el nombre de la tabla no debe de contener mas de 30 caracteres
ejemplo:
-listamos todas las tablas o relaciones que tenemos creadas. no debe aparecer nada
prueba=# \d;
No relations found.
-creamos una tabla llamada empleados con los campos nombre, apellido, ciudad, fechanacimiento:
create table empleados(nombre varchar(20), apellido varchar(20), ciudad varchar(10), fechanacimiento date);
-volvemos a listar las tablas y observamos los cambios
prueba=# \d
List of relations
Schema | Name | Type | Owner
--------+-----------+-------+----------
public | empleados | table | postgres
(1 row)
-vemos de que se compone la tabla empleados
prueba=# \d empleados
Table "public.empleados"
Column | Type | Modifiers
-----------------+-----------------------+-----------
nombre | character varying(20) |
apellido | character varying(20) |
ciudad | character varying(10) |
fechanacimiento | date |
lista las tablas (relaciones) disponibles
\dt;
nos muestra el nombre de todos los elementos internos de postgres
\dS;
si deseamos borrar la tabla ya creada usamos este comando:
drop table empleados;
++ INSERTAR Y RECUPERAR REGISTRO DE UNA TABLA (insert values) ++
-Un registro es una fila de la tabla que contiene los datos propiamente dichos.
-Cada registro tiene un dato por cada columna (campo).
-Al ingresar los datos de cada registro debe tenerse en cuenta la cantidad y el orden de los campos.
La sintaxis basica:
insert into nombre-tabla (campo1, campo2, campoN) values ('valorcampo1', 'valorcampo2', 'valorcampoN');
INSERT INTO veterinaria VALUES ('juancito','cabral', '809-999-9999', 'rottweiler', '2000/04/20', NULL);
insert into veterinaria values ('juancito','cabral', '809-999-9999', 'rottweiler', '2000/04/20', NULL);
NOTA:
funciona minuscula y mayuscula
EJEMPLO:
ejemplo version standar:
insert into empleados (nombre-dueno, apellido-dueno, telefono-dueno, nombre-masco, fecha-nacimiento, sexo, raza, fecha-fallecimiento) values ('Jose', 'Torres', '888-888-8888', 'Terri', '1980-05-20', 'M', 'Pastor Aleman', NULL);
ejemplo version rapida
insert into empleados values ('Jose', 'Torres', '888-888-8888', 'Terri', '1980-05-20', 'M', 'Pastor Aleman', null);
-EJEMPLO:
-verificamos que no existe ningun dato en la tabla
prueba=# SELECT * from empleados;
nombre | apellido | ciudad | fechanacimiento
--------+----------+--------+-----------------
(0 rows)
ingresamos los siguentes datos
prueba=# insert into empleados values('pedro','peralta','santiago','2000-03-30');
INSERT 0 1
prueba=# insert into empleados values('Mario','Garcia','La Vega','1900-03-30');
INSERT 0 1
nota: Es importante ingresar los valores en el mismo orden en que se nombran los campos. Si se coloca un orden de algun campo diferente hay que hacer modificar el ingreso de los datos
-volvemos a listar el contenido de la tabla:
prueba=# SELECT * from empleados;
nombre | apellido | ciudad | fechanacimiento
--------+----------+----------+-----------------
pedro | peralta | santiago | 2000-03-30
Mario | Garcia | La Vega | 1900-03-30
Borrar las consultas
delete from empleados where nombre='ariel';
++ TIPOS DE DATOS ++
varchar: max 10485760
interger: -2000000000 a 2000000000 aprox
float: 12.22
date: yyyy/mm/dd
VARCHAR(n) Almacena cadena de caracteres de longitud variable, de longitud máxima n.
CHAR(n). Almacena cadena de caracteres de longitud fija, de longitud n.
INTEGER. Almacena números enteros como 2,33,107,15228, etc.
NUMERIC. Almacena números enteros y decimales.
DATE, almacena fechas.
FLOAT: numérico con signo de doble palabra y coma flotante.
TEXT. Guarda textos largos.
SERIAL. Crea una secuencia y la asigna a una columna como llave de la tabla.
++SELECT, WHERE, ORDER y UPDATE++
-para ver todos los atributos de una tabla:
sintaxis:
select * from nombre-tabla;
ejemplo:
prueba=# SELECT * from empleados;
nombre | apellido | ciudad | fechanacimiento
--------+----------+----------+-----------------
pedro | peralta | santiago | 2000-03-30
Mario | Garcia | La Vega | 1900-03-30
-para ver los datos de cierto o ciertos atributos:
sintaxis:
select campo1, campo2, campoN from nombre-tabla;
ejemplo:
base2=# select nombre-dueno,apellido-dueno,raza from veterinaria;
ordena el resultado de descendentemente
base2=# SELECT nombre, apellido from veterinaria order by apellido desc;
ordena el resultado al contrario
base2=# SELECT nombre, apellido from veterinaria order by apellido asc;
si deseamos limitar la cantidad de consultas hechas a 2:
base2=# select nombre, apellido from veterinaria order by apellido limit 2;
para saber los datos de un dueno especificamente:
base2=#select * from veterinaria where nombre='ariel';
para actualizar algun registro:
base2=# update veterinaria set apellido='torrres' where nombre='ariel';
++ANADIR y BORRAR UNA COLUMNA A UNA TABLA++
agregamos la columna fecha de ingreso a nuestra tabla:
ALTER TABLE veterinaria ADD column fechaingreso date;
renombramos una columna:
ALTER TABLE veterinaria RENAME COLUMN fechaingreso to feching;
borramos una columna:
ALTER TABLE veterinaria DROP COLUMN feching;
++ FILTRO (where) ++
select campo1, campo2, campoN from nombre-tabla where condicion1='campo-a-buscar';
nota:
Si ningún registro cumple la condición establecida con el "where", no aparecerá ningún registro.
++ OPERADORES RELACIONALES ++
Los operadores relacionales comparan valores del mismo tipo. Se emplean para comprobar si un campo cumple con una condición.
Los operadores relacionales (o de comparación) nos permiten comparar dos expresiones, que pueden ser variables, valores de campos, etc.
= igual
<> distinto
> mayor
< menor
>= mayor o igual
<= menor o igual
ejemplo:
select * from libros where autor<>'Borges';
select titulo, precio from libros where precio>20;
++ ELIMINAR REGISTROS ++
delete from usuarios;
delete from usuarios where nombre='Marcelo';
++ ACTUALIZAR REGISTROS ++
Actualizar un registro es cuando modificamos alguno de sus valores.
update columna1 set columna2='nuevo-valor';
update columna1 set columna2='nuevo-valor' where campo='';
update usuarios set nombre='Marceloduarte', clave='Marce' where nombre='Marcelo';
++ COMENTARIOS ++
select * from tablas -- este es un comentario;
select * from tablas -/* este es
un comentario
bien largo*/;
++ VALORES NULL ++
"null" significa "dato desconocido" o "valor inexistente". No es lo mismo que un valor "0", una cadena vacía o una cadena literal "null".
los campos no null nunca deben estar vacios
create table libros( titulo varchar(30) not null, autor varchar(20) not null, editorial varchar(15) null, precio float);
==MANEJO DE USUARIOS==
lista todos los roles (usuarios)
\du ;
para crear un usuario
REATE USER nuevo-usuarop WITH PASSWORD <el passw> permisos;
para borrar un usuario
DROP USER usuario-borrar;
CREATE USER username
[ WITH
[ SYSID uid ]
[ PASSWORD 'password' ] ]
[ CREATEDB | NOCREATEDB ] [ CREATEUSER | NOCREATEUSER ]
[ IN GROUP groupname [, ...] ]
[ VALID UNTIL 'abstime' ]
-revisamos que el usuario ariel no esta creado.
prueba=# select * from pg_shadow;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
----------+----------+-------------+----------+-----------+-------------------------------------+----------+-----------
postgres | 10 | t | t | t | md5a3556571e93b0d20722ba62be61e8c2d | |
(1 rows)
prueba=# select * from pg_user;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
----------+----------+-------------+----------+-----------+----------+----------+-----------
postgres | 10 | t | t | t | ******** | |
(1 rows)
pg_user es para usuarios no privilegiados y el pg_shadow es para usuarios privilegiados. la dif es en el campo passwd
-creamos un usuarios con la contrasena 123456
CREATE USER ariel WITH PASSWORD '123456';
-le otorgamos todos los permisos al usuario ariel
GRANT ALL ON empleados TO ariel ;
-ahora confirmamos que nuestro usuario ha sido creado
prueba=# select * from pg_shadow;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
----------+----------+-------------+----------+-----------+-------------------------------------+----------+-----------
postgres | 10 | t | t | t | md5a3556571e93b0d20722ba62be61e8c2d | |
ariel | 16389 | t | t | t | md555656b0bc9c7f30d7620a9265c357bdb | |
(2 rows)
prueba=# select * from pg_user;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
----------+----------+-------------+----------+-----------+----------+----------+-----------
postgres | 10 | t | t | t | ******** | |
ariel | 16389 | t | t | t | ******** | |
(2 rows)
-vamos a crear otor usuario de prueba llamado dexter y le otorgaremos permisos de solo crear base de datos:
prueba=# CREATE USER dexter with password '123456';
prueba=# ALTER USER dexter CREATEDB;
-podemos cambiarle el nombre de un usuario. vamosa cambiar el nombre de dexter por el de charlie.
prueba=# ALTER USER dexter RENAME TO charlie;
-vamos a borrar nuestro usuario charlie para evitar problemas
prueba=# DROP USER charlie;
##GRUPOS
-cuando tenemos muchos usuarios en postgres es aconsejable utilizar grupos. observamos cuales son los grupos creados
prueba=# SELECT * from pg_group
groname | grosysid | grolist
---------+----------+---------
sales | 16392 | {}
(1 rows)
-crearemos un grupo llamado ventas
prueba=# CREATE GROUP ventas;
-agregamos al usuario ariel en el grupo de ventas
prueba=# ALTER GROUP ventas ADD USER ariel;
-ahora borramos el usuario de la lista de ventas
prueba=# ALTER GROUP ventas DROP USER ariel;
-cambiamos el nombre del grupo sales por nuevo
prueba=# ALTER GROUP sales RENAME TO nuevo;
ALTER ROLE
prueba=# SELECT * from pg_group;
groname | grosysid | grolist
---------+----------+---------
ventas | 16393 | {}
nuevo | 16392 | {}
(2 rows)
-borramos el grupo nuevo
prueba=# DROP GROUP nuevo;
DROP ROLE
prueba=# SELECT * from pg_group;
groname | grosysid | grolist
---------+----------+---------
ventas | 16393 | {}
(1 row)
##PERMISOS
-para conceder los permisos la sentencia es:
GRANT permisos ON base-de-datos.tabla TO usuario;
recordemos que los permisos son:
*CONNECT, *CREATE, *TRUNCATE,
SELECT r Can read data from the object.
*INSERT a Can insert data into the object.
*UPDATE w Can change data in the object.
*DELETE d Can delete data from the object.
RULE R Can create a rule on the table
*REFERENCES x Can create a foreign key to a table. Need this on both sides of the key.
*TRIGGER t Can create a trigger on the table.
*TEMPORARY T Can create a temporary table.
*EXECUTE X Can run the function.
*USAGE U Can use the procedural language.
*ALL All appropriate privileges. For tables, this equates to arwdRxt
los permisos se le pueden otorgar a grupos y usuarios
para observar los privilegios debemos de estar en la base de datos
postgres=# \c prueba;
You are now connected to database "prueba".
prueba=# \dp
Access privileges
Schema | Name | Type | Access privileges | Column access privileges
--------+-----------+-------+---------------------------+--------------------------
public | empleados | table | postgres=arwdDxt/postgres+|
| | | ariel=arwdDxt/postgres |
(1 row)
-le daremos al usuario ariel los permisos siguientes en la tabla empleados.
prueba=# GRANT INSERT, UPDATE, DELETE ON TABLE empleados to ariel;
GRANT
-para eliminiar los permisos de ariel de insertar
prueba=# REVOKE INSERT ON empleados FROM ariel;
REVOKE
prueba=# \dp
Access privileges
Schema | Name | Type | Access privileges | Column access privileges
--------+-----------+-------+---------------------------+--------------------------
public | empleados | table | postgres=arwdDxt/postgres+|
| | | ariel=rwdDxt/postgres |
(1 row)
vemos que la a ha sido eliminada
podemos cambiar de dueno de una tabla
prueba=# ALTER TABLE empleados OWNER TO ariel;
ALTER TABLE
prueba=# \dp
Access privileges
Schema | Name | Type | Access privileges | Column access privileges
--------+-----------+-------+---------------------+--------------------------
public | empleados | table | ariel=arwdDxt/ariel |
(1 row)
==BACKUP Y RESTAURAR==
++ BACKUP ++
pg_dump -c NOMBRE_DE_LA_BD > ARCHIVO.sql
++ RESTAURAR ++
pg_restore -a -v -e -Fc -O –disable-triggers -d prueba prueba.data.dump
pg_restore -i -h localhost -p 5432 -U postgres -d mibase -v "/home/damian/backups/mibase.backup"
-i le indica que ignore la versión (entre el comando y la base de datos).
-h localhost es el host de nuestro PostgreSql.
-p 5432 es la indicación del puerto donde corre el servicio.
-U postgres especifica que se usará el usuario postgres para la operación.
-d mibase es para que realize la restauración sobre una base de datos en particular, en este caso mibase.
-v ejecutará el comando en modo verbose (así podremos ir viendo la salida de cada paso del proceso).
/home/damian/backups/mibase.backup es el archivo que usaremos como backup y que queremos ingresar.
Este ha sido mi trabajo desde hace semanas y lo comparto con ustedes. Es posible mejorarlo, agregar mas ejemplos, casos mas complicados. Esto sera trabajo para un futuro.
Este documento es liberado por la licencia GPL, asi que compartanlo, modifiquenlo y compartan sus modificaciones para que siga creciendo. Cualquier preguntas o comentario estoy por aca...
--------------------------------------------------------------------------------------------------------------------------------------
Referencias:
http://www.cyberciti.biz/faq/howto-add-postgresql-user-account/
http://www.davidpashley.com/articles/postgresql-user-administration.html
http://www.postgresql.org/docs/8.4/static/index.html
http://www.postgresql.org/docs/9.1/interactive/index.html
http://www.efaber.net/formacion/fp/curso_acs/3_a.html
http://structio.sourceforge.net/guias/servidor_OpenBSD/postgresql.html
http://es.wikipedia.org/wiki/Base_de_datos
http://es.wikipedia.org/wiki/PostgreSQL
http://www.postgresqlya.com.ar/temarios/descripcion.php?cod=160&punto=2
http://es.tldp.org/Tutoriales/NOTAS-CURSO-BBDD/notas-curso-BD/
http://www.davidpashley.com/articles/postgresql-user-administration.html#id2564083 permisos y usuarios
http://www.escomposlinux.org/lfs-es/blfs-es-SVN/server/postgresql.html
http://www.davidpashley.com/articles/cert-authority.html certificados
http://perso.wanadoo.es/vitalino/doc/tutorial/capitulo3.html
http://www.thegeekstuff.com/2009/04/linux-postgresql-install-and-configure-from-source/
http://www.commandprompt.com/ppbook/c18591.htm -- crear usuarios
http://www.commandprompt.com/ppbook/c4890.htm --intro a psql
http://www.guia-ubuntu.org/index.php?title=PostgreSQL
http://palomo.usach.cl/docshtml/node4.html
http://www.commandprompt.com/ppbook/x486 -- instalacion paso a paso
http://www.commandprompt.com/ppbook/c16573.htm -- manejar y controlar postgres
No hay comentarios:
Publicar un comentario