Desafios De Los Sistemas Distribuidos

* sistema distribuido

Se define un sistema distribuido como aquel en el que los componentes de hardware y software, localizados en computadores unidos mediante una red, comunican y coordinan sus acciones sólo mediante el paso de mensajes.

Ø  Desafíos

Ø  Heterogeneidad

Ø  Extensibilidad

Ø  Seguridad

Ø  Escalabilidad

Ø  Tolerancia a Fallas

Ø  Concurrencia

Ø  Transparencia

Desafíos: Heterogeneidad

La heterogeneidad se aplica en los siguientes elementos:

*Redes

*Hardware de computadores

*Sistemas operativos

*Lenguajes de programación

*Implementaciones de diferentes desarrolladores

Middleware: es el estrato de software que provee una abstracción de programación, así como un enmascaramiento de la heterogeneidad subyacente de las redes, hardware, sistemas operativos y lenguajes de programación. Ejemplo: Corba, Java RMI

Código móvil:

*Código Móvil: código que puede enviarse desde un computador a otro y ejecutarse en este último.

*El concepto de máquina virtual ofrece un modo de crear código ejecutable sobre cualquier hardware

Desafíos: Extensibilidad

Es la característica que determina si el sistema puede extenderse de varias maneras. Un sistema puede ser abierto o cerrado con respecto a extensiones de hardware o de software. Para lograr la extensibilidad es imprescindible que las interfaces clave  sean publicadas.

Los Sistemas Distribuidos Abiertos pueden extenderse a nivel de hardware mediante la inclusión de computadoras a la red y a nivel de software por la introducción de nuevos servicios y la re implementación de los antiguos.

Otro beneficio de los sistemas abiertos es su independencia de proveedores concretos.

Desafíos: Seguridad

La seguridad tiene tres componentes: Confidencialidad: protección contra individuos no autorizados Integridad: protección contra la alteración o corrupción Disponibilidad: protección contra la interferencia que impide el acceso a los recursos

Existen dos desafíos que no han sido resueltos en su totalidad:

*Ataques de denegación de servicio

*Seguridad del código móvil

Desafíos: Escalabilidad

Se dice que un sistema es escalable si conserva su efectividad cuando ocurre un incremento significativo en el número de recursos y en el número de usuarios. El diseño de SD escalables presenta los siguientes retos:

Control de costo de los recursos físicos: para que un sistema con n usuarios sea escalable, la cantidad de recursos físicos necesarios para soportarlo debería ser O(n).

Controlar la degradación del rendimiento: Ejemplo: Los algoritmos que emplean estructuras jerárquicas se comportan mejor frente al crecimiento de la escala, que los algoritmos que emplean estructuras lineales.

Evitar cuellos de botella: los algoritmos deberían ser descentralizados.

Prevenir el desbordamiento de los recursos de software

Desafíos: Tratamiento de fallos

Detección de fallos: Ejemplo. Se pueden utilizar sumas de comprobación (checksums) para detectar datos corruptos en un mensaje.

Enmarascamiento de fallos: Ejemplo.

*Los mensajes pueden retransmitirse

*Replicar los datos

Tolerancia de fallos: los programas clientes de los servicios pueden diseñarse para tolerar ciertos fallos. Esto implica que los usuarios tendrán también que tolerarlos.

Recuperación de fallos: implica el diseño de software en el que, tras una caída del servidor, el estado de los datos puede reponerse o retractarse (rollback) a una situación anterior.

Redundancia: emplear componentes redundantes.

Desafíos: Concurrencia

Existe la posibilidad de acceso concurrente a un mismo recurso. La concurrencia en los servidores se puede lograr a través de threads. Cada objeto que represente un recurso compartido debe responsabilizarse de garantizar que opera correctamente en un entorno concurrente. Para que un objeto sea seguro en un entorno concurrente, sus operaciones deben sincronizarse de forma que sus datos permanezcan consistentes.

Desafíos: Transparencia

Transparencia de acceso: permite acceder a los recursos locales y remotos empleando operaciones idénticas. Transparencia de ubicación: permite acceder a los recursos sin conocer su localización. Transparencia de concurrencia: permite que varios procesos operen concurrentemente sobre recursos compartidos sin interferencia mutua.

Transparencia de replicación: permite replicar los recursos sin que los usuarios y los programadores necesiten su conocimiento. Transparencia frente a fallos: permite ocultar fallos. Transparencia de movilidad: permite la reubicación de recursos y clientes en un sistema sin afectar la operación de los usuarios y los programas.

Transparencia de rendimiento: permite reconfigurar el sistema para mejorar el desempeño según varíe su carga. Transparencia al escalado: permite al sistema y a las aplicaciones expandirse en tamaño sin cambiar la estructura del sistema o los algoritmos de aplicación.

Scrip De Prueva

drop database ulv7
create database ulv7
use ulv7
CREATE TABLE Profesores(
ID_Profesor int,
Nombre VARCHAR(20),
Direccion VARCHAR(40),
Telefono VARCHAR(15),
PRIMARY KEY (ID_Profesor)
)
insert into Profesores(ID_Profesor,Nombre,Direccion,Telefono)values(123,'Fausto Ruiz','Tuxtla Gutierrez','9610000000');
insert into Profesores(ID_Profesor,Nombre,Direccion,Telefono)values(124,'Miguel Domingue','Tuxtla Gutierrez','9610000003');
insert into Profesores(ID_Profesor,Nombre,Direccion,Telefono)values(125,'Fausto Ruiz','Tuxtla Gutierrez','9610000004');
select * from Profesores


CREATE TABLE Alumno
(
ID_Alumno INT ,
Carrera_ID_Carrera int,
Nombre VARCHAR(20) ,
Direccion VARCHAR(40) ,
Telefono VARCHAR(25) ,
PRIMARY KEY (ID_Alumno)
)
insert into Alumno(ID_Alumno,Carrera_ID_Carrera,nombre,direccion,telefono)values(11,999,'Oswaldo','Tuxtla Gutierrez','9610000008');
insert into Alumno(ID_Alumno,Carrera_ID_Carrera,nombre,direccion,telefono)values(12,998,'Ilner','Tuxtla Gutierrez','9610000006');
insert into Alumno(ID_Alumno,Carrera_ID_Carrera,nombre,direccion,telefono)values(13,997,'Ana','Tuxtla Gutierrez','9610000007');
select * from Alumno



CREATE TABLE Materia
(
ID_Materia INT ,
Carrera_ID_Carrera int,
Calificaciones_ID_Calificaciones INT,
Nombre VARCHAR(20),
PRIMARY KEY (ID_Materia, Calificaciones_ID_Calificaciones)
)
insert into materia(ID_materia,Carrera_ID_Carrera,Calificaciones_ID_Calificaciones,Nombre)values(12345,999,001,'programacion 1');
insert into materia(ID_materia,Carrera_ID_Carrera,Calificaciones_ID_Calificaciones,Nombre)values(12346,998,002,'teleprocesos');
insert into materia(ID_materia,Carrera_ID_Carrera,Calificaciones_ID_Calificaciones,Nombre)values(12347,997,003,'electonica');
select * from Materia

CREATE TABLE Calificaciones
(
ID_Calificaciones INT,
Materias VARCHAR(30) ,
Alumno_ID_Alumno INT,
PRIMARY KEY (ID_Calificaciones, Alumno_ID_Alumno) ,
)
insert into calificaciones(ID_calificaciones,Materias,Alumno_ID_Alumno)values(001,'programacion 1',11);
insert into calificaciones(ID_calificaciones,Materias,Alumno_ID_Alumno)values(002,'teleprocesos',12);
insert into calificaciones(ID_calificaciones,Materias,Alumno_ID_Alumno)values(003,'electronica',13);
select * from calificaciones

CREATE TABLE Carrera
(
ID_Carrera int,
id_alumno int,
id_profesor int,
PRIMARY KEY (ID_Carrera)
)
insert into Carrera(ID_Carrera,id_alumno,id_profesor)values(7777777,11,123);
insert into Carrera(ID_Carrera,id_alumno,id_profesor)values(7777778,12,124);
insert into Carrera(ID_Carrera,id_alumno,id_profesor)values(7777779,13,125);
select * from Carrera

CREATE TABLE Carga_academica
(
ID_carga int,
Profesores_IP_Profesor int,
Materia_ID_Materia INT,
Materia_Calificaciones_ID_Calificaciones INT,
PRIMARY KEY (ID_carga,Profesores_IP_Profesor,Materia_ID_Materia,Materia_Calificaciones_ID_Calificaciones) ,
)
insert into Carga_academica(ID_carga,Profesores_IP_Profesor,Materia_ID_Materia,Materia_Calificaciones_ID_Calificaciones)values(90,123,12345,001);
insert into Carga_academica(ID_carga,Profesores_IP_Profesor,Materia_ID_Materia,Materia_Calificaciones_ID_Calificaciones)values(91,124,12346,002);
insert into Carga_academica(ID_carga,Profesores_IP_Profesor,Materia_ID_Materia,Materia_Calificaciones_ID_Calificaciones)values(92,125,12347,003);
select * from Carga_academica

CREATE TABLE Carrera_has_Profesores
(
Carrera_ID_Carrera int,
Profesores_IP_Profesor INT,
Profesores_Carga_academica_ID_carga int,
PRIMARY KEY (Carrera_ID_Carrera, Profesores_IP_Profesor, Profesores_Carga_academica_ID_carga) ,

)

insert into Carrera_has_Profesores(Carrera_ID_Carrera,Profesores_IP_Profesor,Profesores_Carga_academica_ID_carga)values(7777777,123,444);
insert into Carrera_has_Profesores(Carrera_ID_Carrera,Profesores_IP_Profesor,Profesores_Carga_academica_ID_carga)values(7777778,124,445);
insert into Carrera_has_Profesores(Carrera_ID_Carrera,Profesores_IP_Profesor,Profesores_Carga_academica_ID_carga)values(7777779,125,446);
select * from Carrera_has_Profesores

Mapa Mental

Redes

Base de datos

Sistemas Distribuidos

¿Que es una base de datos (DB)?

-Colección de datos relacionados del mismo contexto y almacenados sistemáticamente para su uso.
-Un conjunto de información almacenada en memoria auxiliar que permite acceso directo y un conjunto de programas que manipulan esos datos.
Base de Datos es un conjunto exhaustivo no redundante de datos estructurados organizados independientemente de su utilización y su implementación en máquina accesibles en tiempo real y compatibles con usuarios concurrentes con necesidad de información diferente y no predicable en tiempo.

¿Qué es un sistema manejador de base de datos (SMBD)?

Software que administra bases de datos y muestra la interfaz entre los datos y el usuario.

¿Qué es SQL?
En muchos casos, el esquema básico de operación es una serie de scripts que rigen el comportamiento de una base de datos.

Debido a la diversidad de lenguajes y de bases de datos existentes, la manera de comunicar entre unos y otras sería realmente complicada a gestionar de no ser por la existencia de estándares que nos permiten el realizar las operaciones básicas de una forma universal.

Es de eso de lo que trata el Structured Query Language que no es mas que un lenguaje estándar de comunicación con bases de datos. Hablamos por tanto de un lenguaje normalizado que nos permite trabajar con cualquier tipo de lenguaje (ASP o PHP) en combinación con cualquier tipo de base de datos (MS Access, SQL Server, MySQL...).

El hecho de que sea estándar no quiere decir que sea idéntico para cada base de datos. En efecto, determinadas bases de datos implementan funciones específicas que no tienen necesariamente que funcionar en otras.

Aparte de esta universalidad, el SQL posee otras dos características muy apreciadas. Por una parte, presenta una potencia y versatilidad notables que contrasta, por otra, con su accesibilidad de aprendizaje.

¿Qué es LDD?

Tareas de definición de estructuras, procedimientos y funciones para la Base de Datos

¿Qué es LMD?

Tarea de inserción, modificación, eliminación de datos en una Base de Datos.