Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Integración: estrategias de integración con sistemas externos. servicios web

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 28 de noviembre de 2011 por EducaMadrid

578 visualizaciones

Este taller tiene la intención de instruir las nociones, indicaciones y premisas básicas a la hora de realizar diferentes integraciones de servicios con Moodle, ya sean ofrecidos por terceras empresas, por ejemplo el correo electrónico de Yahoo, como servicios internos, por ejemplo la integración con la aplicación de gestión académica o con Mahara.

Más información Transcripción

Descargar la transcripción

Antes de começarmos, vamos a trabajar sobre o modo 2.2 00:00:00
Os que tenéis portátilos, os que tenéis portátilos, 00:00:12
que tenhas 2,2 instalados, 00:00:28
cuando os veis, téis instalado a implantación dos motos 00:00:36
solo observas o pilar 00:00:42
contrarrestes el cuadro 00:00:50
né que nemos 00:00:56
modo de montar e integrar 00:00:56
na máquina de inverno 00:01:00
não é un odo 00:01:03
é un superarr very true 00:01:07
recipado 00:01:10
e simbólicamente recipado 00:01:12
e círcalo a mil copos 00:01:15
e agregar 00:01:17
a máquina ao ritmo 00:01:20
mentre molle explicando 00:01:23
toda a parte 00:01:27
e até que cheguemos a parte práctica 00:01:29
ir pasando por 00:01:32
en vendrá 00:01:34
el mundo 00:01:36
bueno, vuelva a ir 00:01:37
ósea, esta tipa de que 00:01:38
si, una vez 00:01:40
é un mundo 00:02:05
e o arxivo é un mundo 00:02:18
non sei que máis 00:02:20
punto 5 00:02:22
coxeis esto 00:02:23
hai tres arxivos 00:02:24
de los tres, ósea 00:02:27
hai tres confinidos 00:02:28
e confinidos 00:02:29
se coxeis confinidos 00:02:30
confinidos máis pequenos 00:02:31
confinidos máis baixos 00:02:32
se saes de tres pequenos 00:02:34
se descopias 00:02:35
bueno, non me he presentado 00:02:42
non, está 00:02:48
en las máquinas 00:02:50
de aquí 00:02:52
é un xp 00:02:53
el arxivo 00:02:58
máquina de implós 00:02:59
que passa por mi implós 00:03:00
é un arxivo 00:03:02
é o arxivo 00:03:03
traballaremos 00:03:05
no arxivo 00:03:06
onde 00:03:08
instaleis o mundo todo 00:03:10
bueno, me presento 00:03:14
sobre todo 00:03:16
mi nombre é 00:03:18
otro imá 00:03:19
teño 00:03:20
tres palavras 00:03:24
que arxivo vale a arxivo 00:03:26
si, vos pois a dar 00:03:28
nociones 00:03:30
máxicas 00:03:33
para 00:03:35
entender 00:03:37
que é un servicio web 00:03:38
tener un conocimento 00:03:41
de todo o que implica 00:03:43
conectarse 00:03:46
o interconectarse 00:03:47
mediante un servicio web 00:03:49
vamos a hacer 00:03:52
que 00:03:54
model 2.0 00:03:55
vamos a habilitar 00:03:57
o servicio 00:03:58
o servicio web 00:03:59
i vamos a ver 00:04:01
las diferentes funciones 00:04:05
vamos a crear o servicio 00:04:06
el testeo 00:04:08
desas funciones 00:04:09
externamente 00:04:10
vamos a 00:04:12
utilizar 00:04:13
el mismo 00:04:15
el mismo model 00:04:17
que lleva 00:04:18
de implementado 00:04:19
un cliente 00:04:20
i lo vamos a probar 00:04:23
porque 00:04:25
una de las 00:04:28
cosillas 00:04:30
es que 00:04:32
de nuevas que viene 00:04:33
en el modelo 2.0 00:04:34
son los servicios web 00:04:35
entonces 00:04:37
a ser nuevo 00:04:38
no todo funciona 00:04:39
que quede claro 00:04:45
que yo no estoy metido 00:04:46
ni en el desarrollo 00:04:47
ni en nada 00:04:48
de lo web 00:04:49
yo simplemente os voy a contar 00:04:51
las nociones básicas 00:04:54
para entender 00:04:55
como van a venir 00:04:56
los servicios web 00:04:57
a partir del modelo 2.0 00:04:59
y adelante 00:05:01
supongo que 00:05:02
irán mejorándose 00:05:04
pero vamos 00:05:06
en un estado bastante 00:05:07
bíblico 00:05:08
lo primero es todo 00:05:16
vamos a ver 00:05:22
una serie de conceptos básicos 00:05:23
para después 00:05:30
ver diferentes 00:05:31
estándares 00:05:32
los estándares 00:05:34
nos van 00:05:36
os voy a dar 00:05:37
nociones 00:05:38
de como se deberían 00:05:40
hacer las cosas 00:05:41
que no quiere decir 00:05:42
que las tengamos que hacer así 00:05:43
ni que estén hechas así 00:05:45
que son nociones básicas 00:05:46
para conseguir 00:05:48
diferentes niveles 00:05:49
de integración 00:05:50
diferentes aplicaciones 00:05:51
y vamos a verlo 00:05:54
para estrategias 00:05:55
y al final 00:05:57
vamos a trabajar 00:05:58
sobre el modelo 2.0 00:05:59
antes de empezar 00:06:09
por el tema 00:06:13
de la interoperabilidad 00:06:15
entre aplicaciones 00:06:16
surge la palabra 00:06:18
integrar 00:06:19
que significa integrar 00:06:20
integrar 00:06:23
habitualmente 00:06:26
tenemos 00:06:28
una aplicación 00:06:30
que es la 00:06:32
la más 00:06:34
grande 00:06:35
la que 00:06:37
lo gestiona todo 00:06:38
habitualmente 00:06:42
esta aplicación 00:06:44
grande 00:06:46
necesita de otras 00:06:49
aplicaciones 00:06:50
para 00:06:53
obtener datos 00:06:56
por ejemplo 00:06:58
el ejemplo que vamos a ver 00:06:59
me voy a centrar 00:07:01
bastante 00:07:02
es un sistema 00:07:03
de gestión académica 00:07:04
con los diferentes 00:07:09
la interconexión 00:07:11
con los diferentes 00:07:12
satélites 00:07:15
con los cuales 00:07:17
forma 00:07:19
todo el ente universitario 00:07:20
en este caso 00:07:23
veremos 00:07:24
que 00:07:25
Moodle 00:07:27
necesita de 00:07:28
hablar 00:07:30
en este caso 00:07:31
con 00:07:32
el sistema de gestión académica 00:07:33
y este 00:07:35
y esta 00:07:36
aplicación 00:07:37
a la vez 00:07:38
también 00:07:40
se conecta a otras 00:07:41
a otros satélites 00:07:42
estos dos sistemas 00:07:44
proveen de información 00:07:45
a nuestro 00:07:48
sistema de gestión 00:07:49
académica 00:07:51
y al final 00:07:53
se pueden 00:07:54
traspasar datos 00:07:55
a nuestro Moodle 00:07:57
¿Cómo lo hacemos? 00:08:00
La solución 00:08:04
hasta ahora 00:08:06
la gran mayoría 00:08:08
tiene hecha 00:08:11
solución a medida 00:08:12
las soluciones a medida son 00:08:14
pues yo conozco 00:08:17
exactamente 00:08:19
como está montado 00:08:20
todas y cada una 00:08:22
de mis aplicaciones 00:08:23
hago 00:08:26
cosillas 00:08:28
en los cuales 00:08:29
para 00:08:30
traspasar esa información 00:08:32
ese traspaso 00:08:34
puede ser 00:08:35
en un sentido 00:08:36
o en otro 00:08:38
depende 00:08:40
de lo crítico que sea 00:08:41
y después del que veremos 00:08:43
es el pasado en esta 00:08:45
¿Cuántos 00:08:46
de aquí son 00:08:47
desarrolladores? 00:08:48
¿Habéis 00:08:49
o tocáis 00:08:50
código de Moodle? 00:08:51
Pues 00:08:57
los que 00:08:58
no toquéis 00:08:59
código de Moodle 00:09:00
no toquéis 00:09:02
código de Moodle 00:09:03
son 00:09:04
desarrolladores 00:09:05
que 00:09:06
son 00:09:07
desarrolladores 00:09:08
que 00:09:09
son 00:09:10
desarrolladores 00:09:11
que 00:09:12
son 00:09:13
desarrolladores 00:09:14
de código de Moodle 00:09:15
la primera parte 00:09:17
serán 00:09:20
Vais a ver 00:09:25
los conocimientos básicos 00:09:26
después ya veremos 00:09:27
kodido 00:09:28
esté taller 00:09:32
donde que 00:09:35
toca y prorama 00:09:36
cosillas 00:09:37
no vamos a programar 00:09:40
porque non todo funciona 00:09:41
entonces para que no pare 00:09:42
nos vamos a 00:09:44
a deixar máis 00:09:46
o serviz de web 00:09:47
de Moodle 00:09:48
pero veremos 00:09:49
2 diciones 00:09:50
o como facerlo 00:09:53
vamos a centrar 00:09:58
un sistema 00:09:59
que este na cadestra 00:10:00
o nosos sistemas 00:10:02
general 00:10:03
se non sois 00:10:04
talentosos 00:10:05
universitarios 00:10:06
de Moodle 00:10:08
estas dos aplicaciones 00:10:11
se soportan 00:10:12
sobre sistemas gestores 00:10:14
de base de datos 00:10:15
habituales 00:10:16
que 00:10:19
poden coincidir 00:10:20
con cualquera 00:10:22
de ellos 00:10:23
o non 00:10:25
se coincide 00:10:26
podemos hacer 00:10:31
una transferencia 00:10:32
de datos 00:10:35
de una sincronización 00:10:36
teóricamente sencilla 00:10:39
se non coincide 00:10:40
será máis complexa 00:10:41
entonces 00:10:42
el sistema 00:10:43
de sincronización 00:10:44
pode ser 00:10:48
mediante 00:10:50
vistas 00:10:51
si por ejemplo 00:10:52
utilizamos 00:10:53
cofres ou 00:10:54
en este encuentro 00:10:55
podemos ver 00:10:56
el sistema 00:10:58
principal 00:10:59
os puedo ofrecer 00:11:00
una vista 00:11:01
de parte 00:11:02
de los datos 00:11:03
y aquí vamos 00:11:04
a concretar 00:11:05
un poquillo 00:11:06
y nos vamos a centrar 00:11:07
en usuarios 00:11:08
gestión de usuarios 00:11:09
entonces 00:11:11
para 00:11:12
almacenar usuarios 00:11:13
habitualmente 00:11:14
se tiene una tabla 00:11:16
de usuarios 00:11:17
entonces 00:11:18
tenemos 00:11:19
nuestra tabla 00:11:20
principal 00:11:21
en el sistema 00:11:23
sistema principal 00:11:28
que 00:11:30
tiene todo 00:11:31
un conjunto 00:11:32
de campos 00:11:33
este conjunto 00:11:35
de campos 00:11:36
se pueden ofrecer 00:11:37
todos o no 00:11:38
habitualmente 00:11:39
todos 00:11:41
en este caso 00:11:42
es Noodle 00:11:43
no todos los 00:11:44
campos que tenemos 00:11:45
en nuestro 00:11:46
en nuestra tabla 00:11:47
principal 00:11:48
se pueden 00:11:50
sincronizar 00:11:51
con la tabla 00:11:52
de usuarios 00:11:53
que tiene 00:11:55
nuestra aplicación 00:11:56
externa 00:11:57
entonces 00:11:58
para securizar 00:11:59
o para pasar 00:12:00
los datos 00:12:01
correspondientes 00:12:02
se pueden crear 00:12:03
vistas 00:12:04
también 00:12:06
se pueden crear 00:12:07
procedimientos 00:12:08
o funciones 00:12:09
por ejemplo 00:12:10
así como 00:12:11
también 00:12:12
que se puede 00:12:13
soportar 00:12:14
puede ser el soporte 00:12:15
básico 00:12:16
en un sitio 00:12:17
y un otro 00:12:18
para después 00:12:19
paquetes o programas 00:12:20
hagan 00:12:21
la transferencia 00:12:22
de datos 00:12:23
así como 00:12:24
datos de usuarios 00:12:25
podemos hablar 00:12:26
de calificaciones 00:12:27
etc 00:12:28
por ejemplo 00:12:31
podemos tener 00:12:32
nuestro sistema 00:12:33
FORTH 00:12:34
o lo barato 00:12:35
que nos ofrece 00:12:36
toda una paquetería 00:12:37
de funciones 00:12:39
y procedimientos 00:12:40
que nos extraen 00:12:41
dicha información 00:12:44
mediante un programa 00:12:46
escrito 00:12:47
en PHP 00:12:48
en Ruby 00:12:49
en lo que queráis 00:12:50
hace la sincronización 00:12:52
a la base de datos 00:12:54
de un usuario 00:12:55
o conoce exactamente 00:12:57
como es 00:12:59
y hace la transferencia 00:13:00
y ahí se puede utilizar 00:13:03
los ya desarrollados 00:13:06
como queráis 00:13:08
o como sea 00:13:10
y después 00:13:12
si es un sistema 00:13:13
que comparte 00:13:14
el mismo sistema 00:13:18
gestor de bases de datos 00:13:19
se pueden hacer 00:13:20
transferencias 00:13:21
inmediatas 00:13:22
por ejemplo 00:13:23
puede hablar a un usuario 00:13:24
en la 00:13:25
aplicación de gestión a cadena 00:13:26
con la que 00:13:27
tiene sus hermanos 00:13:28
tiene un 00:13:30
nuevo 00:13:31
compañero de trabajo 00:13:32
entonces hablar con el 00:13:34
adapta 00:13:35
disparadores 00:13:37
puede hacer la transferencia 00:13:38
inmediata 00:13:39
a nuestra 00:13:41
base de datos 00:13:42
destino 00:13:43
entonces es mas 00:13:45
simple 00:13:46
lo mas divertido es que 00:13:50
después 00:13:51
de la aplicación 00:13:53
destino 00:13:54
podemos necesitar 00:13:55
información 00:13:56
por ejemplo 00:13:57
si tenemos 00:13:58
en este caso 00:13:59
por ejemplo 00:14:00
podemos 00:14:01
querer 00:14:02
las calificaciones 00:14:03
de nuestros 00:14:04
alumnos 00:14:05
en el sistema 00:14:07
gestor de bases de datos 00:14:08
entonces 00:14:09
o tendremos que 00:14:10
programarlo 00:14:11
tendremos que utilizar 00:14:12
tratar esta información 00:14:14
de forma personalizada 00:14:16
nuestra 00:14:20
aplicación 00:14:21
que quieres 00:14:22
utilizar 00:14:23
otro concepto 00:14:30
que es un servicio web 00:14:31
ahora hemos visto 00:14:33
integrar 00:14:34
necesitamos 00:14:35
compartir 00:14:36
información 00:14:37
duplicar 00:14:40
información 00:14:41
porque al final 00:14:42
tenemos 00:14:43
n aplicaciones 00:14:44
y muchas 00:14:45
pueden ser externas 00:14:46
y suelen tener 00:14:47
su propia gestión 00:14:48
que ya tenemos 00:14:49
incorporada 00:14:50
entonces 00:14:51
queremos 00:14:52
esparcir 00:14:53
esos datos 00:14:54
podemos integrar 00:14:56
por ejemplo 00:14:57
un servicio web 00:14:58
que es un servicio web 00:14:59
es una app 00:15:00
todos podemos saber 00:15:01
que es una app 00:15:02
que nos hemos quedado 00:15:03
enamorados 00:15:04
es un 00:15:06
interface 00:15:07
es un conjunto 00:15:09
de funciones 00:15:10
procedimientos 00:15:11
identificados 00:15:12
por ejemplo 00:15:13
leemos un usuario 00:15:14
que pasa 00:15:16
y lees 00:15:17
ese usuario 00:15:18
que tiene la característica 00:15:21
de que se acenta 00:15:22
vía 00:15:23
web 00:15:24
entonces 00:15:25
mediante el protocolo 00:15:26
estamos en protocolo 80 00:15:29
vía 00:15:32
segura 00:15:33
40 dpi 00:15:34
tiene la característica 00:15:37
que yo como cliente 00:15:38
cuando me conecto 00:15:39
a un servicio web 00:15:40
que es generalmente 00:15:41
externo 00:15:42
esa 00:15:44
esa 00:15:45
esa 00:15:47
petición 00:15:48
se ejecuta ahí 00:15:49
entonces 00:15:50
cuando yo tengo 00:15:52
la capacidad 00:15:53
de ejecutar 00:15:54
funciones 00:15:55
en sistemas externos 00:15:56
tengo 00:15:59
visto 00:16:00
permitir que 00:16:02
clientes 00:16:03
se conecten a mi 00:16:04
y me ejecuten 00:16:05
parte del código 00:16:06
tiene 00:16:08
toda una 00:16:09
consecuencia 00:16:11
de seguridad 00:16:12
entonces 00:16:14
mas adelante veremos 00:16:15
todas 00:16:16
estas 00:16:17
características 00:16:18
los servicios web 00:16:21
tienen la característica 00:16:22
que 00:16:23
utilizan el formato 00:16:24
xml 00:16:25
entonces 00:16:27
por ejemplo 00:16:29
vamos a ver 00:16:31
una 00:16:32
documentada 00:16:34
de por ejemplo 00:16:36
twitter 00:16:37
porque vamos a ver la de twitter 00:16:39
y no vemos la de moodle 00:16:40
porque la de moodle 00:16:41
no se 00:16:42
genera 00:16:43
se ve que hay algún tipo 00:16:44
de bug 00:16:45
y aún 00:16:46
después lo vemos 00:16:47
en el caso práctico 00:16:48
que lo vamos a activar 00:16:49
que no lo vamos a poder ver 00:16:50
se ve que 00:16:52
vamos a encontrar 00:16:53
retoques por ahí 00:16:54
por ejemplo 00:16:59
aquí tenemos 00:17:14
API 00:17:18
gracias 00:17:29
vemos la API 00:17:41
los diferentes 00:17:44
apartados 00:17:45
para poder utilizar 00:17:46
esta API 00:17:47
aquí que encontraremos 00:17:48
encontraremos 00:17:49
lo que ahora 00:17:51
nos irá explicar 00:17:52
protocolos 00:17:53
funciones 00:17:54
significaciones 00:17:55
especificaciones 00:17:56
etc 00:17:58
por ejemplo 00:18:04
si queremos 00:18:05
que 00:18:07
un cliente 00:18:09
que acceda a nosa página 00:18:10
este ya 00:18:12
que este autenticado 00:18:13
en twitter 00:18:14
lee 00:18:18
los 00:18:20
esa aplicación 00:18:24
por ejemplo 00:18:26
podemos utilizar 00:18:27
las diferentes 00:18:30
librerías 00:18:31
que 00:18:36
en este caso 00:18:37
twitter ofrece 00:18:38
entonces 00:18:40
la idea que quiero que 00:18:41
obtenéis es que 00:18:42
el moodle 00:18:43
va a implementar 00:18:44
una cosa similar 00:18:46
no exactamente igual 00:18:49
pero 00:18:50
conceptualmente igual 00:18:52
entonces 00:18:53
podremos 00:18:55
para este caso 00:18:56
twitter ofrece 00:18:57
diferentes librerías 00:18:58
para diferentes 00:18:59
lenguajes 00:19:00
de programación 00:19:01
para que podamos acceder 00:19:02
entonces 00:19:03
para ver 00:19:04
porque nos ofrece esto 00:19:05
porque nosotros 00:19:06
para comunicarnos 00:19:07
con un servicio web 00:19:08
externo 00:19:09
tendremos que 00:19:11
enviar la información 00:19:12
que 00:19:13
el servicio web 00:19:14
requiere 00:19:16
y nos devolverá 00:19:17
lo que 00:19:20
esa función 00:19:21
de la 00:19:22
API 00:19:23
y ahora vamos a ver 00:19:25
como se puede 00:19:26
ejecutar 00:19:27
todas estas 00:19:31
posibilidades 00:19:32
entonces 00:19:41
al final 00:19:44
lo que tendremos es que 00:19:46
una aplicación 00:19:48
requerirá 00:19:51
que 00:19:52
el sistema 00:19:53
remoto 00:19:54
que ofrece 00:19:55
servicios web 00:19:57
le ejecute 00:20:00
una necesidad 00:20:03
una función 00:20:04
y le devuelva 00:20:05
esta aplicación 00:20:06
tendrá la característica 00:20:08
que 00:20:09
será enviada 00:20:10
mediante el formador xml 00:20:11
y será devuelta 00:20:14
con ese mismo formato 00:20:16
entonces 00:20:18
debemos proveer 00:20:19
nuestra aplicación 00:20:22
en este caso 00:20:23
el modelo que estamos 00:20:24
utilizando 00:20:25
lo está implementando 00:20:26
ahora mismo 00:20:27
toda la programación 00:20:29
específica 00:20:30
para poder 00:20:31
entender 00:20:32
todo este formador 00:20:33
como es 00:20:35
interoperabilidad 00:20:36
entonces 00:20:39
podemos encontrarnos 00:20:40
cualquier cosa 00:20:41
al encontrarnos 00:20:49
diferentes 00:20:50
cosas 00:20:52
cuales sean 00:20:53
problemáticas 00:20:54
utilizamos 00:20:55
un lenguaje 00:20:57
de definición 00:20:58
de websites 00:21:00
los dos 00:21:02
websites 00:21:03
que 00:21:05
habitualmente 00:21:06
suelen 00:21:07
combinarse 00:21:08
con 00:21:10
especificación 00:21:11
soa 00:21:13
más 00:21:15
un formato 00:21:16
xml 00:21:17
entonces 00:21:20
a día de hoy 00:21:23
tenemos dos versiones 00:21:24
la descripción 00:21:28
de servicios web 00:21:29
la versión 00:21:32
1.x 00:21:33
la versión 2 00:21:36
la versión 1 00:21:37
y la versión 2 00:21:38
que 00:21:39
hay diferencias 00:21:40
entre ellos 00:21:41
entonces 00:21:42
cuando nosotros 00:21:43
queramos 00:21:44
comunicarnos 00:21:45
con una aplicación 00:21:47
para que ejecute 00:21:48
un servicio web 00:21:49
tendremos que especificar 00:21:51
que protocolo 00:21:52
estamos utilizando 00:21:54
porque 00:21:56
nos contestará 00:21:57
con ese mismo 00:21:58
protocolo 00:21:59
con esa misma 00:22:00
definición 00:22:01
como veis 00:22:07
hay diferentes 00:22:08
hay diferencias 00:22:10
las más 00:22:11
fundamentales 00:22:13
porque 00:22:14
porque 00:22:15
de 1.1 00:22:17
se pasa a 2.0 00:22:18
porque hay un cambio 00:22:20
mayor 00:22:21
como muda 00:22:22
cuando hay cambios 00:22:23
mayores 00:22:24
pues porque por ejemplo 00:22:25
lenguaje de descripción 00:22:27
de la versión 00:22:30
únicamente son 00:22:32
los métodos 00:22:33
gamepost 00:22:34
la descripción 2.0 00:22:37
permite 00:22:41
tanto game 00:22:43
como post 00:22:44
como put 00:22:45
como delete 00:22:46
etc 00:22:47
todos los métodos 00:22:48
explicados 00:22:49
de acceso 00:22:51
vía web 00:22:54
todos los métodos 00:22:55
y después 00:22:57
una 00:22:59
un tema de sintaxis 00:23:00
también 00:23:01
se cambió 00:23:03
lo que es 00:23:05
el servicio 00:23:06
cuando tú 00:23:07
haces una medición 00:23:09
te dices vale 00:23:10
pues cuando me lo devuelvas 00:23:11
me lo tienes que devolver aquí 00:23:12
y donde se dice aquí 00:23:15
pues 00:23:16
point 00:23:19
aquí había un problema 00:23:20
mucha gente confundía 00:23:22
un puerto 00:23:23
como el puerto 00:23:24
donde me ha recibido 00:23:25
y no 00:23:26
por eso se cambió 00:23:27
por ejemplo 00:23:28
para 00:23:30
el point 00:23:31
porque es donde quiero 00:23:32
que me devuelvas 00:23:33
esa 00:23:36
esa medición 00:23:37
vamos a ver un ejemplo 00:23:40
¿cómo se define? 00:23:44
pues vamos 00:23:45
versión 00:23:46
codificación 00:23:49
lo de ahí 00:23:51
atrás no es 00:23:52
¿pero si se bajaran 00:23:57
a mitad? 00:23:58
¿como se baja a mitad? 00:24:00
si, si 00:24:02
ahí se ve 00:24:05
por esa otra vez 00:24:08
esto teóricamente 00:24:23
está subida 00:24:24
creo 00:24:25
que me dijeron 00:24:32
que lo subirían 00:24:33
bueno 00:24:38
¿aquí que se define? 00:24:39
pues 00:24:40
defines el 00:24:41
protocolo 00:24:42
donde tiene que 00:24:43
ir a buscar 00:24:44
el protocolo 00:24:45
de definición 00:24:46
para que entienda 00:24:47
o sea 00:24:49
coja la definición 00:24:50
del web service 00:24:51
tú le das 00:24:54
la descripción 00:24:55
entonces 00:24:56
le dices 00:24:57
mis aplicaciones 00:24:58
van 00:24:59
si me contestas 00:25:03
por el puerto 00:25:04
por Http 00:25:06
por Http 00:25:07
tiene que ir 00:25:08
a buscar 00:25:09
el esquema 00:25:10
definido 00:25:12
por la 00:25:13
web de C 00:25:14
de ahí 00:25:15
y si va 00:25:17
mediante SOA 00:25:18
o utiliza 00:25:19
todo SOA 00:25:20
tiene que ir a buscar 00:25:22
la definición 00:25:23
para ver que coincide 00:25:24
después 00:25:31
los tipos 00:25:36
defines 00:25:38
también tienes que 00:25:39
especificar 00:25:40
qué tipo tú utilizas 00:25:41
entonces 00:25:42
para el elemento 00:25:45
petición 00:25:46
vas a utilizar 00:25:48
secuencias 00:25:49
lo tendrás que especificar 00:25:51
si vas a utilizar 00:25:52
streams 00:25:58
también lo tienes que especificar 00:26:01
y si su uso 00:26:03
es requerido 00:26:04
o no es requerido 00:26:05
y para el elemento 00:26:07
respuesta 00:26:08
también hay que especificar 00:26:09
qué tipo 00:26:10
todo esto hay que especificar 00:26:11
aunque 00:26:13
como vamos a ver 00:26:14
todo esto 00:26:16
en Moodle 00:26:17
en cualquier aplicación 00:26:18
usualmente 00:26:19
no se debe especificar 00:26:20
sino que se 00:26:21
utilizamos unas 00:26:22
librerías 00:26:23
por debajo 00:26:24
que 00:26:25
ya hacen este trabajo 00:26:26
pero 00:26:27
lo que yo 00:26:28
intento mostraros 00:26:30
toda una complejidad 00:26:32
que implica 00:26:33
conectarse 00:26:35
via un servicio 00:26:36
después 00:26:39
le dices 00:26:42
los diferentes 00:26:43
la interfaz 00:26:44
que tiene que utilizar 00:26:45
por ejemplo 00:26:46
cuando hay errores 00:26:47
pues 00:26:48
si hay un error de cliente 00:26:49
pues 00:26:50
que se vaya 00:26:51
al elemento 00:26:52
respuesta 00:26:53
que lo hemos definido antes 00:26:54
si hay un error 00:26:55
de seguidor 00:26:56
pues que 00:26:57
también se vaya 00:26:58
al elemento 00:26:59
respuesta 00:27:03
que hemos definido 00:27:04
que operaciones 00:27:06
permitimos 00:27:07
o que operaciones 00:27:08
permitimos 00:27:09
de servicio 00:27:10
tanto hoy en como 00:27:14
bueno 00:27:15
se lo vas decidiendo 00:27:16
y después 00:27:22
todas las operaciones 00:27:24
que permitimos 00:27:25
entonces 00:27:27
para 00:27:28
cuando se parece 00:27:29
con VHTTP 00:27:30
vamos a ver 00:27:32
que interfaz utiliza 00:27:35
que operaciones 00:27:39
y que metodo 00:27:40
el protocolo 00:27:43
VHTTP 00:27:44
tiene que utilizar 00:27:45
así 00:27:48
después 00:27:49
así como 00:27:50
también 00:27:51
que es 00:27:52
la siguiente 00:27:53
parte 00:27:54
que también se especifica 00:27:56
exactamente 00:27:57
como 00:27:58
tiene que responder 00:27:59
a ese tipo 00:28:00
de decisiones 00:28:01
y después 00:28:03
el servicio 00:28:04
una vez 00:28:08
descrito 00:28:09
se puede utilizar 00:28:17
diferentes estándares 00:28:18
entonces 00:28:20
lo que hemos visto 00:28:21
hasta ahora 00:28:22
simplemente es para describir 00:28:23
no hemos dicho nada 00:28:24
cuando se nos envían 00:28:29
peticiones web 00:28:31
los 00:28:33
las librerías 00:28:36
que vienen implementadas 00:28:37
tienen pilas de 00:28:40
servicios web 00:28:41
esas pilas 00:28:43
simplemente se 00:28:44
es para 00:28:46
utilizar cuando 00:28:47
un client 00:28:48
n clientes 00:28:49
están 00:28:50
reclamando servicios web 00:28:51
yo los voy 00:28:52
almacenando 00:28:53
y tratando por capas 00:28:54
entonces 00:28:57
en la capa de transportes 00:28:58
se especifica 00:29:00
como se deben 00:29:04
transmitir 00:29:05
a nivel de red 00:29:07
utilizando el 00:29:08
protocolo 00:29:09
como se deben transmitir 00:29:13
los paquetes 00:29:14
a nivel de red 00:29:15
a nivel de mensajería 00:29:17
lo que hace es 00:29:18
coge el protocolo 00:29:20
que vamos a ver 00:29:21
que es SOAP 00:29:23
o otro 00:29:24
y lo transforma 00:29:25
en un XML 00:29:26
XML 00:29:27
hace una transformación 00:29:28
así cuando 00:29:30
cogemos 00:29:31
pues ya tenemos 00:29:32
parte del trabajo hecho 00:29:33
la capa 00:29:38
de descripción 00:29:39
es que 00:29:40
la capa que mira exactamente 00:29:42
como debe proceder 00:29:44
o como está 00:29:46
descrito 00:29:47
ese web service 00:29:48
y después hay 00:29:51
otra capa 00:29:52
que es 00:29:53
la de descubrir 00:29:54
en ese 00:29:55
servicios web 00:29:56
entonces 00:29:57
las que 00:29:58
que dice el protocolo 00:30:01
para 00:30:04
UDDI 00:30:06
ahora 00:30:09
que es 00:30:10
un protocolo 00:30:11
industrial 00:30:12
hecho para la industria 00:30:14
porque por ejemplo 00:30:16
a nivel de Google 00:30:17
nos interesa 00:30:18
a lo mejor 00:30:19
publicar 00:30:20
que 00:30:22
otros servicios 00:30:24
otras aplicaciones 00:30:25
descubran 00:30:27
puedan utilizar 00:30:29
nuestros servicios web 00:30:32
pero a lo mejor 00:30:33
Twitter, Facebook 00:30:35
Twitter 00:30:36
LinkedIn 00:30:38
etc 00:30:39
si que les interesa utilizar 00:30:40
web service 00:30:42
de las otras 00:30:43
aplicaciones 00:30:44
entonces 00:30:46
que utiliza 00:30:47
que se utiliza 00:30:48
para 00:30:49
saber 00:30:50
que funcionalidad 00:30:51
que servicios web 00:30:52
ofrecen 00:30:53
pues el protocolo UDDI 00:30:54
que es un estándar 00:30:55
de oasis 00:30:56
y por debajo 00:30:57
es una 00:30:58
implementación 00:30:59
es un 00:31:02
bueno es un antecesor 00:31:03
es el de 00:31:05
WB descubrir 00:31:06
que es el protocolo 00:31:07
básico 00:31:08
que 00:31:09
realmente es el que utiliza 00:31:10
por ejemplo 00:31:11
Moose 00:31:14
evidentemente 00:31:16
como hacemos 00:31:17
como 00:31:18
nos 00:31:19
comunicamos 00:31:20
con una aplicación 00:31:21
externa 00:31:22
y sabemos 00:31:23
que 00:31:24
servicios web 00:31:25
entonces hay 00:31:27
un lenguaje 00:31:28
para 00:31:32
requerir 00:31:35
o para preguntar 00:31:36
a esa aplicación 00:31:37
que funcionalidad 00:31:38
entonces 00:31:39
ya no lo describimos 00:31:40
como antes 00:31:42
sino que 00:31:43
queremos 00:31:44
interoperar 00:31:45
queremos descubrir 00:31:46
que funcionalidades 00:31:48
ofrecen 00:31:50
en servicios 00:31:51
externos 00:31:53
¿habéis entendido? 00:31:56
todo esto 00:32:03
muchas veces 00:32:05
no somos conscientes 00:32:06
pero todo esto 00:32:08
protocolos 00:32:09
y estas peticiones 00:32:10
y estas definiciones 00:32:11
se utilizan por debajo 00:32:12
y de ahi 00:32:16
que 00:32:17
sea dificil 00:32:20
implementar 00:32:21
servicios web 00:32:22
si acaba de salir 00:32:24
por ejemplo 00:32:25
ahora mismo 00:32:26
que van a publicar 00:32:27
los servicios 00:32:28
la 1.9 00:32:29
vinieron servicios web 00:32:31
se tiraron a la basura 00:32:33
yo no me voy a meter 00:32:35
con los servicios web 00:32:36
que estan implementados 00:32:37
la 1.9 00:32:38
porque la 2.0 00:32:39
son totalmente diferentes 00:32:40
y los servicios web 00:32:42
de Google 2.0 00:32:44
no estan acabados 00:32:47
programar 00:32:50
y vienen bugs 00:32:51
y viendo todo esto 00:32:53
vais a entender 00:32:55
que tambien es normal 00:32:56
porque despues por debajo 00:32:57
realmente es cuando 00:32:59
se programan las funciones 00:33:00
y vamos a ver 00:33:02
ejemplos 00:33:03
bueno 00:33:04
despues de lo de 00:33:05
standard y protocolos 00:33:06
a ver 00:33:07
tenemos 00:33:08
que 00:33:09
web service 00:33:10
nos ofrece 00:33:12
podemos describir 00:33:14
estos servicios 00:33:15
pues vamos a utilizar 00:33:17
protocolos para 00:33:18
entonces podemos utilizar 00:33:19
el protocolo 00:33:20
XMR 00:33:21
XMR de RPC 00:33:22
que tiene 00:33:24
estos tipos de datos 00:33:25
XMR de RPC 00:33:32
tiene 00:33:34
tenia 00:33:35
o tiene la caracteristica 00:33:36
de que es muy simple 00:33:37
al ser tan simple 00:33:38
a ver la utilidad 00:33:43
que tiene 00:33:44
XMR de RPC 00:33:45
creo 00:33:48
surgio 00:33:49
a necesidad 00:33:50
de crear 00:33:51
una evolución 00:33:52
para 00:33:53
contener 00:33:54
muchísimos 00:33:55
tipos de datos 00:33:56
a poder planear 00:33:59
entonces se creo SOA 00:34:00
la especificación 00:34:03
de SOA 00:34:04
tenemos 00:34:08
una capa 00:34:09
tenemos 00:34:13
una capa 00:34:14
en control 00:34:16
con 00:34:18
una cabecera 00:34:20
un ciber 00:34:21
el bode 00:34:23
entonces 00:34:25
el SOA 00:34:26
como se hace SOA 00:34:27
se encapsula 00:34:29
junto con 00:34:35
toda la descripción 00:34:37
bueno, despues lo vamos a ver 00:34:38
y para que 00:34:40
veáis un ejemplo 00:34:41
real 00:34:43
de BUDE 00:34:44
por ejemplo 00:34:45
se especifica 00:34:46
se especifica 00:34:48
la versión 00:34:50
en el código 00:34:51
se define el esquema 00:34:55
mi aplicación 00:34:59
donde 00:35:00
se esta ejecutando 00:35:01
en este caso 00:35:03
hemos encontrado 00:35:04
un BUDE 00:35:05
dentro del 00:35:07
host 00:35:08
de cabeceras 00:35:10
no se especifica nada 00:35:11
se puede especificar o no 00:35:13
por ejemplo 00:35:16
en el BUDE 00:35:17
la BUDE que diría 00:35:18
quiero 00:35:19
que me ejecutes 00:35:20
en este caso 00:35:22
BUDE user 00:35:23
get user 00:35:24
by user name 00:35:25
que es una función 00:35:26
que esta 00:35:27
implementada en BUDE 00:35:29
y le pasamos 00:35:31
como parámetro 00:35:32
porque si damos la definición 00:35:33
del BUDE series 00:35:35
que os acabo de mencionar 00:35:38
necesita que le pasemos 00:35:40
un o el parámetro 00:35:42
y se especifica 00:35:43
de esta forma 00:35:44
se cierra 00:35:47
porque es como 00:35:49
la imagen de TAS 00:35:50
típico de XML 00:35:51
y se cierra 00:35:53
esto puede ser 00:35:54
puede crecer 00:35:56
o puede disminuir 00:35:57
dependiendo 00:35:58
de lo que necesitemos 00:35:59
de lo que envíe 00:36:00
aun os he mencionado 00:36:08
todo el tema de seguridad 00:36:09
porque claro 00:36:11
si yo 00:36:12
publico 00:36:13
un servicio web 00:36:14
que es 00:36:15
borrar 00:36:17
usuarios 00:36:18
tendré que 00:36:20
ponerse 00:36:21
seguridad ahí en medio 00:36:23
entonces 00:36:25
existe 00:36:28
un estándar 00:36:29
que 00:36:31
web server security 00:36:33
que es un estándar de oasis 00:36:34
que especifica 00:36:36
todo un conjunto 00:36:37
protocol 00:36:39
de estándares 00:36:40
que se pueden aplicar 00:36:41
por encima 00:36:42
de todo 00:36:43
que hemos estudiado hasta ahora 00:36:44
seguridad 00:36:48
mediante 00:36:49
certificados 00:36:50
claves 00:36:51
públicas 00:36:52
para activar etc 00:36:53
hay todo 00:36:54
todo un conjunto 00:36:55
de estándares 00:36:56
bastante 00:36:57
extensos 00:36:58
y que no voy a entrar 00:36:59
ahora mismo 00:37:00
en todo este tema 00:37:01
ya veremos como 00:37:03
y bueno 00:37:06
para que 00:37:07
no hablemos del TAS 00:37:08
porque hemos visto 00:37:10
todo bien 00:37:11
los conceptos básicos 00:37:13
para entender 00:37:14
este simple 00:37:15
esquema 00:37:17
tenemos un cliente 00:37:19
solicita 00:37:21
un servicio web 00:37:23
ou una aplicación de estilo 00:37:25
pero 00:37:28
tiene 00:37:30
que preguntar 00:37:31
como pregunta 00:37:33
mediante el lenguaje 00:37:34
de descripción 00:37:35
de web service 00:37:36
que funciones tiene 00:37:39
puede preguntarlo 00:37:40
a lo mejor ya lo sabe 00:37:41
a lo mejor lo tiene que preguntar 00:37:42
al igual 00:37:46
que 00:37:49
el servicio 00:37:50
que nos provee 00:37:51
tambien puede 00:37:52
provee 00:37:54
los servicios web 00:37:56
que ofrece 00:37:58
con todo este contante 00:38:03
despues nos devuelve 00:38:04
la respuesta 00:38:05
con el mismo 00:38:07
protocolo 00:38:08
con el cual 00:38:09
hemos 00:38:11
preguntado 00:38:12
hecho la petición 00:38:14
de acuerdo 00:38:17
niveles de integración 00:38:31
hasta donde integramos 00:38:33
pues 00:38:34
típicamente 00:38:36
tenemos 00:38:37
dos 00:38:38
caosísticas diferentes 00:38:39
que es 00:38:40
por el veremos 00:38:43
a nuestra aplicación 00:38:44
por ejemplo 00:38:45
el efecto de status 00:38:46
que es 00:38:47
sistema académico 00:38:48
mi sistema 00:38:49
de sistema académico 00:38:50
con mi 00:38:51
model 00:38:52
está dentro 00:38:53
de mi 00:38:54
entonces 00:38:55
es un sistema interno 00:38:56
que no sale 00:38:57
publicado 00:38:58
publicamente 00:39:01
web 00:39:02
entonces como aplicaciones 00:39:03
internas 00:39:04
segura 00:39:06
esteticamente 00:39:07
y despues 00:39:08
puedo tener 00:39:09
servicio de externo 00:39:10
por ejemplo 00:39:11
puedo 00:39:12
que la universidad 00:39:14
no se 00:39:19
la universidad 00:39:20
se conecte a mi sistema 00:39:21
de gestión académica 00:39:22
y a mi servicio web 00:39:23
entonces ya es 00:39:24
un nivel externo 00:39:25
que se me conecta 00:39:27
a mi aplicación 00:39:28
entonces 00:39:29
los niveles de seguridad 00:39:30
pueden ser 00:39:31
diferentes 00:39:32
y ya entramos en 00:39:34
sistemas de seguridad 00:39:35
que preguntas 00:39:38
nos tenemos que hacer 00:39:39
la primera de todas 00:39:40
que información 00:39:42
comun 00:39:43
tratan 00:39:44
mis aplicaciones 00:39:45
en este caso 00:39:46
si tenemos 00:39:48
el efecto de 00:39:50
la tabla de usuarios 00:39:51
es la tabla de usuarios 00:39:53
pero tambien 00:39:54
puede ser 00:39:55
el sistema de cursos 00:39:57
o la tabla de cursos 00:39:59
la tabla de manipulaciones 00:40:01
etc 00:40:02
entonces primero 00:40:03
que tenemos comun 00:40:04
una vez 00:40:07
que sabemos 00:40:09
que información 00:40:10
tenemos comun 00:40:11
que integridad 00:40:14
puedo 00:40:16
que a veces no se puede 00:40:17
o me dejan 00:40:20
eso me exploya 00:40:21
a mojor por políticas 00:40:23
internas 00:40:24
de nuestro 00:40:25
de nuestra entidad 00:40:27
podemos 00:40:28
podemos o no podemos 00:40:30
que entre el externo 00:40:32
que entre el externo 00:40:33
realice 00:40:34
diferentes 00:40:36
traspasos de edad 00:40:38
y al final 00:40:44
una vez se 00:40:45
que información 00:40:46
tengo en comun 00:40:47
que integridad 00:40:50
quiero 00:40:51
o me dejan 00:40:52
y puedo dar 00:40:53
tengo que 00:40:57
preguntarme 00:41:01
que servicios 00:41:02
con esa información 00:41:03
que servicios 00:41:04
puedo ofrecer 00:41:05
por ejemplo 00:41:06
yo digo 00:41:07
tengo la aplicación 00:41:08
google 00:41:10
y la aplicación 00:41:11
del sistema 00:41:12
que datos 00:41:13
compartidos 00:41:14
usuarios 00:41:15
manipulaciones 00:41:16
cursos 00:41:17
entonces 00:41:18
quiero 00:41:19
o puedo 00:41:20
ofrecer 00:41:21
esa integridad 00:41:22
de datos 00:41:23
que 00:41:24
las dos aplicaciones 00:41:25
puedan 00:41:26
pasarse 00:41:27
interactuar 00:41:29
entre ellas 00:41:30
y una vez 00:41:33
sabemos esto 00:41:36
que puedo ofrecer 00:41:38
o que servicios 00:41:39
quiero ofrecer 00:41:40
a lo mejor 00:41:41
solo me interesa 00:41:42
que 00:41:43
pueda 00:41:44
insertar datos 00:41:45
o insertar usuarios 00:41:47
y no haga 00:41:48
por ejemplo 00:41:49
borrar usuarios 00:41:50
una vez 00:41:53
sabemos 00:41:59
que servicios 00:42:01
puedo dar 00:42:02
los dejaré hacer 00:42:04
o no 00:42:05
entonces 00:42:06
para consultas 00:42:08
de estos 00:42:09
datos críticos 00:42:10
dejaré 00:42:13
o no 00:42:14
modificar 00:42:15
inserción o no 00:42:16
cabe decir 00:42:17
que 00:42:18
os hablo de 00:42:20
tablas 00:42:21
o información 00:42:22
crítica 00:42:23
crítica 00:42:24
a temas 00:42:25
diferentes de 00:42:26
seguridad 00:42:27
porque 00:42:28
si yo quiero 00:42:29
que me consulte 00:42:30
el sistema 00:42:32
el sistema 00:42:35
de gestión académica 00:42:36
me consulte 00:42:37
el calendario 00:42:38
de que tengo 00:42:39
publicado 00:42:40
en el moodle 00:42:41
hay 00:42:42
otros protocolos 00:42:43
y otras funcionalidades 00:42:44
que existen 00:42:45
para ello 00:42:46
y que no requieren 00:42:48
de toda esta 00:42:49
integridad 00:42:50
para hacer nada 00:42:51
y son mucho 00:42:53
más simples 00:42:54
entonces 00:42:55
lo que tengo 00:42:57
detectar 00:43:00
exactamente 00:43:01
que necesidad 00:43:04
de datos críticos 00:43:05
necesito pasar 00:43:06
porque hay otros datos 00:43:07
por ejemplo 00:43:08
los coros 00:43:09
se publican mediante 00:43:10
RSS 00:43:11
lo calendario 00:43:12
lo puedo 00:43:13
modificar 00:43:14
etc. 00:43:15
en la libre 00:43:16
entonces 00:43:17
implementar 00:43:18
servicios web 00:43:19
para sustituir 00:43:20
o compaginar 00:43:21
servicios de 00:43:24
consultas 00:43:26
con datos 00:43:27
es tontería 00:43:29
es trabajar 00:43:30
para nada 00:43:31
entonces también 00:43:32
lo tenemos que 00:43:33
tener en cuenta 00:43:34
y al final 00:43:36
lo que nos hace 00:43:38
interesar 00:43:39
un servicio web 00:43:40
es la seguridad 00:43:41
que queramos tener 00:43:42
¿de acuerdo? 00:43:44
bueno 00:43:47
que esfuerzo 00:43:50
y sacrificio 00:43:51
debemos realizar 00:43:52
esta es la mitad 00:43:54
la famosa frase 00:43:55
para 00:43:57
estandartizar 00:43:58
la funcionalidad 00:43:59
nosotros 00:44:01
habitualmente 00:44:02
cada uno 00:44:04
de los sistemas 00:44:05
propios 00:44:07
de cada universidad 00:44:08
de cada entidad 00:44:09
utilizan 00:44:11
diferentes datos 00:44:12
lo mejor 00:44:15
que 00:44:18
existen diferentes 00:44:19
estándares 00:44:20
que pueden 00:44:21
adaptarse 00:44:22
a nuestro 00:44:24
a nuestra forma 00:44:25
de almacenar 00:44:26
esos datos 00:44:27
esta estandarización 00:44:29
nos hace 00:44:33
nos hace 00:44:37
surgir 00:44:38
que 00:44:39
parametrizar 00:44:40
o sea 00:44:41
si yo por ejemplo 00:44:42
necesito leer 00:44:43
un usuario 00:44:44
a un hall 00:44:45
como 00:44:48
universidad de Aida Valadares 00:44:49
intelecto 00:44:50
que esa función 00:44:51
sea por 00:44:52
un identificador 00:44:53
otra universidad 00:44:54
porque sea 00:44:55
por un 00:44:56
nombre de usuario 00:44:57
etc. 00:44:58
lo que debemos hacer es 00:45:00
intentar 00:45:01
estandartizar 00:45:02
o monje y tal 00:45:03
para 00:45:04
poder 00:45:05
interoperar 00:45:06
más 00:45:07
fácilmente 00:45:09
¿para que? 00:45:14
y después 00:45:15
únicamente 00:45:17
no nosotros 00:45:18
debemos 00:45:19
para empezar 00:45:20
por ejemplo 00:45:22
si se me produce 00:45:23
una caída 00:45:24
del sistema 00:45:25
tengo que 00:45:26
devolver algo 00:45:27
no puedo dejar 00:45:28
el sistema 00:45:29
que me está 00:45:30
haciendo una 00:45:31
perfección 00:45:32
o dado 00:45:33
liderando 00:45:34
debemos responder 00:45:35
algo que sea 00:45:36
coherente 00:45:37
entonces 00:45:38
lo que yo puedo 00:45:39
hacer es 00:45:40
si me leen 00:45:41
usuarios 00:45:42
cuando devolvo 00:45:43
un usuario 00:45:44
devolver 00:45:45
simplemente 00:45:46
un objeto 00:45:47
y cuando hay 00:45:48
más de uno 00:45:49
devolver 00:45:50
una más 00:45:51
no puedo hacer eso 00:45:52
tengo que edificar 00:45:53
que ese es coherente 00:45:54
entonces 00:45:55
tanto si es éxito 00:45:56
como es fracaso 00:45:57
la edificación 00:45:58
tiene que ser 00:45:59
adecuada 00:46:00
y dependiendo 00:46:02
del nivel de seguridad 00:46:03
deberemos tomar 00:46:05
medidas adicionales 00:46:06
SSL 00:46:08
etc. 00:46:09
todo 00:46:13
el tramado este 00:46:14
puede 00:46:16
disminuir 00:46:17
el rendimiento 00:46:18
porque no solo 00:46:19
tenemos 00:46:20
que 00:46:21
securizar 00:46:22
securizar 00:46:23
significa 00:46:24
ralentizar 00:46:25
muchas veces 00:46:26
hay soluciones 00:46:27
pero claro 00:46:28
tenemos que 00:46:29
tenemos que 00:46:33
valorar 00:46:34
si es adecuado 00:46:35
no hacer esa inversión 00:46:36
entonces 00:46:39
al final 00:46:40
como 00:46:41
la función por ejemplo 00:46:42
de lectura 00:46:43
de todos 00:46:44
los usuarios 00:46:45
me está 00:46:46
ralentizando 00:46:47
porque 00:46:48
5 universidades 00:46:49
o 10 00:46:51
o 2 00:46:52
o 1 00:46:53
o sistema 00:46:54
académico 00:46:55
cuando me den los usuarios 00:46:56
me tumba el sistema 00:46:57
entonces 00:46:58
deberéis limitar 00:46:59
esa funcionalidad 00:47:00
entonces 00:47:01
no únicamente 00:47:02
temas de seguridad 00:47:04
sino que también 00:47:05
el rendimiento 00:47:06
como que 00:47:07
puedo 00:47:08
quiero 00:47:09
o me dejan obedecer 00:47:10
limita 00:47:12
sino que también 00:47:14
temas de rendimiento 00:47:15
también 00:47:16
limita 00:47:17
esa funcionalidad 00:47:18
no puedes limitar 00:47:19
este nivel 00:47:22
conceptual 00:47:23
un poco general 00:47:24
centrado 00:47:27
en principio 00:47:28
a notar 00:47:29
una vez 00:47:32
que hemos visto 00:47:33
que es un servicio web 00:47:34
interoperar 00:47:36
a estándares 00:47:37
que hay que utilizar estándares 00:47:39
y tal 00:47:40
pues 00:47:41
vamos a entrar 00:47:42
que estándares 00:47:43
podemos utilizar 00:47:44
que eso depende 00:47:46
del nivel de integración 00:47:47
que queramos ofrecer 00:47:48
entonces 00:47:49
podemos reforzar 00:47:51
la interoperabilidad 00:47:52
utilizando estándares 00:47:54
estándares 00:47:55
hay capas 00:47:59
de estándares 00:48:00
que 00:48:01
los estándares que os 00:48:02
que vamos a ver 00:48:04
que los debo explicar 00:48:05
simplemente mencionar 00:48:06
nos sirven para 00:48:08
aumentar 00:48:09
la interoperabilidad 00:48:10
interoperabilidad 00:48:12
con dos 00:48:14
diferentes niveles 00:48:15
que 00:48:16
os voy a mencionar 00:48:19
por ejemplo 00:48:20
si queremos 00:48:21
aumentar 00:48:22
la interoperabilidad 00:48:23
con 00:48:25
el nivel de 00:48:27
arquitectura 00:48:28
podemos utilizar esto 00:48:29
de estándares 00:48:30
por ejemplo 00:48:31
el Corda 00:48:32
estandartiza 00:48:35
la federación 00:48:36
de búsquedas 00:48:37
de repositorios 00:48:38
y recursos de aprendizaje 00:48:39
o DNS 00:48:41
que es 00:48:42
el elemento 00:48:43
más famoso 00:48:44
que realiza estándares 00:48:45
ofrece 00:48:48
interoperabilidad 00:48:49
entre 00:48:50
la capa 00:48:51
en la capa de aplicaciones 00:48:52
que las aplicaciones 00:48:53
sean interoperables 00:48:54
y fácilmente 00:48:55
arquitectura 00:48:58
escalar 00:48:59
por ejemplo 00:49:02
aquí 00:49:03
podríamos 00:49:04
también ver 00:49:05
el estándar 00:49:06
no sé si lo conocéis 00:49:07
pero 00:49:08
famoso 00:49:09
bueno, después 00:49:15
si queremos 00:49:16
estandarejar 00:49:17
competencias 00:49:18
por ejemplo 00:49:19
el ministerio 00:49:20
el ministerio del espacio 00:49:22
le digo bueno pues 00:49:23
defino que 00:49:24
estas competencias 00:49:25
para 00:49:26
grado 00:49:27
tiene que tener estas competencias 00:49:31
entonces 00:49:33
nuestro sistema 00:49:34
nuestra aplicación 00:49:35
ya digo nuestra aplicación 00:49:37
ya no me han activado google 00:49:38
puede 00:49:40
hacer 00:49:41
intercambio 00:49:42
de decisiones 00:49:43
de competencias 00:49:44
mediante por ejemplo 00:49:45
este estándar 00:49:46
entonces 00:49:47
el teoría 00:49:48
ese estándar 00:49:49
se puede 00:49:50
en la universidad 00:49:51
por ejemplo 00:49:52
pueden ir a consultar 00:49:53
este en este caso 00:49:56
para 00:49:58
preguntar 00:49:59
que competencias 00:50:00
básicas deben tener 00:50:01
y si nosotros 00:50:02
queremos añadir 00:50:03
añadimos 00:50:04
y eso ya va 00:50:05
pero 00:50:06
podemos 00:50:07
consultar por ejemplo 00:50:08
estamos en 00:50:10
grado de informática 00:50:12
pues vamos a ver 00:50:13
el MI 00:50:14
que 00:50:15
que competencias 00:50:16
ofrece 00:50:17
podemos consultar 00:50:18
podemos interoperar con ellos 00:50:19
importar 00:50:22
ese contenido 00:50:23
después existe 00:50:24
otros estándares 00:50:27
por ejemplo 00:50:29
el de datos 00:50:30
otros codos 00:50:31
este por ejemplo 00:50:32
es el europeo 00:50:33
y después de contenidos 00:50:34
todos 00:50:35
todos 00:50:36
hemos oído hablar 00:50:37
consultado otra vez 00:50:39
que es el IMS 00:50:40
y el FDI 00:50:41
es el intercambio 00:50:42
de metadatos 00:50:43
estructurales 00:50:44
meta 00:50:45
el europeo de intercambio 00:50:46
entre diferentes 00:50:47
categorizaciones 00:50:48
que no tienen nada 00:50:49
que ver 00:50:50
con otra 00:50:51
por ejemplo 00:50:52
esta 00:50:53
escrita en php 00:50:54
y la otra está 00:50:55
en xml 00:50:56
por la misma 00:50:57
meta 00:50:58
etc 00:50:59
bueno 00:51:00
capas de metadatos 00:51:01
tenemos este 00:51:02
este estándar 00:51:06
y por ejemplo 00:51:07
en el intercambio 00:51:08
de información 00:51:09
de usuarios 00:51:10
podemos utilizar 00:51:11
el IMS 00:51:12
interfax 00:51:13
que es un estándar 00:51:14
que por ejemplo 00:51:15
Moodle no lleva 00:51:16
implementado 00:51:17
que es 00:51:18
que permite 00:51:19
definir 00:51:20
exactamente 00:51:21
usuarios 00:51:23
con bastantes 00:51:24
capos 00:51:25
y paratoridades 00:51:26
cursos 00:51:27
y sus matriculas 00:51:28
correspondientes 00:51:29
entonces 00:51:30
yo lo digo 00:51:31
con esto 00:51:32
bueno 00:51:33
pero aparte 00:51:34
existen otros 00:51:35
yo lo digo 00:51:36
que 00:51:37
Moodle 00:51:38
intervente 00:51:39
todo esto 00:51:40
pero 00:51:41
se implementan 00:51:43
esto 00:51:44
de estándares 00:51:45
los sistemas 00:51:46
serán más 00:51:47
interoperables 00:51:48
entonces 00:51:49
teóricamente 00:51:50
tiene que ser 00:51:51
mejor eso 00:51:52
intente 00:51:53
fácil 00:51:54
traspaso 00:51:55
de información 00:51:56
y ejecución 00:51:57
sus 00:51:59
dinámicas 00:52:00
bueno 00:52:01
que estrategias 00:52:02
puedo 00:52:03
utilizar 00:52:04
para 00:52:05
este tipo 00:52:06
actividades 00:52:09
implementación 00:52:11
WebServices 00:52:13
pues 00:52:14
por una parte 00:52:15
puedo empezar 00:52:16
definir 00:52:18
WebServices 00:52:19
por ejemplo 00:52:20
Moodle 00:52:21
no trabaja 00:52:22
para definir 00:52:23
WebServices 00:52:24
y por otra parte 00:52:25
podíamos 00:52:26
podemos 00:52:28
implementar 00:52:29
estandarización 00:52:31
con los 00:52:32
estándares 00:52:33
que 00:52:34
he mencionado 00:52:35
para 00:52:36
la transferencia 00:52:37
de datos 00:52:38
entonces 00:52:39
podemos ir 00:52:40
por partes 00:52:41
separadas 00:52:42
empezamos 00:52:43
con uno 00:52:44
y después nos metemos 00:52:45
con otro 00:52:46
y después con otro 00:52:47
y después con otro 00:52:48
bien 00:52:50
realmente 00:52:51
vamos 00:52:52
todos a la vez 00:52:53
a nivel de 00:52:54
estándares 00:52:55
por lo que 00:52:56
yo llamo 00:52:57
como la bastida 00:52:58
que 00:52:59
a la estandarización 00:53:00
todo 00:53:01
seguro que 00:53:02
que 00:53:03
pero bueno 00:53:04
son diferentes 00:53:05
las reglas 00:53:06
entonces 00:53:07
vamos a ver 00:53:09
en el caso práctico 00:53:11
que 00:53:14
bien 00:53:16
para que 00:53:30
los que 00:53:31
os he pasado 00:53:32
la máquina 00:53:33
virtual 00:53:34
que he 00:53:35
creado 00:53:36
el usuario 00:53:37
es Acme 00:53:38
y la contraseña 00:53:39
para que 00:53:41
podáis 00:53:42
entrar en 00:53:43
el mundo 00:53:44
como 00:53:45
administradores 00:53:46
entonces 00:53:47
vamos a 00:53:48
empezar 00:53:49
con 00:53:50
caso 00:53:52
práctico 00:53:53
pues 00:53:54
vamos 00:53:55
empezar 00:53:57
con 00:53:58
caso 00:54:00
práctico 00:54:01
que 00:54:02
os he pasado 00:54:03
en el 00:54:04
mundo 00:54:05
pues 00:54:06
vamos a 00:54:07
empezar 00:54:08
con 00:54:09
caso 00:54:11
práctico 00:54:12
pues 00:54:13
vamos 00:54:14
empezar 00:54:16
con 00:54:17
caso 00:54:19
práctico 00:54:20
pues 00:54:21
vamos 00:54:22
empezar 00:54:24
con 00:54:25
caso 00:54:27
que 00:54:28
que 00:54:31
nos 00:54:32
nos 00:54:33
nos 00:54:34
nos 00:54:35
nos 00:54:36
nos 00:54:37
nos 00:54:38
nos 00:54:39
nos 00:54:40
nos 00:54:41
nos 00:54:44
nos 00:54:45
nos 00:54:46
mapa 00:54:47
que 00:54:48
nos 00:54:49
nos 00:54:50
nos 00:54:51
nos 00:54:52
matam 00:54:53
mapa 00:54:56
asas 00:54:57
nos 00:54:58
nos 00:54:59
nos 00:55:00
nos 00:55:01
nos 00:55:02
nos 00:55:03
nos 00:55:04
nos 00:55:05
nos 00:55:06
nos 00:55:07
nos 00:55:08
nos 00:55:09
nos 00:55:10
nos 00:55:11
nos 00:55:12
nos 00:55:13
nos 00:55:14
nos 00:55:15
nos 00:55:16
nos 00:55:17
nos 00:55:18
nos 00:55:19
nos 00:55:20
nos 00:55:21
nos 00:55:22
nos 00:55:23
nos 00:55:24
nos 00:55:25
nos 00:55:26
nos 00:55:27
nos 00:55:28
nos 00:55:29
nos 00:55:30
nos 00:55:31
nos 00:55:32
nos 00:55:33
nos 00:55:34
nos 00:55:35
nos 00:55:36
nos 00:55:37
nos 00:55:38
nos 00:55:39
nos 00:55:40
nos 00:55:41
nos 00:55:42
nos 00:55:43
nos 00:55:44
nos 00:55:45
nos 00:55:46
nos 00:55:47
nos 00:55:48
nos 00:55:49
nos 00:55:50
nos 00:55:51
nos 00:55:52
nos 00:55:53
nos 00:55:54
Apoyar por que a Moodle 00:55:55
Apoyar por que a Moodle 00:55:59
Apoyar por que a Moogle 00:56:01
Encontraremos diferentes partes 00:56:37
Información general de como están configurados 00:56:55
E o Moodle ofrece dois tipos de ofrecendas 00:56:59
Podemos dizer que un sistema remoto controle parte do Moodle 00:57:12
Neste caso, o sistema de atención agraria podría controlar parte do sistema Moodle 00:57:21
O que os próprios usuarios que estén autorizados 00:57:29
Poden conectarse e usar os elementos web que ofrecemos 00:57:34
Cada uno deles tiñe unha configuración 00:57:40
Para un sistema que controla, que é un pouco máis importante definir 00:57:53
O sistema interno que é máis fácil de ver 00:58:00
Podemos administrar protocodos e administrar usuarios 00:58:09
Que protocodos utilizamos? 00:58:20
Os he mencionado XMF e RFC 00:58:22
Estes dois están soportados por Moodle 00:58:28
Pero non únicamente estes dois 00:58:31
Porque estos protocolos 00:58:35
Habitualmente se programan en entornos PHP, Python, Google Digital 00:58:43
Por exemplo, o protocolo REST é bastante utilizado en entornos ARM 00:58:53
E, evidentemente, o .NET 00:59:01
A parte disto, hai bastantes más 00:59:07
Configuraciónes máis de protocodos 00:59:10
Según o equipo de desarrollo 00:59:13
Que, por exemplo, se non sabéis 00:59:19
A parte do Moodle que está metido no grupo de grupo 00:59:22
Dinámicos para todos os protocolos 00:59:30
E o que os he comentado 00:59:36
Vamos ao bloque de administración 00:59:39
Relamos 00:59:48
Clicamos sobre Advance 00:59:52
Advance 00:59:54
E, se vamos abaixo 00:59:58
Véis que, por defecto, non viene a habilitar 01:00:04
Entón, o que hai de fazer é habilitar 01:00:09
Relamos e guardamos cambios 01:00:17
Relamos 01:00:24
Unha vez guardado 01:00:31
Nos vamos ao Plugins 01:00:36
Web Service 01:00:39
Overview 01:00:43
O que é o que he dicho 01:00:50
Nos dámos 2 formas 01:00:52
O sistemas controlados externos 01:00:57
O usuarios 01:01:00
Como clientes 01:01:03
Vamos a ver uno 01:01:11
E vamos a ver o sistema controlado por una aplicación externa 01:01:13
Que é moito máis amplio 01:01:16
Son las mismas dos CERN 01:01:18
E tenen moito máis ansias 01:01:19
E un poquillo máis complexos 01:01:20
E vemos este tamén 01:01:22
Intuícitamente vemos o dobro 01:01:24
Entón, o primero que nos dice 01:01:26
Que o protocolo 01:01:28
Os Web Service están habilitados 01:01:32
Se non os vieramos habilitados 01:01:35
Nos harían 01:01:37
A segunda parte nos dice 01:01:40
Os protocolos que tenemos habilitados 01:01:44
En este caso 01:01:46
Aún non tenemos ningún protocolo habilitado 01:01:47
Porque nos decidimos 01:01:50
Que protocolos 01:01:52
Ofrecemos 01:01:54
Entón 01:02:00
En esa pantallita 01:02:03
Se ve que 01:02:04
Tenen os cuatro protocolos 01:02:06
E teóricamente 01:02:10
Puedes instalar 01:02:12
E desinstalar protocolos 01:02:14
Si, perfecto 01:02:16
Algún 01:02:18
Algún desarrollador 01:02:21
Crea un novo protocolo 01:02:23
Lo pode instalar 01:02:27
E le aparecerían 01:02:29
Lo que agora mesmo non está implementado 01:02:33
Como a partir de la Google 2 01:02:36
1, 2, 2, 2, 3 01:02:38
Ya estarán 01:02:40
Implementados 01:02:43
Y cabe mencionar que 01:02:45
Ahora mismo 01:02:46
Desinstalar 01:02:47
Tampoco está implementado 01:02:48
Entón 01:02:51
Aunque nos aparezca el link 01:02:52
Non lo vamos a hacer 01:02:54
Vale 01:02:55
Dime 01:02:58
Activar, desactivar aquí el XMLRPC 01:02:59
E incluiría en este set del 4 01:03:01
Desactivar aquí el XMLRPC 01:03:03
E incluiría en este set del 4 01:03:05
Desactivar aquí el XMLRPC 01:03:11
Incluiría en el model del 4 01:03:14
Y si yo tengo conectado un model con otro 01:03:16
¿Tiene que ver con esta activación? 01:03:18
No, no, no 01:03:21
Es totalmente diferente 01:03:22
Una cosa es 01:03:23
Interconexión del model 01:03:24
El hub 01:03:26
Y otra cosa es 01:03:27
Seguir los protocolos que hacemos 01:03:28
Vale 01:03:31
Por ejemplo 01:03:32
Vamos a activar 01:03:33
SOA 01:03:40
Para activar SOA 01:03:41
Simplemente 01:03:42
Tengo que abrir 01:03:43
Para que se vean bien 01:03:48
Entonces 01:03:49
Después 01:03:54
Hay un parámetro 01:03:55
Justo abajo 01:03:56
Que es 01:03:58
Crear la documentación para este protocolo 01:03:59
O para los diferentes protocolos 01:04:02
Y las funciones 01:04:04
O los servicios que nosotros tenemos 01:04:05
Entonces 01:04:07
Si activamos esta opción 01:04:08
Cuando funcione 01:04:11
Nos generará documentación 01:04:13
Que por ejemplo hemos visto 01:04:15
O muy similar a lo que hemos visto 01:04:17
Cuando lo hemos visto 01:04:19
Vale 01:04:22
Entonces 01:04:23
Os recomiendo que la activemos 01:04:24
Así nos autogenerará la documentación 01:04:26
Y guardamos los cambios 01:04:29
Volvemos 01:04:40
Y ahora ya 01:04:41
Tenemos un protocolo habilitado 01:04:42
La tercera parte que nos requiere 01:04:47
Es crear un usuario completo 01:04:52
Aquí 01:04:57
El sistema es un poco completo 01:04:58
Por que? 01:05:00
Por que podemos crear 01:05:02
Bueno vamos a crear 01:05:03
Ahora mismo 01:05:04
Un usuario 01:05:05
Y ese usuario 01:05:06
Por defecto se crea 01:05:08
Con unos roles 01:05:10
Que es el siguiente caso 01:05:12
Mirad 01:05:14
Que capacidades 01:05:15
Tiene 01:05:16
Que roles 01:05:17
Tiene que 01:05:18
Que permisos 01:05:19
Tiene ese usuario 01:05:21
Según que permisos tenga ese usuario 01:05:23
Podremos o no podremos 01:05:25
Ejecutar 01:05:27
Diferentes funciones 01:05:29
Entonces 01:05:30
Muy probablemente 01:05:32
Tengamos que 01:05:33
Crear 01:05:34
Uno especifico 01:05:35
Y no poner uno general 01:05:37
Para 01:05:41
Ese usuario de aplicación externa 01:05:43
Por que? 01:05:46
Digo uno especifico 01:05:47
Uno general 01:05:48
Por que si por ejemplo 01:05:49
Para simplificar 01:05:50
Para que no tenga que 01:05:51
Tocar toda la barbaridad 01:05:53
De capacidades que están definidas 01:05:55
Para ese role 01:05:57
Y digo bueno 01:05:59
Para que sea administrador 01:06:00
Pues tenemos un 01:06:01
Un gran 01:06:03
Agujero de seguridad 01:06:04
Por que si por ejemplo 01:06:05
Estamos habitando un edificio 01:06:06
De gestión de usuarios 01:06:08
Ese usuario cuando se conecta 01:06:10
A nuestro móvil 01:06:11
Tenga otro administrador 01:06:12
Entonces podrá tocar lo que quiera 01:06:13
No es exactamente así 01:06:18
Pero 01:06:20
Para que lo comprendáis 01:06:21
Podría darse el caso 01:06:22
Vale? 01:06:24
Bueno vamos a crear un usuario 01:06:26
Se supone que todos lo sabéis hacer 01:06:29
Le ponemos nombre a aplicación 01:06:39
Por defecto 01:06:57
Muy bien está configurado 01:07:00
Para que sean cosas manuales 01:07:01
Pues aquí 01:07:03
Si desplegamos 01:07:05
La autenticación 01:07:06
En ese usuario 01:07:07
La última de todas 01:07:08
Es autenticación 01:07:10
Vía webseries 01:07:11
Entonces 01:07:12
Si nosotros creamos un usuario 01:07:13
Y no veamos 01:07:14
La autenticación 01:07:15
En ese usuario 01:07:16
Podrá ejecutar 01:07:17
Ninguna 01:07:18
Ningún webseries 01:07:19
Porque no estará autenticada 01:07:20
En nuestro sistema 01:07:21
Vale? 01:07:24
Si tenemos usuarios 01:07:25
Nuestros 01:07:27
Que vengan a dar la autenticación 01:07:28
La otra parte 01:07:30
No sería necesario 01:07:33
Pero como estamos creando 01:07:34
Una autenticación externa 01:07:35
En conjunto 01:07:36
De parte de nuestro sistema 01:07:37
Vale? 01:07:39
Habeis entendido? 01:07:41
Ahorita 01:07:46
No le ponemos 01:07:47
The password 01:07:48
Pues el mismo que 01:07:50
Que tengamos con los listadores 01:07:52
Es igual 01:07:53
Al que queráis 01:07:56
Mientras respetéis 01:07:57
El estándar 01:07:59
Está definido en Google 01:08:01
Vamos generando los campos 01:08:13
Si, lo mínimo 01:08:25
Lo mínimo porque 01:08:38
Como estamos creando 01:08:39
Un usuario 01:08:40
Con el voluntario 01:08:41
Pues 01:08:42
Tenemos que dar 01:08:43
Los campos mínimos 01:08:44
Ahora 01:08:50
Hay que editar 01:08:51
Unos minutos 01:08:55
Llegamos 01:09:02
Bueno, hemos creado 01:09:09
El otro desde 01:09:11
El taller que 01:09:12
En este mismo taller 01:09:13
Que teníamos 01:09:14
Vale? 01:09:16
Tenemos un usuario nuevo 01:09:17
Como si fuera 01:09:18
Otro 01:09:19
Más 01:09:20
De nuestro sistema 01:09:21
Model 01:09:22
Vale? 01:09:23
Pero 01:09:24
Una vez 01:09:26
Creado este usuario 01:09:30
Una cosa importantísima 01:09:34
Que hay que hacer 01:09:35
Habilitar 01:09:37
El método 01:09:38
De la autenticación 01:09:39
Vía 01:09:40
Website 01:09:41
Como sabéis 01:09:42
Bluebees 01:09:49
Authentication 01:09:50
Bueno 01:09:51
En Google 01:09:52
Desde el 1.9 01:09:53
Para abajo 01:09:54
Estaba el usuario 01:09:55
De autenticación 01:09:56
O curso de autenticación 01:09:57
No me acuerdo 01:09:58
Pero ahora está mutado 01:09:59
Si vamos 01:10:03
A los métodos de autenticación 01:10:05
Que nuestro site 01:10:06
Permite 01:10:08
Justo abajo del todo 01:10:10
Están 01:10:12
Los websites 01:10:13
De autenticación 01:10:14
Entonces 01:10:16
Tenemos que 01:10:17
Habilitarlo 01:10:18
Porque podemos crear 01:10:19
Podemos crear servicios 01:10:20
Funciones, etc 01:10:21
Pero si no tenemos 01:10:22
Autenticación 01:10:23
Ese usuario 01:10:24
Tampoco va a entrar 01:10:25
Vale? 01:10:28
Entonces 01:10:32
Si lo hice 01:10:33
Abrimos 01:10:36
Un poco de guardar 01:10:41
De acuerdo? 01:10:45
Y ahora 01:10:48
Si que 01:10:49
Ese usuario 01:10:50
Podrá conectar 01:10:51
A nuestro 01:10:52
De acuerdo? 01:10:55
Vamos 01:11:00
A más 01:11:03
Para simplificar 01:11:14
No voy a crear 01:11:16
Bueno 01:11:18
Para simplificar 01:11:20
Usage 01:11:21
Para la publicidad 01:11:22
O sea 01:11:23
Los permisos que tiene 01:11:24
Ese usuario 01:11:25
Veremos que línea 01:11:27
De lo que dijimos 01:11:28
Me parece que 01:11:29
Por defecto 01:11:30
Es usuario autenticado 01:11:31
O algo así 01:11:32
O estudiante 01:11:33
O usuario 01:11:34
Algo así 01:11:36
Lo que tenemos 01:11:39
Lo que tendríamos 01:11:40
Que hacer ahora mismo 01:11:41
Ir a node 01:11:43
Ese nuevo node 01:11:44
Es crear un nuevo node 01:11:45
Y asignar 01:11:46
Los permisos 01:11:47
Que queramos 01:11:48
Como mínimo 01:11:49
Debería tener 01:11:51
Como mínimo 01:12:19
Debería tener 01:12:20
Las capacidades 01:12:21
Que tenemos 01:12:24
Habilitadas 01:12:25
En este ejemplo 01:12:26
Que he hablado 01:12:27
Tenemos 01:12:28
Habilitado 01:12:29
El protocolo SOA 01:12:30
Entonces 01:12:31
Ese node 01:12:32
Que creemos 01:12:34
Debe tener 01:12:35
Como mínimo 01:12:36
Poder usar 01:12:37
SOA 01:12:38
Si no tiene 01:12:39
Este permiso 01:12:40
No lo podremos hacer 01:12:41
Aparte de los otros 01:12:44
Que otros 01:12:47
Hablamos de 01:12:48
De acuerdo 01:12:50
Entonces 01:12:52
Como 01:12:53
Voy a simplificar 01:12:54
Y voy a utilizar 01:12:55
El node administrador 01:12:56
Para hacer esta cosa 01:12:57
Este ejemplo 01:12:59
Pues 01:13:00
Voy a habilitarlo 01:13:01
Vamos a ver 01:13:06
Vamos a ver 01:13:19
Ahí 01:13:21
Igual no? 01:13:24
Alguna duda? 01:13:36
Aquella que vio 01:13:38
No sé que me está grabando 01:13:49
Mira 01:14:00
Me acerco 01:14:03
Porque no veo 01:14:04
Después 01:14:08
Sigue 01:14:10
Sí 01:14:19
Vale 01:14:24
Tenemos que ir 01:14:25
Bueno 01:14:27
Una vez 01:14:28
Habilitada la autenticación 01:14:29
Tenemos que dar 01:14:31
La capacidad 01:14:32
O sea 01:14:33
Teóricamente 01:14:36
Debo ir a Sanseguro 01:14:37
Es crear un role 01:14:38
Un role 01:14:41
Como 01:14:42
Administrador 01:14:43
Estudiante 01:14:44
Nuevo 01:14:45
Que sea 01:14:46
Y como mínimo 01:14:48
A ese role 01:14:49
Darle 01:14:50
El permiso 01:14:51
Para utilizar 01:14:52
Los protocolos 01:14:53
Que anteriormente 01:14:54
Tenemos 01:14:55
Habilitado 01:14:57
¿Por qué? 01:14:58
Porque si no 01:14:59
No lo puedo utilizar 01:15:00
Entonces 01:15:01
Por mucha conexión 01:15:02
Web service 01:15:03
Que queramos 01:15:04
De ese usuario 01:15:05
No lo podrá 01:15:06
Habilitar 01:15:07
Eso es lo que 01:15:08
Teóricamente 01:15:09
Lo que he hecho yo 01:15:10
Es ir al administrador 01:15:11
Para simplificar 01:15:12
Y le he dado el permiso 01:15:13
Que no ha venido 01:15:14
Teóricamente 01:15:15
No ha venido 01:15:16
Seguimos 01:15:23
No, es la misma 01:15:30
Web service overview 01:15:31
Bluebeams 01:15:40
Web service overview 01:15:41
Bueno 01:15:44
Una vez tenemos 01:15:45
Bueno 01:15:47
Me he dejado 01:15:48
Una cosa importante 01:15:49
Tenemos que 01:15:50
A ese usuario 01:15:51
Que acabamos de crear 01:15:52
Darle 01:15:54
El role 01:15:55
Loan 01:15:56
Del 01:15:57
Role 01:15:58
Que también 01:15:59
Acabamos de crear 01:16:00
Entonces voy a hacer 01:16:01
Me voy 01:16:02
A un tiempo 01:16:05
Permiso 01:16:16
Save 01:16:17
Permiso 01:16:25
Así 01:16:27
Sisto el permiso 01:16:28
Me voy 01:16:31
A manager 01:16:33
Y le digo 01:16:34
Que programa 01:16:35
Que el usuario 01:16:37
Que acabo de 01:16:38
Crear 01:16:40
Tenga ese role 01:16:42
Simplemente asignar 01:16:43
Un role de sistema 01:16:44
A un usuario 01:16:45
Teóricamente 01:16:46
Si sois administradores 01:16:48
Lo habéis hecho 01:16:50
Un montón de veces 01:16:51
Tampoco tiene demasiada complicación 01:16:53
Bueno 01:17:03
Una vez hecho 01:17:04
Estos pasos 01:17:05
Másicos 01:17:06
Ahora vamos a crear 01:17:07
El servicio web 01:17:09
Para crear el servicio web 01:17:10
Vamos 01:17:12
Al paso número 5 01:17:13
Que es 01:17:15
Save web service 01:17:16
Y aquí 01:17:20
Vemos que no tenemos 01:17:22
Creados 01:17:23
Ningún servicio web 01:17:24
Aquí nos saldrían 01:17:25
Los seres 01:17:26
Servicios web 01:17:27
Que tenemos habilitados 01:17:28
Y añadimos uno 01:17:29
Por ejemplo 01:17:35
Gestión del usuario 01:17:36
Estamos 01:17:41
Gestión del usuario 01:17:44
Que podemos 01:17:46
Bueno, tenéis que clicar 01:17:47
Para ver todos los 01:17:49
Los 01:17:50
Las que nos han enseñado 01:17:51
Las formas y cuentas 01:17:52
Y tenéis que ir 01:17:54
Partiendo todos los casos 01:17:55
Tenemos que habilitarlo 01:18:01
Porque ese servicio web 01:18:03
Lo hemos habilitado 01:18:04
Desaí 01:18:05
Nosotros marcaremos 01:18:08
Como habilitado 01:18:10
Daremos 01:18:17
Habilitaremos 01:18:20
O sea podemos 01:18:21
Generar dos tipos 01:18:23
De seguridad 01:18:24
Para ese servicio web 01:18:25
O dos tipos de características 01:18:27
De ejecución 01:18:29
O decir 01:18:31
Exactamente 01:18:32
Que usuarios 01:18:34
Pueden ejecutarlo 01:18:35
Para no 01:18:39
Liarme 01:18:41
En ir 01:18:43
Y habilitar 01:18:44
A ciertos usuarios 01:18:45
Por ejemplo 01:18:46
Como algo muy exagerado 01:18:47
Puede decir pues 01:18:50
Que 01:18:51
El usuario 01:18:52
Que se intente conectar 01:18:53
O intente utilizar 01:18:55
Ese servicio web 01:18:56
Pues deberá tener 01:18:58
Yo que sé 01:19:00
El primero deberá 01:19:01
El user 01:19:03
De deep profile 01:19:04
Pues si ese usuario 01:19:06
Que está en el sistema 01:19:08
Tiene esa capacidad 01:19:10
Podrá utilizar ese servicio 01:19:16
Entonces 01:19:17
Podemos hacerlo de dos formas 01:19:20
Si habilizamos 01:19:24
Usuarios 01:19:26
Autorizados 01:19:28
Tendremos que añadirlo 01:19:29
Si tiene esa capacidad 01:19:31
Como rol global 01:19:32
Pode 01:19:33
En cualquier parte del sistema 01:19:34
Como rol global 01:19:36
Y eso 01:19:39
Y después 01:19:43
Lo que podemos hacer 01:19:44
Es que 01:19:45
Si requerimos esa capacidad 01:19:46
Pues a ese 01:19:47
Al rol 01:19:49
Que acabamos de crear 01:19:50
Para el usuario 01:19:51
Debemos 01:19:52
Debemos darle 01:19:53
Esa capacidad 01:19:54
¿Entendéis? 01:19:56
Rol que acabamos de crear 01:19:57
O ese 01:19:58
Que debemos 01:19:59
Darle pues 01:20:00
Esa capacidad 01:20:02
De aquí 01:20:03
Cualquiera 01:20:04
La que sea 01:20:05
Entonces debemos 01:20:06
Dar el rol 01:20:07
¿De acuerdo? 01:20:09
Vamos a hacerlo de dos formas 01:20:10
Yo utilizaré 01:20:11
De usuarios 01:20:12
Autorizados 01:20:13
Porque habitualmente 01:20:14
Suelen ser usuarios 01:20:15
Muy entre 01:20:16
Pocos y escudos 01:20:17
Entonces 01:20:20
Yo agredito este 01:20:21
Y le 01:20:22
Acabo de crear 01:20:24
Ese servicio web 01:20:25
Pero ese servicio web 01:20:27
No haga nada 01:20:28
Porque no 01:20:30
Le he dicho 01:20:31
Que funciones 01:20:32
Puede ejecutar 01:20:33
Porque un servicio web 01:20:35
Puede estar 01:20:36
Puede ejecutar 01:20:37
N funciones 01:20:38
Puede ejecutar 01:20:39
N métodos 01:20:40
Para hacer 01:20:42
Forma 01:20:43
Entonces ahora 01:20:45
Debemos 01:20:48
Añadir 01:20:49
Las funciones 01:20:56
Damos 01:20:58
Añadir 01:20:59
Y elegimos 01:21:00
Que funciones 01:21:01
Perdimos 01:21:02
De utilizar 01:21:03
Ese servicio web 01:21:04
Y ahora diréis 01:21:07
¿Esto de donde viene? 01:21:08
Eso es lo que veremos despues 01:21:09
Baseado en el código 01:21:12
On programadores 01:21:13
A nivel de programacio 01:21:14
Porque únicamente 01:21:15
Se puede 01:21:16
Quan tú creas 01:21:17
Si un 01:21:18
Modulo adicionado 01:21:20
Por ejemplo 01:21:21
Tú vas a decir 01:21:22
Pues esta función 01:21:23
Esta funcion 01:21:24
Esta función 01:21:25
Van a 01:21:26
Poderse utilizar 01:21:27
Para el servicio web 01:21:28
Lo que suele ser 01:21:29
Es casi 01:21:30
Utilizar para el servicio web 01:21:31
Veremos como hacerlo 01:21:33
Y como implementarlo 01:21:34
Todas estas funciones 01:21:38
Están implementadas 01:21:39
Ya con el servicio web 01:21:40
Todas estas funciones 01:21:41
A dia de hoy 01:21:42
Están implementadas 01:21:43
Lo que no todas 01:21:44
Funcionan correctamente 01:21:45
Esa es la historia 01:21:48
Vale 01:21:52
De acuerdo 01:21:58
Vale 01:21:59
Por ejemplo 01:22:02
Seleccionamos 01:22:05
Como estamos en gestión 01:22:07
De usuario 01:22:08
Seleccionamos 01:22:11
Las cuatro 01:22:12
Las cuatro ultimas funciones 01:22:13
Que son de usuario 01:22:14
Y le damos al botón 01:22:16
De añadir funciones 01:22:17
Seleccionamos 01:22:20
Y añadimos 01:22:21
Y la pantalla 01:22:23
Que nos ofrece 01:22:24
Ahora mismo 01:22:25
Munde de 01:22:26
Tienes 01:22:27
Estas funciones 01:22:28
Estas funciones 01:22:29
Una pequena descripción 01:22:32
Esta descripción 01:22:33
Llame 01:22:34
Donde se impone 01:22:35
Donde se añade 01:22:36
Con la posibilidad 01:22:38
De eliminar 01:22:40
Esas funciones 01:22:41
Se nos equivocamos 01:22:42
Yo me tiro 01:22:43
La gestión 01:22:44
O la creación 01:22:45
De grupos 01:22:46
Me equivoco 01:22:47
La puedo eliminar 01:22:48
Y eso sigue 01:22:49
Y cuando creas 01:22:53
Una función 01:22:54
Tu como desarrollador 01:22:55
Dices 01:22:56
Para ejecutar 01:22:57
Yo que se 01:23:03
La creación de usuarios 01:23:04
El usuario 01:23:07
Que quiera 01:23:08
Ejecutar 01:23:09
Esa función 01:23:13
Esteja web 01:23:14
Tiene que tener la capacidad 01:23:16
Que por ejemplo 01:23:18
La de crear 01:23:20
Mude 01:23:21
Barra 01:23:22
Use 01:23:23
Dos grupos creados 01:23:24
Si no tiene esa capacidad 01:23:26
Por mucho que digamos 01:23:28
Que 01:23:29
Un usuario este 01:23:30
Capacitado 01:23:31
Para utilizar 01:23:32
Ese servicio web 01:23:33
Y ese servicio web 01:23:35
Este 01:23:36
Habilitado 01:23:37
A ejecutar esa función 01:23:38
Si no tiene esa capacidad 01:23:40
Ese usuario 01:23:41
No lo podrá ejecutar 01:23:42
Entonces 01:23:43
Ahora es cuando 01:23:44
Volvemos 01:23:45
A la exhibición 01:23:46
Del role que hemos creado 01:23:47
Y habilitamos estas capacidades 01:23:49
Nos preocupeis 01:23:51
Porque 01:23:53
Cuando 01:23:55
En una pantalla 01:23:58
Que veremos ahora 01:23:59
Dice 01:24:02
Mude ya te informa 01:24:04
De que 01:24:05
A ese usuario 01:24:06
Le están faltando 01:24:07
Esas capacidades 01:24:08
Entonces 01:24:09
Que por mucho que este 01:24:10
Habilitado 01:24:11
No lo podrá ejecutar 01:24:12
Y eso lo veremos 01:24:13
Ahora 01:24:14
A continuación 01:24:15
Cuando 01:24:16
Definamos 01:24:18
Que usuario 01:24:19
Le están autorizando 01:24:20
De ejecutar ese servicio web 01:24:21
Vamos allá 01:24:23
Ya vereis que 01:24:35
De primero 01:24:37
Me ha saltado 01:24:38
Del 01:24:39
Punto número 5 01:24:40
Me ha saltado 01:24:41
Al punto número 6 directamente 01:24:42
Y ahora 01:24:44
Vamos a seleccionar 01:24:45
Ese 01:24:48
El usuario 01:24:49
Lo podemos 01:24:51
Podemos ir directamente 01:24:52
Desde el punto número 7 01:24:53
Si vemos 01:24:56
Si vamos 01:24:57
A los servicios web 01:24:59
También existe 01:25:01
La posibilidad de ir directamente 01:25:04
Que es necesario o no 01:25:07
Eso ya depende 01:25:08
Del servicio web 01:25:09
Si hemos marcado 01:25:11
Que son los que ejecuten 01:25:13
Usuarios autorizados 01:25:15
O va por capacidades 01:25:16
Entonces 01:25:18
Usuarios autorizados 01:25:22
Añadimos el usuario 01:25:27
Que acabamos de crear 01:25:28
Y ahora es cuando 01:25:31
Vamos a verlo 01:25:33
Y aquí 01:25:36
Si no hubiese esa capacidad 01:25:37
Nos dirían ellos 01:25:40
Que el usuario 01:25:42
O el usuario 01:25:44
Le faltan dos 01:25:45
Le faltan todas 01:25:46
Esas capacidades 01:25:47
Para poder ejecutar 01:25:48
Ese servicio web 01:25:50
Entonces 01:25:51
Añadimos 01:25:52
Pero no te dicen 01:25:53
De ahí 01:25:54
Ya tu 01:25:56
Yo como administrador 01:25:57
Ya vas ahí 01:25:58
Lo decimos 01:25:59
De acuerdo 01:26:00
Y bueno 01:26:12
Y ahora 01:26:14
Es cuando va a cerrar 01:26:16
Porque vamos a cerrarlo 01:26:18
Y ahora mismo va a cerrar 01:26:20
Pero vosotros vamos a ver 01:26:21
Entonces 01:26:23
Antes de utilizarlo 01:26:27
Vamos a ver 01:26:29
Una característica 01:26:31
De autenticación 01:26:32
Que es 01:26:35
La autenticación 01:26:37
De un usuario 01:26:39
Para un servicio 01:26:41
Mediante un token 01:26:42
Entonces 01:26:45
¿Cómo hacemos eso? 01:26:47
Pues 01:26:49
En el punto número 8 01:26:50
Eso es opcional 01:26:51
Eso ya 01:26:52
O sirve 01:26:57
Para que nuestros usuarios 01:26:58
O tengan que ver 01:26:59
Este 01:27:00
En vez de usuario y contraseña 01:27:01
O directamente con el token 01:27:03
Moodle ya sabe 01:27:05
Si es el usuario 01:27:07
Puede ejecutar ese servicio 01:27:08
Y directamente se autentica 01:27:09
Pues padre 01:27:11
Si eso ya lo hace 01:27:12
Vendo la autenticación 01:27:13
Ya lo hace 01:27:14
Entonces 01:27:22
Para 01:27:28
Al darle 01:27:31
A crear ese token 01:27:32
Buscamos 01:27:35
El usuario concreto 01:27:37
Aquí como tenemos 01:27:38
Si no 01:27:40
Tenemos más facilidad 01:27:42
Buscamos el usuario 01:27:43
Le damos 01:27:44
Definimos que servicio 01:27:47
Que estamos 01:27:49
Vamos a crear ese token 01:27:50
Aquí 01:27:52
Saldrían todos los servicios 01:27:53
Que tuviéramos definido 01:27:54
En nuestro nuevo sistema 01:27:56
Moodle 01:27:57
Y aparte 01:28:00
Existen 01:28:01
Dos tipos de restricciones 01:28:02
Podemos restringir 01:28:06
Por intento 01:28:08
Podemos decir 01:28:10
Ese usuario 01:28:11
Ese servicio web 01:28:13
Solo se podrá conectar 01:28:14
Desde esa máquina 01:28:15
Y no 01:28:17
O de esas máquinas 01:28:18
Y no de cualquier otra 01:28:19
Cualquier otra 01:28:21
O podemos decir 01:28:22
Que ese servicio web 01:28:23
De gestión 01:28:24
De gestión académica 01:28:26
De gestión de usuarios 01:28:28
Por ejemplo 01:28:30
Si tuviéramos por años 01:28:31
Gestión 01:28:32
Académica 01:28:33
Por curso académico 01:28:34
Podemos decir 01:28:37
Que está habilitado 01:28:38
Hasta tal día 01:28:39
A partir de esa fecha 01:28:41
Ya no está habilitado 01:28:43
Ese servicio web 01:28:44
De repente 01:28:45
Se desautoriza 01:28:46
A ese usuario 01:28:47
A utilizar 01:28:48
A utilizar 01:28:49
Ese servicio web 01:28:50
Vale? 01:28:52
Y aquí 01:28:53
La IP restricción 01:28:54
La IP 01:28:55
Coma IP 01:28:56
Coma IP 01:28:57
Típico de 01:28:58
Cuestionarios 01:29:00
Creo que es 01:29:01
Vale? 01:29:04
Y ahí 01:29:05
Aparentemente 01:29:06
No podemos ver 01:29:07
Ningún tipo de restricciones 01:29:08
Y ahí vemos 01:29:11
El toque 01:29:14
Pues por eso 01:29:17
Cuando se conecte 01:29:19
A nuestro sistema 01:29:20
Poniendo el parámetro 01:29:22
Se llama W toque 01:29:25
Y esa resta 01:29:31
Ese usuario 01:29:33
Ya estará autorizado 01:29:34
A ejecutar 01:29:35
Ese servicio web 01:29:36
Y directamente 01:29:38
Ya estará autenticado 01:29:39
Si ya no 01:29:40
Si ya no está 01:29:41
Autenticado 01:29:42
O sea 01:29:43
Si quieres autenticar ese toque 01:29:44
Tú lo puedes usar 01:29:45
Literalmente 01:29:46
Sin tener que validar 01:29:47
Nada más 01:29:48
Bueno ya se valió 01:29:49
Automaticamente 01:29:50
Vale? 01:29:51
Y así ya no tendríamos 01:29:52
Passwords 01:29:53
Poder 01:29:54
De acuerdo? 01:29:55
Evidentemente 01:29:58
Si hubiésemos 01:30:00
Especificado 01:30:01
Los dos cargos 01:30:02
Saldrían 01:30:03
Podríamos borrar 01:30:04
Y ahora ya 01:30:08
A vuestra 01:30:09
Podemos testear 01:30:20
El servicio 01:30:21
Que acabamos de crear 01:30:22
Para testearlo 01:30:26
Vamos 01:30:29
Al último punto 01:30:30
Ahora es cuando falla 01:30:35
Evidentemente 01:30:36
Podremos 01:30:40
Esto ya 01:30:43
Ahora ya 01:30:44
A partir de aquí es 01:30:45
Como si fuéramos 01:30:46
Un servicio totalmente externo 01:30:47
Un cliente fuera del Moodle 01:30:49
Que se conecta 01:30:52
A nuestro Moodle 01:30:53
Para saber si funciona o no funciona 01:30:55
Decidimos 01:31:01
Que método de autenticación 01:31:02
Utiliza 01:31:03
Si simple 01:31:04
Como sea 01:31:05
Usuario 01:31:06
Password 01:31:07
O mediante el token 01:31:08
Que acabamos de crear 01:31:09
Podemos simple 01:31:12
Bueno 01:31:15
Esto es como 01:31:16
Un servicio 01:31:17
Después vendremos 01:31:21
Utilizaremos el protocolo 01:31:22
Si tuvieramos 01:31:23
Los cuatro 01:31:24
Porque no sabíamos cuatro 01:31:25
Aquí 01:31:29
Por ejemplo 01:31:31
Crearemos un usuario 01:31:32
Esto lo ponemos 01:31:36
En la piel del cliente 01:31:38
Nos autenticamos 01:31:46
Aquí especificaríamos 01:32:01
El usuario 01:32:02
Y el password 01:32:03
Si fuera token 01:32:04
Pues aquí nos saldría token 01:32:05
Y aquí 01:32:06
Los parámetros 01:32:07
Del usuario 01:32:08
Que queremos crear 01:32:09
Que parámetros 01:32:10
Podremos enviar 01:32:11
Pues los que permitan 01:32:12
La función 01:32:13
Bueno 01:32:14
Ahora 01:32:15
Podemos 01:32:16
Enviar 01:32:17
Los parámetros 01:32:18
Que nos permitan 01:32:19
La función 01:32:20
Y aquí 01:32:21
Podemos 01:32:22
Enviar 01:32:23
Los parámetros 01:32:24
Que nos permitan 01:32:25
La función 01:32:26
Y aquí 01:32:27
Podemos enviar 01:32:28
Los parámetros 01:32:29
Bueno aquí 01:32:31
Podríamos 01:32:32
Debe ser 01:32:33
Usuario 01:32:38
Password 01:32:39
Usuario 01:32:40
Ponemos cualquier 01:32:49
Y cuando le damos 01:32:50
A ejecutar 01:32:51
Directamente 01:32:54
Debería funcionar 01:32:57
Y efectivamente 01:32:58
Ha funcionado 01:32:59
Y eso es lo que nos devuelve 01:33:04
Lo que nos devuelve 01:33:06
No es realmente esto 01:33:07
Esto es la traducción 01:33:09
Para que nosotros 01:33:10
Lo podamos entender 01:33:11
Aquí 01:33:12
Nos envía 01:33:13
Todo ese XML 01:33:14
Que hemos visto antes 01:33:15
¿De acuerdo? 01:33:17
¿Que pasa? 01:33:19
A día de hoy 01:33:20
La función 01:33:21
Por ejemplo 01:33:22
De crear usuario 01:33:23
No tiene la validación 01:33:24
De por ejemplo 01:33:25
Como tiene 01:33:26
El formulario 01:33:27
Que si el 01:33:28
Si el correo electrónico 01:33:31
Está duplicado 01:33:32
Pues está duplicado 01:33:33
Si no le metéis 01:33:35
El password 01:33:36
Pues te vende uno 01:33:37
Que sea 01:33:38
Si no 01:33:39
Si tampoco 01:33:41
Si no le ponéis 01:33:42
Ni nombre 01:33:43
Ni apellidos 01:33:45
Tampoco que lo ponéis 01:33:46
No hay ningún control 01:33:47
¿Vale? 01:33:49
A día de hoy 01:33:50
Supongo que esto 01:33:51
Se iría mejorando 01:33:52
Así como vaya pasando 01:33:54
Bueno 01:33:55
Somos desarrolladores 01:33:56
¿Como lo haríamos? 01:34:00
¿Como funcionan? 01:34:01
¿Como funcionarán? 01:34:02
¿O como funcionan 01:34:04
Los edificios web 01:34:05
En 2.0? 01:34:06
A nivel de programación 01:34:08
Nosotros tenemos 01:34:10
Nuestro 01:34:13
Nuestro módulo 01:34:15
Nuestro plugin 01:34:16
Vamos a ver 01:34:20
¿Vale? 01:34:26
Si miráis 01:34:54
Aquí 01:34:56
En la parte 01:34:57
Izquierda 01:35:00
Vuestra 01:35:02
Sabéis que si queréis 01:35:06
Un módulo nuevo 01:35:07
Lo del TB 01:35:08
Cuando lo instaláis 01:35:09
Lo debéis 01:35:11
Soltar ahí 01:35:12
Y directamente 01:35:13
Moodle lo que hace 01:35:15
Es que va 01:35:16
A la carpeta DB 01:35:17
Porque es el funcionamiento 01:35:19
Estándar de Moodle 01:35:20
Y se va 01:35:22
A ficherito 01:35:23
Instant.xms 01:35:24
Que hace la traducción 01:35:25
Para los 01:35:26
Sistemas gestores 01:35:27
De las datas 01:35:28
Que tengamos por debajo 01:35:29
Lo crea 01:35:31
Crea las tablas 01:35:32
Crea los campos 01:35:33
Pone los registros 01:35:34
Que hagan falta 01:35:35
Etcétera 01:35:37
Entonces 01:35:39
Es ahí 01:35:40
Donde 01:35:41
Se debería 01:35:42
O se debe meter 01:35:43
Un ficherito 01:35:45
Que 01:35:47
Se llama 01:35:48
Service.php 01:35:49
Y ahí 01:35:52
Se especifican 01:35:53
La descripción 01:35:55
De las funciones 01:35:58
Y has 01:36:00
Y se puede 01:36:02
Llegar 01:36:04
A crear 01:36:05
Servicios también 01:36:06
Entonces 01:36:08
Ahí 01:36:09
Hay dos 01:36:10
Es un poco 01:36:15
Bueno 01:36:16
Se podría mejorar 01:36:17
Pero bueno 01:36:18
Ahora mismo voy a toquear 01:36:19
Y supongo que 01:36:20
Estará en tiempo a cambiar 01:36:22
Este sistema 01:36:23
Simplemente 01:36:24
Es retocado 01:36:25
Haciendo un poco 01:36:26
Más usable 01:36:27
Más entendible 01:36:28
Pero bueno 01:36:29
Es la función así 01:36:30
Hay una función 01:36:31
Una variable 01:36:32
Que se llama 01:36:34
Función 01:36:35
¿Lo veis? 01:36:36
Función 01:36:37
Ahí se especifican 01:36:39
Las funciones 01:36:40
Es la descripción 01:36:41
De las funciones 01:36:42
¿Cómo se especifican? 01:36:43
Pues 01:36:44
Se especifican 01:36:46
Las funciones 01:36:47
Que hemos visto 01:36:48
Por ejemplo 01:36:50
En el caso que estamos viendo 01:36:51
La de 01:36:52
Para crear 01:36:54
Grupos 01:36:55
¿Y cómo se especifican? 01:36:57
Pues 01:36:58
Te dices 01:36:59
El nombre de la clase 01:37:00
El nombre de la clase 01:37:01
Se define por 01:37:02
Tres partes separadas 01:37:03
Bueno 01:37:04
Una fija 01:37:05
Y las otras 01:37:06
Dos son variables 01:37:07
Entonces tenemos 01:37:09
Que 01:37:10
La parte fija 01:37:11
Es externa 01:37:12
La primera parte 01:37:16
Donde pone 01:37:17
Moodle 01:37:18
Ahí 01:37:19
Iría 01:37:21
La sección 01:37:22
Donde está innovada 01:37:24
Ese servicio web 01:37:26
Por ejemplo 01:37:27
Si es del core 01:37:28
Otra moodle 01:37:30
Pero si es de otra parte 01:37:31
Pues pondrá 01:37:33
La parte correspondiente 01:37:34
Bloques 01:37:35
Y lo que sea 01:37:36
¿Vale? 01:37:37
Y después 01:37:38
La categoría 01:37:40
Por ejemplo 01:37:41
Si tenemos 01:37:42
Que vamos a crear 01:37:43
Funcionalidad para grupos 01:37:45
Pues pondremos 01:37:47
Bloques 01:37:48
Y ahí 01:37:49
Las diferentes funciones 01:37:50
Bueno 01:37:53
Si por ejemplo veis 01:37:54
Si os fijáis 01:37:56
Con el 01:37:57
Efecto de la comparativa 01:37:58
Lo veréis 01:38:00
Rápida 01:38:01
Después 01:38:03
Especificamos el método 01:38:04
La especificación del método 01:38:06
Es lo que realmente 01:38:09
Va a ejecutar 01:38:10
Ejecutar el servicio externo 01:38:12
Que no es 01:38:13
La función interna 01:38:14
De moodle 01:38:15
No es la función 01:38:16
Crear de grupos 01:38:17
De moodle core 01:38:19
Cores y servicios web 01:38:21
Si no que es 01:38:23
La de creación de grupos 01:38:24
Que estará definida 01:38:27
En el classpath 01:38:29
En el classpath 01:38:32
Se dice 01:38:33
Donde está ubicado 01:38:34
Ese servicio web 01:38:35
Pues donde está 01:38:37
La implementación 01:38:38
De ese servicio web 01:38:39
Entonces 01:38:41
Ahí si vamos a 01:38:42
Crowe 01:38:43
External link 01:38:44
Que external link 01:38:45
Es inamovible 01:38:46
Es standard 01:38:47
O sea 01:38:48
Todo lo que sea 01:38:49
El servicio web 01:38:50
El UDDI 01:38:51
Que es 01:38:52
Especificado antes 01:38:53
Hace el descubrimiento 01:38:54
De las funciones internas 01:38:55
A través del 01:38:56
External link 01:38:57
Después 01:39:01
La descripción 01:39:02
Que ya os he dicho 01:39:03
De donde saldría 01:39:04
Que tipo es 01:39:05
Si es de lectura 01:39:06
Si es de escritura 01:39:07
Las capacidades mínimas 01:39:10
Que tiene que tener 01:39:11
El usuario 01:39:12
Que quiera ejecutar 01:39:13
Esa función 01:39:14
O ese método 01:39:15
En este caso 01:39:17
Es la de 01:39:18
Comandants 01:39:19
Blocks 01:39:20
De acuerdo 01:39:22
Si hubiera más 01:39:23
Pues 01:39:24
Aquí 01:39:25
Coma 01:39:26
Tal 01:39:27
Coma tal 01:39:28
Coma tal 01:39:29
Vale 01:39:30
Y ahora 01:39:33
Nos vamos 01:39:34
Crowe 01:39:40
External link 01:39:47
Y aquí 01:39:50
Está 01:39:54
Implementación 01:39:56
Primero de todo 01:40:02
Se tiene que invocar 01:40:03
La clase 01:40:04
Del core 01:40:05
Que es 01:40:07
La external API 01:40:08
Que ya ha programado 01:40:10
El modo de core 01:40:12
Con el 01:40:13
Con lodo y tal 01:40:15
Como creáis 01:40:18
La clase 01:40:19
La clase 01:40:20
Es la que hemos definido 01:40:21
Y existen 01:40:23
Tres funciones 01:40:24
Una 01:40:25
Opcional 01:40:26
Y las otras 01:40:27
Dos obligatorias 01:40:28
La opcional 01:40:30
Empezamos por la opcional 01:40:31
Pues 01:40:32
Dos parámetros 01:40:33
Si pasamos parámetros 01:40:34
Evidentemente 01:40:36
Pasaremos 01:40:37
Porque estamos 01:40:38
Transferiendo información 01:40:39
Queremos especificar 01:40:42
Que estructura 01:40:43
Va a tener 01:40:46
Entonces 01:40:47
Ahora entenderemos 01:40:48
Porque 01:40:49
Tenemos que 01:40:51
Crear 01:40:52
Por ejemplo 01:40:53
En este caso 01:40:54
Concreto 01:40:55
External 01:40:56
Móvil 01:40:57
De estructura 01:40:58
External 01:40:59
Simple 01:41:00
De estructura 01:41:01
Etc 01:41:02
Todo esto hace la traducción 01:41:03
A lo que hemos visto 01:41:04
En la primera parte 01:41:05
Literalmente 01:41:06
Y la descripción 01:41:07
Que hemos visto 01:41:08
En el service 01:41:09
La definición 01:41:12
De web service 01:41:13
Pero 01:41:14
Programando 01:41:15
Y eso hace la definición 01:41:16
A todo el estándar 01:41:17
Que hemos visto 01:41:18
¿De acuerdo? 01:41:20
Después, bueno 01:41:22
Aquí se le pasan los parámetros 01:41:23
Se especifican los parámetros 01:41:25
Y después 01:41:27
Las dos funciones 01:41:28
Inamovibles 01:41:30
Que siempre tienen que estar 01:41:31
Evidentemente 01:41:33
El desarrollo 01:41:34
De la 01:41:35
Función 01:41:37
Del método 01:41:39
En este caso 01:41:41
Era 01:41:42
La de crear libros 01:41:43
Que la hemos definido 01:41:44
Con toda 01:41:45
La programación 01:41:47
Y ahí 01:41:48
Es cuando podemos utilizar 01:41:49
La funcionalidad del core 01:41:51
La funcionalidad 01:41:53
De Moodle 01:41:54
Especial 01:41:55
Simplemente con 01:41:56
Validamos los parámetros 01:41:57
Con la función 01:41:59
Que acabamos 01:42:00
De declarar anteriormente 01:42:01
Realizamos las transacciones 01:42:04
Correspondientes 01:42:05
Del método 01:42:06
Que estamos implementando 01:42:07
Y eso ya depende 01:42:09
Es programación Moodle 01:42:10
Entonces 01:42:12
Ahí siguen los estándares 01:42:13
Y después 01:42:16
Que 01:42:17
Y después 01:42:19
Que nos falta 01:42:20
Que devolvemos 01:42:29
Hemos quedado 01:42:31
Que 01:42:32
Nosotros pedimos 01:42:33
Y nos tiene que devolver 01:42:34
Una respuesta 01:42:35
Que sea coherente 01:42:37
Entonces 01:42:39
El método 01:42:41
Ión 01:42:42
Returns 01:42:43
Es lo que devolverá 01:42:44
Y que devolverá 01:42:46
Pues 01:42:47
Lo que acabo de crear 01:42:50
En este caso 01:42:51
Devolvemos 01:42:53
Devolvemos 01:42:54
Una estructura 01:42:55
Y esto es lo que devolve 01:42:57
Esto es lo que traduce 01:42:58
Estos campos 01:43:00
A la definición 01:43:02
Si utilizamos SOAP 01:43:03
Pues se va a utilizar 01:43:05
La especificación SOAP 01:43:06
Versión TAR 01:43:07
Si utilizamos XMR 01:43:09
Va a XMR 01:43:11
Lo detalla 01:43:13
Si utilizamos L 01:43:14
Que es un 01:43:15
Formato de Adobe 01:43:16
Para Microsoft.net 01:43:17
Pues 01:43:18
Crea 01:43:19
El pinche I 01:43:20
Porque es un binario 01:43:21
Lo crea y lo envía 01:43:23
¿De acuerdo? 01:43:24
Y así funciona 01:43:25
Me parece que ya no me dejo 01:43:29
Nada más 01:43:30
Bueno, sí 01:43:32
Por último 01:43:34
De todo 01:43:35
Ahora sí que 01:43:36
Ya acabo 01:43:37
Toda esta 01:43:43
Infraestructura 01:43:44
Todo lo que acabamos 01:43:45
De crear 01:43:46
Mude 01:43:47
Con 01:43:48
Con 01:43:49
Con 01:43:50
Con 01:43:51
Con 01:43:52
Con 01:43:53
Con 01:43:54
Con 01:43:55
Con 01:43:56
Con 01:43:57
Con 01:43:58
Con 01:43:59
Con 01:44:00
Con 01:44:01
Con 01:44:02
Con 01:44:03
Con 01:44:04
Con 01:44:05
Con 01:44:06
Con 01:44:07
Con 01:44:08
Con 01:44:09
Con 01:44:10
Con 01:44:11
Con 01:44:12
Con 01:44:13
Con 01:44:14
Con 01:44:15
Con 01:44:16
Con 01:44:17
Con 01:44:18
Con 01:44:19
Con 01:44:20
Con 01:44:21
Con 01:44:22
Con 01:44:23
Con 01:44:24
Con 01:44:25
Con 01:44:26
Con 01:44:27
Con 01:44:28
Con 01:44:29
Con 01:44:30
Con 01:44:31
Con 01:44:32
Con 01:44:33
Con 01:44:34
Con 01:44:35
Con 01:44:36
Con 01:44:37
Con 01:44:38
Con 01:44:39
Con 01:44:40
Con 01:44:41
Con 01:44:42
Con 01:44:43
Con 01:44:44
Con 01:44:45
Con 01:44:46
Con 01:44:47
Con 01:44:48
Con 01:44:49
Con 01:44:50
Con 01:44:51
Con 01:44:52
Con 01:44:53
Con 01:44:54
Con 01:44:55
Con 01:44:56
Con 01:44:57
Con 01:44:58
Con 01:44:59
Con 01:45:00
Con 01:45:01
Con 01:45:02
Con 01:45:03
Con 01:45:04
Con 01:45:05
Con 01:45:06
Con 01:45:07
Con 01:45:08
Con 01:45:09
Con 01:45:11
Con 01:45:12
Con 01:45:13
Con 01:45:14
Con 01:45:15
Con 01:45:16
Con 01:45:17
Con 01:45:18
Con 01:45:19
Con 01:45:20
Con 01:45:21
Con 01:45:22
Con 01:45:23
Con 01:45:24
Con 01:45:25
Con 01:45:26
Con 01:45:27
Con 01:45:28
Con 01:45:29
Con 01:45:30
Con 01:45:31
Con 01:45:32
Con 01:45:33
Con 01:45:34
Con 01:45:35
Con 01:45:36
Con 01:45:37
Centro 01:45:38
Centro 01:45:40
Centro 01:45:41
Centro 01:45:42
Centro 01:45:44
Centro 01:45:45
Centro 01:45:46
Centro 01:45:48
Centro 01:45:49
Centro 01:45:50
Centro 01:45:51
Centro 01:45:53
Centro 01:45:54
Centro 01:45:55
Centro 01:45:56
Centro 01:46:04
Centro 01:46:05
Centro 01:46:06
Centro 01:46:07
Centro 01:46:10
Centro 01:46:11
Centro 01:46:12
Centro 01:46:14
Centro 01:46:16
Centro 01:46:17
Centro 01:46:18
Centro 01:46:19
Fuego 01:46:23
Fuego 01:46:24
Fuego 01:46:25
Fuego 01:46:26
Fuego 01:46:27
Fuego 01:46:28
Fuego 01:46:29
Fuego 01:46:30
Fuego 01:46:31
Fuego 01:46:32
Fuego 01:46:33
Fuego 01:46:34
Fuego 01:46:35
Fuego 01:46:36
Fuego 01:46:37
Fuego 01:46:38
Fuego 01:46:39
Fuego 01:46:40
Fuego 01:46:41
Fuego 01:46:42
Fuego 01:46:43
Fuego 01:46:44
Fuego 01:46:45
Fuego 01:46:46
Fuego 01:46:47
Fuego 01:46:48
Fuego 01:46:49
Fuego 01:46:50
Fuego 01:46:51
Fuego 01:46:52
Fuego 01:46:53
Valoración:
  • 1
  • 2
  • 3
  • 4
  • 5
Eres el primero. Inicia sesión para valorar el vídeo.
Idioma/s:
es
Autor/es:
Toni Mas
Subido por:
EducaMadrid
Licencia:
Reconocimiento - No comercial - Sin obra derivada
Visualizaciones:
578
Fecha:
28 de noviembre de 2011 - 15:31
Visibilidad:
Público
Enlace Relacionado:
Moodle La Rioja 2011
Descripción ampliada:

 Estructura del taller:
1. Conceptos básicos.
i.¿Que significa integrar?
ii.Servicios web.
iii.Niveles de integración.
iv.Esfuerzos y sacrificios a realizar.
2. Estándares.
i.Exposición de estándares por niveles de integración.
ii.Estrategias para integrar los servicios.
3. Ejemplos:
i.Integración de servicios externos, ofrecidos por terceros.
ii.Integración con servicios internos.

Objetivos:
(a) Dotar al asistente de los conocimientos suficientes para poder elegir, y hasta elaborar, estrategias de integración con sistemas externos.
(b) Instruir los conceptos básicos a tener en cuenta a la hora de elegir herramientas externas para ofrecer servicios adicionales para Moodle.
(c) Involucrar al asistente en la necesidad de desarrollar sistemas que utilicen estándares, para así facilitar y potenciar la interoperabilidad entre ellos, y con ello aumentar su potencialidad y escalabilidad.
(d) Dar conocimiento de la realidad actual de Moodle: ventajas y desventajas. (compromisos, barreras, problemas, limitaciones, etc).
(e) Exponer la potencialidad que tendrá Moodle en su versión 2.0 y posteriores.

Duración:
1h′ 46′ 46″
Relación de aspecto:
5:4 Es el estándar al cual pertenece la resolución 1280x1024, usado en pantallas de 17". Este estándar también es un rectángulo.
Resolución:
720x576 píxeles
Tamaño:
445.72 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid