Download - Administración de Base de Datos
ADMINISTRACIÓN DE BASE DE DATOS
INTEGRANTES:
FRANCO APARICIOMARCO BALMORI
FRANCO ORTEGA ADONAY
GAMEZ MORALES JOEL MAURICIO
GONZÁLEZ SANTOS JESSICA ESTEFANÍA GPE.
VITE DELGADILLO BRANDON RAMSEL
CATEDRÁTICO:
ING. EFRÉN ROLANDO ROMERO LEÓN
SEXTO SEMESTRE
BITACORA, MEMORIA COMPARTIDA, BACKUP Y PARTICIONES
03 DE DICIEMBRE DEL 2014
Contenido
Introducción ................................................................................................................................. 1
Bitácora ........................................................................................................................................ 2
Memoria compartida con clúster. ........................................................................................... 12
Particiones ................................................................................................................................. 23
Back up ...................................................................................................................................... 29
Replicación .................................................................................................................................. 38
Conclusiones ............................................................................................................................. 45
Introducción
Un sistema de bases de datos es básicamente un sistema computarizado para
llevar registros. Los usuarios del sistema pueden agregar nuevos archivos,
insertar, recuperar, modificar, eliminar datos dentro de estos archivos y eliminar
los archivos existentes dentro de la base de datos.
Durante la unidad número 3 realizamos diferentes prácticas que nos ayudaron
a adquirir experiencia en el uso de las bases de datos realizamos prácticas de:
Bitácora
Memoria compartida distribuida (clúster)
Back up
Particiones
Bitácora
Permite guardar las transacciones realizadas sobre una base de datos en
específico, de tal manera que estas transacciones puedan ser auditadas y
analizadas posteriormente. Pueden obtenerse datos específicos de la
transacción como son la Operación que se realizó, el Usuario de BD y
Windows, Fecha, Maquina y Programa.
Memoria compartida distribuida (clúster)
Los sistemas de memoria compartida distribuida (DSM) representan la
creación hibrida de dos tipos de computación paralelos: la memoria distribuida
en sistemas multiprocesador y los sistemas distribuidos. Ellos proveen la
abstracción de memoria compartida en sistemas con memorias distribuidas
físicamente y consecuentemente combinan las mejores características de
ambos enfoques.
Back up
Es una copia de los datos originales que se realiza con el fin de disponer de un
medio para recuperarlos en caso de su pérdida. Las copias de seguridad son
útiles ante distintos eventos y usos: recuperar los sistemas informáticos y los
datos de una catástrofe informática, natural o ataque; restaurar una pequeña
cantidad de archivos que pueden
haberse eliminado accidentalmente, corrompido, infectado por un virus
informático u otras causas; guardar información histórica de forma más
económica que los discos duros y además permitiendo el traslado a
ubicaciones distintas de la de los datos originales; etc..
Particiones
Las particiones dividen una tabla en partes lógicas. A continuación, cada
partición se puede procesar (actualizar) de forma independiente o en paralelo
con otras particiones. Las particiones pueden mejorar la escalabilidad y facilitar
el uso de bases de datos grandes. De forma predeterminada, cada tabla tiene
una partición que incluye todas las columnas.
A continuación veremos cada una de las prácticas que realizamos con su
desarrollo de cada una.
Bitácora
Heidi
Permite guardar las transacciones realizadas sobre una base de datos en
específico, de tal manera que estas transacciones puedan ser auditadas y
analizadas posteriormente.
Pueden obtenerse datos específicos de la transacción como son la Operación
que se realizó, el Usuario de BD y Windows, Fecha, Maquina y Programa.
ALERTAS
Registro y envío de notificaciones al momento en que se produzca un evento
de modificación de datos en los sistemas de acuerdo a los criterios definidos
por el usuario.
BITACORA
Herramienta que permite registrar, analizar, detectar y notificar eventos que
sucedan en cualquier sistema de información utilizado en las organizaciones.
Evita que las empresas tengan que realizar cambios a sus sistemas aplicativos
con el fin de obtener información esencial o requerida por la Auditoria,
disminuyendo costos y tiempo de desarrollo informático. Esto nos puede servir
para la Prevención y/o detección de fraudes, consiguiendo importantes ahorros
a las empresas.
Apoyo en el control de cambios del Sistema, al proporcionar diferencias entre la
Base de Datos (BD) y Diccionario de Datos (DD) en relación a estructura de
tablas y tablas que existen en el DD pero ya no existen en la BD y viceversa.
· No se requiere hacer cambios en los sistemas de producción para la
implementación de la bitácora.
· A través de los parámetros se generan las pantallas de consulta y reportes sin
necesidad de programar.
· Acceso a la bitácora a través de una aplicación WEB.
· Control de Acceso a la información de la bitácora a través de Roles.
· Se puede implementar en los sistemas de información que utilicen las
principales bases de datos del mercado: ORACLE, SQL SERVER, INFORMIX,
SYBASE.
· Permite hacer el seguimiento de todos los cambios que ha tenido un registro.
· Registra información acerca de eventos relacionados con el sistema que la
genera.
1. Crear la base de datos
create database prueba1;
show databases;
use prueba1;
2. Crear una tabla llamadas personas
create table personas (id_persona int auto_increment primary
key, nombre varchar (50), apellido_p varchar (50), apellido_m
varchar(50), edad int, peso double, talla double);
3. Crear un procedimiento almacenado para insertar registros
DELIMITER $$
DROP PROCEDURE IF EXISTS `prueba1`.`Insertar` $$
CREATE PROCEDURE `prueba1`.`Insertar`(in nombre varchar (50),
apellido_p varchar (50), apellido_m varchar(50), edad int, peso
double, talla double)
BEGIN
INSERT INTO personas (nombre,apellido_p, apellido_m , edad ,
peso , talla) VALUES (nombre,apellido_p, apellido_m , edad ,
peso , talla );
END $$
DELIMITER;
4. Crear un procedimiento almacenado para actualizar registros
DELIMITER $$
DROP PROCEDURE IF EXISTS `prueba1`.`Actualizar` $$
CREATE PROCEDURE `prueba1`.`Actualizar` (in id_personax
int,edadx int,pesox double)
BEGIN
update personas set edad=edadx,peso=pesox where
id_persona=id_personax;
END $$
DELIMITER ;
5. Crear un procedimiento almacenado para eliminar registros
DELIMITER $$
DROP PROCEDURE IF EXISTS `prueba1`.`Borrar` $$
CREATE PROCEDURE `prueba1`.`Borrar` (in id int)
BEGIN
delete from personas where id_persona=id;
END $$
DELIMITER ;
6. Invocar los procedimientos almacenados
Call Insertar (‘Horacio’,’Gomez’,’Carmona’,25,65,1.68);
Call Insertar (‘Hugo’,’Torres’,’Mendez’,32,67,1.70);
Call Actualizar (1, 26, 66);
Call Borrar (2)
Ver registros
Select * from personas;
7. Crear un procedimiento almacenado que muestre todos los
registros
DELIMITER $$
DROP PROCEDURE IF EXISTS `sp_verPersonas` $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_verPersonas`()
select *from personas $$
DELIMITER ;
Para invocarlo
Call sp_verPersonas();
8. Crear tabla que lleve un control de quien hace cambios en la
base de datos prueba1
CREATE TABLE infobase (usuario varchar (50), descripcion varchar
(50),
fecha TIMESTAMP default now());
9. Crear trigger para la inserción
delimiter $$
create trigger tr_insercion
befote insert on personas
for each row
begin
insert into infobase values(user(),’persona creada’,now());
end $$
10. Crear trigger para la actualización
delimiter $$
create trigger tr_actualizacion
befote update on personas
for each row
begin
insert into infobase(usuario,descripcion,fecha)
values(user(),’persona modificada’,now());
end $$
11. Crear trigger para la eliminación
delimiter $$
create trigger tr_borrado
befote delete on personas
for each row
begin
insert into infobase values(user(),’persona eliminada’,now());
end $$
Ver cambios
Select *from infobase;
12. Crear procedimiento almacenado para ver un registro en
particular
DELIMITER $$
DROP PROCEDURE IF EXISTS `sp_verPersona` $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_verPersona`(in
id_buscar int)
select *from personas where id_persona=id_buscar $$
DELIMITER ;
13. Ahora hacer una operación: calcular el I.M.C. (Índice de
Masa Corporal) de las personas registradas
Fórmula: peso/(talla*talla)
DELIMITER $$
DROP PROCEDURE IF EXISTS `sp_verImc` $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_verImc`()
select id_persona,nombre,edad,peso,talla,peso/(talla*talla) from
personas $$
DELIMITER ;
http://www.genap.com.mx/Bitacora.pdf
SQL SERVER
La bitácora es un componente esencial de SQL server, el cual utiliza para
registrar un historial de cada modificación que sufre la base de datos como
resultado de las transacciones. Dicho registro es de vital para mantener la
integridad de los datos y poder deshacer los cambios resultantes de tracciones
incompletas ya sea por error del sistema o por la cancelación por parte delos
usuarios
Primero creamos una base de datos y una tabla, la cual más adelante te servirá
para realizar el trigger que dará forma a la bitácora.
CREATE TABLE consultorio_auditado
( id int IDENTITY NOT FULL,
operacion varchar (10) DEFAULT NULL,
usuario varchar(40) DEFAULT NULL,
host varchar(30) DEFAULT NULL,
modificado data time DEFAULT NULL,
tabla varchar(40) DEFAULT NULL,
PRIMARY KAY (id))
La creación del trigger es para determinar los movimientos de insertar.
create trigger tr_consultorio
on consultorio
after insert
as Begin
insert into consultorio_auditado (host, usuario, operacion,modificado, tabla )
values (@@SERVERNAME, SUSER_NAME(), ‘insert’,GETDATE(), ‘consultorio’)
end
Ingresamos datos a nuestra tabla.
insert into consultorio values (1,’maternidad’,12,25)
Y por ultimo verificamos si se guardo nuestro el reporte de nuestra bitacora
Memoria compartida con clúster.
MySQL adaptada para el entorno de computación distribuida. Usa el motor de
almacenamiento NDB Clúster para permitir la ejecución de varios servidores
MySQL en un clúster. Este motor de almacenamiento está disponible en las
distribuciones binarias de MySQL. Esta una tecnología de base de datos en
memoria que permite que el sistema gestor de base de datos (SGBD) funcione
utilizando hardware no muy costoso y con requerimientos mínimos tanto de
software como de hardware claro esta si cada uno de los equipos son de la
mismas arquitectura, está diseñado para no tener un solo punto de falla, cada
componente tiene su propia porción de disco y memoria para trabajar.
Un clúster MySQL integra un servidor MySQL estándar y un motor de
almacenamiento en memoria llamado NDB clúster, funcionando en un conjunto
de una o más computadoras. Cada una de estas computadoras ejecutando uno
o más procesos, que pueden consistir en procesos de MySQL server, nodos de
almacenamiento de datos, servidor administrador del clúster, o programas
especializados para acceder a los datos.
¿Qué es un nodo?
Este tipo de nodo almacena los datos. La cantidad de nodos de este tipo dentro
del clúster es igual a la cantidad de réplicas por la cantidad de fragmentos. Es
decir, si se manejan 4 réplicas de los datos con 2 fragmentos, se necesitarían 8
nodos de datos. No es necesario manejar más de una réplica. Este tipo de
nodo se levanta utilizando el comando ndbd.
Pasos para realizar un clúster.
1.- Se debe descargar MySQL Clúster de la página oficial
http://mysql.com/downloads/cluster/ ,una vez que estemos en la página
descargamos de acuerdo a nuestro sistema operativo.
2.- Tener 3 ó 4 computadoras, dos de ellas usamos el sistema operativo
Windows 7, y en una Windows XP.
3.- Establecer las IP fija en cada equipo.
4.- Hacer ping entre ellas
172.16.1.3 (Administrador “tommy”)
172.16.1.4 (Nodo de Datos “arys”)
172.16.1.5 (Nodo de Datos “marco”)
5.- desactivar los servicios del Firewall y los del Antivirus.
6.- MySQL clúster MySQL-clúster –gpl-7.1.15a-win32.zip.zip que
posteriormente extraeremos ala raíz c:\ y renombrar a MySQL.
Configuración de nodos
Primero tenemos que descomprimir los archivos MySQL clúster MySQL-clúster
– gpl-7.1.15a-win32.zip.zip en cada ordenador correspondiente en el disco local
c:\ luego renombramos la carpeta que se crea, como MySQL.
Una vez hecho lo anterior se procede a crear el archivo de configuración desde
bloc de notas, para los nodos de datos, el cual deberá guardarse dentro de la
carpeta conf. Dicho archivo contendrá lo siguiente:
De acuerdo a la imagen este es el contenido del documento. Nota Por cada
computador o nodo que se conecte, se debe agregar un [Ndbd] y su contenido
con la dirección IP correspondiente del nodo. Y al final del documento por cada
nodo agregado se agrega la etiqueta [Mysqld].
Los nodos de datos se definen bajo el bloque [ndbd] definiendo casi los mismos
parámetros que para el nodo administrador ya que los nodos de datos no
definen el parámetro basedir, se debe definir también un Id para los nodos.
En config.ini se agregan los bloques [mysqld] dependiendo del número de
nodos sql que se quieran levantar. Una vez definido el archivo config.ini se
procede a arrancar el nodo administrador.
El archivo que contiene el computador que será nodo, debe ser guardado con
el nombre “config.ini”, en la opción de guardado aparece “txt” y “Todos los
Archivos”. Debe seleccionarse para guardarlo como “Todos los Archivos”.
En una nueva ventana de cmd ejecutada como administrador, se deben
ingresar los siguientes comandos:
cd..
cd..
cd my_cluster
mysql/bin/ndb_mgmd –f conf/config.ini –initial –configdir=c:\my_cluster\conf\
Esto servirá para levantar la conexión y dando acceso a las IP integradas en el
archivo “config.ini”
Ahora en otra ventana de “cmd” como administrador, se deben ejecutar los
siguientes comandos:
cd..
cd..
cd mysql
cd bin
ndb_mgm
show
El último comando “show” permite observar los nodos conectados al clúster, y
también identificar su tarea definida de manera inmediata al actualizar con este
comando y verificar los equipos conectados.
Por ultimo para usar el “MySQL Clúster” es necesario ejecutarlo o levantarlo
iniciar el servicio. Abriendo una nueva ventana en “cmd” como administrador.
Por lo que se debe usar el siguiente comando.
cd..
cd..
cd mysql
cd bin
mysqld –console
Se podrá observar en la pantalla como se levantan los servicios de MySQL
Clúster.
Ahora para probar MySQL Clúster se debe ejecutar una ventana más de “cmd”.
Que será el MySQL Clúster der servidor o Administrador. Y se usaran los
siguientes comandos para entrar.
cd..
cd..
cd mysql
cd bin
mysql –u root –p
Con esas instrucciones bastara para entrar MySQL Clúster del Administrador.
Una vez dentro ya se pueden hacer pruebas usando los comandos necesarios
como “show databases;”
Que mostraran las bases de datos del administrador, o incluso crear nuevas
bases de datos que se verán reflejadas en los nodos o esclavos, y estos
esclavos desde su configuración podrán acceder estas bases de datos y crear
consultas diferentes
¿Cómo conectar un nodo al clúster?
Hecho lo anterior ahora en el Disco local c:\ crearemos una carpeta llamada
my_cluster y dentro de esta carpeta crearemos las siguientes carpetas:
conf
Dentro de esta carpeta crearemos las 2 siguientes carpetas:
mysqld_data
mysql
ndbinfo
ndb_data
Una vez hecho lo anterior se procede a crear el archivo de configuración desde
bloc de notas, para los nodos de datos, el cual deberá guardarse dentro de la
carpeta conf. Dicho archivo contendrá lo siguiente:
[mysqld]
ndbcluster
nort -4003
ndb-connectring – ’host -172.16.1.2’
[mysql_cluster]
ndb-connetstring– ‘host -172.16.1.2’
El Puerto que indiques debe ser diferente a 3306 de preferencia mayor a 4000,
además de que el puerto seleccionado sea diferente con los otros puertos
elegidos de los nodos de datos y que no sea 3306 puesto que ese está
ocupado por otro dominio de MySQL. Y la dirección IP cambia según la se la
dirección del Servidor.
El archivo que contiene el computador que será nodo debe ser guardado con el
nombre “my.cnf”, en la opción de guardado aparece “txt” y “Todos los
Archivos”. Debe seleccionarse para guardarlo como “Todos los Archivos”.
El archivo debe guardarse en la carpeta “my_cluster”, dentro de la carpeta
“conf”.
Verificar que existe conexión entre el equipo administrador y el nodo que se
conectara. Usando la consola o “cmd”, una vez adentro usando el comando
“ping 172.16.1.2” en este caso con la dirección IP del equipo al que se desea
conectar.
Enseguida en otra pantalla de “cmd” se ejecutan los siguientes comandos para
copiar los archivos al conjunto de carpetas ya creadas en la carpeta
my_cluster. Cada ventana nueva de “cmd” ejecutada como Administrador.
cd..
cd..
Copy c:\mysql\data\mysql my_cluster\mysqld_data\mysql
Ahora se podrá observa mientras se copean los archivos, en caso de que ya
existan, en la pantalla pregunta si desea reescribir en ese caso, se escribe
“todo”, copeando cada archivo de nuevo.
Ahora se copean otros archivos en esa misma pantalla con el siguiente
comando Copy c:\mysql\data\ndbinfo my_cluster\mysqld_data\ndbinfo
Es necesario la ejecución de otra ventana de “cmd” como administrador, para
crear la conexión del nodo con el administrador, con los siguientes comandos.
cd..
cd..
cd my_cluster
c:\mysql\bin\ndbd –c 172.16.1.2:1186
En este comando se incluye la dirección IP del servidor.
Ahora se ejecuta otro comando diferente en una ventana nueva de “cmd”. Que
permitirá establecer la conexión a través del archivo ya creado dentro del
conjunto de carpetas el “my.cnf”.
cd..
cd..
cd my_cluster
c:/mysql/bin/mysqld –default-file conf/my.cnf --console
Ahora se debe acceder al mysql del servidor usando los siguientes comandos.
cd..
cd..
cd mysql
cd bin
mysql –h 172.16.1.2 –u marco –p
Sustituyendo en el último comando la dirección IP del servidor, el usuario que
fue creado en el administrador y contiene todos los privilegios en este caso
“marco” y la contraseña si es que, existe.
Ahora ya está conectado el nodo, puede acceder a las bases de datos y
trabajar con ella. Un primer comando para ver las bases de datos del
administrador o servidor, es “show databases;”
Heidi
Particiones
Particionar tablas en MySQL nos permite rotar la información de nuestras
tablas en diferentes particiones, consiguiendo así realizar consultas más
rápidas y recuperar espacio en disco al borrar los registros. El uso más común
de particionado es según fecha (date).
PARTICIONES POR RANGO
Heidi
Por rango: para construir nuestras particiones especificamos rangos de
valores.
1.- Se crean las particiones.
2.- Se visualizan las particiones
PARTICIONES POR HASH
1.- Se crean las particiones
PARTICIONES POR CLAVE
RESULTADO.
SQL server
Creamos una función de partición con la siguiente consulta
CREATE PARTITION FUNCTION myRangePF (int)
as range LEFT FOR VALUES (1,100,1000);
Damos donde a la partición
CREATE PARTITION SCHEME myRangePS
Y donde la vamos a ubicar
AS PARTITION myRangePF
TO (Text1FG, Text2FG,Text3FG,Text4FG);
La creación de esta tabla es para a completar el procedimiento según el rango
que dimos son los valores a guardar
CREATE TABLE ReturnsArchive (ReturnID int identity, ProductID int,
CustomerID INT, ReturnDate datetime)
ON myRangePS1 (ReturnID);
Una vez generada la consulta verificamos las propiedades de la base de datos
Y revisamos el almacenamiento,
Back up
Uno de los problemas que podemos tener en un motor de base de datos
utilizado para desarrollo es la constante creación y eliminación de bases,
principalmente cuando tenemos muchos proyectos, lo que nos dificulta la tarea
de hacer Backup.
PASOS PARA GENERAR BACKUP EN HEIDI-SQL
BACK UP
1.- Clic derecho sobre la base de datos, seleccionamos la opción de Exportar
base de datos como SQL.
Tabla donde
se almaceno
la partición
2.- En esta ventana seleccionamos el lugar donde se guardara y le damos un
nombre al Backup a generar.
3.- Damos clic en Exportar.
4.- En este caso lo guardamos en el escritorio y ahí aparece.
RESULTADO
SQL SERVER
PASOS PARA REALIZAR EL BACK UP
Damos clic derecho sobre la base de datos buscamos Tasks y después Back
up
Seleccionamos la ruta a donde se va a guardar
Nos arrogara una ventana de éxito
Para comprobar que nuestro back up está realizado eliminamos la base de
datos.
Una vez no creada
La restauraremos
Buscándola en la dirección que la dejamos
Aparece la base de datos con un nuevo nombre pero con las mismas características de la
eliminada anteriormente.
Replicación La replicación es un conjunto de tecnologías destinadas a la copia y
distribución de datos y objetos de base de datos desde una base de datos a
otra, para luego sincronizar ambas bases de datos y mantener su
coherencia. La replicación permite distribuir datos entre diferentes ubicaciones
y entre usuarios remotos o móviles mediante redes locales y de área extensa,
conexiones de acceso telefónico, conexiones inalámbricas e Internet.
SQL SERVER
Empezaremos por crear nuestra replicación utilizando las herramientas que
SQL nos ofrecen, damos clic derecho en replicación, local publication y new
publication.
Nos arroga las siguientes ventanas.
Seleccionamos la base de datos a replicar.
También las tablas.
Y configuramos el usuario y la contraseña que vallamos a utilizar
Esta ventana nos dira los resultados y si esta lista para replicar
Replicación en MySQL
Modificar el archivo my.ini, este se encuentra en la siguiente ruta C:\Program
Files (x86)\MySQL\MySQL Server 5.0. Abrimos el archivo para modificarlo,
colocando lo siguiente (ver imagen) debajo de [mysqld] en SERVER SECTION.
Hacemos un ping con la dirección IP del esclavo para conectarnos, ahora
debemos entrar a la terminal de MySQL con el comando mysql –u root –p
Una vez entramos a la terminal de MySQL insertemos el siguiente comando:
grant replication slave on *.* to ‘nombre_esclavo’@’IP_esclavo’ identified by
‘contraseña’; este comando es para crear una cuenta de usuario de replicación
para que el esclavo se pueda loguear.
Luego insertamos el siguiente: flush privileges; con este le daremos todos los
privilegios al maestro para poder hacer dicha replica.
Ahora lo que vamos hacer es mostrar las bases de datos con las que contamos
para tener la réplica que queremos obtener, con el siguiente comando
digitamos: show databases; y procedemos a usar dicha base de datos con el
comando: use nombre_basedatos la cual hemos escogido de las cuales
tenemos en el motor MySQL
Con el siguiente comando mysqldump –u root –p
nombre_basedatos>respaldo.sql lo que haremos es crear un respaldo de la
base de datos que utilizaremos (no es un BackUp). Una vez ya creado el
archivo de respaldo (respaldo.sql), procedemos a buscarlo en la ruta
C:\Program Files (x86)\MySQL\MySQL Server 5.0\bin que es donde se
encuentra alojado después de haberse creado y procedemos a copiarlo en el
disco “C:\” del esclavo para que este lo encuentre de una manera fácil y rápida,
y nuevamente entramos a la terminal de MySQL con el comando mysql –u root
–p
Esclavo
Modificar el archivo my.ini, este se encuentra en la siguiente ruta C:\Program
Files (x86)\MySQL\MySQL Server 5.0. Abrimos el archivo para modificarlo,
colocando lo siguiente (ver imagen) debajo de [mysqld] en SERVER SECTION.
Lo siguiente es crear una nueva base de datos con el mismo nombre de la
base de datos que tiene el maestro a la cual se le está trabajando la réplica,
para crearla digitamos el comando: create database nombre_basedatos;
Ya una vez creada la base de datos procedemos a utilizarla con el comando:
use nombre_basedatos y luego salimos de la terminal con el comando exit.
Una vez ya tengamos el respaldo.sql en el disco “C:\” procedemos a realizar a
crear las tablas que respaldamos en dicho archivo el cual hicimos en el
maestro con el siguiente comando: mysql –u root –p
nombre_basedatos<c:\respaldo.sql esperamos que se realice dicho proceso de
respaldo y luego reiniciamos los servicios de MySQL.
Comprobar Replicación
Slave (Esclavo)
Insertar el comando use nombre_basedatos
Mostrar las tablas insertando el comando show tables;
Se escoge una tabla cualquiera (se debe conocer sus valores
informáticos) con el comando select * from nombre_tabla;
Master (Maestro)
Nos devolvemos al maestro (el queda con en unlock tables;) e
insertamos el comando use nombre_basedatos
Ahora insertamos valores informaticos en la tabla que acaba de escoger
el esclavo con el comando insert into nombre_tabla values (‘’); ejemplo:
insert into zona values (‘A123’,’Zotano’);
Se inserta el comando select * from nombre_tabla; para comprobar que
hizo la inserción exitosamente.
Slave (Esclavo)
Nuevamente nos devolvemos al esclavo y digitamos otra vez select *
from zona; y este deberá mostrar la inserción que acaba de hacer el
maestro.
Para comprobar nuevamente de que hay replica correctamente
escribimos el siguiente comando que nos dirá si está funcionando como
debe ser: show slave status \G; si muestra un 0 está funcionando
correctamente de lo contrario mostrara un Null.
Conclusiones
Aprendimos a generar transacciones sobre la base de datos y estas puedan
ser checadas y analizadas en un cierto periodo, también podemos obtener de
tos específicos de dichas transacciones como, Operaciones que se generó el
usuario tanto de Base de Datos como el de interfaz.
En esta práctica aprendimos a generar una BackUp que este nos ayudara a
tener el respaldo de la base de datos de una cierta fecha por si la base de
datos genera algún error y para no afectar a la base de datos y empezar desde
cero se generó el back up, restaurar una pequeña de archivos que pudieron
haber ser eliminado accidentalmente.
Generalmente se aprendió a dividir tablas de la base de datos en partes lógicas
lo cual nos ayudara a procesar de manera independiente o paralelas con otras
particiones lo cual nos ayudara que la Base de datos no tenga ningún error
(BD).