Fabian Martinez Rincon

Instalación

Fri, 13 Mar 2026 00:00:00 GMT

Preparando entorno para Pascal

PC Decente

https://code.visualstudio.com/download

Buscamos estas extenciones en el vscode

Descargamos pascal de la pagina oficial

https://www.freepascal.org/download.html

Se descargan este

https://sourceforge.net/projects/freepascal/

Le dan a todo siguiente

Una vez que estan, se pueden crear un archivo ejemplo.pas y pegan lo siguiente

program ej1a_promedio;
var
  num1, num2, promedio: real;
begin
  writeln('Ingrese el primer numero:');
  readln(num1);
  writeln('Ingrese el segundo numero:');
  readln(num2);

  promedio := (num1 + num2) / 2;
  writeln('El promedio es: ', promedio:0:2);
end.

Ya estaria todo!!

PC Sobreviviente

Descargamos Geany

https://www.geany.org/

Lo instale normal, todo siguiente y me anduvo

PC Super Humilde

https://onecompiler.com/pascal

Ingreso

Fri, 27 Feb 2026 00:00:00 GMT

Ingreso

Algunos videos explicativos sobre el proyecto:

import YoutubeVideo2 from "@/components/YoutubeVideo2.astro"

Lab Genetics

Fri, 05 Dec 2025 00:00:00 GMT

Videos sobre el proyecto

Algunos videos explicativos sobre el proyecto:

import YoutubeVideo2 from "@/components/YoutubeVideo2.astro"

🧬 Introducción

Que proyecto mas maravilloso :/

Marco de indagación para generar “Prototipo de solución”:

“Un laboratorio que centraliza muestras biológicas (de otros laboratorios) para mandarlas a analizarlas al exterior quiere digitalizar su funcionamiento ya que actualmente no cuentan con un soporte digital”

🤝🏼 Para Colaborar
🧰 Recursos
⚙️ Instalación
🕹️ Ejecución
👨‍💻 Variables de Entorno
👤 Usuarios

🤝🏼 Para Colaborar

Para asegurarnos de que estamos en la rama main, antes de crear una mara

git branch

Si ya creamos una rama y queremos ir a esa, usamos

git checkout {nombre-rama}

Si no existe la rama, la creamos con un nombre descriptivo

git checkout -b {nombre-rama}

Una vez que estamos en la rama, hacemos un pull para asegurarnos de que estamos actualizados

git pull origin main

Hacemos la pull request

git add .
git commit -m "Mensaje descriptivo"
git push origin {nombre-rama}

🧰 Recursos

⚙️ Instalación

Creamos el entorno Virtual

python -m venv .venv

Activamos el entorno

.venv\Scripts\activate

En caso de no tener permisos

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass

Instalamos las dependencias (Solo hace falta la primera vez)

pip install -r requirements.txt -r requirements-dev.txt

🕹️ Ejecución

flask resetdb
flask seeddb

Para correr la aplicación

livetw dev

O los siguientes dos

flask run --debug
livetw dev --no-flask

👨‍💻 Variables de Entorno

Para configurar las variables de entorno, copiamos y renombramos el archivo .env.example a .env y configuramos las variables de entorno.

DB_PASS = "postgres"
DB_USER = "postgres"
DB_NAME = "localhost"
DB_HOST = "grupo08"

[!NOTE]
Las enfermedades raras son enfermedades geneticas

Programación 1 - Practica 1

Fri, 05 Dec 2025 00:00:00 GMT

Practicas Programacion 1

Algunos videos explicativos sobre el proyecto:

import YoutubeVideo2 from "@/components/YoutubeVideo2.astro"

🧬 Introducción

Que proyecto mas maravilloso :/

Marco de indagación para generar “Prototipo de solución”:

“Un laboratorio que centraliza muestras biológicas (de otros laboratorios) para mandarlas a analizarlas al exterior quiere digitalizar su funcionamiento ya que actualmente no cuentan con un soporte digital”

🤝🏼 Para Colaborar
🧰 Recursos
⚙️ Instalación
🕹️ Ejecución
👨‍💻 Variables de Entorno
👤 Usuarios

🤝🏼 Para Colaborar

Para asegurarnos de que estamos en la rama main, antes de crear una mara

git branch

Si ya creamos una rama y queremos ir a esa, usamos

git checkout {nombre-rama}

Si no existe la rama, la creamos con un nombre descriptivo

git checkout -b {nombre-rama}

Una vez que estamos en la rama, hacemos un pull para asegurarnos de que estamos actualizados

git pull origin main

Hacemos la pull request

git add .
git commit -m "Mensaje descriptivo"
git push origin {nombre-rama}

🧰 Recursos

⚙️ Instalación

Creamos el entorno Virtual

python -m venv .venv

Activamos el entorno

.venv\Scripts\activate

En caso de no tener permisos

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass

Instalamos las dependencias (Solo hace falta la primera vez)

pip install -r requirements.txt -r requirements-dev.txt

🕹️ Ejecución

flask resetdb
flask seeddb

Para correr la aplicación

livetw dev

O los siguientes dos

flask run --debug
livetw dev --no-flask

👨‍💻 Variables de Entorno

Para configurar las variables de entorno, copiamos y renombramos el archivo .env.example a .env y configuramos las variables de entorno.

DB_PASS = "postgres"
DB_USER = "postgres"
DB_NAME = "localhost"
DB_HOST = "grupo08"

👤 Usuarios

Owner
Administrador de Laboratorio
Laboratorio
Medico
Paciente
Transportista

[!NOTE]
Las enfermedades raras son enfermedades geneticas

Practicas de Base de Datos 1

Sun, 26 Oct 2025 00:00:00 GMT

📒 Estudiando

import YoutubeVideo from "@/components/YoutubeVideo.astro"

Aquí tenés una versión más clara, prolija y bien redactada, ideal para tu blog. Mantiene tu contenido, pero lo ordena mejor, corrige errores y mejora la lectura.

Modelado de Datos (Conceptos Generales)

El modelado de datos proporciona una notación para describir cómo se organizan, estructuran y manipulan los datos dentro de un sistema. Un modelo de datos suele incluir:

Estructura de los datos
Restricciones que deben cumplir los datos
Operaciones permitidas sobre esos datos

En conjunto, estos elementos definen la estructura subyacente de una base de datos.

Clasificación de los modelos de datos

Una forma habitual de clasificarlos es distinguir entre:

Modelos lógicos
Modelos físicos

La diferencia principal radica en el nivel de abstracción y el tipo de elementos que representan. Mientras que los modelos lógicos se enfocan en qué datos se manejan y sus relaciones, los modelos físicos se concentran en cómo se almacenan esos datos en el sistema.

Modelos de datos lógicos

Dentro de los modelos lógicos, podemos distinguir dos grandes grupos:

📌 Modelos lógicos basados en objetos

Modelo de Entidades y Relaciones (ER)
Modelo Orientado a Objetos

📌 Modelos lógicos basados en registros

Modelo Relacional → Este es el que utilizaremos en la materia.

Algunos modelos en particular

Modelo de Entidades y Relaciones (ER)

Modelo de Entidades y relaciones (ER)

Es un modelo de datos lógico basado en objetos:

abstracción del mundo real
Representa el significado de los datos
Es independiente de los detalles de la implementación física

Modelo de entidades y relaciones desde los elementos que define un modelo de datos:

Estructura
- Conjunto de Entidades
- Conjunto de Relaciones
- Atributos
Restricciones del modelo
- Cardinalidad, identificador, grado

Entidades

Es una 'cosa o concepto' que puede ser identificada y distinguible de otra 'cosa o concepto'. Como por ejemplo:

'Juan con DNI 12345678'
'Auto modelo 2015 patente PRI'

Relación

Es una asociación de entidades como por ejemplo:

Juan con dni 1234567 es_dueño_de Auto modelo 2015 patente PRI

Atributo

Representa información acerca de una entidad o una relación. Por ejemplo:

Nombre, DNI, Patente, Modelo, Patente

Dominio de un Atributo

Conjunto de valores que pueden tomar un atributo en particular. Por ejemplo:

Nombre puede ser una cadena de máximo 50 letras del abecedario.

Rol de una entidad en una relacion

Indica la función que tiene la entidad en la relación. Por ejemplo:

tutor_de Jose con dni 123456 es tutor_de Juan cuyo dni es 234567. Juan, tiene el rol de tutelado_por

Conjunton de Entidades

Es un conjunto de entidades del mismo tipo. Por ejemplo:

El conjunto de todas las personas que poseen un nombre y tienen DNI puede llamarse PERSONA.
El conjunto de todos los autos que poseen información del modelo y de la patente puede llamarse AUTO.

Conjunto de Relaciones

Es un conjunto de relaciones del mismo tipo. Por ejemplo:

ES_DUEÑO_DE es un conjunto de relaciones entre entidades PERSONA y AUTO.

Los terminos entidad y conjunto de entidades seran intercambiables, haciendo abuso del vocabulario Los terminos relacion y conjunto de relaciones seran intercambiables, haciendo abuso del vocabulario

Restricciones: Cardinalidad

Determina el número de veces en el que puede participar una entidad en una relación.

Indica dependencia (importancia de la cardinalidad mínima)

Total o de existencia: participación obligatoria (mínimo 1)
Parcial: participación opcional (mínimo 0)

Tomamos un conjunto binario de relaciones R entre dos conjuntos de entidades A y B, la cardinalidad (considerando los extremos máximos de cada lado de R) puede ser:

1 a 1
1 a muchos
Muchos a muchos

Restricciones: Grado

Representa el número máximo de veces que una entidad puede estar relacionada con otra.

Ejemplos:

1, n -> Grado n
1, 1 -> Grado 1

Restricciones: Clave o Identificador

Restricción de unicidad del valor del atributo
Sirven para identificar de manera única a una `entidad``
Toda entidad posee al menos una posible clave o identificador
Puede ser:
- Simple
- Compuesto

Diagrama de entidades y relaciones

Representación gráfica de la estructura de los datos

Como se representan los elementos

| Entidad | Relación | Atributo | Cardinalidad | |-----------|-----------|-----------|-----------| | | | | |

Notación de atributos descriptores e identificadores simples y compuestos en una entidad

| Simple | Compuesto | De una entidad (Solo descriptivos) | |-----------|-----------|-----------| | | | |

Ejemplo de un diagrama de Entidades y Relaciones

¿Como se lee esta cardinalidad?

Una persona tiene al menos 1 auto y al menos un auto y a lo sumo n. Y un auto es poseído por una única persona.

Un ejemplo de diagrama de entidades y relaciones -ROL-

¿Como se lee esta cardinalidad?

Una persona es superior de cero o muchas otras personas. Una persona trabaja para a lo sumo una persona.

En algunos ejemplos se omite poner atributos en las entidades Al momento de realizar los ejercicios propuestos en la materia, tener en cuenta que toda entidad debe al menos tener un atributo.

Modelo de entidades y relaciones ampliado

Especialización y Generalización

Especialización

Es el resultado de tomar un subconjunto de entidades de un nivel para formar un conjunto de entidades de nivel más bajo. Por ejemplo:

Tenemos empleados de un hospital. De los médicos nos interesa su matrícula. Puede haber empleados que no son médicos.

Generalización

Es el resultado de tomar uno o más conjuntos de entidades (de nivel más bajo) y producir un conjunto de entidades de un nivel más alto. Por ejemplo:

Distintos tipos de cuenta: cajas de ahorro y cuentas corrientes, pero ambas son consideradas cuentas

Mecanismos de abstracción

Parcial Teórico de Sistemas y Organizaciones

Wed, 22 Oct 2025 00:00:00 GMT

Examen de Sistemas y Organizaciones – Tema 2 (29/9/2025)

Parte A – Múltiple Choice

1. Según la Teoría General de Sistemas, el aporte metodológico se relaciona principalmente con:

La simplificación del lenguaje
La reducción de costos
La programación de computadoras
La estructura del razonamiento

La estructura del razonamiento ✅

2. Existe sinergia cuando:

No hay interacción entre subsistemas
El todo es igual a la suma de las partes
El todo es más que la suma de las partes
El todo es menos que la suma de las partes

El todo es más que la suma de las partes ✅

3. Un sistema abierto se caracteriza porque:

Intercambia energía, materia e información con el medio
No intercambia energía ni información con el medio
Permanece aislado totalmente
Funciona únicamente en equilibrio

Intercambia energía, materia e información con el medio ✅

4. ¿Quién es considerado el fundador de la TGS moderna?

Norbert Wiener
Kenneth Boulding
George Klir
Ludwig von Bertalanffy

Ludwig von Bertalanffy ✅

5. El contexto de un sistema es:

Un elemento interno del sistema
Lo mismo que metasistema
El conjunto de objetos exteriores que rodean e influyen en el sistema
El conjunto de subsistemas

El conjunto de objetos exteriores que rodean e influyen en el sistema ✅

Preguntas de desarrollo

¿Qué significa que la TGS sea una teoría integradora y cuál es su importancia?
Defina las componentes básicas de un sistema (entradas, procesos, salidas, retroalimentación).
Explique con ejemplos la diferencia entre un sistema, un metasistema y el contexto.
Defina sinergia y explique por qué "el todo es más que la suma de las partes".
¿Qué se entiende por recursividad en los sistemas y cómo se relaciona con los niveles jerárquicos (sistema, subsistema, metasistema)?

Otro parcial

¿Qué se entiende por recursividad en los sistemas? ¿Cómo se relaciona con los niveles jerárquicos (sistema, subsistema, metasistema)?
Explique qué significa que un sistema sea abierto y qué intercambia con su entorno.
Diferencie entre sistema abierto y sistema cerrado con un ejemplo de cada uno.
Defina qué se entiende por estructura de un sistema.
Defina qué se entiende por organización de un sistema y cómo se relaciona con la estructura.

Parte A - Múltiple Choice

¿Quién es considerado el fundador de la TGS moderna?

Kenneth Boulding
Norbert Wiener
George Klir
Ludwig von Bertalanffy

✅ Ludwig von Bertalanffy

Un sistema abierto se caracteriza porque:

No intercambia energía ni información con el medio
Funciona únicamente en equilibrio
Permanece aislado totalmente
Intercambia energía, materia e información con el medio

✅ Intercambia energía, materia e información con el medio

Según la Teoría General de Sistemas, el aporte metodológico se relaciona principalmente con:

La programación de computadoras
La simplificación del lenguaje
La reducción de costos
La estructura del razonamiento

✅ La estructura del razonamiento

Existe sinergia cuando:

No hay interacción entre subsistemas
El todo es más que la suma de las partes
El todo es menos que la suma de las partes
El todo es igual a la suma de las partes

El todo es más que la suma de las partes ✅

El contexto de un sistema es:

El conjunto de objetos exteriores que rodean e influyen en el sistema
El conjunto de subsistemas
Un elemento interno del sistema
Lo mismo que metasistema

✅ El conjunto de objetos exteriores que rodean e influyen en el sistema

Teoricas

Explique la diferencia entre homeostasis y morfogénesis.
Defina qué es un sistema de control y su relación con la información.
Explique la diferencia entre retroalimentación positiva y negativa.
Defina qué se entiende por variedad en un sistema y cómo el control actúa sobre ella.
Detalle los principales aportes de la Teoría General de Sistemas y explique por qué representaron un cambio frente al pensamiento mecanicista.

Primer Parcial de Matemáticas 4

Fri, 10 Oct 2025 00:00:00 GMT

https://youtu.be/DfwWEvyZGWY?si=aMl1qzhjDDe-ONxM

TP 3 Numeros

Ejercicio 1

Número par -> Un número entero $$ n $$ es par si existe un número entero $$ k $$ tal que $$ n = 2k $$ Es decir, $$ n $$ es divisible por 2.

Número impar -> Un número entero $$ n $$ es impar si existe un número entero $$ k $$ tal que $$ n = 2k + 1 $$ Es decir, $$ n $$ no es divisible por 2.

Demostración -> Para que un número sea simultáneamente par e impar, debería cumplir ambas definiciones al mismo tiempo.
Es decir, existirían enteros $$ k_1 $$ y $$ k_2 $$ tales que:

$$ n = 2k_1 \quad \text{y} \quad n = 2k_2 + 1 $$

Esto implica que:

$$ 2k_1 = 2k_2 + 1 $$

Restando ambos lados:

$$ 2k_1 - 2k_2 = 1 $$

Simplificando:

$$ 2(k_1 - k_2) = 1 $$

Conclusión -> Aquí se llega a una contradicción, ya que el lado izquierdo de la ecuación es un número par (por ser múltiplo de 2), mientras que el lado derecho es 1, que es impar.
No existe ningún par de enteros $$k_1$$ y $$k_2$$ que satisfagan esta igualdad.

Por lo tanto:

$$ \text{No hay enteros que sean simultáneamente pares e impares.} $$

Ejercicio 2

Analizar si las siguientes afirmaciones son verdaderas o falsas.

(a) Si $$a \mid 1 \quad \text{entonces} \quad a = 1 \ \text{o}\ a = -1$$

1 = a·k, con k ∈ ℤ
k = 1/a

Para que esta ecuación sea verdadera, k debe ser igual a $$ \frac{1}{a} $$.
Pero, para que k sea un entero, a debe ser un divisor de 1.

Los divisores de 1 son aquellos números enteros que, multiplicados por otro entero, dan como resultado 1.
Estos divisores son, únicamente:

a = 1
a = -1

ya que $$ 1 = 1 \times 1 $$ y $$ 1 = (-1) \times (-1) $$.

La afirmación es VERDADERA.

(b) $$ a \mid b \ \text{y}\ b \mid c \ \text{entonces}\ a \mid c$$

b = a·k₁, con k₁ ∈ ℤ.
c = b·k₂, con k₂ ∈ ℤ.

c = a·k₁·k₂
c = a·k₃, con k₃ ≡ k₁·k₂ ∈ ℤ.

La afirmación es VERDADERA.

(c) $$ a(a - 1) \ \text{es par} $$

Si a es par, (a - 1) es impar y, entonces, el producto es par.
Si a es impar, (a - 1) es par y, entonces, el producto es par.

La afirmación es VERDADERA.

(d) $$ x \mid y \ \text{y}\ y \mid z \ \text{entonces}\ x \mid yz$$

y = x·k₁, con k₁ ∈ ℤ.
z = y·k₂, con k₂ ∈ ℤ.

yz = x·k₁·z
yz = x·k₃, con k₃ ≡ k₁·z ∈ ℤ.

La afirmación es VERDADERA.

Ejercicio 3

Si a un número se lo divide por 5, el resto es 3 y si se lo divide por 7, el resto es 4.

$$ x = 5k_1 + 3, \quad k_1 \in \mathbb{Z} $$
$$ x = 7k_2 + 4, \quad k_2 \in \mathbb{Z} $$

Igualando ambas expresiones:

$$ 5k_1 + 3 = 7k_2 + 4 $$
$$ 5k_1 = 7k_2 + 1 $$
$$ k_1 = 3, \quad k_2 = 2 $$
$$ x = 5 \times 3 + 3 = 15 + 3 = 18 $$
$$ x = 7 \times 2 + 4 = 14 + 4 = 18 $$
$$ x = 35k_3 + 18, \quad k_3 \in \mathbb{Z} $$

Por lo tanto, si se lo divide por 35, el resto es 18.

Ejercicio 4

Sean $$ a $$ y $$ b $$ dos números enteros que tienen restos 4 y 7 respectivamente en la división por 11. Hallar los restos de la división por 11 de $$ a + b^2 $$.

Variables:

$$ a = 11k_1 + 4, \quad k_1 \in \mathbb{Z} $$
$$ b = 11k_2 + 7, \quad k_2 \in \mathbb{Z} $$

Paso 1: Calculamos la suma

Sabemos que ambos números son múltiplos de 11 más su respectivo resto.
Sumando las dos expresiones obtenemos:

$$ a + b = 11k_1 + 4 + 11k_2 + 7 $$
$$ a + b = 11 (k_1 + k_2) + 11 $$
$$ a + b = 11 (k_1 + k_2 + 1) $$

Por lo tanto -> $$ a + b = 11k_3, \quad k_3 \equiv (k_1 + k_2 + 1) \in \mathbb{Z} $$

Paso 2: Calculamos el cuadrado (Elevamos ambos lados al cuadrado):

$$ (a + b)^2 = (11k_3)^2 $$
$$ (a + b)^2 = 11 \times 11k_3^2 $$
$$ (a + b)^2 = 11k_4, \quad k_4 \equiv 11k_3^2 \in \mathbb{Z} $$

Por lo tanto, el resto de la división por 11 de $$ (a + b)^2 $$ es 0.

Ejercicio 5

Convertir los siguientes números de base 10 a base 8:

$$ 98 = 8 \times 12 + 2 $$
$$ 12 = 8 \times 1 + 4 $$
$$ 1 = 8 \times 0 + 1 $$

Por lo tanto:

$$ 98 = (142)_8 $$

$$ 44 = 8 \times 5 + 4 $$
$$ 5 = 8 \times 0 + 5 $$

Por lo tanto:

$$ 44 = (54)_8 $$

$$ 20 = 8 \times 2 + 4 $$
$$ 2 = 8 \times 0 + 2 $$

Por lo tanto:

$$ 20 = (24)_8 $$

Ejercicio 6

Calcular el máximo común divisor entre:

$$ (24, 16) = (16, 8) = (8, 0) = 8 $$

Por lo tanto:

$$ \text{mcd}(16, 24) = 8 $$

$$ (70, 50) = (50, 20) = (20, 10) = (10, 0) = 10 $$

Por lo tanto:

$$ \text{mcd}(70, 50) = 10 $$

$$ (121, 88) = (88, 33) = (33, 22) = (22, 11) = (11, 0) = 11 $$

Por lo tanto:

$$ \text{mcd}(121, 88) = 11 $$

$$ (-90, 90) = (90, 0) $$

Por lo tanto:

$$ \text{mcd}(-90, 90) = 90 $$

$$ (980, 224) = (224, 84) = (84, 56) = (56, 28) = (28, 0) = 28 $$

Por lo tanto:

$$ \text{mcd}(980, 224) = 28 $$

Ejercicio 7

Probar que si $$ a $$ y $$ b $$ son enteros:

(a) $$a + b \ \text{es coprimo con} \ a$$

Definición de coprimo -> Dos números son coprimos si su máximo común divisor es 1.

$$ a = dk_1, \quad k_1 \in \mathbb{Z} $$
$$ a + b = dk_2, \quad k_2 \in \mathbb{Z} $$

Igualando ambas expresiones:

$$ dk_1 + b = dk_2 $$
$$ b = dk_2 - dk_1 $$
$$ b = d(k_2 - k_1) $$
$$ b = dk_3, \quad k_3 \equiv (k_2 - k_1) \in \mathbb{Z} $$

No hay razón para que $$a$$ y $$b$$ tengan un divisor común que no sea $$d = 1$$. Por lo tanto:

$$ (a + b,, a) = 1 $$

(b) $$\text{Si } a \text{ es no nulo, } (a, 0) = |a|$$

$$ a = |a|k_1, \quad k_1 \in \mathbb{Z} $$
$$ 0 = |a|k_2, \quad k_2 \in \mathbb{Z} $$

No hay divisores comunes entre $$ a $$ y $$ 0 $$ que sean mayores a $$ |a| $$.
Por lo tanto:

$$ (a, 0) = |a| $$

(c) $$(a, b) = 1 \ \text{entonces} \ ma + nb = k, \ \text{con } m, n, k \in \mathbb{Z}$$

ma + nb= 1.

Ejercicio 8

Hallar $$mcd(5k + 3, 3k + 2) $$, para cualquier k entero

$$(5k + 3,, 3k + 2) = (3k + 2,, 2k + 1) = (2k + 1,, k + 1) = (k + 1,, k) = (k,, 1) = (1,, 0)$$

Por lo tanto:

$$ \text{mcd}(5k + 3,, 3k + 2) = 1 $$

Ejercicio 9

Sean $$ ( a, b \in \mathbb{Z} ) $$ y sea $$ p $$ primo. Demostrar que si $$ ( p \mid ab ) $$ entonces $$ ( p \mid a ) $$ ó $$ ( p \mid b ) $$.

Mostrar que esto no se cumple si $$ p $$ no es primo.

$$ a = p_1^{e_1} p_2^{e_2} \dots p_m^{e_m}, \quad p_i \in \mathbb{Z}, \quad i = 1, 2, \dots, m $$

$$ b = q_1^{f_1} q_2^{f_2} \dots q_n^{f_n}, \quad q_i \in \mathbb{Z}, \quad i = 1, 2, \dots, n $$

$$ ab = p^s k, \quad k \in \mathbb{Z} $$

donde $$ k $$ es el producto de los factores primos que no son $$ p $$ y $$ s $$ es el número de veces que $$ p $$ divide el producto $$ ab $$.

Dado que $$ p $$ es primo y que $$ ab $$ se compone de factores primos, $$ p $$ debe aparecer en la factorización de, al menos, uno de los factores $$ a $$ o $$ b $$.

Esto no se cumple si $$ p $$ no es primo.
Consideremos un contraejemplo:

$$ p = 6, \quad a = 2, \quad b = 3 $$

$$ p \mid ab \Rightarrow 6 \mid 6 $$

pero

$$ p \nmid a \Rightarrow 6 \nmid 2 \quad \text{y} \quad p \nmid b \Rightarrow 6 \nmid 3 $$

Por lo tanto, si $$ p $$ no es primo, la propiedad deja de cumplirse.

Ejercicio 10

Hallar, si existe, un número entero $$ q $$ tal que $$ 7290q $$ es el cubo de un entero.

1️⃣ Factorización de 7290

Comenzamos descomponiendo $$ 7290 $$ en sus factores primos:

$$ 7290 = 3645 \times 2 \ 7290 = 1215 \times 3 \times 2 \ 7290 = 405 \times 3^2 \times 2 \ 7290 = 135 \times 3^3 \times 2 \ 7290 = 45 \times 3^4 \times 2 \ 7290 = 15 \times 3^5 \times 2 \ 7290 = 5 \times 3^6 \times 2 $$

Por lo tanto, la factorización prima de 7290 es:

$$ 7290 = 2 \times 3^6 \times 5 $$

2️⃣ Hallar el valor de $$ q $$

Para que $$ 7290q $$ sea el cubo de un número entero, cada exponente en la factorización debe ser múltiplo de 3.

Actualmente tenemos:

$$ 2^1 $$
$$ 3^6 $$
$$ 5^1 $$

Faltan potencias para que todos los exponentes sean múltiplos de 3.
Necesitamos completar:

$$ 2^1 \to 2^3 $$ → multiplicamos por $$ 2^2 $$
$$ 3^6 \to 3^6 $$ → ya es múltiplo de 3
$$ 5^1 \to 5^3 $$ → multiplicamos por $$ 5^2 $$

Por lo tanto:

$$ q = 5^2 \times 2^2 $$

$$ q = 25 \times 4 = 100 $$

3️⃣ Comprobamos que $$ 7290q $$ sea un cubo perfecto

Multiplicamos ambos:

$$ n^3 = 7290 \times 100 $$

Reemplazamos por las factorizaciones:

$$ n^3 = (5 \times 3^6 \times 2) \times (5^2 \times 2^2) $$

Agrupando factores semejantes:

$$ n^3 = 5^3 \times 3^6 \times 2^3 $$

Extraemos la raíz cúbica:

$$ n = (5^3 , 3^6 , 2^3)^{\frac{1}{3}} = 5 \times 3^2 \times 2 $$

Simplificamos:

$$ n = 5 \times 9 \times 2 = 90 $$

✅ Por lo tanto:

$$ \boxed{q = 100 \quad \text{y} \quad n = 90.} $$

Ejercicio 11

Demostrar que dados $$ a $$ y $$ b $$ en $$ \mathbb{Q} $$ tales que $$ a < b $$, existe otro número racional $$ x $$ tal que $$ a < x < b $$.

1️⃣ Punto de partida

Sabemos que $$ a < b $$.
Queremos encontrar un número racional $$ x $$ que esté entre ellos, es decir:

$$ a < x < b. $$

2️⃣ Proponemos un candidato

Un candidato natural es el promedio aritmético de ambos:

$$ x = \frac{a + b}{2}. $$

Este número es racional porque $$ a, b \in \mathbb{Q} $$ y la suma y división entre racionales sigue siendo racional.

3️⃣ Demostramos que $$ a < \frac{a + b}{2} $$

Partimos de la desigualdad inicial $$ a < b $$:

$$ a + a < a + b $$

Sumamos $$ a $$ en ambos lados.
Luego simplificamos:

$$ 2a < a + b $$

Dividimos por 2 (como 2 > 0, la desigualdad se mantiene):

$$ a < \frac{a + b}{2} $$

✅ Por lo tanto, el promedio es mayor que $$ a $$.

4️⃣ Demostramos que $$ \frac{a + b}{2} < b $$

Partimos nuevamente de $$ a < b $$ y ahora sumamos $$ b $$ en ambos lados:

$$ a + b < b + b $$

Simplificamos:

$$ a + b < 2b $$

Dividimos por 2:

$$ \frac{a + b}{2} < b $$

✅ Entonces el promedio es menor que ( b ).

5️⃣ Conclusión

Hemos probado que:

$$ a < \frac{a + b}{2} < b $$

Por lo tanto, el número racional $$ x = \frac{a + b}{2} $$ cumple con la condición pedida.

✅ Resultado final:

$$ \boxed{x = \frac{a + b}{2}} $$

es un número racional tal que $$ a < x < b $$.

Ejercicio 12

Probar que no existe un número racional cuyo cubo sea igual a 2.

1️⃣ Suposición inicial

Supongamos, por contradicción, que existe un número racional $$\frac{p}{q}$$, con $$p, q \in \mathbb{Z}$$, $$ q \neq 0 $$, y en su forma más simple (es decir, $$ p $$ y $$ q $$ son coprimos), tal que:

$$ \left(\frac{p}{q}\right)^3 = 2 $$

2️⃣ Desarrollo de la ecuación

Elevando al cubo:

$$ \frac{p^3}{q^3} = 2 $$

Multiplicamos ambos lados por $$ q^3 $$:

$$ p^3 = 2q^3 $$

Esto implica que $$ p^3 $$ es un número par, ya que es el doble de otro entero.

3️⃣ Deducción: $$ p $$ debe ser par

Si $$ p^3 $$ es par, entonces $$ p $$ también es par.
Por lo tanto, podemos escribir:

$$ p = 2k $$

donde $$ k $$ es un número entero.

4️⃣ Sustitución en la ecuación original

Sustituyendo $$ p = 2k $$ en $$ p^3 = 2q^3 $$:

$$ (2k)^3 = 2q^3 $$

Desarrollamos:

$$ 8k^3 = 2q^3 $$

Dividimos ambos lados por 2:

$$ 4k^3 = q^3 $$

O equivalentemente:

$$ q^3 = 2 \times (2k^3) $$

Esto muestra que $$ q^3 $$ también es par, lo cual implica que $$ q $$ también es par.

5️⃣ Contradicción

Si tanto $$ p $$ como $$ q $$ son pares, entonces ambos tienen un factor común (el 2).
Esto contradice la suposición inicial de que $$ \frac{p}{q} $$ está en su forma más simple (coprimos).

6️⃣ Conclusión

Dado que llegamos a una contradicción, no puede existir tal número racional.
Por lo tanto:

$$ \boxed{\text{No existe un número racional cuyo cubo sea igual a 2.}} $$

Ejercicio 13

Indique la parte real $$ \text{Re}(z) $$ y la parte imaginaria $$ \text{Im}(z) $$ de los siguientes complejos:

a) $$ z = \sqrt{-49} $$

Paso 1 – Reescribimos el número negativo:
Recordemos que $$ -1 $$ se asocia con la unidad imaginaria $$ i $$, donde $$ i^2 = -1 $$:

$$ z = \sqrt{-1 \times 49} $$

Paso 2 – Separamos los factores:

$$ z = \sqrt{49} \times \sqrt{-1} $$

Paso 3 – Simplificamos cada raíz:

$$ z = 7 \times \sqrt{-1} $$

Paso 4 – Reemplazamos $$\sqrt{-1} = i$$:

$$ z = 7i $$

✅ Entonces, el número complejo es puramente imaginario.

Parte real:
$$ \text{Re}(z) = 0 $$
Parte imaginaria:

$$ \text{Im}(z) = 7 $$

b) $$ z = \sqrt{-20} $$

Paso 1 – Reescribimos el número negativo:

$$ z = \sqrt{-1 \times 20} $$

Paso 2 – Separamos las raíces:

$$ z = \sqrt{20} \times \sqrt{-1} $$

Paso 3 – Reemplazamos $$\sqrt{-1}$$:

$$ z = \sqrt{20} , i $$

✅ El número también es puramente imaginario.

Parte real:
$$ \text{Re}(z) = 0 $$
Parte imaginaria:
$$ \text{Im}(z) = \sqrt{20} $$

c) $$ z = \sqrt{-\dfrac{9}{16}} $$

Paso 1 – Separar numerador y denominador en la raíz:

$$ z = \frac{\sqrt{-9}}{\sqrt{16}} $$

Paso 2 – Reescribir el número negativo como producto con $$-1$$:

$$ z = \frac{\sqrt{-1 \times 9}}{\sqrt{16}} $$

Paso 3 – Separar los factores de la raíz:

$$ z = \frac{\sqrt{-1} \times \sqrt{9}}{\sqrt{16}} $$

Paso 4 – Calcular cada raíz:

$$ z = \frac{3\sqrt{-1}}{4} $$

Paso 5 – Sustituir $$\sqrt{-1} = i$$:

$$ z = \frac{3}{4}i $$

✅ El número complejo obtenido es puramente imaginario.

Parte real:
$$ \text{Re}(z) = 0 $$
Parte imaginaria:
$$ \text{Im}(z) = \frac{3}{4} $$

d) $$ z = -8 $$

Paso 1 – Identificamos el tipo de número:

El valor $$z = -8$$ es un número real puro, ya que no tiene parte imaginaria.

Podemos escribirlo como:

$$ z = -8 + 0i $$

Paso 2 – Determinamos sus componentes:

Parte real:
$$ \text{Re}(z) = -8 $$
Parte imaginaria:
$$ \text{Im}(z) = 0 $$

✅ Por lo tanto, $$ z $$ pertenece al conjunto de los números reales ($$ \mathbb{R} $$) y también al de los complejos ($$ \mathbb{C} $$), con parte imaginaria nula.

e) $$ z = 7i $$

Paso 1 – Identificamos el tipo de número:

El número $$ z = 7i $$ es puramente imaginario, ya que no posee parte real.

Podemos expresarlo como:

$$ z = 0 + 7i $$

Paso 2 – Determinamos sus componentes:

Parte real:
$$ \text{Re}(z) = 0 $$
Parte imaginaria:
$$ \text{Im}(z) = 7 $$

✅ Por lo tanto, $$ z $$ se encuentra sobre el eje imaginario en el plano complejo.

f) $$ z = (3 + i) + (5 - 4i)$$

Paso 1 – Desarrollamos la suma:

$$ z = 3 + i + 5 - 4i $$

Paso 2 – Agrupamos las partes reales e imaginarias:

$$ z = (3 + 5) + (1 - 4)i $$

Paso 3 – Simplificamos:

$$ z = 8 - 3i $$

Paso 4 – Identificamos las componentes:

Parte real:
$$ \text{Re}(z) = 8 $$
Parte imaginaria:
$$ \text{Im}(z) = -3 $$

✅ Por lo tanto, $$ z = 8 - 3i $$ es un número complejo con parte real positiva y parte imaginaria negativa.

g) $$ z = 3i - (5 - 2i) $$

Paso 1 – Quitamos el paréntesis aplicando el signo menos:

$$ z = 3i - 5 + 2i $$

Paso 2 – Reordenamos los términos reales e imaginarios:

$$ z = -5 + (3i + 2i) $$

Paso 3 – Simplificamos las partes semejantes:

$$ z = -5 + 5i $$

Paso 4 – Identificamos las componentes:

Parte real:
$$ \text{Re}(z) = -5 $$
Parte imaginaria:
$$ \text{Im}(z) = 5 $$

✅ Por lo tanto, $$ z = -5 + 5i $$ es un número complejo con parte real negativa y parte imaginaria positiva.

h) $$ z = \dfrac{1 + 3i}{3 - i} $$

Paso 1 – Racionalizamos el denominador:

Multiplicamos numerador y denominador por el conjugado del denominador $$ 3 + i $$:

$$ z = \dfrac{(1 + 3i)(3 + i)}{(3 - i)(3 + i)} $$

Paso 2 – Desarrollamos el numerador:

$$ (1 + 3i)(3 + i) = 1 \cdot 3 + 1 \cdot i + 3i \cdot 3 + 3i \cdot i $$

Simplificamos:

$$ = 3 + i + 9i + 3i^2 $$

Recordando que $$ i^2 = -1 $$:

$$ = 3 + 10i - 3 = 9 + 10i + (-1) \Rightarrow 9 + 10i - 1 = 8 + 10i $$

(En el desarrollo del ejemplo original, los términos se agrupan directamente con la sustitución de $$i^2 = -1$$).

Paso 3 – Desarrollamos el denominador:

$$ (3 - i)(3 + i) = 3^2 - i^2 = 9 - (-1) = 10 $$

Paso 4 – Simplificamos la fracción:

$$ z = \dfrac{9 + 10i - 3}{10} = \dfrac{10i}{10} = i $$

Paso 5 – Identificamos las componentes:

Parte real:
$$ \text{Re}(z) = 0 $$
Parte imaginaria:
$$ \text{Im}(z) = 1 $$

✅ Por lo tanto, el número complejo resultante es puramente imaginario:
$$ z = i $$

i) $$ z = \dfrac{1 - i}{(1 + i)^2} $$

Paso 1 – Expandimos el denominador:

$$ (1 + i)^2 = (1 + i)(1 + i) = 1 + 2i + i^2 $$

Como $$ i^2 = -1 $$:

$$ (1 + i)^2 = 1 + 2i - 1 = 2i $$

Por lo tanto:

$$ z = \dfrac{1 - i}{2i} $$

Paso 2 – Racionalizamos el denominador:

Multiplicamos numerador y denominador por el conjugado de $$ 2i $$, que es $$ -2i $$:

$$ z = \dfrac{(1 - i)(-2i)}{2i(-2i)} $$

Paso 3 – Desarrollamos el numerador:

$$ (1 - i)(-2i) = -2i + 2i^2 = -2i - 2 $$

y el denominador:

$$ 2i(-2i) = -4i^2 = 4 $$

Paso 4 – Simplificamos:

$$ z = \dfrac{-2 - 2i}{4} = -\dfrac{1}{2} - \dfrac{1}{2}i $$

Paso 5 – Identificamos las componentes:

Parte real:
$$ \text{Re}(z) = -\dfrac{1}{2} $$
Parte imaginaria:
$$ \text{Im}(z) = -\dfrac{1}{2} $$

✅ Por lo tanto,
$$ z = -\dfrac{1}{2} - \dfrac{1}{2}i $$ es un número complejo con partes real e imaginaria iguales en magnitud y negativas.

Ejercicio 14

La suma de un número complejo y su conjugado es −8 y la suma de sus módulos es 10. ¿De qué números complejos se trata?

1️⃣ Representación general

Sea: $$ z = a + ib, \quad \bar{z} = a - ib $$

2️⃣ Suma del número con su conjugado

Sabemos que: $$ z + \bar{z} = -8 $$

Reemplazamos: $$ (a + ib) + (a - ib) = -8 $$

Simplificamos: $$ 2a = -8 $$

Despejamos: $$ a = -4 $$

3️⃣ Suma de los módulos

También se cumple que: $$ |z| + |\bar{z}| = 10 $$

Pero como el módulo de un número complejo y el de su conjugado son iguales: $$ |z| = |\bar{z}| $$

Entonces: $$ 2|z| = 10 $$

Dividimos por 2: $$ |z| = 5 $$

4️⃣ Aplicamos la fórmula del módulo

Sabemos que: $$ |z| = \sqrt{a^2 + b^2} $$

Reemplazamos ( a = -4 ): $$ \sqrt{(-4)^2 + b^2} = 5 $$

Elevamos ambos lados al cuadrado: $$ 16 + b^2 = 25 $$

Restamos 16: $$ b^2 = 9 $$

Tomamos raíz cuadrada: $$ |b| = 3 $$

Por lo tanto: $$ b = \pm 3 $$

5️⃣ Soluciones finales

Sustituyendo los valores de ( a ) y ( b ):

$$ z_1 = -4 + 3i $$

$$ z_2 = -4 - 3i $$

✅ Conclusión: -> Los números complejos que cumplen las condiciones dadas son:

$$ \boxed{z_1 = -4 + 3i \quad \text{y} \quad z_2 = -4 - 3i.} $$

Ejercicio 15

Hallar, si existe, $$ x $$ real tal que $$ \text{Re}(z) = \text{Im}(z) $$ siendo $$ z = \dfrac{x + 2i}{4 - 3i} $$

1️⃣ Racionalizamos el denominador

Multiplicamos numerador y denominador por el conjugado de $$4 - 3i$$, que es $$4 + 3i$$:

$$ z = \dfrac{(x + 2i)(4 + 3i)}{(4 - 3i)(4 + 3i)} $$

2️⃣ Desarrollamos el numerador

$$ (x + 2i)(4 + 3i) = 4x + 3xi + 8i + 6i^2 $$

Como $$i^2 = -1$$:

$$ = 4x + 3xi + 8i - 6 $$

Agrupamos las partes reales e imaginarias:

$$ = (4x - 6) + (3x + 8)i $$

3️⃣ Desarrollamos el denominador

$$ (4 - 3i)(4 + 3i) = 4^2 - (3i)^2 = 16 - (-9) = 25 $$

4️⃣ Reescribimos $$z$$

$$ z = \dfrac{(4x - 6) + (3x + 8)i}{25} $$

Separando en parte real e imaginaria:

$$ z = \dfrac{4x - 6}{25} + \dfrac{3x + 8}{25}i $$

5️⃣ Condición: $$\text{Re}(z) = \text{Im}(z)$$

Igualamos ambas expresiones:

$$ \dfrac{4x - 6}{25} = \dfrac{3x + 8}{25} $$

Multiplicamos por 25 y simplificamos:

$$ 4x - 6 = 3x + 8 $$

Despejamos:

$$ x = 14 $$

6️⃣ Verificamos el valor de ( z )

Sustituimos ( x = 14 ) en la expresión de ( z ):

$$ z = \dfrac{4(14) - 6}{25} + \dfrac{3(14) + 8}{25}i $$

Calculamos:

$$ z = \dfrac{56 - 6}{25} + \dfrac{42 + 8}{25}i $$

$$ z = \dfrac{50}{25} + \dfrac{50}{25}i $$

$$ z = 2 + 2i $$

✅ Conclusión:

El valor real que cumple la condición es:

$$ \boxed{x = 14} $$

y el número complejo correspondiente es:

$$ \boxed{z = 2 + 2i.} $$

Ejercicio 16

Encontrar, si existe, un valor de $$ k $$ real para que el complejo $$ \frac{2 - (1 + k)i}{1 - ki} $$ sea un número real.

1) Racionalizamos el denominador

Multiplicamos numerador y denominador por el conjugado de $$1-ki$$, que es $$1+ki$$: $$ z=\frac{(2-(1+k)i)(1+ki)}{(1-ki)(1+ki)}. $$

El denominador queda $$ (1-ki)(1+ki)=1-(ki)^2=1+k^2. $$

2) Desarrollamos el numerador

$$ (2-(1+k)i)(1+ki) =2+2ki-(1+k)i-(1+k)k,i^2. $$

Como $$i^2=-1$$:

$$ =2+2ki-(1+k)i+(1+k)k. $$

Separando partes real e imaginaria:

$$ \text{Real: } 2+(1+k)k=2+k+k^2, \qquad \text{Imaginaria: } 2k-(1+k)=k-1. $$

Entonces $$ z=\frac{(2+k+k^2)+(k-1)i}{1+k^2}. $$

3) Condición para que (z) sea real

$$z$$ es real $$\iff$$ su parte imaginaria es $$0$$:

$$ \frac{k-1}{1+k^2}=0 ;;\Longrightarrow;; k-1=0 ;;\Longrightarrow;; \boxed{k=1}. $$

4) Valor de (z) para (k=1)

$$ z=\frac{2+1+1}{1+1}=\frac{4}{2}= \boxed{2}. $$

Conclusión. El valor buscado es $$\boxed{k=1}$$ y en ese caso $$z$$ resulta real e igual a $$\boxed{2}$$.

Ejercicio 17

Calcular las siguientes potencias:

a) $$ i^{489} $$

Paso 1 – Usamos el ciclo de potencias de $$i$$:

Recordemos que:

$$ i^1 = i, \quad i^2 = -1, \quad i^3 = -i, \quad i^4 = 1 $$

Por lo tanto, las potencias de $$i$$ se repiten cada 4.

Paso 2 – Dividimos el exponente entre 4:

$$ 489 = 4 \times 122 + 1 $$

Paso 3 – Reescribimos la potencia:

$$ i^{489} = i^{4 \times 122 + 1} $$

$$ i^{489} = (i^4)^{122} \cdot i^1 $$

Paso 4 – Simplificamos:

$$ (i^4)^{122} = 1^{122} = 1 $$

$$ i^{489} = 1 \cdot i = i $$

✅ Resultado final:

$$ \boxed{i^{489} = i} $$

b) $$ -i^{1026} $$

Paso 1 – Descomponemos el exponente:

$$ 1026 = 4 \times 256 + 2 $$

Por lo tanto:

$$ -i^{1026} = -i^{4 \times 256 + 2} $$

Paso 2 – Aplicamos la propiedad de potencias:

$$ -i^{1026} = -\left( i^{4 \times 256} \cdot i^2 \right) $$

Paso 3 – Simplificamos usando ( i^4 = 1 ):

$$ -i^{1026} = -\left( (i^4)^{256} \cdot (-1) \right) $$

$$ -i^{1026} = -\left( 1^{256} \cdot (-1) \right) $$

$$ -i^{1026} = -(-1) $$

Paso 4 – Resultado final:

$$ \boxed{-i^{1026} = 1} $$

c) $$(3i)^{168} $$

Paso 1 – Separamos la potencia:

$$ (3i)^{168} = 3^{168} \cdot i^{168} $$

Paso 2 – Descomponemos el exponente de $$i$$:

$$ 168 = 4 \times 42 + 0 $$

Entonces:

$$ i^{168} = i^{4 \times 42 + 0} = (i^4)^{42} \cdot i^0 $$

Paso 3 – Simplificamos usando $$i^4 = 1$$ y $$i^0 = 1$$:

$$ i^{168} = 1^{42} \cdot 1 = 1 $$

Paso 4 – Reemplazamos en la expresión original:

$$ (3i)^{168} = 3^{168} \cdot 1 $$

$$ (3i)^{168} = 3^{168} $$

✅ Resultado final:

$$ \boxed{(3i)^{168} = 3^{168}} $$

Ejercicio 18

Dados los siguientes números complejos, encontrar la forma más adecuada para realizar las operaciones pedidas:

$$ \begin{aligned} z_1&=3+3i &\quad z_2&=-1+i &\quad z_3&=5+4i &\quad z_4&=9 &\quad z_5&=5i \ z_6&=-7 &\quad z_7&=-4-4i &\quad z_8&=-8i &\quad z_9&=2-2i &\quad z_{10}&=3-4i \end{aligned} $$

Operaciones:

a) $$ z_1+z_7 $$

Paso 1 – Reemplazamos los valores:

$$ z_1 + z_7 = (3 + 3i) + (-4 - 4i) $$

Paso 2 – Agrupamos términos reales e imaginarios:

$$ z_1 + z_7 = (3 - 4) + (3i - 4i) $$

Paso 3 – Simplificamos:

$$ z_1 + z_7 = -1 - i $$

✅ Resultado final:

$$ \boxed{z_1 + z_7 = -1 - i} $$

b) $$ z_5 - z_3 $$

Paso 1 – Reemplazamos los valores:

$$ z_5 - z_3 = 5i - (5 + 4i) $$

Paso 2 – Quitamos el paréntesis:

$$ z_5 - z_3 = 5i - 5 - 4i $$

Paso 3 – Agrupamos las partes reales e imaginarias:

$$ z_5 - z_3 = (-5) + (5i - 4i) $$

Paso 4 – Simplificamos:

$$ z_5 - z_3 = -5 + i $$

✅ Resultado final:

$$ \boxed{z_5 - z_3 = -5 + i} $$

c) $$ z_9 \cdot z_6 $$

Paso 1 – Reemplazamos los valores:

$$ z_9 z_6 = (2 - 2i)(-7) $$

Paso 2 – Distribuimos el producto:

$$ z_9 z_6 = 2(-7) - 2i(-7) $$

$$ z_9 z_6 = -14 + 14i $$

✅ Resultado final:

$$ \boxed{z_9 z_6 = -14 + 14i} $$

d) $$ \dfrac{z_8}{z_{10}} $$

Datos:

$$ z_8 = -8i, \qquad z_{10} = 3 - 4i $$

Paso 1 – Escribimos la fracción:

$$ \dfrac{z_8}{z_{10}} = \dfrac{-8i}{3 - 4i} $$

Paso 2 – Racionalizamos el denominador:

Multiplicamos numerador y denominador por el conjugado de $$3 - 4i$$, que es $$3 + 4i$$:

$$ \dfrac{z_8}{z_{10}} = \dfrac{-8i(3 + 4i)}{(3 - 4i)(3 + 4i)} $$

Paso 3 – Desarrollamos el numerador:

$$ -8i(3 + 4i) = -24i - 32i^2 $$

Como $$i^2 = -1$$:

$$ -24i - 32(-1) = -24i + 32 $$

Paso 4 – Desarrollamos el denominador:

$$ (3 - 4i)(3 + 4i) = 9 - (4i)^2 = 9 - (-16) = 25 $$

Paso 5 – Reescribimos la expresión:

$$ \dfrac{z_8}{z_{10}} = \dfrac{32 - 24i}{25} $$

$$ \dfrac{z_8}{z_{10}} = \dfrac{32}{25} - \dfrac{24}{25}i $$

✅ Resultado final:

$$ \boxed{\dfrac{z_8}{z_{10}} = \dfrac{32}{25} - \dfrac{24}{25}i} $$

e) $$ z_3 + z_6 $$

Paso 1 – Reemplazamos los valores:

$$ z_3 + z_6 = (5 + 4i) + (-7) $$

Paso 2 – Agrupamos las partes reales e imaginarias:

$$ z_3 + z_6 = (5 - 7) + 4i $$

Paso 3 – Simplificamos:

$$ z_3 + z_6 = -2 + 4i $$

✅ Resultado final:

$$ \boxed{z_3 + z_6 = -2 + 4i} $$

f) $$ z_2 - z_6 $$

Paso 1 – Reemplazamos los valores:

$$ z_2 - z_6 = (-1 + i) - (-7) $$

Paso 2 – Eliminamos el paréntesis:

$$ z_2 - z_6 = -1 + i + 7 $$

Paso 3 – Agrupamos términos:

$$ z_2 - z_6 = ( -1 + 7 ) + i $$

Paso 4 – Simplificamos:

$$ z_2 - z_6 = 6 + i $$

✅ Resultado final:

$$ \boxed{z_2 - z_6 = 6 + i} $$

g) $$ z_3 \cdot z_{10} $$

Paso 1 – Reemplazamos los valores:

$$ z_3 z_{10} = (5 + 4i)(3 - 4i) $$

Paso 2 – Aplicamos la propiedad distributiva:

$$ z_3 z_{10} = 15 - 20i + 12i - 16i^2 $$

Paso 3 – Simplificamos términos semejantes y recordamos que $$i^2 = -1$$:

$$ z_3 z_{10} = 15 - 8i - 16(-1) $$

$$ z_3 z_{10} = 15 - 8i + 16 $$

Paso 4 – Sumamos las partes reales:

$$ z_3 z_{10} = 31 - 8i $$

✅ Resultado final:

$$ \boxed{z_3 z_{10} = 31 - 8i} $$

h) $$ z_1^{3} $$

1️⃣ Forma binómica

$$ z_1 = 3 + 3i $$

$$ z_1^3 = (3 + 3i)^3 $$

Aplicamos la expansión del cubo: $$ (a + b)^3 = a^3 + 3a^2b + 3ab^2 + b^3 $$

$$ z_1^3 = 3^3 + 3(3^2)(3i) + 3(3)(3i)^2 + (3i)^3 $$

$$ z_1^3 = 27 + 81i + 9(9i^2) + 27i^3 $$

Recordando que $$i^2 = -1$$ y $$i^3 = -i$$:

$$ z_1^3 = 27 + 81i + 81(-1) + 27(-i) $$

$$ z_1^3 = 27 + 81i - 81 - 27i $$

$$ z_1^3 = -54 + 54i $$

2️⃣ Módulo y argumento

$$ z_1^3 = 27 + 81i - 81 - 27i $$

$$ z_1^3 = -54 + 54i $$

2️⃣ Módulo y argumento

$$ |z_1| = \sqrt{3^2 + 3^2} = \sqrt{9 + 9} = \sqrt{18} = 3\sqrt{2} $$

$$ \alpha = \tan^{-1}\left(\frac{3}{3}\right) = \tan^{-1}(1) = \frac{\pi}{4} $$

3️⃣ Forma trigonométrica

$$ z_1 = |z_1|(\cos \alpha + i \sin \alpha) $$

$$ z_1^3 = (|z_1|)^3 [\cos(3\alpha) + i \sin(3\alpha)] $$

$$ z_1^3 = (3\sqrt{2})^3 [\cos(3 \cdot \frac{\pi}{4}) + i \sin(3 \cdot \frac{\pi}{4})] $$

$$ z_1^3 = 27 \cdot 2\sqrt{2} [\cos\left(\frac{3\pi}{4}\right) + i \sin\left(\frac{3\pi}{4}\right)] $$

$$ z_1^3 = 54\sqrt{2} \left(-\frac{1}{\sqrt{2}} + i \frac{1}{\sqrt{2}}\right) $$

$$ z_1^3 = -54 + 54i $$

✅ Resultado final:

$$ \boxed{z_1^3 = -54 + 54i} $$

i) $$ z_{9}^{9} $$

1) Módulo y argumento de $$z_9$$:

$$ |z_9|=\sqrt{2^2+(-2)^2}=\sqrt{8}=2\sqrt{2}, \qquad \alpha=\arg(z_9)=\tan^{-1}!\left(\frac{-2}{2}\right)=\tan^{-1}(-1)=-\frac{\pi}{4}. $$

2) De Moivre:

$$ z_9^{,9}=\big(|z_9|,e^{i\alpha}\big)^{9} =|z_9|^{9},e^{i,9\alpha} =(2\sqrt{2})^{9},e^{-i,\frac{9\pi}{4}}. $$

Como $$-\dfrac{9\pi}{4}\equiv -\dfrac{\pi}{4}\ (\text{mod }2\pi)$$:

$$ z_9^{,9}=(2\sqrt{2})^{9}\left[\cos!\left(-\frac{\pi}{4}\right)+ i\sin!\left(-\frac{\pi}{4}\right)\right] =(2\sqrt{2})^{9}\left(\frac{1}{\sqrt{2}}-\frac{i}{\sqrt{2}}\right). $$

3) Simplificación del módulo:

$$ (2\sqrt{2})^{9}=2^{9}(\sqrt{2})^{9} =2^{9}\cdot 2^{\frac{9}{2}} =2^{13}\sqrt{2}. $$

Entonces:

$$ z_9^{,9}=2^{13}\sqrt{2}\left(\frac{1}{\sqrt{2}}-\frac{i}{\sqrt{2}}\right) =2^{13}(1-i). $$

✅ Resultado final:

$$ \boxed{,z_9^{,9}=2^{13}(1-i)=8192-8192,i, }. $$

j) $$ z_{5}^{15} $$

Paso 1 – Reemplazamos el valor de $$z_5$$:

$$ z_5^{15} = (5i)^{15} $$

Paso 2 – Separación de potencias:

$$ z_5^{15} = 5^{15} \cdot i^{15} $$

Paso 3 – Descomposición del exponente:

$$ i^{15} = i^{4 \times 3 + 3} $$

Paso 4 – Simplificación usando $$i^4 = 1$$:

$$ i^{15} = (i^4)^3 \cdot i^3 $$

$$ i^{15} = 1^3 \cdot i^3 $$

Paso 5 – Recordamos que $$i^3 = -i$$:

$$ i^{15} = -i $$

Paso 6 – Sustituimos en la expresión original:

$$ z_5^{15} = 5^{15} \cdot (-i) $$

$$ z_5^{15} = -5^{15} i $$

✅ Resultado final:

$$ \boxed{z_5^{15} = -5^{15} i} $$

Estos ejercicio son bastantes complejos y los obviamos :(

k) $$ z_{10}^{3} $$

l) Hallar las raíces cuartas de $$ z_2 $$.

m) Hallar las raíces cúbicas de $$ z_4 $$.

n) Hallar las raíces séptimas de $$ i $$.

AWS IoT Node-Red

Sun, 05 Oct 2025 00:00:00 GMT

Indice

ACLARACION DEL TRABAJO:

DEBIDO A FALTA DE TIEMPO NO SE LLEGO A SACAR TODAS LAS IMAGENES DEL PROTOTIPO FINAL NI DE ACTUALIZAR LOS JSON, por lo que las imagenes no son 100% representativas del trabajo realizado en clase. Las imagenes que muestran lo ultimo realizado son las del flujo de Node-red en el ejercicio 5 y 6, algunas de las demas (como por ejemplo las del dashboard) estan desactualizadas. Para ver la ultima version del dashboard, ver el video.

1) Desplegar dos instancias t3.micro con Linux Debian 13 en AWS EC2: Instancia A e Instancia B.

Las siguientes imagenes muestran el inicio exitoso de las instancias EC2 en AWS, Instancia A e Instancia B. El proceso de creación se completó correctamente, incluyendo la inicialización, la configuración de grupos y reglas de seguridad, y el lanzamiento final. Las instancia quedaron listas para su conexión y posterior instalación de Node-RED.

2) Instalar “Node-RED” en ambas instancias.

Primero configuramos las reglas de entrada del grupo de seguridad asociado a las instancias, habilitando el puerto 22 (SSH) para permitir el acceso remoto desde cualquier dirección IP, y se agregando una regla TCP personalizada en el puerto 1880, utilizada por Node-RED para su interfaz web. Esta configuración permite acceder al panel de control de Node-RED desde el navegador, garantizando la comunicación externa necesaria para el proyecto.

Ya habiendo configurado las reglas de entrada, ejecutamos los siguientes comandos en ambas instancias para instalar node-red:

sudo apt update
sudo apt install snapd
sudo snap install core
sudo snap install node-red

Y para verificar su correcto funcionamiento utilizamos el comando sudo apt install net-tools para disponer de utilidades de red y, posteriormente, sudo netstat -na | grep 1880 para confirmar que el servicio de Node-RED se encuentra escuchando en el puerto 1880, indicando que la instalación y el despliegue se realizaron correctamente.

Posteriormente probamos el acceso a la interfaz gráfica de Node-RED mediante el navegador, utilizando las direcciónes públicas de las instancias.

Estos pasos confirman que la instalación y configuración del entorno Node-RED en las instancias se realizaron correctamente y que el servicio se encuentra operativo.

3) Instalar el nodo “node-red-dashboard”.

En la siguientes imagenes se puede ver el menú de configuración de Node-RED, para instalar el paquete node-red-dashboard. Este módulo permite crear interfaces gráficas interactivas (dashboards) para visualizar y controlar variables del sistema, como el estado de la iluminación o los temporizadores. La instalación de este nodo es fundamental para el desarrollo del panel de control utilizado en el proyecto.

4) Registrar ambas instancias como objetos/dispositivos en AWS IoT para poder operar mediante el protocolo MQTT.

En la siguiente imagen se muestra el paso de descarga del kit de conexión en el servicio AWS IoT Core, correspondiente al dispositivo A01-IOT-A. El kit incluye los archivos necesarios para establecer la comunicación segura entre la instancia EC2 y el servicio IoT. Estos elementos permiten autenticar el dispositivo y garantizar una conexión segura mediante el protocolo MQTT.

Una configuracion necesaria para su correcto funcionamiento es la de la política de seguridad, la cual fue actualizada de la siguiente manera: Se configuro la versión activa de la política la versión 2, que tiene como proposito permitir todas las acciones (iot:*) sobre cualquier recurso (*).

El mismo procesamiento fue realizado para el dispositivo A01-IOT-B.

5) Desarrollar, en la instancia A, la solución de un “CONTROL REMOTO” para gestionar la iluminación de un ambiente: ´botón “ENCENDIDO/ON”, botón “APAGADO/OFF”, informe de estado de la luminaria y funcionalidad “TIMER de 5s” para que activada dicha funcionalidad, al encender la luminaria se apague a los 5 segundos.

Dentro de la Instancia A, se pueden encontrar los botones ON, OFF y el Timer ON/OFF con distintas funciones que manejan la lógica del encendido, apagado y el temporizador de 5 segundos. Cuando el temporizador está activo, la lámpara se apaga automáticamente después de esos 5 segundos de apretado el boton ON. Todas las acciones se envían por MQTT al canal configurado en AWS IoT, que luego es recibido por la Instancia B, encargada de mostrar el estado de la luminaria.

Si nos fijamos en panel de control hecho con Node-RED Dashboard, se podran ver elementos como los botones ON y OFF y un switch Timer ON/OFF. Desde el dashboard se puede encender y apagar la led o activar el temporizador de la luminaria, que la apaga automáticamente después de 5 segundos de apretado el boton ON.

NODOS A DETALLAR:

Function 2 se encarga de manejar el estado del temporizador usando una variable global llamada TIMER_ON, cambiando cada vez que se ejecuta el estado de la variable: Si TIMER_ON está en 1, la función la cambia a 0 y si está en 0, la cambia a 1. De esta forma, el sistema alterna entre los dos modos (automático y manual) y mantiene sincronizado el estado del temporizador con el interruptor del panel.
Function 1 se encarga de manejar el apagado de la luz teniendo en cuenta si el temporizador está activo: Esto lo hace revisando el valor de la variable global TIMER_ON, que guarda el estado del temporizador. Si el temporizador está activado, la función envía un mensaje al delay para que luego de 5 segundos se los transmita al la Function 3. En cambio, si el temporizador no está activo, no se envía nada, y el delay no se activa.
A su vez, si delay se activa, Function 3 simplemente cambia el valor del payload a 0 (lo que representa el estado de apagado) y lo envía al mismo canal MQTT que controla la luz. De esta manera, cuando el temporizador está activo, el flujo primero enciende la luz con payload = 1 y, tras los 5 segundos, esta función la apaga enviando payload = 0. Así logramos un sistema automático que prende y apaga sin intervención manual.

6) Desarrollar, en la instancia B, la solución para controlar la “ILUMINACIÓN” de un ambiente simulando el “ENCENDIDO/APAGADO” de la luminaria, informando el estado de la “LUMINARIA” y el estado del “TIMER”.

Dentro de la Instancia B se estableció la recepción de las señales recibidas por los canales A01 - CANAL 1, A01 - CANAL 2, que envian, respectivamente, sus valores hacia un gauge y a una celda de texto que indica el estado del timer.

Los valores recibidos se muestran en tiempo real dentro del dashboard.

7) Las instancias A y B deben comunicarse por medio de MQTT utilizando el bróker de AWS IoT.

En la intancia 1, en la configuración del nodo MQTT dentro de Node-RED, se incorporon los certificados de seguridad proporcionados por AWS para establecer una conexión segura con el bróker MQTT. Se cargon: El certificado del dispositivo (A01-IOT-A.cert.pem), la clave privada (A01-IOT-A.private.key) y el certificado raíz de Amazon (AmazonRootCA1.pem), asegurando la autenticación y el cifrado de las comunicaciones.

El nodo ademas tiene la siguiente configuracion: Se habilita la opción “Use TLS”, asociando el conjunto de certificados A01-CERTIFICADOS previamente cargado, garantizando así una conexión segura y cifrada. Además, se utiliza el protocolo MQTT versión 3.1.1, con conexión automática y sesión limpia, lo que asegura una comunicación estable y autenticada con el servidor IoT.

Por ultimo, el nodo está asociado al servidor A01-ND, que contiene los certificados de autenticación configurados previamente, y se define el tópico “A0-CANALLL”, que representa el canal de comunicación por el cual se enviarán los mensajes MQTT. Ademas, se le configuro el QoS para que tenga tipo 0.

Similarmente, se hicieron las configuraciones necesarias para la instancia B

Configuración TLS para la Instancia B, donde se cargan los certificados necesarios para la conexión segura con AWS IoT:

A01-IOT-B.cert.pem (certificado del dispositivo)
A01-IOT-B.private.key (clave privada)
AmazonRootCA1.pem (certificado raíz).

Con esto generamos la comunicación cifrada y autenticada entre Node-RED y el bróker MQTT.

Imagenes finales que muestran el funcionamiento

Ejemplo que muestra el funcionamiento esperado

Resolucion

ACLARACION DEL TRABAJO:

Como se comento al inicio del trabajo, DEBIDO A FALTA DE TIEMPO NO SE LLEGO A SACAR TODAS LAS IMAGENES DEL PROTOTIPO FINAL NI DE ACTUALIZAR LOS JSON, por lo que las imagenes no son 100% representativas del trabajo realizado en clase. Las imagenes que muestran lo ultimo realizado son las del flujo de Node-red en el ejercicio 5 y 6, algunas de las demas (como por ejemplo las del dashboard) estan desactualizadas. Para ver la ultima version del dashboard, ver el video.

JSON de instancias

Intancia 1

[
    {
        "id": "8e0cbc430664e608",
        "type": "function",
        "z": "5e1db891e60b5c59",
        "name": "function 2",
        "func": "// Obtener el valor de la variable global \"TIMER_ON\"\nvar timerOn = global.get(\"TIMER_ON\");\n\nif (timerOn) {\n    global.set('TIMER_ON', 0);\n    \n    msg.payload = 0;\n    return msg;  \n} else {\n    global.set('TIMER_ON', 1);\n\n\n\n    msg.payload = 1;\n    return msg;  \n}\n\nreturn null;\n",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "// Code added here will be run once\n// whenever the node is started.\nglobal.set('TIMER_ON', 0);\n",
        "finalize": "",
        "libs": [],
        "x": 720,
        "y": 440,
        "wires": [
            [
                "4643e7018dabdb67",
                "a9649b8b6a640eb1"
            ]
        ]
    }
]

Instancia 2

[
    {
        "id": "851e7fe4014bb0d5",
        "type": "tab",
        "label": "Flow 1",
        "disabled": false,
        "info": "",
        "env": []
    },
    {
        "id": "bf13f7c233638d0b",
        "type": "mqtt in",
        "z": "851e7fe4014bb0d5",
        "name": "",
        "topic": "A0 - CANAL 1",
        "qos": "0",
        "datatype": "auto-detect",
        "broker": "89528596d9aa8d87",
        "nl": false,
        "rap": true,
        "rh": 0,
        "inputs": 0,
        "x": 350,
        "y": 260,
        "wires": [
            [
                "d2dea35af5752b39",
                "92e0e2c9e46981de"
            ]
        ]
    },
    {
        "id": "d2dea35af5752b39",
        "type": "ui_gauge",
        "z": "851e7fe4014bb0d5",
        "name": "",
        "group": "93785911cc895a9d",
        "order": 0,
        "width": 0,
        "height": 0,
        "gtype": "gage",
        "title": "gauge",
        "label": "units",
        "format": "{{value}}",
        "min": 0,
        "max": "1",
        "colors": [
            "#00b500",
            "#e6e600",
            "#ca3838"
        ],
        "seg1": "",
        "seg2": "",
        "diff": false,
        "className": "",
        "x": 610,
        "y": 260,
        "wires": []
    },
    {
        "id": "da8eff1728975e77",
        "type": "mqtt in",
        "z": "851e7fe4014bb0d5",
        "name": "",
        "topic": "A0 - CANAL 2",
        "qos": "0",
        "datatype": "auto-detect",
        "broker": "89528596d9aa8d87",
        "nl": false,
        "rap": true,
        "rh": 0,
        "inputs": 0,
        "x": 170,
        "y": 360,
        "wires": [
            [
                "46131f48d11a2d93"
            ]
        ]
    },
    {
        "id": "43e3a7017615bf0b",
        "type": "ui_text",
        "z": "851e7fe4014bb0d5",
        "group": "93785911cc895a9d",
        "order": 1,
        "width": 0,
        "height": 0,
        "name": "",
        "label": "ESTADO DE TIMER",
        "format": "{{msg.payload}}",
        "layout": "row-spread",
        "className": "",
        "style": false,
        "font": "",
        "fontSize": 16,
        "color": "#000000",
        "x": 640,
        "y": 360,
        "wires": []
    },
    {
        "id": "c350c83e29f26b57",
        "type": "mqtt out",
        "z": "851e7fe4014bb0d5",
        "name": "",
        "topic": "A0 - CANAL 3",
        "qos": "0",
        "retain": "",
        "respTopic": "",
        "contentType": "",
        "userProps": "",
        "correl": "",
        "expiry": "",
        "broker": "89528596d9aa8d87",
        "x": 620,
        "y": 460,
        "wires": []
    },
    {
        "id": "92e0e2c9e46981de",
        "type": "function",
        "z": "851e7fe4014bb0d5",
        "name": "function 1",
        "func": "if (msg.payload === 1) {\n    msg.payload = true;\n    return msg;\n} else if (msg.payload === 0) {\n    msg.payload = false;\n    return msg;\n}\n\n// Si no es 0 ni 1, no enviar nada\nreturn null;\n",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 380,
        "y": 460,
        "wires": [
            [
                "c350c83e29f26b57",
                "ef083061253f6d22"
            ]
        ]
    },
    {
        "id": "ef083061253f6d22",
        "type": "ui_text",
        "z": "851e7fe4014bb0d5",
        "group": "93785911cc895a9d",
        "order": 1,
        "width": 0,
        "height": 0,
        "name": "",
        "label": "ESTADO DE LED",
        "format": "{{msg.payload}}",
        "layout": "row-spread",
        "className": "",
        "style": false,
        "font": "",
        "fontSize": 16,
        "color": "#000000",
        "x": 590,
        "y": 560,
        "wires": []
    },
    {
        "id": "46131f48d11a2d93",
        "type": "function",
        "z": "851e7fe4014bb0d5",
        "name": "function 2",
        "func": "if (msg.payload === 1) {\n    msg.payload = true;\n    return msg;\n} else if (msg.payload === 0) {\n    msg.payload = false;\n    return msg;\n}\n\n// Si no es 0 ni 1, no enviar nada\nreturn null;\n",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 400,
        "y": 380,
        "wires": [
            [
                "43e3a7017615bf0b"
            ]
        ]
    },
    {
        "id": "89528596d9aa8d87",
        "type": "mqtt-broker",
        "name": "",
        "broker": "a19dtnoi0vf30n-ats.iot.us-east-1.amazonaws.com",
        "port": "8883",
        "tls": "aea41aa768c86303",
        "clientid": "",
        "autoConnect": true,
        "usetls": true,
        "protocolVersion": "5",
        "keepalive": "60",
        "cleansession": true,
        "autoUnsubscribe": true,
        "birthTopic": "",
        "birthQos": "0",
        "birthRetain": "false",
        "birthPayload": "",
        "birthMsg": {},
        "closeTopic": "",
        "closeQos": "0",
        "closeRetain": "false",
        "closePayload": "",
        "closeMsg": {},
        "willTopic": "",
        "willQos": "0",
        "willRetain": "false",
        "willPayload": "",
        "willMsg": {},
        "userProps": "",
        "sessionExpiry": ""
    },
    {
        "id": "93785911cc895a9d",
        "type": "ui_group",
        "name": "Default",
        "tab": "32ebd9f119ce5fb1",
        "order": 1,
        "disp": true,
        "width": "6",
        "collapse": false,
        "className": ""
    },
    {
        "id": "aea41aa768c86303",
        "type": "tls-config",
        "name": "A01-B",
        "cert": "",
        "key": "",
        "ca": "",
        "certname": "A01-IOT-B.cert.pem",
        "keyname": "A01-IOT-B.private.key",
        "caname": "AmazonRootCA1.pem",
        "servername": "",
        "verifyservercert": false,
        "alpnprotocol": ""
    },
    {
        "id": "32ebd9f119ce5fb1",
        "type": "ui_tab",
        "name": "Home",
        "icon": "dashboard",
        "disabled": false,
        "hidden": false
    }
]

Estas fueron todas las imagenes finales del proyecto

Lanzando una instancia de AWS EC2

Thu, 11 Sep 2025 00:00:00 GMT

Indice

1. Lanzar instancia EC2 (t3.micro, Debian 13).
2. Conexión SSH.
3. Configurar como servidor web (Apache2).
4. Configurar Security Group (HTTP, SSH, ICMP).
5. Crear index.html en DocumentRoot.
6. Verificar los tres tráficos (HTTP, SSH, ICMP).
7. Apagar y encender la instancia → verificar ICMP.
8. Reservar y asociar IP Elástica.
9. Verificar acceso con IP elástica (y que la IP pública previa no funcione).
10. Hacer ping a la IP elástica.
11. Lanzar nueva instancia (t3.micro, Debian 13).
12. Configurarla con TAG INSTANCIA-2.
13. Crear index.html con la leyenda correspondiente.
14. Re-asociar la IP Elástica.
15. Verificar ping sin pérdida de paquetes.
16. Verificar acceso web.
17. Apagar la instancia y chequear ICMP.
18. Encenderla y verificar ICMP.
19. Cambiar puerto de Apache de 80 → 8080.
20. Verificar acceso web en el puerto 8080.
21. Liberar IP Elástica y terminar instancias.

Ejercicio 1: Lanzar instancia EC2

1) Lanzar una instancia en AWS EC2, de tipo “t3.micro” con AMI “Debian 13”.

Para comenzar con la práctica, se procedió a crear una nueva instancia EC2 en la consola de Amazon Web Services (AWS).

Se asignó el nombre A01 a la instancia, lo que permite identificarla fácilmente dentro del entorno.
Se seleccionó la Imagen de máquina de Amazon (AMI) correspondiente a Debian 13 (20250814-2204), que provee el sistema operativo base para la máquina virtual.
Como tipo de instancia, se utilizó t3.micro, que pertenece a la capa gratuita de AWS y es suficiente para realizar pruebas de laboratorio.
El sistema asignó por defecto un volumen de almacenamiento de 8 GiB, suficiente para esta práctica.
Se creó un nuevo grupo de seguridad que más adelante será configurado para permitir los accesos requeridos.

Una vez revisada la configuración en el resumen de la derecha, se hizo clic en “Lanzar instancia” para desplegar el recurso en la nube.

Durante el lanzamiento de la instancia, AWS solicita la creación de un par de claves (Key Pair) para garantizar el acceso seguro vía SSH.

Se asignó el nombre A01-1 al par de claves.
Se seleccionó el tipo de clave RSA, ampliamente utilizado para conexiones seguras mediante cifrado asimétrico.
Como formato de archivo se eligió .ppk utilizado en sistemas Windows.
AWS generó el archivo privado automáticamente y lo descargó al equipo. Este archivo debe guardarse en un lugar seguro, ya que será imprescindible para conectarse a la instancia más adelante.

Para controlar el acceso a la instancia desde la red, se creó un grupo de seguridad denominado A01-SG1.

Se seleccionó la opción Crear grupo de seguridad, lo que permite establecer reglas de tráfico personalizadas para esta instancia.
Se asignó el nombre A01-SG1 y se generó automáticamente una descripción por defecto.
En las reglas de entrada, se dejo por defecto, lo que permite entradas ssh desde cualquier lugar del mundo. Esto sera modificado en una paso siguiente de esta actividad.

Una vez configurados los parámetros principales (nombre, AMI, tipo de instancia, par de claves y grupo de seguridad), se procedió a iniciar el lanzamiento.

Ejercicio 2: Conexión SSH

2) Realizar la conexión a la instancia vía SSH.

Una vez lanzada la instancia EC2, se procedió a establecer la conexión remota utilizando el protocolo SSH, que permite la administración segura del servidor.

Desde la consola de AWS, se identificó la dirección IP pública asignada a la instancia (en este caso, oculta en las capturas por seguridad).
Se utilizó la herramienta PuTTY, donde se configuraron los siguientes parámetros:
- En la pestaña Session, se ingresó la dirección IP pública en el campo Host Name (or IP address) y el puerto 22, correspondiente a SSH.

En la sección SSH → Auth, se cargó el archivo de clave privada previamente generado.

Al abrir la sesión, se utilizó el usuario admin, correspondiente a la AMI Debian 13 seleccionada.
Tras la autenticación con la clave privada, se obtuvo acceso exitoso a la terminal de la instancia, quedando lista para su administración y configuración como servidor web.

Ejercicio 3: Configurar como servidor web (Apache2)

3) Configurar la instancia como servidor WEB (TAG: “AXX-INSTANCIA-1”): utilizar la herramienta “apt-get” para instalar “Apache2”.

NOTA: Recuerde realizar el upgrade del repositorio

Una vez establecida la conexión vía SSH, se procedió a configurar la instancia para que funcione como servidor web. Para esto, se utilizó Apache2, un servidor HTTP de código abierto muy utilizado en entornos Linux.

Actualizar repositorios del sistema Se ejecutó el siguiente comando para asegurarse de que la lista de paquetes y sus versiones estén actualizadas:
```
sudo apt-get update
```
Esto permite descargar la información más reciente de los repositorios de Debian antes de instalar nuevos paquetes.
Instalar Apache2 Posteriormente, se instaló el servidor web con el comando:
```
sudo apt-get install apache2
```
Esto descargó e instaló todos los paquetes necesarios para el correcto funcionamiento del servidor HTTP Apache.

Con estos pasos, la instancia quedó preparada para servir contenido web a través del protocolo HTTP (puerto 80).

Ejercicio 4: Configuración del Security Group

4) Configurar el grupo de seguridad (Security Group) de la instancia para permitir: a. Tráfico Port TCP 80 (HTTP), disponible desde 0.0.0.0/0. b. Tráfico Port TCP 22 (SSH), disponible desde la red o dirección IP de su LAN. c. Tráfico ICMP, disponible desde 0.0.0.0/0.

NOTA: Se deben realizar las pruebas correspondientes de funcionamiento a los protocolos citados (tanto antes de configurar el grupo de seguridad como posterior a la configuración de cada regla); las pruebas deben formar parte de la documentación a entregar.

Para que la instancia EC2 pueda recibir y responder correctamente distintos tipos de tráfico, se configuraron las reglas de entrada del grupo de seguridad (Security Group) asociado a la misma.

Regla HTTP (puerto 80/TCP): Se permitió el tráfico HTTP desde cualquier dirección (0.0.0.0/0). Esto permite acceder al servidor web Apache desde cualquier navegador en Internet.
Regla SSH (puerto 22/TCP): Se habilitó el acceso SSH, restringido a la IP de la red local. Esto mejora la seguridad al limitar el acceso administrativo a direcciones específicas. Para saber cual es la IP de la red local se utilizo un servicio web encontrado al buscar en internet "Cual es mi IP?".

Regla ICMP (Ping): Se permitió el tráfico ICMP desde cualquier origen (0.0.0.0/0), lo que habilita realizar pruebas de conectividad hacia la instancia mediante el comando ping.

Verificación de conectividad

Prueba ICMP (Ping): Inicialmente, al ejecutar un ping hacia la IP pública de la instancia, no se obtenían respuestas debido a que aún no estaban configuradas las reglas de seguridad. Tras habilitar ICMP en el Security Group, se comprobó la correcta respuesta a los paquetes, confirmando que la instancia era accesible desde Internet. | Antes | Despues | |-----------|--------| | | |
Prueba HTTP: Una vez habilitado el tráfico en el puerto 80, se accedió desde un navegador a la IP pública de la instancia, mostrando la página por defecto de Apache2 en Debian, lo que confirma que el servidor web estaba en ejecución y accesible.
Prueba SSH: Se validó también que la conexión SSH seguía funcionando correctamente, tanto antes como después de ajustar las reglas del grupo de seguridad.

Ejercicio 5: Crear archivo index.html

5) Crear en el “DocumentRoot” de Apache, el archivo index.html, que contengan el nombre de la instancia “AXX-INSTANCIA-1 - AÑO 2025 - PRÁCTICA 1”

Una vez instalado Apache2 y verificado su funcionamiento, se procedió a personalizar la página principal del servidor web agregando la identificación de la instancia.

Acceso al directorio DocumentRoot de Apache El contenido web por defecto se almacena en la ruta:
```
cd /var/www/html/
```
Edición del archivo index.html Se utilizó el editor de texto nano con privilegios de superusuario para modificar el archivo principal:
```
sudo nano index.html
```
Inserción de la leyenda solicitada Dentro del archivo se reemplazó el contenido por el texto requerido:
```
A01-INSTANCIA-1 – AÑO 2025 – PRÁCTICA 1
```
Guardado y verificación Una vez guardados los cambios, se accedió a la dirección IP pública de la instancia mediante un navegador web. El servidor respondió mostrando la nueva página personalizada, confirmando que Apache estaba sirviendo correctamente el archivo modificado.

Ejercicio 7: Apagar y encender la instancia → verificar ICMP

7) Apagar la instancia. Volver a encenderla, y luego, volver a verificar el tráfico ICMP. (Tenga en cuenta de describir en la monografía de la práctica la situación encontrada).

En este ejercicio se buscó comprobar cómo afecta el ciclo de apagado/encendido de una instancia EC2 a su conectividad de red.

Prueba inicial de ICMP (Ping): Antes de detener la instancia, se ejecutó un ping hacia la IP pública de la misma. Las solicitudes recibieron respuesta con valores de latencia, confirmando la conectividad de la instancia.
Apagado de la instancia: Desde la consola de AWS, se seleccionó la instancia A01 y se eligió la opción Detener instancia. AWS mostró una advertencia indicando que no se generarían más cargos de uso ni transferencia de datos, aunque los volúmenes asociados y las IP elásticas seguirían facturando mientras la instancia estuviera detenida.
Encendido de la instancia: Una vez detenida, se volvió a encender la instancia mediante la opción Iniciar instancia en la consola de AWS. El estado cambió a En ejecución, lo que habilitó nuevamente los servicios de red y acceso remoto.
Verificación ICMP tras el encendido: Se repitió la prueba de ping hacia la IP pública asignada. En este caso, se observó que las solicitudes no recibían respuesta, quedando en “Tiempo de espera agotado”. Esto ocurre porque, al apagar y volver a encender una instancia, su dirección IP pública cambia. Por lo tanto, si se intenta hacer ping a la IP anterior, se producirá un error, ya que ya no existe una máquina asociada a esa dirección.

Ejercicio 8: Reservar IP Elástica

8) Reservar una IP Elástica y asociarla a la instancia “AXX-INSTANCIA-1”

Con el fin de asegurar que la instancia mantenga siempre la misma dirección pública, incluso después de apagarse y volver a encenderse, se procedió a reservar y asociar una IP Elástica en AWS.

Reserva de IP Elástica: Desde la consola de AWS, en la sección Direcciones IP elásticas, se solicitó una nueva dirección. El sistema asignó la IP 54.157.104.45 y se le agregó la etiqueta A01-elastica para identificarla fácilmente.
Asociación de la IP a la instancia: A continuación, se seleccionó la opción Asociar dirección IP elástica.
- Se eligió como recurso la instancia A01-INSTANCIA-1, que estaba en estado running.
- Se mantuvo la configuración predeterminada.
Confirmación de asociación: AWS mostró el mensaje de confirmación indicando que la dirección IP 54.157.104.45 había sido asociada correctamente a la instancia.

Ejercicio 9: Verificar acceso con IP elástica (y que la IP pública previa no funcione)

Verificar el acceso vía un navegador WEB, por medio de la IP Elástica y que la misma YA NO ES accesible por la IP pública asignada previa la asociación de la IP Elástica.

Una vez asociada la IP Elástica a la instancia A01-INSTANCIA-1, se procedió a verificar el acceso desde distintos puntos de red.

Prueba con la IP Elástica (54.157.104.45):

Verificación de acceso vía navegador: Desde un navegador web, se accedió a http://54.157.104.45/, comprobando que el servidor Apache devolvía la página personalizada de la práctica.

Prueba con la IP pública previa: La instancia tenía asignada una dirección IP pública temporal (54.234.245.179).
- Al intentar acceder a esta IP, no se obtuvo respuesta ni por ping ni por navegador web, confirmando que la asociación de la IP Elástica reemplaza la accesibilidad de la IP pública asignada automáticamente.

Ejercicio 10: Hacer ping a la IP elástica

10) Abrir una consola y ejecutar el comando “ping” a la IP Elástica, verificando la NO pérdida de paquetes.

Con la IP Elástica ya asociada a la instancia A01-INSTANCIA-1, se realizó una prueba de conectividad desde una terminal local:

Se realizó un ping a la dirección elástica, obteniendo respuestas estables con tiempos de entre 170 y 190 ms.

Esta prueba confirma que la IP Elástica mantiene la conectividad con la instancia, incluso si ésta se reinicia o cambia de IP pública temporal.

Ejercicio 11: Lanzar nueva instancia (t3.micro, Debian 13)

11) Lanzar una nueva instancia en AWS EC2, de tipo “t3.micro” con AMI “Debian 13”. Se creó una nueva instancia EC2 de tipo t3.micro utilizando la AMI Debian 13, tal como se indica en la consigna. Los pasos son los mismos que los ya explicados anteriormente, por lo que no se volveran a explicar.

Ejercicio 12: Configurarla con TAG INSTANCIA-2

12) Configurar la nueva instancia con TAG “AXX-INSTANCIA-2”. A la nueva instancia se le configuró el TAG con el nombre A01-INSTANCIA-2, lo que permite identificarla fácilmente dentro de la consola de AWS.

Ejercicio 13: Crear archivo index.html con la leyenda correspondiente

13) Crear en el “DocumentRoot” el archivo index.html, que contengan la leyenda siguiente: “AXX-INSTANCIA-2 – AÑO 2025 – PRÁCTICA 1”. Dentro del directorio DocumentRoot de Apache (/var/www/html/), se editó el archivo index.html y se reemplazó el contenido por la leyenda solicitada:

A01-INSTANCIA-2 – AÑO 2025 – PRÁCTICA 1

Al acceder desde un navegador a la dirección IP pública de la instancia, se mostró la página personalizada, confirmando la correcta configuración del servidor web.

Ejercicio 14: Re-asociar la IP Elástica a la instancia “AXX-INSTANCIA-2”.

En este paso se reasignó la IP Elástica previamente reservada (54.xx.xx.xx) a la nueva instancia AXX-INSTANCIA-2.

Durante el proceso, AWS advierte que si la IP ya estaba asociada a otra instancia (en este caso AXX-INSTANCIA-1), será automáticamente desasociada y vinculada a la nueva.

Una vez confirmada la acción, la consola mostró que la IP Elástica quedó correctamente asociada a AXX-INSTANCIA-2, garantizando que esta instancia pueda mantener conectividad pública estable independientemente de reinicios.

Ejercicio 15: Verificar por consola, la NO pérdida de paquetes.

Se ejecutó el comando ping hacia la IP Elástica 54.157.104.45, comprobando la correcta conectividad con la instancia AXX-INSTANCIA-2.

El resultado mostró respuestas constantes con tiempos estables de latencia y sin pérdida de paquetes, lo cual confirma que la IP Elástica se encuentra correctamente asociada y accesible desde el exterior.

Ejercicio 16: Verificar el acceso vía un navegador WEB, por medio de la IP Elástica, que responda el “AXX-INSTANCIA-2”.

Se accedió desde un navegador a la IP Elástica 54.157.104.45, comprobando que la instancia AXX-INSTANCIA-2 responde correctamente al servicio HTTP.

En la página de bienvenida de Apache se visualiza la leyenda configurada en el archivo index.html:

“A01 – INSTANCIA 2 – AÑO 2025 – PRÁCTICA 1”

Ejercicio 17: Apagar la instancia y chequear ICMP

17) Apagar la instancia “AXX-INSTANCIA-2”. Verificar el tráfico ICMP.

Se apagó la instancia AXX-INSTANCIA-2 desde la consola de AWS. Mientras la instancia estuvo en ejecución, el comando ping a la IP Elástica respondió correctamente sin pérdida de paquetes. Una vez que la instancia fue detenida, el tráfico ICMP dejó de responder, confirmando que al estar apagada la instancia no procesa solicitudes de red.

| Imagen 1 | Imagen 2 | Imagen 3 | |-----------|--------| ----------------| | | | |

Ejercicio 18: Encenderla y verificar ICMP

18) Volver a encender la instancia y verificar que el tráfico ICMP retoma la respuesta al encendido de la misma.

Se volvió a encender la instancia AXX-INSTANCIA-2 desde la consola de AWS. Durante el apagado, las solicitudes ICMP (ping) no obtenían respuesta. Una vez encendida nuevamente, el tráfico ICMP retomó correctamente, respondiendo los paquetes enviados.

Ejercicio 19: Verificar acceso web

19) Cambiar el puerto del servidor WEB de la instancia “AXX-INSTANCIA-2” del TCP 80 al TCP 8080.

Se modificó la configuración del servidor web Apache en la instancia AXX-INSTANCIA-2, cambiando el puerto de escucha de 80 a 8080. Para permitir el acceso, se actualizó el Grupo de Seguridad en AWS agregando la regla de entrada correspondiente al puerto 8080/TCP.

Luego, se verificó el acceso web ingresando a la dirección pública de la instancia junto con el puerto :8080, confirmando que el servidor Apache responde correctamente en el nuevo puerto.

Ejercicio 20: Verificar el acceso WEB desde una navegador.

Una vez configurado el servidor web Apache en la instancia AXX-INSTANCIA-2 para escuchar en el puerto 8080, se procedió a verificar el acceso desde un navegador.

Se ingresó a la dirección http://54.157.104.45:8080, confirmando que la página de inicio de Apache se despliega correctamente, con la leyenda personalizada “AXX-INSTANCIA-2 – AÑO 2025 – PRÁCTICA 1”.

Ejercicio 21: Liberar la IP Elástica y “terminar” ambas instancias.

Liberar la IP Elástica: Desde la consola de AWS, se seleccionó la dirección IP elástica asociada a las instancias. Luego, se utilizó la opción “Liberar direcciones IP elásticas”, lo que permite devolver dicha IP al pool de direcciones públicas de Amazon, dejándola disponible para otros usuarios.

Terminar instancias EC2: Posteriormente, se seleccionaron ambas instancias creadas (A01 y A01-INSTANCIA2) y se eligió la opción “Terminar”. Esta acción elimina de forma definitiva las instancias, liberando los recursos asociados.

Con estas acciones se concluye el ciclo de vida de las instancias creadas durante la práctica, asegurando que no queden recursos activos ni generen costos adicionales.

Map Reduce

Fri, 29 Aug 2025 00:00:00 GMT

MapReduce

Es un framework para distribuir tareas en múltiples nodos

El espíritu de MapReduce es "escriba una vez y lea muchas"

Ventajas

Paralelización y distribución de tareas automática
Escalable
Tolerante a fallos
Monitoreo y capacidad de seguridad
Flexibilidad de programación (Java, Python, C#, Ruby, C++)
Abstracción al programador

Es, a su vez, un paradigma de programación. Hay que pensar como resolver un problema sin tener acceso a todos los datos

Ejemplo (cálculo del promedio):

acum = 0
for d in datos:
    acum = acum + d
prom = acum / len(datos)

¿Cómo calculo el promedio de una lista de números si se que no tengo acceso a TODOS los valores?

El problema del cálculo del promedio se debe "repensar". Pedirle a cada nodo que sume y cuente sus datos

acum = 0; n = 0
for nodo in cluster:
    acum = acum + nodo.acum     # Esto se ejecuta en paralelo
    n = n + nodo.n
promedio = acum / n

Se pensó en un proceso genérico que permita resolver cualquier problema

Paradigma MapReduce

Toda tarea MapReduce se divide en dos fases:

Fase map: en la que los datos de entrada son procesados, uno a uno, y transformados en un conjunto intermedio de datos.
Fase reduce: se reúnen los resultados intermedios y se reducen a un conjunto de datos resumidos, que es el resultado final de la tarea.

En el ejemplo del promedio:

Map

Pedirle a cada nodo que sume y cuente sus datos

Reduce

acum = 0; n = 0
for nodo in cluster:
    acum = acum + nodo.acum
    n = n + nodo.n
promedio = acum / n

La unidad de trabajo de MapReduce es un Job

Un Job se divide en una tarea map y una tarea reduce.
Los Jobs de MapReduce son controlados por un daemon conocido como JobTracker, el cual reside en el "nodo master"
Los clientes envían Jobs MapReduce al JobTracker y este distribuye la tarea usando otros nodos del cluster
Esos nodos se conocen como TaskTracker y son responsables de la ejecución de la tarea asignada y reportar el progreso al JobTracker

Un job MapReduce es un proceso que se divide en cuatro fases:

Map → Shuffle → Sort → Reduce

Map y reduce son las tareas que se deben programar para la aplicación. Cada TaskTracker ejecuta la tarea encomendada (map o reduce) Shuffle y sort son internas en la ejecución del job.

Las tareas de map y reduce trabajan con el concepto de <clave, valor>.

Entrada de datos

MapReduce se "alimenta" de uno o mas archivos:

En el caso de archivos de texto plano, cada línea del archivo es un dato a procesar.
La clave de los archivos de texto plano es el offset de la línea dentro del archivo.

El o los archivos de entrada son divididos en "splits" y cada TaskTracker trabaja sobre un "split".

Tarea Map

Se ejecutan múltiples instancias de la tarea map sobre diferentes porciones del dataset.

Se intenta que cada map se ejecute sobre una copia local del dataset para minimizar el tráfico de datos. Una tarea map solo ve una porción del dataset de entrada.

La tarea map lee los datos en forma de pares <k1, v1> y produce una lista de cero, uno o más pares <k2, v2>.

<k1, v1> ➔ list(<k2, v2>) donde k2 es un identificador definido para el problema utilizado para agrupar los datos.

Una tarea map debería analizar una tupla en forma independiente del resto de las tuplas.

Ejemplo del Promedio

Suponemos que los valores llegan todos juntos, en formato string, separados por algún carácter que permite hacer la operación de split.

Paso 1 Map

Por lo general la clave de entrada (k1) no se usa, aunque depende del problema. En este ejemplo no lo estamos usando. Para el map, la clave de salida es un valor arbitrario (Ya veremos porqué) y como valor de salida devolvemos la tupla (acum, n)

Paso 4 Reduce

Finalizadas las tareas intermedias shuffle y sort se ejecuta la tarea reduce.

La tarea reduce lee los datos en forma de pares <k2, list(v2)> y produce una lista de cero o más pares <k3, v3>.

<k2, list(v2)> ➔ list(<k3, v3>)

La tarea reduce tiene todos los elementos para poder realizar cualquier operación de "resumen".

K2 es nuestro valor arbitrario "1", que no lo usamos en este ejemplo. En v2 tenemos TODAS las tuplas (acum, n) devueltas por cada taskTracker que ejecutó la tarea map

SIEMPRE tendremos que recorrer el iterable v2 usando un for
La salida del job será la tupla formada por una clave arbitraria (no importa en este ejemplo) y el cálculo del promedio

def map(k1, v1):
    values = v1.split()
    acum = 0
    for v in values:
        acum = acum + float(v)
    return (1, (acum, len(values)))

def reduce(k2, v2):
    acum = 0; n = 0
    for v in v2:
        acum = acum + v[0]
        n = n + v[1]
    return (k2, acum / n)

Otro ejemplo

Se posee un dataset con resultados de eventos. De cada evento se conoce su resultado ("POSITIVO", "NEUTRO", "NEGATIVO").

Se desea saber cuantos eventos positivos, neutrales y negativos hay en todo el dataset.

El dataset es uno o más archivos de texto donde en cada línea está el resultado del evento.

POSITIVO
POSITIVO
NEGATIVO
NEUTRO
POSITIVO
NEUTRO
NEGATIVO
NEGATIVO
NEUTRO
POSITIVO
NEGATIVO

Tarea map: nuestra intención es contar la ocurrencia de cada tipo de evento.

V1 es el tipo de evento "POSITIVO", "NEUTRO", "NEGATIVO"

Aca tenemos un problema ya que no importa la informacion que estemos trayendo, siempre vamos a estar trabajando con un reduce. (No estamos distribuyendo bien la carga)

def map(k1, v1):
    return (1, v1)

¿Qué sucede si usamos una única clave intermedia?

El valor lo usamos como clave intermedia. En este ejemplo el valor intermedio v2, no lo usamos, por eso le ponemos un valor arbitrario

Al hacer esto, tenemos 3 claves intermedias (3 taskTrackers)

def map(k1, v1):
    return (v1, 1)

Los positivos negativos y neutros estan coloreados. Cuantas veces vamos a ejecutar la tarea map?? ESO NO LO SABEMOS, LO DECIDE EL JOBTRACKER. Pero lo que si podemos hacer, que con esto que tenemos tres claves distintas, es asegurarnos, en el mejor de los casos, se ejecuten tres taskTrackers y cada uno va a hacer la tarea de reduce de cada una de esas tres claves.

En la fase reduce podemos lograr la paralización de tareas por claves y que se va a ejecutar la función reduce, tantas veces, como claves intermedias distintas generen los maps. En el mejor de los casos en caso de tener nodos suficientes cada nodo ejecutara un reduce para cada clave, logrando una paralelización completa. En el peor de los casos, tendremos un unico nodo, un unico TaskTracker procesando las tres claves de manera secuencial. (Nosotros no nos tenemos que preocupar en esa parte).

Tanto la fase reduce como la map, se va a paralelizar tanto como se pueda.

Cada TaskTracker que ejecuta la tarea de reduce recibe todas las tuplas del tipo "POSITIVO", "NEUTRO" o "NEGATIVO".
Solo hay que contar cuantas ocurrencias existen.
Tendremos una salida por cada tipo de evento.

Solo hay que contar ocurrencias

def map(k1, v1):
    return (v1, 1)

def reduce(k2, v2):
    n = 0
    for v in v2:
        n = n + 1
    return ( k2 , n)

En este ejemplo se ejecutan tres reducers. Cada uno hace la contabilidad de las tuplas que se generaron para cada una de las tres claves ("POSITIVO", "NEUTRO", "NEGATIVO")

Practica 1

Dado el siguiente dataset

| Split 1 | | Split 2 | | Split 3 | | Split 4 | | |---------|-----|---------|-----|---------|-----|---------|-----| | Key | Value | Key | Value | Key | Value | Key | Value | | 34 | 21 | 23 | 45 | 3 | 21 | 30 | 91 | | 21 | 34 | 12 | 12 | 15 | 10 | 31 | 32 | | 10 | 18 | 36 | 18 | 14 | 18 | 32 | 53 | | 32 | 45 | 4 | 97 | 3 | 15 | 19 | 35 |

Responda para cada job:

¿Cuántas veces (invocaciones) se ejecuta la función map?
¿Cuántas veces (invocaciones) se ejecuta la función reduce?
¿Cuántos mappers se ejecutan?
¿Cuántos reducers se ejecutan?
¿Qué datos recibe cada función reduce?
¿Cuál es la salida de cada job?

a) Job A

¿Cuántas veces se ejecuta la función map? 16 (Una por cada linea)
¿Cuántas veces se ejecuta la función reduce? 4 (Una por cada split)
¿Cuántos mappers se ejecutan? Se ejecutan 4 mappers (uno por cada nodo en el mejor de los casos)
¿Cuántos reducers se ejecutan? Se ejecuta 1 reducer ya que al escribir (1, v1) se agrupan todos los valores en una sola clave (por lo que no permite la concurrencia)
¿Qué datos recibe cada función reduce? Recibe una lista de values

# Genera un solo archivo con todos los valores
# por ejemplo
# (1, "21")
# (1, "34")
# (1, "18")
def map(k1, v1, context):
    context.write(1, v1)

# Recibe una lista con todos los valores
# Y cuenta los valores simplemente
# Retorna k2 que es 1 y n que seria la cantidad
# de valores en este caso 16
def reduce(k2, v2, context):
    n = 0
    for v in v2:
        n = n + 1
    context.write(k2, n)

¿Cuál es la salida de cada job? La salida de cada Job es (1, 16)

b) Job B

¿Cuántas veces se ejecuta la función map? 16 (Una por cada key diferente)
¿Cuántas veces se ejecuta la función reduce? 4 (Una por cada split)
¿Cuántos mappers se ejecutan? Se ejecutan 4 mappers (uno por cada nodo en el mejor de los casos)
¿Cuántos reducers se ejecutan? Se ejecuta 1 reducer ya que al escribir (1, v1) se agrupan todos los valores en una sola clave (por lo que no permite la concurrencia)
¿Qué datos recibe cada función reduce? Recibe una lista de values

# Genera un solo archivo con todos los valores
# por ejemplo
# (1, "21")
# (1, "34")
# (1, "18")
def map(k1, v1, context):
    context.write(1, v1)

# Recibe una lista con todos los valores
# Y suma los valores simplemente
def reduce(k2, v2, context):
    n = 0
    for v in v2:
        n = n + v
    context.write(k2, n)

¿Cuál es la salida de cada job? La salida de cada Job es (1, 565)

Split 1 -> 21 + 34 + 18 + 45 = 118
Split 2 -> 45 + 12 + 18 + 97 = 172
Split 3 -> 21 + 10 + 18 + 15 = 64
Split 4 -> 91 + 32 + 53 + 35 = 211
Total -> 118 + 172 + 64 + 211 = 565

c) Job C

¿Cuántas veces se ejecuta la función map? 16 (Una por cada linea)
¿Cuántas veces se ejecuta la función reduce? 8 (Dos por cada split)
¿Cuántos mappers se ejecutan? 4 mappers
¿Cuántos reducers se ejecutan? 2 reducers (Uno para cada clave intermedia)
¿Qué datos recibe cada función reduce? * Recibe una lista de keys

# Si la key valor es mayor a 30 lo guarda con la key y la guarda con 1
# En caso contrario lo guarda la key y le pone el valor 2
def map(k1, v1, context):
    if (v1 < 30):
        context.write(1, k1)
    else:
        context.write(2, k1)

# Se ejecuta dos veces, uno con las keys con los valores menores a 30
# Y otra con los mayores a 30
def reduce(k2, v2, context):
    max = -1
    for v in v2:
        if(v > max):
            max = v
    context.write(k2, max)

Primero se filtra por los valores menores a 30 y guarda las keys

¿Cuál es la salida de cada job?

(1, [34, 10, 12, 36, 3, 15, 14, 3]) -> De este se queda el mayor 36
(2, [21, 32, 23, 4, 30, 31, 32, 19]) -> De este se queda el mayor 32

El resultado es (1, 36) (2, 32)

d) Job D

¿Cuántas veces se ejecuta la función map? 16 veces
¿Cuántas veces se ejecuta la función reduce? Se ejecuta reduce() 14 veces (una por cada clave única).
¿Cuántos mappers se ejecutan? 4 mappers
¿Cuántos reducers se ejecutan? 14 reducers (unique keys)
¿Qué datos recibe cada función reduce? Cada reducer recibe una lista de Value elementos, todos iguales, generados por el map.

def map(k1, v1, context):
    for v in range(v1):
        context.write(k1, v1)

def reduce(k2, v2, context):
    n = 0
    for v in v2:
        n = n + 1
    context.write(k2, n)

¿Cuál es la salida de cada job?

(34, 21), (34, 21), ... (21 veces)
(21, 34), (21, 34), ... (34 veces)
...
(19, 35), (19, 35), ... (35 veces)

Las salidas del job son (Key, cantidad) donde cantidad es el número de repeticiones, equivalente a Value.

e) Job E

¿Cuántas veces se ejecuta la función map? unas 16 veces
¿Cuántas veces se ejecuta la función reduce? unas 16 veces
¿Cuántos mappers se ejecutan? 4 mappers
¿Cuántos reducers se ejecutan? 13 reducers (unique values)
¿Qué datos recibe cada función reduce?

def map(k1, v1, context):
    context.write(v1, k1)

def reduce(k2, v2, context):
    n = 0
    for v in v2:
        n = n + 1
    context.write(v, n)

¿Cuál es la salida de cada job? ey, numero entre 1 y veces que aparece su value

3) ¿Cómo haría para obtener el top 20 de las palabras más usadas?

Como reduce no tiene acceso al orden de aparición ni a líneas específicas, y una palabra puede aparecer en distintas líneas, no es posible agrupar las ocurrencias por línea. Por eso, las apariciones totales se muestran desordenadas y requieren procesamiento adicional externo (por ejemplo, en Excel) si se desea un orden o agrupación específica.

5) Indique si utilizando el dataset Libros es posible resolver los siguientes problemas:

a. Obtener los títulos de todos los libros

Si, ya que el offset del titulo es 0 en todos los archivos.

b. Obtener la cantidad de palabras promedio por párrafo

Si, la función map pasa la cantidad de palabras del párrafo que procesó, y la reduce calcula el promedio sumando las cantidades de palabras pasadas, y la cantidad de párrafos se obtiene a partir de la cantidad de VALORES recibidos.

c. Obtener la cantidad de párrafos promedio por libro

No, porque la clave no contiene info del archivo origen?

d. Obtener la cantidad de caracteres del párrafo más extenso

Se puede obtener la cantidad de caracteres de cada párrafo (ordenado de menor a mayor ya que el valor es único por dato/linea), el máximo estará al final de alguna salida...

e. Cantidad total de párrafos con diálogos (se entiende por párrafo con diálogo aquel que empieza con un guión)

Si, ya que siguen un mismo "prefijo" y se pueden contabilizar todos bajo una única clave, de modo de obtener un solo resultado

f. El diálogo más largo (se entiende por diálogo a una secuencia de párrafos con diálogo que aparecen de manera consecutiva)

No, porque no se conoce información del dato anterior.

g. El top 20 de las palabras más usadas por cada libro

No, desconozco el archivo origen

6) Ejercicio

Una empresa proveedora de internet realizó una encuesta para conocer el grado de satisfacción de sus clientes, en un formulario web los clientes debían completar un campo con los textos "Muy satisfecho", "Algo satisfecho", "Poco satisfecho", “Disconforme” o "Muy disconforme". Utilice el dataset Encuesta para saber cuántos clientes están en cada una de las cinco categorías.

Respuesta

La función map enviará cada respuesta como clave, asignándole el valor 1. De esta forma, todas las respuestas iguales se agruparán bajo una misma clave. Luego, la función reduce sumará la cantidad de apariciones de cada clave para obtener el total por categoría.

Sin embargo, observamos que el formato no siempre se respeta: existen muchas variantes con errores tipográficos como "muy satisfecho", "muys atisfecho" o "disconfrome", que dificultan el conteo correcto.

Por ello, para obtener resultados confiables, es necesario aplicar una etapa de normalización previa o durante el map, que agrupe variantes similares en alguna de las cinco categorías válidas: "Muy satisfecho", "Algo satisfecho", "Poco satisfecho", "Disconforme" y "Muy disconforme".

Esto puede lograrse usando comparaciones por similitud (por ejemplo, con difflib.get_close_matches en Python), o validaciones exactas contra una lista predefinida de opciones válidas. Una vez agrupadas correctamente, el reduce podrá contabilizar cuántos clientes están en cada categoría con mayor precisión.

7) Ejercicio

El dataset Inversionistas posee los nombres, dni, fecha de nacimiento (día, mes y año como campos separados) e importe invertido por diferentes personas en la apertura de un nuevo negocio en la ciudad. Se desea saber:

a) El nombre del inversionista más joven
b) El total del importe invertido por todos los inversionistas
c) El promedio de edad

Implemente una solución en MapReduce. ¿Se puede resolver los tres problemas en un único job?

Respuesta

No, no se pueden resolver los tres puntos con un solo Job, ya que:

a) requiere obtener el máximo de una fecha
b) requiere la suma de importe
c) requiere el promedio de edades, lo cual implica contar e ingresar las edades explícitamente

Cada una tiene requerimientos distintos y estructuras de datos diferentes.

Ejercicio 8)

Si contáramos con un cluster donde podemos configurar 100 nodos para la tarea de reduce ¿De qué manera se podrían usar esos 100 nodos en el ejemplo de los eventos POSITIVO, NEGATIVO y NEUTRO visto en la teoría?

Producir en los mappers unas tuplas con clave "POSITIVO" + random(33) Esto permite forzar la paralelización

Parcial Inge 3

Sat, 12 Jul 2025 00:00:00 GMT

Resumen Administración de Proyectos

Un proyecto es una secuencia de actividades únicas, complejas y conectadas que tienen un objetivo o propósito específico

Un proyecto tiene un alcance limitado, siempre resulta en un producto u "entregable", y su éxito se mide por el cumplimiento del presupuesto, el tiempo de entrega y las especificaciones del producto.

Proyecto - Líder de Proyecto

Es un jugador de equipo que motiva al personal usando sus conocimientos.

Desarrollar el plan del proyecto: Esto implica definir cómo se ejecutará el proyecto, estableciendo las actividades, los recursos necesarios y los plazos.
Identificar los requerimientos y el alcance del proyecto: Es crucial definir claramente qué se va a hacer y qué no se va a hacer para evitar desviaciones y asegurar un enfoque claro.
Comunicar y reportar a los interesados: El líder de proyecto debe mantener informados a todas las partes relevantes sobre el avance, los problemas y las decisiones del proyecto.
Administrar recursos humanos y materiales: Esto incluye la asignación, gestión y motivación del equipo del proyecto, así como la gestión de los recursos físicos necesarios.
Controlar tiempos: El líder de proyecto debe supervisar el cronograma del proyecto para asegurar que las actividades se completen según lo planeado y tomar acciones correctivas si es necesario.
Identificar y controlar riesgos: Esto implica anticipar posibles problemas y desarrollar estrategias para mitigarlos.
Administrar costos y presupuesto: El líder de proyecto debe gestionar el presupuesto del proyecto, asegurando que los costos se mantengan dentro de los límites establecidos.
Asegurar la calidad: Esto implica establecer estándares de calidad y realizar revisiones para garantizar que el producto final cumpla con las expectativas.
Evaluar el desempeño del proyecto: El líder de proyecto debe medir el progreso y el rendimiento del proyecto en relación con los objetivos establecidos.

Parámetros de un Proyecto

Los parámetros de un proyecto son los elementos que definen su alcance y éxito. Los principales son

Alcance: Enunciado que define los límites del proyecto. Establece qué se va a hacer y, de manera implícita, qué no se va a hacer. Es fundamental que sea definido correctamente. Puede cambiar.
Calidad: En el desarrollo de un proyecto, existen dos tipos de calidad a considerar: la calidad del producto final y la calidad del proceso utilizado para crearlo. Asegurar la calidad es una de las tareas del responsable del proyecto.
Costo: El costo se refiere al presupuesto disponible para completar el proyecto.
Tiempo: El tiempo es la ventana temporal dentro de la cual el proyecto debe ser terminado.
Recursos: Los recursos son los activos necesarios para la realización del proyecto, tales como personas, equipos, facilidades físicas o artefactos. Tienen una disponibilidad limitada y su uso debe ser planificado; también pueden ser contratados a terceros. Algunos recursos son fijos y otros variables a largo plazo. Son centrales para la planificación de las actividades del proyecto y para su finalización ordenada, siendo las personas el recurso más importante en proyectos de desarrollo de sistemas.

La idea principal detrás del "Triángulo de Alcance" es que estos tres aspectos (alcance/calidad, tiempo/costo, y recursos) están en constante interacción y deben mantenerse en equilibrio. Cualquier modificación en uno de estos vértices del triángulo inevitablemente tendrá un impacto en los otros dos.

Se pueden clasificar en:"

Duración: Tiempo estimado que tomará completar el proyecto, desde la planificación hasta la entrega final. A mayor duración, mayor incertidumbre.
Riesgo: Probabilidad de fracaso del proyecto o de que no cumpla con sus objetivos
Complejidad: Es la medida de la dificultad técnica y organizativa del proyecto. Factores clave serían: Tamaño del sistema, Número de módulos, Integraciones con otros sistemas, Lógica de negocio, etc.
Valor Comercial: Representa el impacto económico o estratégico que el proyecto tiene para la organización.
Costo: Es la inversión económica estimada necesaria para completar el proyecto.

Resultado en este cuadro:

| TIPO | DURACIÓN | RIESGO | COMPLEJIDAD | TECNOLOGÍA | PROBLEMAS | |----------|---------------|-------------|------------------|---------------------|------------------------| | A | > 18 Meses | Alto | Alta | De avanzada | Seguros | | B | 9–18 Meses | Medio | Media | Actual | Alta probabilidad | | C | 3–9 Meses | Bajo | Baja | Mejor del tipo | Algunos | | D | < 3 Meses | Muy Bajo | Muy Baja | Práctica | Ninguno |

Tener en cuenta que para la práctica no clasificamos por A, B, C o D. Vamos viendo una a una cada categoría y explicamos que valor tendría el proyecto para la misma.

Causas de Fracaso de un Proyecto

No prestar la suficiente atención a…

Caso de negocio: Si no se comprende claramente por qué se está llevando a cabo el proyecto, o si los beneficios esperados no se definen o validan adecuadamente, el proyecto puede fracasar por no entregar valor a la organización
Calidad: Ignorar o no priorizar la calidad del producto o del proceso puede llevar a entregables defectuosos, insatisfacción del cliente y, en última instancia, al fracaso del proyecto
Definición y medida de los entregables: Si no se especifica con claridad qué se debe entregar al final del proyecto y cómo se medirá su éxito, puede haber confusión, expectativas no cumplidas y la percepción de que el proyecto no tuvo éxito.

Inadecuada…

Definición de responsabilidades: Si los roles y responsabilidades de los miembros del equipo y otros interesados no están claramente definidos, puede haber duplicación de esfuerzos, falta de rendición de cuentas y conflictos que lleven al fracaso.
Planificación y coordinación de recursos: Una planificación deficiente de los recursos (humanos, materiales, financieros, etc.) y una mala coordinación pueden resultar en escasez, cuellos de botella y retrasos que afecten el éxito del proyecto.

Pobre estimación de…

Duración: Subestimar el tiempo necesario para completar las actividades del proyecto puede llevar a cronogramas irreales, presión excesiva sobre el equipo y, finalmente, al incumplimiento de los plazos.
Costos: Una estimación inexacta del presupuesto necesario para el proyecto puede resultar en la falta de fondos en etapas críticas, la necesidad de reducir el alcance o la calidad, o la cancelación del proyecto.

Falta de…

Comunicación con los interesados: Una comunicación deficiente con los stakeholders del proyecto (clientes, patrocinadores, equipo, etc.) puede generar malentendidos, expectativas no gestionadas, falta de apoyo y, en última instancia, el fracaso del proyecto.
Compromiso de los interesados: Si los interesados clave no están involucrados y comprometidos con el proyecto, pueden surgir obstáculos, falta de apoyo y resistencia al cambio que dificulten el éxito.
Control de calidad: No implementar procesos de control de calidad adecuados puede llevar a la aceptación de entregables defectuosos, lo que requerirá retrabajo y puede afectar el cronograma y el presupuesto, o resultar en un producto final deficiente.
Control de avance: No realizar un seguimiento regular del progreso del proyecto y no tomar acciones correctivas ante las desviaciones puede hacer que los problemas se acumulen y lleven al fracaso.

Ciclo de Vida de un Proyecto

El ciclo de vida de un proyecto es un proceso que va desde la concepción y planificación, pasando por la ejecución y el control, hasta su cierre formal.

Definir el proyecto/Iniciar: Establecer claramente los objetivos del proyecto, su alcance y los criterios de éxito.
Desarrollar un plan detallado/Planificar: Se elabora una hoja de ruta exhaustiva para la ejecución del proyecto
Ejecución del proyecto: Se lleva a cabo el trabajo real del proyecto según el plan establecido.
Monitorear/Controlar: Durante la ejecución, es esencial realizar un seguimiento del progreso del proyecto en relación con el plan
Terminación/Cierre: Esta etapa marca el final formal del proyecto.

Administración de Proyectos

La administración de proyectos es la planificación, la delegación, el seguimiento y el control de todos los aspectos del proyecto y la motivación de los participantes para satisfacer los requisitos del proyecto

Optimización de Recursos
Cumplimiento de Plazos y Presupuestos
Mejora en la Calidad
Gestión Efectiva de Riesgos
Satisfacción de los Interesados

Alto nivel de innovación
Complejidad
Requerimientos ambiguos
Falta de competencias necesarias
Herramientas y técnicas inmaduras
Cumplir con regulaciones de gobierno
Cumplir con plazos
Tratar con proveedores
Reportar a altas autoridades
Retener personal calificado
Administrar personal con diferentes niveles de productividad
Administrar equipos distribuidos en diferentes ubicaciones
Administrar entornos multi-culturales y multi-lingua

Principios de una buena administración

Los proyectos siempre necesitan ser gestionados para tener éxito.
El proyecto es un proceso finito con un comienzo y un final definidos.
Se requiere un compromiso sincero de todos los interesados.
Normalmente se requiere entrenamiento.

Programas

Un programa es un grupo de proyectos relacionados que se gestionan de manera coordinada para obtener beneficios. Se ocupa de los resultados y proporciona un paraguas bajo el cual estos proyectos pueden ser coordinados.

La administración de programas busca integrar los proyectos de modo que se produzca un resultado mayor que la suma de sus partes. Es complementaria a la Administración de Proyectos.

| Característica | Programa | Proyecto | | -------------------- | ------------------------------------------------- | ------------------------------------------- | | Alcance | Amplio y flexible. | Limitado y concreto. | | Cambio | Se espera y acepta. | Se minimiza. | | Medición del Éxito | ROI y beneficios organizacionales. | Presupuesto, tiempo y especificaciones. | | Liderazgo | Enfocado en relaciones y visión estratégica. | Enfocado en tareas y cumplimiento de metas. | | Planificación | General y orientativa. | Detallada y operativa. | | Gerentes | Coordinan múltiples proyectos para generar valor. | Ejecutan productos bajo restricciones. |

En este contexto, la administración de proyectos se enfoca en la gestión de cada proyecto individual dentro del programa, mientras que la administración de programas se encarga de supervisar y coordinar estos proyectos relacionados para alcanzar objetivos estratégicos más amplios.

Work Breakdown Structure (WBS)

WBS es una descripción jerárquica (top-down) del trabajo que se debe realizar para completar el proyecto. Es similar a una descomposición funcional.

Dividimos el trabajo en actividades y las actividades en tareas que son lo más bajo.
Tiene forma de árbol, la raíz es el proyecto o meta a cumplir, los diversos nodos intermedios son las actividades y las hojas las tareas.

Tenemos que buscar que ese árbol esté balanceado o no muy desproporcionado

El Líder de Proyecto se encarga de la confección del WBS. Las formas de construcción son:

Top-down (de equipo completo o sub-equipos).
Bottom-up

Top-down de equipo completo:

Todos los miembros participan en la descomposición.
Se comienza desde la meta y se particiona hasta que los participantes estén satisfechos en la definición del trabajo.
Luego de la definición se debe secuenciar y determinar qué actividades se pueden hacer concurrentes.
Ventaja: Todos los miembros tienen la oportunidad de prestar atención al WBS y discutirlo en su definición.

Top-down de sub-equipos:

Todo el equipo realiza el primer nivel y luego se crean tantos sub-equipos como actividades haya en el nivel uno.
Un sub-equipo puede necesitar ayuda externa.
Demanda menos tiempo que el enfoque anterior.

Bottom-up:

Parecido al Brainstorming.
Actúa como el Top-down de sub-equipos en la división del primer nivel y la asignación de grupos por actividades. Cada sub-grupo realiza un "Brainstorming" para sub-dividir esa actividad de primer nivel

Diseñar y planificar el trabajo: Permite a los integrantes del equipo visualizar cómo puede definirse y administrarse el proyecto.
Diseñar la arquitectura: Gráfico del trabajo del proyecto donde se muestra cómo se relacionan los items a realizar.
Planificar: Tenemos que estimar esfuerzo, tiempos y recursos para el último nivel.
Informar el estado del proyecto: Se usa como estructura para mostrar el grado de avance

Estado Medible: En cualquier momento tengo que poder saber el estado de desarrollo de esa tarea.
Acotada: Tiene que poseer una duración acotada.
Producir un entregable: El entregable es el output de la Tarea.
Tiempo y costo estimable: Si no se pueden estimar ni el costo ni el tiempo, entonces no es una Tarea (no es atómico).
Duración aceptable: La duración de una tarea no debe exceder los 15 días (10 laborables), aunque puede haber excepciones.
Independiente: Al iniciar la actividad no se tiene que necesitar de ningún input adicional para arrancar.

Duración y Esfuerzo de Trabajo

La duración de una actividad se define como el tiempo transcurrido en días laborables para finalizar el proyecto, sin considerar feriados, fines de semana, días no laborables.

El esfuerzo de trabajo es la labor requerida para completar una actividad. Esta labor se puede realizar en horas consecutivas o no

| Concepto | Resumen | | ----------------------- | ----------------------------------------------------------------------------------------------- | | Duración | Tiempo total en días laborables desde el inicio al fin, incluyendo inactividad o solapamientos. | | Esfuerzo de Trabajo | Cantidad de trabajo (ej. horas-persona) necesaria, sin importar cuánto tiempo calendario tome. |

Variación en los perfiles: Las personas pueden tener distintos perfiles para completar la actividad, algunos más adecuados que otros. Una estrategia es estimar la duración basándonos en los perfiles de las personas.
Eventos inesperados.
Eficiencia del tiempo de trabajo: Trabajando de manera focalizada podemos lograr una mayor eficiencia, tenemos que evitar interrupciones y proveer un ambiente que facilite la concentración.
Errores e interpretaciones erróneas

Similitud con otras actividades: Estimar el esfuerzo en base a actividades similares de otro proyectos.
Datos históricos: Estimar en base a las estimaciones de actividades similares de otros proyectos en base a datos fehacientes y registrados.
Juicio experto: Las estimaciones las realizan consultores externos o expertos en la metodología o tecnología. El Juicio Experto no tiene que venir del Vendedor (esto no es objetivo).
Técnica Delphi: Técnica de grupo que extrae y resume el conocimiento del grupo para arribar una estimación. Cada miembro del grupo hará estimaciones individuales.
- Se realizan 3 pasadas para llegar a la estimación mediana (el promedio). En cada pasada se toman los extremos, estos extremos debaten y luego se hace la siguiente pasada con nuevos conocimientos.
Técnica de 3 puntos: Se necesitan 3 estimaciones, la optimista, la pesimista y la media.
- La técnica de la estimación es un promedio pesado Estimacion = (Optimista + 4*Media + Pesimista) / 6
- La optimista es la más corta (caso feliz).
- La pesimista es la más larga (caso triste, todo falla)
- La media es la normal o usual de la actividad.
Técnica Delphi de banda ancha: Combinación de las 2 anteriores. Se basa en la Delphi pero a cada integrante se le pide que haga las 3 estimaciones de los 3 puntos.

Estimación de Costos

Las Estimaciones de Costos son predicciones de cuanto tiempo, esfuerzo y perfiles de RRHH (recursos humanos) son requeridos para construir un sistema de software

Dominio de aplicación.
Hardware.
Herramientas.
Técnicas.
Personal

Opinión Experta*: Tomamos ventaja de la experiencia de un personal de desarrollo senior.
Analogía: Comparamos el proyecto con presupuestos de proyectos pasados.
Descomposición: Focalizamos el análisis en el producto o en las tareas requeridas para construirlo, descomponemos el productos en componentes, actividades y tareas.
Modelos: Son técnicas que identifican contribuyentes claves al esfuerzo, generando fórmulas matemáticas que relacionan estos ítems al esfuerzo. Hay 2 enfoques:
- Bottom-up: Primero estimamos las partes de menor nivel.
- Top-down: Estimamos el producto entero y luego los componentes se calculan como porciones relativas del todo.

En planificación: Se necesita saber cuantos recursos va a insumir.
En control: Se necesita saber cuanto se hizo y cuanto falta

COCOMO original - Constructive Cost Model

Es una colección de tres modelos de estimación de esfuerzo, duración y costo para proyectos, que difieren en la cantidad de información que se tiene sobre el proyecto y el nivel de detalle en la estimación del esfuerzo y el tiempo de desarrollo

Modelo Básico

Es aplicable cuando se conoce muy poco del proyecto.
Se utiliza en las etapas iniciales, donde la información disponible es limitada.

Modelo Intermedio

Es aplicable luego de la especificación de requerimientos.
Se utiliza cuando se tiene un poco más de conocimiento sobre el proyecto, como el lenguaje y las herramientas a utilizar.

Modelo Avanzado (o Detallado):

Es aplicable cuando se termina el diseño.

El modelo Básico ofrece una estimación rápida y general al inicio del proyecto, el modelo Intermedio refina la estimación al considerar los conductores de costos que influyen en el esfuerzo, y el modelo Avanzado proporciona una estimación aún más precisa al aplicar el modelo intermedio a los componentes individuales del sistema y considerar las diferentes fases del desarrollo.

Orgánico: Procesa datos y usa bases de datos. Focalizado en transacciones y recuperación de datos.
Semi-embebido: Intermedio entre orgánico y embebido. Mayor procesamiento de transacciones.
Embebido: Software de tiempo real, parte integral de un sistema mayor basado en hardware.

En el modelo COCOMO original, el esfuerzo requerido para desarrollar software se estima en base a tres factores principales:

Constantes del modelo: Dependientes del tipo de sistema.
Tamaño del software: Medido en miles de líneas de código entregadas (KSDI).
Factor de ajuste: Modifica el esfuerzo según diferentes características del proyecto.

Tipos de modelos en COCOMO:

En el modelo básico, el factor de ajuste es 1 (no se modifica).
En los modelos intermedio y avanzado, este factor se calcula considerando distintos atributos del proyecto, agrupados en 4 categorías:

Categorías de atributos que afectan el esfuerzo:

Del producto: Confiabilidad, complejidad, tamaño de base de datos.
Del hardware: Restricciones técnicas, rendimiento, almacenamiento.
Del personal: Experiencia, habilidades, conocimiento del lenguaje y herramientas.
Del proyecto: Calidad del proceso, herramientas utilizadas, planificación.

Gestión de Beneficios

Enfoque estratégico que tiene como principal objetivo asegurar que los beneficios sean identificados, definidos claramente, vinculados a los resultados estratégicos, y que cumplan con los criterios de ser específicos, medibles, realizables, realistas y limitados en el tiempo.

Su enfoque consiste en un proceso que incluye la identificación, cuantificación, realización revisión de dichos beneficios. Este enfoque se desarrolla a través de las siguientes etapas:

Desarrollo de una Estrategia de Gestión de Beneficios: Define cómo el programa gestionará los beneficios, incluyendo cómo serán cuantificados y medidos, y los sistemas y procesos para hacer seguimiento del progreso y la realización.
Identificación y Cuantificación de Beneficios (Perfiles de Beneficios): Se identifican los beneficios en áreas como calidad de servicio, sociedad, economía, ajuste estratégico y administración interna.
Planificación para la Realización de Beneficios (Plan de Realización de Beneficios): Se crea un cronograma completo de todos los perfiles de beneficios, definiendo cuándo se realizará cada uno e incluyendo hitos para la revisión y detalles de actividades de traspaso necesarias después del cierre del programa.
Realización de Beneficios: Se entregan los beneficios incrementales a través de la implementación de los productos del proyecto, lo que a menudo requiere cambios estructurales y/o de procesos dentro de las organizaciones.
Revisión de Beneficios: Se valida regularmente el valor de los beneficios esperados y realizados a los ojos de los stakeholders. Los objetivos clave son evaluar y actualizar los

Gestión de los Interesados/Stakeholders

Es el proceso de identificar y comunicarse efectivamente con aquellas personas o grupos que tienen interés en los resultados de los programas/proyectos. También gestiona las relaciones con las partes interesadas como una forma de lograr influencia y resultados positivos de los programas y proyectos. Características principales perfiles y el plan de realización, asegurar la alineación con los objetivos del programa, validar el valor para los stakeholders, y evaluar el nivel de logro contra los perfiles previstos.

Análisis y compromiso efectivo de los interesados a distintos niveles: Esto implica que los interesados, tanto internos como externos a la organización, deben ser analizados y comprometidos de manera eficaz para lograr los objetivos del programa en términos de apoyo y compromiso.
Planificación de las comunicaciones: La gestión de los interesados incluye la planificación de las comunicaciones.
Uso e identificación efectiva de canales de comunicación: Se deben utilizar e identificar de manera efectiva los diferentes canales de comunicación para alcanzar los objetivos del programa.
Comunicación clara, consistente y enfocada: A nivel estratégico, la comunicación con los interesados debe ser clara, consistente, enfocada en lo esencial y en un lenguaje comprensible para todos.
Proceso continuo: La gestión de los interesados debe ser vista como un proceso continuo en todas las iniciativas del programa y vinculada al ciclo de vida de la iniciativa y los controles de la institución.

Objetivos de la gestión de los interesados (stakeholders):

Identificar a los interesados.
Definir claramente los intereses e influencias de los interesados.
Asegurar que los interesados se comprometan de acuerdo a sus intereses e influencias en el programa. Asegurar que los interesados se comprometan, se apropien y apoyen el programa.

Preguntas que responde:

¿QUIÉN? (Identificar los interesados)
¿QUÉ? (Crear y analizar los perfiles de los interesados)
¿CÓMO? (Definir estrategia de participación de los interesados)
¿CUÁNDO? (Planificar la participación)
¿HACER? (Participación de los interesados)
¿RESULTADOS? (Medir la efectividad)

La Gestión de los Stakeholders se basa en 5 procesos:

La identificación de los interesados y sus intereses se representa de diversas formas, siendo una de ellas a través de un mapa de los interesados. Este mapa es una matriz que muestra a los interesados y sus intereses particulares en el programa

| STAKEHOLDERS | DIRECCIÓN ESTRATÉGICA | FINANCIERA | CAMBIOS OPERACIONALES | INTERFAZ CON LOS CLIENTES | |--------------------------|---------------------------|----------------|----------------------------|-------------------------------| | Clientes | Bajo | Medio | Alto | Alto | | Grupos de Proyectos | Medio | Medio | Alto | Medio | | Personal | Medio | Medio | Alto | Medio | | Organismos Reguladores | Alto | Medio | Bajo | Medio | | … | … | … | … | … |

El análisis de los stakeholders comprende entender y analizar su influencia e impacto en el proyecto. Esto es necesario para diseñar canales de comunicación apropiados que respondan a las necesidades e intereses de los stakeholders.

Para analizar usamos una matriz de impacto de los stakeholders donde se incluyen los siguientes datos:

En un eje de la matriz se representa el "POSIBLE IMPACTO DEL PGM EN LOS STAKEHOLDERS". Este eje evalúa el nivel de impacto que el programa podría tener en cada uno de los stakeholders, categorizándolo generalmente en niveles como Alto, Medio y Bajo.
En el otro eje de la matriz se representa la "IMPORTANCIA DE LOS STAKEHOLDERS EN EL PROGRAMA". Este eje evalúa la relevancia o significancia de cada stakeholder para el éxito del programa, también categorizada en niveles como Alto, Medio y Bajo.

Consiste en definir un marco que permita la participación efectiva de los stakeholders. Tenemos a Definir:

¿Cómo definimos un objetivo claro para el compromiso?
¿Cómo mantenemos el compromiso dentro de los límites?
¿Quién debe ser responsable de participar?
¿Cuál es el mejor método de compromiso?
¿Cómo medimos el éxito?

La comunicación es un factor crítico de éxito para cualquier proceso de transformación.

Buscamos principalmente concientizar a los stakeholders sobre los beneficios y el impacto, obtener el compromiso del personal de las organizaciones con los cambios a ser introducidos, promover mensajes claves del programa, etc. Para realizar esta tarea, se confecciona un plan de comunicación que incluye los siguientes datos:

Qué se comunicará y la autoridad requerida para la comunicación.
Cómo se comunicará.
Quién comunicará.
Cuándo se comunicará.

Posibles canales de comunicación:

Seminarios y workshops: Permiten el contacto directo con los interesados.
Prensa/Medios: Son canales ideales para públicos externos más amplios.
Boletines, instrucciones, anuncios, informes: Pueden utilizarse para comunicar información general y específica relacionada con interesados particulares.

Es necesario para mantener el impulso y el programa en marcha.

Esta gestión asegura que:

Existe un entendimiento compartido sobre lo que se entiende por “stakeholder”.
Existe un conjunto detallado de grupos de stakeholders orientados a la práctica.
Existen metas establecidas para cada grupo o conjunto de grupos de stakeholders.
Existe un plan de comunicaciones claro para alcanzar estas metas
Los miembros del equipo de gestión del programa están motivados para alcanzar estas
metas.
Los grupos de stakeholders se sienten suficientemente comprometidos con el programa y comprenden los objetivos y limitaciones de los mismos.
Se miden las opiniones de los stakeholders y se actúa en consecuencia

Gestión de Riesgos

Un riesgo es un evento potencial (negativo o positivo) que podría afectar el curso del programa o proyecto. Se gestiona para minimizar amenazas o aprovechar oportunidades.

Un problema es una cuestión actual, ya presente o en discusión, que obstaculiza el proyecto. No confundir con el concepto de riesgo.

Identificar riesgos Tipos: Estratégicos, De programa, De proyecto y Operativos.
Registrar riesgos en un repositorio formal. Es el repositorio central de toda la información sobre riesgos. Permite priorizar, tomar acción y hacer seguimiento.
Asignar propiedad del riesgo a personas con capacidad para gestionarlos. Cada riesgo debe ser asignado a un responsable que tenga autoridad y competencia para actuar.
Evaluar los riesgos (probabilidad e impacto). Se mide: Probabilidad de que ocurra. Impacto en caso de que ocurra.
Planificar acciones de mitigación.
Implementar acciones.
Evaluar efectividad de las acciones tomadas.
Incorporar la gestión de riesgos al programa.
Definir una estrategia formal de gestión de riesgos.

Transferir: pasar el riesgo a un tercero (ej. seguros).
Terminar: modificar el proyecto para eliminar el riesgo.
Tolerar: aceptar el riesgo y no actuar (usado para riesgos menores).
Tratar: aplicar acciones para reducir la probabilidad o el impacto.

Calidad

La Calidad es un concepto que tiene un significado que tiende a ser ambiguo y subjetivo, podemos quedarnos con una definición de Calidad que nos dice que es una propiedad o conjunto de propiedades inherentes a algo, que permiten juzgar su valor.

Según ISO 9000 es el grado e el que un conjunto de características inherentes cumple con los requisitos.

La Calidad de la Empresa se ve definida por:

Calidad de los procesos de Negocio
Calidad de los Sistemas de Información
- Calidad de la Infraestructura: calidad de redes y sistemas de software, etc.
- Calidad de Software: de las aplicaciones construidas, mantenidas, etc.
- Calidad de Datos: que ingresan en el SI.
- Calidad de Información: relacionada con la Calidad de Datos.
- Calidad de Gestión: presupuesto, planificación y programación.
- Calidad de servicio: procesos de atención al cliente.

La Calidad del Software se refiere a qué tan bien un software cumple con los requerimientos funcionales y no funcionales esperados, así como con las necesidades del usuario y del negocio. Se divide en Calidad del producto y Calidad del proceso de desarrollo

Calidad del producto: Los aspectos que medimos son la Calidad interna (medible a partir de las características intrínsecas), Calidad externa (medible en el comportamiento del producto) y Calidad en uso (medible durante el uso efectivo por parte del usuario).
Calidad del proceso: Los requisitos más significativos del proceso de software son:
- Que produzca los resultados esperados.
- Que estén basados en una correcta definición.
- Que sean mejorados en función de los objetivos de negocio.

"Sin un buen proceso de desarrollo es casi imposible obtener un buen producto".

Norma es una regla obligatoria o un conjunto de requisitos que se deben cumplir, normalmente es establecida por organismos oficiales o internacionales. Define criterios específicos que deben seguirse en procesos, productos o servicios

Estándar es un modelo o referencia aceptada como guía o mejor práctica, no es obligatorio pero sí recomendado como ejemplo a seguir. Es más flexible y adaptable al contexto de cada organización.

No confundir una con la otra, la diferencia entre ellas radica en el grado de obligatoriedad y en su uso formal.

El término de norma es más fuerte que el término estándar.

| Organismo | ¿Qué hace? | | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | ISO - International Organization for Standardization | Promueve una estandarización a nivel internacional de normas técnicas para diferentes ramas de la industria. | | IEC - International Electrotechnical Commission | Organización de normalización en los campos: eléctrico, electrónico y tecnologías relacionadas. | | ISO/IEC | Las normas que se relacionan al software se desarrollan y publican por los dos organismos de arriba. | | IRAM | Promueve el uso de las normas ISO en Argentina y es el responsable de realizar las traducciones oficiales. Las normas ISO que han sido adoptadas por IRAM, se las denomina IRAM–ISO. | | NM | Identificación de las normas, indica que fue aprobada por la Asociación Mercosur de Normalización. |

Calidad del Producto de Software

El concepto de Calidad de Producto de Software se refiere al conjunto de características que debe tener un software para cumplir con los requisitos funcionales, no funcionales y expectativas del usuario, tanto de forma interna como externa. Es una visión centrada en el software en sí mismo, no en el proceso que lo creó. Evalúa qué tan bien funciona, cómo se comporta y cómo lo percibe el usuario.

La norma ISO/IEC 14598 (ahora reemplazada por ISO/IEC 25040) define un proceso formal para evaluar la calidad de un producto de software de manera sistemática y objetiva.

Etapas en Orden (1 a 5) y ¿Qué se hace?

Establecer los requisitos de la evaluación Definir el propósito de la evaluación, obtener los requisitos de calidad del producto, identificar qué partes del producto se va a evaluar y definir el nivel de rigor de la evaluación.
Especificar la evaluación Seleccionar los módulos de evaluación, definir los criterios de decisión para las métricas y establecer los criterios de decisión generales de la evaluación.
Diseñar la evaluación Planificar las actividades concretas: qué pruebas se realizarán, qué herramientas se usarán, qué recursos humanos y técnicos se necesitan.
Ejecutar la evaluación Realizar las mediciones reales, aplicar los criterios definidos en el paso anterior para interpretar los resultados y registrar todos los hallazgos y resultados de manera organizada.
Finalizar la evaluación Revisar los resultados obtenidos, elaborar el informe de evaluación, incluyendo recomendaciones si corresponde, obtener retroalimentación del proceso de evaluación para mejorar futuras evaluaciones y tratar y almacenar los datos obtenidos.

La ISO/IEC 9126 (ahora reemplazada por la familia SQuaRE ISO/IEC 25000) es un modelo que define y clasifica las características de calidad del software en términos medibles y evaluables, para ayudar tanto en el desarrollo como en la evaluación del producto.

| Norma de la Familia | ¿Qué define? | |-------------------------|---------------------------------------------------------------------| | ISO/IEC 9126-1 | Modelo de calidad del producto software | | ISO/IEC 9126-2 | Métricas externas (evaluación del software ejecutado) | | ISO/IEC 9126-3 | Métricas internas (evaluación sin ejecutar el software) | | ISO/IEC 9126-4 | Métricas de calidad en uso (con el usuario final) |

Divide la Calidad del Software en seis características principales, cada una de ellas con subcaracterísticas (ahora reemplazada por ISO/IEC 25010)

| Característica | ¿A qué se refiere? | Subcaracterísticas | |-------------------------------|----------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------| | Funcionalidad | Qué tan bien el software cumple con las funciones requeridas | Adecuación, Exactitud, Interoperabilidad, Cumplimiento y Seguridad de acceso | | Confiabilidad | Capacidad del software de mantener su rendimiento bajo condiciones específicas | Madurez, Tolerancia a fallos y Recuperabilidad | | Facilidad de Uso | Facilidad con la que el usuario puede entender, aprender y utilizar el software | Inteligibilidad, Atractivo, Facilidad de aprendizaje y Operabilidad | | Eficiencia | Capacidad del software de proporcionar alto rendimiento con pocos recursos | Comportamiento temporal y Utilización de recursos | | Potabilidad | Facilidad para modificar el software | Facilidad de análisis, Facilidad de cambio, Estabilidad y Facilidad de prueba | | Facilidad de Mantenimiento | Capacidad del software para ser trasladado a diferentes entornos | Adaptabilidad, Facilidad de instalación, Conformidad y Facilidad de reemplazo |

Define métricas para evaluar la calidad del software en forma de Tabla (ahora reemplazada por ISO/IEC 250423), teniendo en cuenta las características y subcaracterísticas definidas en la ISO/IEC 9126-1. Cada métrica se define en una tabla con estos campos:

| Componente | Descripción | |----------------------------|--------------------------------------------------------------------------------------------------------| | Nombre de la Métrica | Identifica de manera clara la métrica evaluada | | Propósito | Indica qué aspecto de calidad se mide y con qué fin se utiliza esa métrica | | Descripción | Define en detalle qué mide la métrica y cuál es su alcance | | Fórmula | Expresa cómo se calcula la métrica | | Tipo de medida | Especifica si se trata de una medida objetiva (cuantitativa) o subjetiva (basada en percepción del usuario) | | Nivel de aplicación | Indica si la métrica se aplica a nivel de módulo, componente, sistema completo, etc. | | Interpretación | Señala qué significa un valor alto o bajo para la métrica, y cómo puede ser utilizado para tomar decisiones |

A su vez, define criterios para crear nuevas métricas:

| Criterio | Explicación de qué tener en cuenta | |-----------------------|--------------------------------------------------------------------------------------------------------| | Relevancia | La métrica debe estar directamente relacionada con una característica o subcaracterística de calidad | | Validez | Debe medir exactamente lo que se pretende medir, sin ambigüedad | | Fiabilidad | La métrica debe ofrecer resultados consistentes cuando se aplica en condiciones similares | | Objetividad | Siempre que sea posible, se debe preferir la medición cuantitativa y verificable, por sobre la percepción subjetiva | | Comprensibilidad | Debe ser fácil de interpretar por los interesados | | Viabilidad | La métrica debe ser técnicamente factible de obtener en el entorno donde se aplica |

También explica de qué forma se deben combinar los niveles de las métricas para establecer los niveles de las características y de evaluación

| Seguir en Orden (1 a 4) | ¿Qué hacer? | |--------------------------------------------------|--------------------------------------------------------------------------------------------------------| | Evaluación a nivel de métrica | Puntuamos cada métrica según uno de los 4 niveles. | | Evaluación a nivel de subcaracterística | Las métricas relacionadas a una subcaracterística se combinan, podríamos por ejemplo usar un promedio | | Evaluación a nivel de característica | Se combinan los niveles de todas las subcaracterísticas que componen una característica principal, se puede aplicar nuevamente un promedio | | Evaluación global | Se combinan los niveles de las características principales para emitir una evaluación global del producto |

La familia ISO/IEC 25000, conocida como SQuaRE (Software product Quality Requirements and Evaluation), es un conjunto de normas internacionales que proporcionan un marco estructurado y coherente para definir, medir y evaluar la calidad del software, los datos y su uso.

SQuaRE es un modelo de referencia que reemplaza y amplía normas anteriores como ISO/IEC 9126 y ISO/IEC 14598. Tiene como objetivo definir claramente los requisitos de calidad del software, establecer métricas para medir esa calidad y estandarizar el proceso de evaluación del producto.

División 2500n – Gestión de la calidad: Proporciona guías generales para gestionar la calidad
División 2501n – Modelos de calidad: Define modelos de calidad para productos de software (ISO/IEC 25010) y calidad de datos (ISO/IEC 25012). Estos modelos especifican características y subcaracterísticas quedeben evaluarse
División 2502n – Medición de la calidad: Establece métricas específicas para cada característica
División 2503n – Requisitos de calidad: Proporciona directrices para especificar requisitos de calidad desde la etapa de elicitación
División 2504n – Evaluación de la calidad: Define cómo planificar y ejecutar la evaluación de un producto software

La ISO/IEC 25010 reemplaza la ISO/IEC 9126-1 con un modelo más completo y actualizado, integrando aspectos clave como seguridad y compatibilidad, y dando mayor relevancia a la experiencia del usuario final.

Aspecto: Características principales
- ISO/IEC 9126-1: 6
- ISO/IEC 25010: 8
Aspecto: Seguridad
- ISO/IEC 9126-1: Subcaracterística dentro de Funcionalidad
- ISO/IEC 25010: Característica independiente
Aspecto: Compatibilidad
- ISO/IEC 9126-1: No aparece como categoría
- ISO/IEC 25010: Se agrega como característica nueva
Aspecto: Calidad en uso
- ISO/IEC 9126-1: Definida como concepto aparte
- ISO/IEC 25010: Se integra en el mismo modelo
Aspecto: Estructura
- ISO/IEC 9126-1: Modelo de calidad interna y externa separado del de calidad en uso
- ISO/IEC 25010: Unificación del modelo con mejor integración

Al cuadro de características de la 9126-1 le quitamos la subcaracterística de Seguridad a Funcionalidad y agregamos 2 filas más:

La ISO/IEC 25040 reemplaza la ISO/IEC 14598 con un enfoque más moderno, estructurado y alineado con todo el sistema de evaluación de calidad SQuaRE, permitiendo una evaluación más consistente, completa y reutilizable

Foco
- ISO/IEC 14598: Evaluación del producto de software
- ISO/IEC 25040: Proceso completo de evaluación de calidad, integrado con modelos modernos
Enfoque
- ISO/IEC 14598: Separado del modelo de calidad (9126). La 9126 no estaba integrada a la 14598
- ISO/IEC 25040: Integrado con ISO/IEC 25010 y resto de la familia 25000
Cobertura
- ISO/IEC 14598: Definía evaluación en módulos por roles (desarrollador, adquirente, evaluador independiente)
- ISO/IEC 25040: Define un único modelo de evaluación aplicable a todos los contextos (más flexible y unificado)
Detalle del proceso
- ISO/IEC 14598: Más genérico
- ISO/IEC 25040: Más detallado y normado, con 5 etapas claras

Calidad de los Datos - ISO/IEC 25012

La norma ISO/IEC 25012 define el concepto de Calidad de Datos como: "La capacidad de las características de los datos de satisfacer necesidades explícitas e implícitas bajo condiciones específicas de uso.".

Esto significa que los datos son de calidad cuando cumplen con lo que los usuarios necesitan, ya sea para operar, tomar decisiones, generar información o garantizar la interoperabilidad entre sistemas.

El modelo presenta una clasificación considerando dos puntos de vista (3 si tomamos el combinado):

Punto de Vista: Inherente

¿A qué hace referencia? Se refiere a las propiedades internas de los datos, independientemente del sistema que los gestiona.
¿Qué evalúa?
- Exactitud: Reflejan correctamente la realidad.
- Completitud: Tienen todos los valores necesarios.
- Consistencia: No se contradicen entre sí.

Punto de Vista: Dependiente del sistema

¿A qué hace referencia? Analiza cómo el sistema informático mantiene y permite acceder a los datos en determinadas condiciones de uso.
¿Qué evalúa?
- Credibilidad: El usuario confía en ellos.
- Actualidad: Están actualizados respecto al tiempo requerido.
- Disponibilidad: Accesibles cuando se necesitan.
- Portabilidad: Pueden transferirse entre sistemas.
- Recuperabilidad: Se preservan ante fallos.

Punto de Vista: Inherente + Dependiente

¿A qué hace referencia? Algunas características aplican a ambos enfoques (inherente y dependiente del sistema).
¿Qué evalúa?
- Accesibilidad
- Cumplimiento (con normas o estándares)
- Confidencialidad
- Precisión
- Eficiencia
- Trazabilidad
- Comprensibilidad

Calidad de Servicio - ISO/IEC 20000

La norma ISO/IEC 20000 es un estándar para la certificación de Gestión de Servicios de TI (Tecnologías de la Información) de las empresas.

Define el concepto de Calidad de Servicio como la capacidad de un proveedor de servicios para entregar servicios de tecnología de la información (TI) de acuerdo con los requisitos acordados con los clientes, cumpliendo con las expectativas de calidad definidas.

El estándar ISO/IEC 20000 es un marco de buenas prácticas para la gestión de servicios de TI, y tiene como objetivo garantizar que los proveedores de servicios entreguen servicios TI de alta calidad de manera consistente.

El estándar está compuesto por varios componentes que guían a las organizaciones para establecer y gestionar un Sistema de Gestión de Servicios (SGS) eficiente. Su organización es la siguiente:

Componentes de la norma ISO/IEC 20000

ISO/IEC 20000-1: Especificación Componente principal del estándar y especifica los requisitos para el Sistema de Gestión de Servicios (SGS).
ISO/IEC 20000-2: Código de Prácticas Proporciona orientación y mejores prácticas sobre cómo implementar un SGS basado en los requisitos de la ISO/IEC 20000-1. Aunque no es obligatorio, es muy útil para organizaciones que deseen aplicar el estándar de manera efectiva.
ISO/IEC 20000-3: Guía en la Definición del Alcance y su Aplicabilidad Destinada a los auditores, ofrece directrices sobre cómo realizar auditorías a un SGS implementado conforme a la ISO/IEC 20000-1. Ayuda a evaluar la eficacia de dicha implementación.
ISO/IEC 20000-4: Modelo de Referencia de Procesos Proporciona una metodología para evaluar la gestión de servicios en una organización. Permite medir la eficacia de los servicios entregados y de la implementación del SGS.
ISO/IEC 20000-5: Ejemplo de Implementación Brinda un ejemplo de implementación en un informe técnico.

Calidad de Procesos de Software

Un proceso es una serie de actividades interrelacionadas que a partir de un input generan un output que puede ser un resultado final o el input de otro proceso.

El proceso de software es un concepto amplio, basado en el ciclo de vida y que cubre todos los elementos necesarios como tecnología, personal, artefactos, etc. Se puede ver como un conjunto coherente de tareas relacionadas que conducen a la producción de un producto software incluyendo tanto las actividades técnicas (como el diseño y la codificación) como las actividades de gestión (como la planificación y el seguimiento).

Por buenas prácticas se entiende un conjunto coherente de acciones que han rendido bien en un determinado contexto y que se espera que, en contextos similares, rindan similares resultados.

Podemos definir a una organización como un conjunto de procesos interconectados, que pueden plasmarse por escrito en un diagrama denominado Mapa de Procesos

Tipos de Procesos

Procesos de Gestión: Definen y verifican las políticas, estrategias, objetivos y metas de la organización.
Procesos Operativos: Procesos de producción de bienes y servicios que se entregan al cliente. Están alineados con la misión principal de la organización.
Procesos de Apoyo: Procesos que realizan actividades de apoyo necesarias para el buen funcionamiento de los procesos operativos.

En el mapa de procesos, los clientes son las entidades (internas o externas) que reciben los productos o servicios generados por los procesos clave. Son el destinatario final del valor entregado por la organización. Representan:

Las expectativas y necesidades a satisfacer.
Un punto de partida para la definición de los procesos clave.
La referencia para evaluar la eficacia del sistema.

Modelo de Calidad de los Proceso de Software

Un modelo de calidad software puede definirse como una herramienta que guía a las organizaciones a la mejora continua y a la competitividad, proporcionando un conjunto de buenas prácticas para el ciclo de vida del software.

Un modelo no es una metodología, dice qué hacer pero no cómo hacerlo.

El modelo ISO/IEC 12207 es un estándar internacional que define un marco de referencia para los procesos del ciclo de vida del software. Fue desarrollado para establecer un lenguaje común y una estructura formal que permita gestionar, desarrollar y mantener productos de software con calidad. Su objetivo principal es mejorar la calidad y la eficiencia del software y sus procesos asociados.

Esta norma genera un clasificación de los procesos:

| Categoría | ¿Qué hacen? | |--------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------| | Agreement Processes (Procesos de Acuerdo) | Se centran en establecer los acuerdos entre las partes (cliente y proveedor). | | Organizational Project-Enabling Processes (Procesos Organizacionales de Habilitación de Proyectos) | Apoyan a la organización para establecer, gestionar y mejorar sus capacidades en proyectos. | | Technical Management Processes (Procesos de Gestión Técnica) | Son procesos de gestión del proyecto y del producto a lo largo de su ciclo de vida. | | Technical Processes (Procesos Técnicos) | Son los procesos directamente relacionados con la creación del sistema o software. |

La norma ISO/IEC 15504 tiene como propósito establecer y mejorar la capacidad y madurez de los procesos de las organizaciones en la adquisición, desarrollo, evolución y soporte de productos y servicios.

En relación con la calidad del proceso, la norma ISO/IEC 15504 proporciona un modelo de calidad software que guía a las organizaciones hacia la mejora continua y la competitividad, ofreciendo un conjunto de buenas prácticas para el ciclo de vida del software.

Este modelo está relacionado con los conceptos de nivel de capacidad y nivel de madurez.

Esta norma fue reemplazada por la ISO/IEC 33000, estas son las diferencias:

| Característica | ISO/IEC 15504 (SPICE) | ISO/IEC 33000 | |----------------------------------------|--------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------| | Propósito principal | Evaluación de procesos de software y determinación de su capacidad | Marco genérico para evaluar cualquier tipo de proceso, no solo de software | | Ámbito | Específico de procesos de software | Genérico y extensible | | Estructura | Serie ISO/IEC 15504-1 a 15504-6 | Familia de normas ISO/IEC 330xx, más modular | | Modelo de evaluación | Niveles de capacidad de 0 a 5, con atributos de procesos | Mantiene los niveles de capacidad, pero refina la estructura de evaluación | | Consistencia con otros estándares | Desalineado parcialmente con ISO 12207/15288 en sus primeras versiones | Totalmente alineado con ISO/IEC/IEEE 12207 y 15288 | | Flexibilidad | Menos modular, enfoque más rígido | Más flexible y extensible, admite diferentes modelos de proceso (no solo de software) | | Evaluaciones conformes | Solo evaluaciones SPICE | Permite certificaciones o evaluaciones conforme a modelos personalizados (incluidos ISO, CMMI, etc.) |

SGC - IRAM-ISO 9001:2015

Es una norma internacional certificable que define los requisitos para implementar un Sistema de Gestión de la Calidad (SGC) enfocado en satisfacer al cliente, mejorar procesos y garantizar la calidad de productos/servicios.

Realizar una certificación bajo la norma IRAM-ISO 9001:2015 significa que la organización ha implementado un Sistema de Gestión de la Calidad (SGC) que cumple con los requisitos especificados en esta norma. Este sistema está orientado a asegurar:

La conformidad del producto.
El aumento de la satisfacción del cliente.
La mejora de la eficacia del sistema

La implementación de este sistema, basado en ISO 9001, busca que la organización logre resultados consistentes y predecibles al entender y gestionar sus actividades como procesos interrelacionados

| Principio de calidad | ¿Qué representa? | |--------------------------------------------------------|-----------------------------------------------------------------------------------| | Enfoque al cliente | Cumplir y superar las expectativas del cliente | | Liderazgo | Establecer una dirección y propósito común | | Compromiso de las personas | Involucrar, empoderar y desarrollar a las personas | | Enfoque a procesos | Gestionar actividades como procesos interrelacionados | | Mejora continua | Buscar mejoras permanentes en el desempeño del sistema | | Toma de decisiones basada en la evidencia | Usar datos y hechos para decidir | | Gestión de relaciones | Crear valor mediante relaciones sostenidas con partes interesadas |

La norma ISO 90003:2018 se utiliza como una directriz para la interpretación de la norma ISO 9001:2015 en el contexto del proceso de software.

Su propósito principal es proporcionar una guía para identificar las evidencias dentro del proceso de software que demuestren el cumplimiento de los requisitos establecidos en la norma ISO 9001.

Las certificaciones se hacen bajo la 9001:2015 NO bajo la 90003:2018

Trabajar con un sistema de gestión de calidad basado en ISO 9001 proporciona los siguientes beneficios:

Asegura que su negocio cumpla con los requisitos legales y del cliente
Aumenta el rendimiento de su organización: Al implementar procesos simplificados, ayuda a mejorar la eficiencia operacional.
Asegura la toma de decisiones.
Mejora la satisfacción del cliente.
Optimiza sus operaciones para así cumplir y superar los requisitos de sus clientes.
Mejora su rendimiento financiero.

Establecen las metas a las que se desea llegar con la certificación y deben suponer un avance, buscando la “mejora continua”. Características que deben tener

| Característica | Descripción | Ejemplos | |--------------------|----------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------| | Específicos | Claros, concretos y enfocados en un área o proceso determinado | "Reducir el número de reclamos de clientes del área técnica" | | Medibles | Deben tener indicadores que permitan evaluar el progreso o cumplimiento | "Reducir los reclamos en un 15% respecto al año anterior" | | Alcanzables | Realistas según los recursos, capacidades y contexto de la organización | - | | Relevantes | Deben estar alineados con la política de calidad, las necesidades del cliente y los objetivos estratégicos de la organización | - | | Temporales | Deben tener un plazo definido para su cumplimiento o evaluación | "Alcanzar una disminución del 15% en reclamos antes de diciembre 2025" |

Es una descripción resumida del mismo y su naturaleza. Características

| Característica | Descripción | |------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Coherente con el contexto de la organización | Debe considerar el entorno interno y externo, así como las necesidades de las partes interesadas relevantes | | Incluir los productos y servicios del SGC | Debe indicar claramente qué productos y/o servicios están incluidos dentro del sistema de gestión | | Incluir ubicaciones y unidades relevantes | Si la organización opera en varias sedes o departamentos, el alcance debe especificar a qué sitios se aplica el SGC | | Ser conciso, claro y específico | El texto debe ser fácil de entender y directo, evitando ambigüedades o generalidades excesivas | | Incluir exclusiones justificadas (cuando correspondan) | Cualquier requisito de la norma ISO 9001 excluido debe estar explícitamente mencionado y justificado si no aplica por la naturaleza del producto o servicio | | Documentado y mantenido | El alcance debe estar documentado dentro del SGC, típicamente en el manual de calidad o un documento de contexto, y debe revisarse periódicamente |

Auditoría y Peritaje de Sistemas

| Razón | Descripción | |----------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Costos por pérdida de datos | Los datos proveen a la organización de una "imagen" de sí misma, su entorno y su futuro. Si esa imagen se pierde o es inexacta, se generan grandes pérdidas. | | Costos por decisiones incorrectas | La calidad de las decisiones depende de: - La calidad de los datos (veraces, completos, oportunos). - La correctitud de las reglas de decisión implementadas. | | Costos por abusos computacionales | Los abusos informáticos tienden a generar pérdidas mayores que los fraudes tradicionales. | | Costos por errores de computación | Errores en sistemas automáticos pueden ser graves, ya que: - Son determinísticos. - Se reproducen rápidamente. - Son costosos de corregir. | | Valor del hardware, software y personal | Los recursos de TI son críticos para la operación de las organizaciones. | | Mantenimiento de la privacidad | La automatización permite la integración de grandes volúmenes de datos personales. Esto puede violar derechos si no se audita adecuadamente. | | Evolución controlada del uso de TI | La confiabilidad de los sistemas complejos no está garantizada. Una adopción no controlada puede generar efectos perjudiciales. |

Los abusos computacionales son incidentes relacionados con el uso indebido o malicioso de tecnologías de la información, en los cuales una víctima sufre (o podría haber sufrido) una pérdida, y un perpetrador obtiene (o podría obtener) una ganancia intencional. Tipos de Abusos:

| Tipo | Descripción | |-----------------------------|------------------------------------------------------------------------------------------------------------------------------------------| | Hacking | Acceso no autorizado a sistemas informáticos para leer, modificar, eliminar información o interrumpir servicios | | Virus | Programas maliciosos que infectan archivos, sistemas o macros para dañar, interrumpir o controlar las operaciones del sistema | | Acceso físico ilegal | Ingreso no autorizado a instalaciones físicas como salas de servidores o terminales de trabajo, con el fin de robar, manipular o destruir datos o equipos | | Abuso de privilegios | Uso indebido de accesos o permisos legítimos para fines no autorizados |

Consecuencias de los abusos computacionales

Destrucción de activos.
Sustracción de activos.
Modificación de activos.
Violación de privacidad.
Interrupción de operaciones.
Uso no autorizado de activos.
Daño físico a personas.

Auditoría de Sistemas

La auditoría de sistemas de información es un proceso sistemático y planificado mediante el cual se recolecta, analiza y evalúa evidencia sobre los sistemas informáticos de una organización

| Objetivo | Descripción | |----------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Preservar los activos | La auditoría busca garantizar que los activos relacionados con los sistemas de información estén protegidos contra pérdidas, robos, abusos o destrucción | | Mantener la integridad de los datos | Se refiere a asegurar que los datos sean:- Correctos.- Completos.- Consistentes.- Veraces.Sin integridad, los datos no reflejan la realidad de la organización y pueden llevar a decisiones equivocadas o fraudes. | | Alcanzar los objetivos organizacionales con eficacia | Un sistema de información debe cumplir con los objetivos para los que fue diseñado, facilitando que la organización logre sus metas. Esto implica:- Que responda a las necesidades de los usuarios.- Que esté alineado con los procesos del negocio.- Que permita tomar decisiones oportunas y acertadas. | | Usar los recursos con eficiencia | La auditoría también verifica que los recursos tecnológicos y humanos se estén utilizando de forma óptima |

Se generan 4 resultados clave:

Mejora la salvaguarda de activos.
Mejora la integridad de los datos.
Mejora la efectividad de los sistemas.
Mejora la eficiencia de los sistemas

Alta Gerencia y Sistemas de Control Interno

Que la alta gerencia implemente un sistema de control interno significa que a alta dirección de la organización asume la responsabilidad de establecer mecanismos formales y organizados para:

Proteger los activos
Garantizar la integridad y precisión de los datos
Asegurar el cumplimiento de los objetivos institucionales
Detectar, prevenir y corregir errores o fraudes

Es una forma de establecer reglas, procedimientos y estructuras que permiten controlar y supervisar el uso de los recursos de tecnología de la información. Es importante que lo implemente la alta gerencia porque:

Da legitimidad a los controles.
Permite asignar recursos y presupuesto.
Establece una cultura organizacional de responsabilidad y transparencia.
Sin compromiso de la alta dirección, los controles internos son débiles o simbólicos.

La implementación del control interno se realiza a través de componentes estructurados, que deben ser definidos, comunicados y aplicados dentro de la organización, **estos componentes son:

| Componente | Descripción | |---------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------| | Separación de obligaciones | Evitar que una misma persona pueda iniciar, registrar y autorizar una transacción | | Delegación clara de autoridad y responsabilidad | Establecer roles y responsabilidades bien definidos | | Reclutamiento y capacitación de personal calificado | Asegurar que quienes trabajan en los sistemas estén capacitados técnica y éticamente | | Sistema de autorizaciones | Incluir autorizaciones generales (políticas) y específicas (transacciones individuales) | | Documentos y registros adecuados | Mantener trazabilidad de todas las transacciones importantes, incluso en sistemas automatizados | | Controles físicos y documentación de activos | Proteger físicamente el acceso a servidores, equipos y datos | | Chequeos independientes de performance | Revisar el funcionamiento y rendimiento de los sistemas por terceros o áreas independientes | | Comparación periódica de activos con registros | Verificar que los datos del sistema coincidan con la realidad |

Controles

Un control es un sistema que previene, detecta, o corrige eventos ilegales.

Un control en un sistema de información es un sistema en sí mismo porque no se trata de un único elemento aislado, sino de un conjunto coordinado de componentes y procesos que tienen como objetivo prevenir, detectar o corregir eventos ilegales.

| Aspecto | Preventivo | Detectivo | Correctivo | |--------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Definición | Controles que evitan que ocurra un evento ilegal o no deseado. Se aplican antes de que se produzca una actividad crítica | Son controles que permiten identificar que un evento ilegal o no deseado ha ocurrido | Son controles que corrigen los efectos de un evento no deseado después de que ha sido detectado | | Objetivo | Reducir la probabilidad de que ocurra un error, fraude o evento no autorizado | Descubrir errores, fraudes o eventos no autorizados después de que ocurrieron | Minimizar el impacto de los errores o eventos ilegales y restaurar el estado correcto del sistema | | Ejemplos | - Instrucciones claras y obligatorias para llenar un formulario - Roles y permisos predefinidos - Validación de campos obligatorios - Firewall configurado | - Programa que valida datos y rechaza valores incorrectos - Logs de acceso revisados periódicamente - Alarmas de detección de intrusión - Revisión de conciliaciones | - Sistema que detecta ruido y retransmite paquetes - Restauración desde un backup - Parcheo de seguridad - Reset automático de contraseñas fallidas | | Cuándo actúa | Antes del evento | Después del evento | Después del evento | | Qué hace | Evita que ocurra | Identifica qué ocurrió | Corrige o mitiga el impacto |

La tarea principal del auditor es evaluar si los controles están adecuadamente ubicados y si funcionan correctamente para:

Prevenir eventos ilegales o no deseados.
Detectar estos eventos en caso de que ocurran.
Corregir sus efectos para minimizar pérdidas.

Sigue un proceso sitemático que incluye:

| Pasos en Orden (1 a 4) | ¿Qué hace? | |----------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Identificación de controles existentes | Analiza el sistema y los procesos.Determina qué controles están implementados (tanto gerenciales como de aplicación). | | Evaluación de su confiabilidad | Verifica si cada control cubre los eventos relevantes.Estima cuán confiables son los controles (efectividad, cobertura, posibilidad de falla). | | Recolección de evidencia | Realiza pruebas (walk-throughs, inspecciones, entrevistas, análisis de logs).Evalúa si los controles funcionan en la práctica y no solo en el papel. | | Detección de brechas | Identifica controles ausentes, débiles o ineficientes.Determina el nivel de exposición a riesgos. |

La confiabilidad se refiere a la efectividad real del control para prevenir, detectar o corregir eventos ilegales o no deseados.

| ¿Cómo medimos? | Descripción | |--------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Identificando eventos y transacciones relevantes | El análisis comienza desde las funciones clave del sistema para entender qué debería y qué no debería pasar | | Evaluando cómo los controles responden ante esos eventos | Para cada evento ilegal identificado, se debe evaluar:- ¿Existe un control que lo mitigue?- ¿Está ubicado correctamente en el flujo del proceso?- ¿Actúa de forma preventiva, detectiva o correctiva?- ¿Es automático o manual?- ¿Es consistente ante múltiples escenarios? | | Analizando evidencia de funcionamiento | Los auditores usan técnicas como: Walk-throughs, Revisión de logs, Pruebas de cumplimiento, Entrevistas, etc. | | Estimando el nivel de confiabilidad | Aunque no siempre se cuantifica numéricamente, se puede clasificar según escalas:- Alta (A): El control cubre completamente el evento y funciona con consistencia.- Media (M): El control existe pero no es completamente eficaz o tiene limitaciones.- Baja (B): El control es débil, incompleto o no se aplica de manera confiable. | | Analizando el impacto en el nivel superior | Una vez evaluados los controles de subsistemas de menor nivel, se estima su impacto en los subsistemas superiores, considerando:- Frecuencia del evento- Impacto económico o reputacional- Potencial de fraude o pérdida |

Factorización

Desde el punto de vista de la auditoría de sistemas de información, factorizar un sistema significa:

Dividir un sistema complejo en componentes lógicos más pequeños (subsistemas), cada uno con funciones específicas, para facilitar su comprensión, evaluación y auditoría.

Esta técnica permite al auditor enfocar su análisis en partes manejables del sistema, lo cual es especialmente útil en entornos grandes y heterogéneos.

Factorizamos por las siguientes razones:

Identificar controles relevantes por subsistema.
Evaluar la confiabilidad de cada parte, y así estimar la confiabilidad global.
Asignar responsabilidades y priorizar esfuerzos de auditoría.

| Criterio | Descripción | |--------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Por Función | El auditor identifica primero las funciones principales del sistema y luego divide el sistema de acuerdo a esas funciones | | Acoplamiento y Cohesión | - Acoplamiento bajo: los subsistemas deben ser independientes entre sí en lo posible, lo que facilita su análisis individual.- Alta cohesión: cada subsistema debe estar orientado a una sola función clara, sin mezclar responsabilidades. | | Por tipo de funciones | Funciones gerenciales- Las funciones que se deben realizar para asegurar que el desarrollo, la implementación, operación y mantenimiento de los sistemas de información proceden de una forma planificada y controlada.Funciones de aplicación- Tareas que son necesarias ejecutar para realizar un procesamiento de información confiable. Relacionado con “ciclos”. |

Riesgos de una Auditoría

El concepto de riesgo se analiza como parte de la fórmula RDA = RI ⋅ RC ⋅ RD. Esta expresión refleja cómo los distintos tipos de riesgos interactúan y deben ser gestionados para mantener un nivel aceptable de confianza en el sistema auditado.

RDA: Riesgo Deseado de Auditoría.
RI: Riesgo Inherente.
RC: Riesgo de Control.
RD: Riesgo de Detección.

| Tipo | Descripción | |----------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Riesgo Deseado de Auditoría | Es el nivel máximo de riesgo que el auditor está dispuesto a aceptar, considerando las consecuencias de no detectar errores o irregularidades materiales. No se calcula, se decide en función del entorno, la criticidad del sistema y el impacto potencial. | | Riesgo Inherente | Es el riesgo de que ocurran errores materiales o irregularidades sin considerar aún los controles existentes. Depende de: - Naturaleza del sistema. - Entorno de negocio. - Complejidad del proceso o tecnología. | | Riesgo de Control | Es el riesgo de que los controles internos no funcionen adecuadamente para prevenir o detectar errores o eventos ilegales. | | Riesgo de Detección | Es el riesgo de que los procedimientos de auditoría no logren detectar errores materiales o fraudes, aunque existan. |

Proceso de Auditoría

El proceso de auditoría de sistemas de información consiste en las siguientes etapas:

Es la primera etapa.
Varía si es una auditoría interna o externa.
Tareas Principales
- Determinar el alcance de la auditoría (sistema, conjunto de sistemas o área de TI).
- Emitir opiniones sobre los riesgos (RDA, RI, RC).
- Calcular el Riesgo de Detección (RD) necesario.
- Recolectar y documentar evidencias.

Tipos de procedimientos para recolectar evidencia

| Tipo | Descripción | Técnicas/Ejemplos | |-------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------| | Procedimientos para comprender los controles | Sirven para verificar si los controles existen, cómo están diseñados y si funcionan | Cuestionarios, inspecciones, observaciones | | Testeo de controles | Evalúa si los controles internos (gerenciales y de aplicación) funcionan eficazmente. Permite reducir el alcance de otros testeos si los controles son confiables | Cuestionarios, inspecciones, observaciones, reprocesamiento de datos | | Testeos sustantivos de detalle de transacciones | Analiza si existen errores o irregularidades en el procesamiento de transacciones individuales. También permite evaluar la eficacia y eficiencia operativa | Control de facturación, revisión de cálculos, precios o consultas a base de datos | | Testeos sustantivos de detalle de balances contables | Se realiza para emitir un juicio sobre las pérdidas potenciales si el sistema falla en proteger activos o asegurar integridad de los datos. Son los más costosos de realizar | Control de inventario físico, recálculo de amortizaciones, confirmaciones con terceros | | Procedimientos de revisión analítica | Analizan las relaciones entre ítems de datos para detectar áreas inusuales | Comparar ingresos por ventas entre distintos períodos |

Diferencias entre auditoría interna y externa durante la Planificación

| Aspecto | Auditoría Interna | Auditoría Externa | |------------------------------------|------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------| | Objetivo principal | Evaluar eficiencia e ineficiencias operativas | Evaluar errores en los estados financieros | | Enfoque | Se enfoca en los procesos internos y su impacto operativo | Se enfoca en la exactitud y validez de la información contable presentada | | Tareas de planificación | - Asignar personal adecuado- Obtener info del cliente- Identificar áreas de riesgo- Comprender el negocio mediante revisión analítica | - Investigar nuevos clientes- Obtener contrato- Realizar revisión analítica- Identificar riesgos financieros | | Relación con la organización | Empleado interno o parte de la estructura organizativa | Profesional externo contratado |

Se aplican distintos tipos de procedimientos según el objetivo:
- Comprender los controles internos.
- Testeo de controles (gerenciales y de aplicación).
- Testeos sustantivos (detalle de transacciones y balances contables).
- Procedimientos de revisión analítica.
Se evalúa la efectividad y eficiencia de los sistemas y se estiman posibles pérdidas

Se realiza una evaluación final sobre la confiabilidad de los controles y los riesgos.
Se puede ajustar la profundidad de las pruebas según la fortaleza o debilidad de los controles detectados.
Se completan los testeos necesarios para emitir un juicio fundamentado

Un informe de auditoría de sistemas de información debe ser claro, estructurado y bien fundamentado, normalmente contiene:

| Contenido | Descripción | |-----------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Introducción | Describe los objetivos de la auditoría, es decir, qué se auditó y por qué. Define el alcance del trabajo realizado | | Enfoque general utilizado | Explica la metodología aplicada, incluyendo los procedimientos, técnicas y criterios de evaluación | | Resumen de conclusiones críticas | Enumera los hallazgos relevantes, tales como deficiencias en los controles, irregularidades, o riesgos detectados. Describe el grado de impacto de cada hallazgo | | Recomendaciones | Proporciona acciones correctivas o preventivas para mitigar los riesgos encontrados o mejorar la eficiencia del sistema | | Datos que respaldan las conclusiones/Hallazgos | Incluye la evidencia recolectada (documentación, entrevistas, observaciones, pruebas) | | Opinión de auditoría | El informe puede poseer una Opinión de auditoría que puede ser: Sin calificación, Con calificación, Adversa o Excusada |

Tipos de opinión

| Tipo | Descripción | |----------------------|----------------------------------------------------------------------------------------------------------------------| | Excusada | En base al trabajo realizado no se puede emitir opinión. | | Adversa | Se concluye que han ocurrido pérdidas materiales o que los estados financieros están distorsionados. | | Con calificación | Se concluye que han ocurrido pérdidas materiales o existen registros incorrectos, pero las cantidades no son considerables. | | Sin calificación | El auditor considera que no han ocurrido pérdidas materiales o no existen registros incorrectos. |

Gobernanza de TI

La Gobernanza de Tecnologías de la Información (TI) es un subconjunto del Gobierno Corporativo que se enfoca específicamente en los sistemas de TI, su desempeño y los riesgos asociados a su uso. Se ocupa de la relación entre la estrategia empresarial y la gestión de TI, promoviendo que las decisiones estratégicas relacionadas con TI sean tomadas al más alto nivel de la organización, como una junta directiva corporativa

Tiene como objetivo asegurar que las inversiones en TI generen valor para la organización y que los riesgos relacionados con la tecnología sean mitigados adecuadamente.

Según el Instituto de Gobernanza de TI, se define como el conjunto de estructuras y procesos de liderazgo y organizativos que aseguran que las TI sostienen y extienden las estrategias y objetivos de la organización.

COBIT

COBIT (Control Objectives for Information and Related Technologies) es un marco de referencia creado por ISACA que proporciona un conjunto de recursos, principios y buenas prácticas para ayudar a las organizaciones a adoptar una gobernanza y control efectivos de las TI.

COBIT busca asegurar que las TI generen valor, gestionen los riesgos y utilicen los recursos de manera eficiente, contribuyendo directamente a los objetivos estratégicos de la organización. Para ello, establece una diferenciación clara entre Gobernanza y Administración:

La Gobernanza evalúa, dirige y monitorea.
La Administración planifica, construye, ejecuta y monitorea.

| Elemento | Descripción | |------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Procesos de TI | Clasificados en 2 grandes dominios: Gobernanza y Administración. Son el eje principal de COBIT. | | Objetivos de Control | Son declaraciones del propósito a alcanzar mediante la implementación de controles en cada proceso de TI. Incluyen tanto objetivos de alto nivel como objetivos detallados. | | Prácticas de Control | Proveen el "qué", "cómo" y "por qué" implementar los controles. | | Guías de Auditoría | Orientan sobre cómo auditar los procesos de TI, incluyendo entrevistas, revisión documental y evaluación de riesgos de control. | | Guías de Administración | Incluyen modelos de madurez, factores críticos de éxito (CSF), indicadores clave de metas (KGI) e indicadores clave de desempeño (KPI), facilitando la gestión, evaluación y mejora continua de cada proceso. |

Gobernanza

Se refiere a quién toma las decisiones importantes en materia de tecnologías de la información. Define la autoridad, responsabilidad y rendición de cuentas en la toma de decisiones estratégicas. Su objetivo es asegurar que las TI generen valor, se alineen con los objetivos del negocio y gestionen riesgos adecuadamente.

Administración

Se enfoca en la ejecución de esas decisiones. Implica la planificación, construcción, ejecución y monitoreo de las actividades de TI siguiendo la dirección establecida por la gobernanza.

Satisfacer las necesidades de las partes interesadas

COBIT busca crear valor para las partes interesadas mediante la obtención de beneficios, la optimización de recursos y la gestión adecuada de riesgos.

Cubrir la empresa de extremo a extremo

La gobernanza de TI no se limita al área de sistemas, sino que abarca toda la organización, considerando tanto recursos internos como externos

Aplicar un marco integrado

COBIT se alinea e integra con otros estándares y buenas prácticas (como ITIL, TOGAF, ISO 27001), sirviendo como marco general para la gobernanza y administración de TI empresarial

Habilitar un enfoque holístico

COBIT define y considera siete habilitadores que interactúan entre sí:

Principios, políticas y marcos
Procesos
Estructuras organizacionales
Cultura, ética y comportamiento
Información
Servicios, infraestructura y aplicaciones
Personas, habilidades y aptitudes

Separar las funciones de gobernanza y administración

COBIT distingue claramente entre:

Gobernanza: evalúa, dirige y monitorea
Administración: planifica, construye, ejecuta y evalúa las actividades en función de las directivas de gobernanza

Gobernanza de TI (EDM)

Se centra en evaluar, dirigir y monitorear (EDM: Evaluate, Direct, Monitor). Incluye 5 procesos clave.

Administración de TI Se encarga de planificar, construir, ejecutar y monitorear en línea con la estrategia definida. Se divide en 4 dominios que representan las diferentes etapas del ciclo de vida de los servicios y soluciones de TI con un total de 32 procesos.

APO – Alinear, Planear y Organizar Este dominio abarca la estrategia y la estructura organizacional. Se enfoca en cómo TI puede contribuir al logro de los objetivos de negocio.
BAI – Construir, Adquirir e Implementar Se refiere a la identificación, adquisición, desarrollo, implementación y mantenimiento de soluciones de TI.
DSS – Entregar, Servicio y Soporte Trata sobre la entrega efectiva de servicios de TI, asegurando operaciones estables y seguras, así como soporte a los usuarios.
MEA – Monitorear y Evaluar Se enfoca en la evaluación continua del desempeño, cumplimiento y control interno.

Aplicar COBIT en una organización es importante porque permite establecer un marco estructurado y alineado con las mejores prácticas internacionales para la gobernanza y gestión de TI, asegurando que las tecnologías de la información realmente contribuyan al logro de los objetivos estratégicos del negocio.

Sistemas Colaborativos

Trabajo Colaborativo

El trabajo colaborativo supone poner en común conocimientos, materiales e ideas con la finalidad de compartirlos, normalmente de forma desinteresada para construir un conocimiento común que se pueda utilizar globalmente.

La mayoría de las tareas que realizan los miembros de estas comunidades en forma colaborativa está soportada por herramientas automatizadas.

Requerimientos de las Herramientas

Se deben soportar los dos tipos posibles de interacciones entre los usuarios:

Sincrónicos: Como salas de chat.
Asincrónicos: Foros de correo electrónico.

El soporte debe ser distinto dependiendo si los usuarios interactúan en el mismo o diferente espacio y tiempo:

Modelos Conceptuales de Colaboración

Permite un intercambio de información directo entre los miembros de una comunidad.

Es un intercambio simple y sólo requiere que los miembros posean facilidades de correo electrónico. Existen distintas alternativas:

Los miembros pueden enviarse mensajes entre ellos y todos los otros miembros pueden recibir copias de los mensajes relevantes.
Los mensajes pueden ser distribuidos en base a listas de distribución.

La forma más sencilla de acceso compartido permite que los miembros puedan acceder directamente a los mismos archivos en un repositorio común en un server particular.

El problema que presenta es la coordinación para la edición y actualización del mismo documento por distintos miembros.

Algunas soluciones implementan listas de correo y envío de mails con un aviso de actualización a los miembros, cuando el contenido de la carpeta compartida ha sido modificado.

El acceso mediante páginas interactivas se produce cuando los usuarios pueden colectivamente editar el mismo material.

La principal característica es que los miembros pueden colaborar haciendo comentarios, ya sea en tiempo real o en forma asincrónica editando el mismo (o los mismos) documento(s).

Se asemeja más a una discusión verbal entre los miembros, con el valor agregado de que esta discusión virtual es persistente.

Nacen en torno a un interés común que comparten sus miembros. Son de naturaleza asincrónica, se permite publicar un mensaje en cualquier momento, quedando este siempre visible para que posteriormente cualquier individuo pueda consultarlo y contestar si lo estima oportuno.

Debido a la persistencia de la información, la búsqueda, el análisis, la organización y la interpretación de la misma se facilita. Se divide en tres tipos:

PÚBLICOS: Cualquier persona puede leer y registrar mensajes.
PROTEGIDOS: Foros inalterables para usuarios registrados.
PRIVADOS: Sólo para usuarios registrados – moderador y miembros.

Son programas independientes que acceden y se comunican a través de un repositorio de datos global (blackboard).

La solución completa a un problema no tiene que ser pre-planificada. La evolución del estado determina las estrategias a ser adoptadas

Características

Múltiples componentes acceden al mismo almacenamiento de datos.
Los componentes se comunican entre ellos a través de dicha memoria.
El diseño se centra especialmente en los repositorios compartidos.

Parciales (Se re pudrio todo)

ACL Manager

Sun, 01 Jun 2025 00:00:00 GMT

Proyecto para poder gestionar ACLs (Access Control List) en un entorno Linux, al tener muchos comandos repetidos basados en un excel se me ocurrio que seria mas comodo poder formater los comandos de forma automatica usando una interfaz "Amigable".

import YoutubeVideo from "@/components/YoutubeVideo.astro"

✏️ Interfaz

⚙️ Setup

Creamos el entorno Virtual

python -m venv .venv

Activamos el entorno Virtual

.venv\Scripts\activate

En caso de no tener permisos, utilizar

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass

Instalamos las dependencias

pip install -r requirements.txt

🔴 Botones

`Consultar`

getfacl /home/redes/Desktop

Resultador

# file: home/redes/Desktop
# owner: redes
# group: users
user::rwx
group::---
other::r-x

`Setear`

setfacl -m g::--- /home/redes/Desktop; setfacl -m g:group1:rwx /home/redes/Desktop; setfacl -m g:group2:r-x /home/redes/Desktop; setfacl -m g:group3:--- /home/redes/Desktop

Consultamos el resultado

# file: home/redes/Desktop
# owner: redes
# group: users
user::rwx
group::---
group:group1:rwx
group:group2:r-x
group:group3:---
mask::rwx
other::r-x

`Seteamos de forma Recursiva`

Antes de setear

Comando: ls -l /home/redes/Desktop
total 18124
-rwxrwxrwx  1 redes users      205 May 21 07:57  convert_to_csv.py
-rwxrwxrwx  1 redes users      443 May 21 08:07  ejecutar_permisos.sh
drwxr-xr-x  4 redes users     4096 May 31 07:38  MartinezRincon-0d5ae8-main
-rw-rw-rw-  1 redes users    82968 May 31 06:46  MartinezRincon-0d5ae8-main.zip
-rw-rw-rw-  1 redes users    10282 May 21 06:50 'Permisos 2.0.xlsx'
-rw-r--r--  1 redes users     4345 May 21 07:57  permisos.csv
drwxr-xr-x 16 redes users     4096 May 31 07:02  Python-3.8.10
-rw-r--r--  1 redes users 18433456 May  3  2021  Python-3.8.10.tar.xz

Despues de setear

setfacl -R -m g::--- /home/redes/Desktop; setfacl -R -m g:group1:rwx /home/redes/Desktop; setfacl -R -m g:group2:r-x /home/redes/Desktop; setfacl -R -m g:group3:--- /home/redes/Desktop

Comando: ls -l /home/redes/Desktop
total 18124
-rwxrwxrwx+  1 redes users      205 May 21 07:57  convert_to_csv.py
-rwxrwxrwx+  1 redes users      443 May 21 08:07  ejecutar_permisos.sh
drwxrwxr-x+  4 redes users     4096 May 31 07:38  MartinezRincon-0d5ae8-main
-rw-rwxrw-+  1 redes users    82968 May 31 06:46  MartinezRincon-0d5ae8-main.zip
-rw-rwxrw-+  1 redes users    10282 May 21 06:50 'Permisos 2.0.xlsx'
-rw-rwxr--+  1 redes users     4345 May 21 07:57  permisos.csv
drwxrwxr-x+ 16 redes users     4096 May 31 07:02  Python-3.8.10
-rw-rwxr--+  1 redes users 18433456 May  3  2021  Python-3.8.10.tar.xz

`Eliminar`

Antes de eliminar los permisos

Comando: getfacl /home/redes/Desktop
getfacl: Removing leading '/' from absolute path names
# file: home/redes/Desktop
# owner: redes
# group: users
user::rwx
group::---
group:group1:rwx
group:group2:r-x
group:group3:---
mask::rwx
other::r-x

Elimina los permisos actuales y los que tiene por defecto.

setfacl -b /home/redes/Desktop && setfacl -k /home/redes/Desktop

Comando: getfacl /home/redes/Desktop
getfacl: Removing leading '/' from absolute path names
# file: home/redes/Desktop
# owner: redes
# group: users
user::rwx
group::---
other::r-x

`Eliminar R` (De forma Recursiva)

Antes de eliminar los permisos

Comando: ls -l /home/redes/Desktop
total 18124
-rwxrwxrwx+  1 redes users      205 May 21 07:57  convert_to_csv.py
-rwxrwxrwx+  1 redes users      443 May 21 08:07  ejecutar_permisos.sh
drwxrwxr-x+  4 redes users     4096 May 31 07:38  MartinezRincon-0d5ae8-main
-rw-rwxrw-+  1 redes users    82968 May 31 06:46  MartinezRincon-0d5ae8-main.zip
-rw-rwxrw-+  1 redes users    10282 May 21 06:50 'Permisos 2.0.xlsx'
-rw-rwxr--+  1 redes users     4345 May 21 07:57  permisos.csv
drwxrwxr-x+ 16 redes users     4096 May 31 07:02  Python-3.8.10
-rw-rwxr--+  1 redes users 18433456 May  3  2021  Python-3.8.10.tar.xz

Elimina los permisos actuales y los que tiene por defecto de forma recursiva.

setfacl -R -b /home/redes/Desktop && setfacl -R -k /home/redes/Desktop

Comando: ls -l /home/redes/Desktop
total 18124
-rwx---rwx  1 redes users      205 May 21 07:57  convert_to_csv.py
-rwx---rwx  1 redes users      443 May 21 08:07  ejecutar_permisos.sh
drwx---r-x  4 redes users     4096 May 31 07:38  MartinezRincon-0d5ae8-main
-rw----rw-  1 redes users    82968 May 31 06:46  MartinezRincon-0d5ae8-main.zip
-rw----rw-  1 redes users    10282 May 21 06:50 'Permisos 2.0.xlsx'
-rw----r--  1 redes users     4345 May 21 07:57  permisos.csv
drwx---r-x 16 redes users     4096 May 31 07:02  Python-3.8.10
-rw----r--  1 redes users 18433456 May  3  2021  Python-3.8.10.tar.xz

`Setear Por Defecto`

Antes de setear

Comando: getfacl /home/redes/Desktop
getfacl: Removing leading '/' from absolute path names
# file: home/redes/Desktop
# owner: redes
# group: users
user::rwx
group::---
other::r-x

Seteamos los permisos por defecto

setfacl -d -m g::--- /home/redes/Desktop; setfacl -d -m g:group1:rwx /home/redes/Desktop; setfacl -d -m g:group2:r-x /home/redes/Desktop; setfacl -d -m g:group3:--- /home/redes/Desktop

Comando: getfacl /home/redes/Desktop
getfacl: Removing leading '/' from absolute path names
# file: home/redes/Desktop
# owner: redes
# group: users
user::rwx
group::---
other::r-x
default:user::rwx
default:group::---
default:group:group1:rwx
default:group:group2:r-x
default:group:group3:---
default:mask::rwx
default:other::r-x

`Setear` Por Defecto de Forma Recursiva

Antes de setear

ls -l /home/redes/Desktop
total 18124
-rwx---rwx  1 redes users      205 May 21 07:57  convert_to_csv.py
-rwx---rwx  1 redes users      443 May 21 08:07  ejecutar_permisos.sh
drwx---r-x  4 redes users     4096 May 31 07:38  MartinezRincon-0d5ae8-main
-rw----rw-  1 redes users    82968 May 31 06:46  MartinezRincon-0d5ae8-main.zip
-rw----rw-  1 redes users    10282 May 21 06:50 'Permisos 2.0.xlsx'
-rw----r--  1 redes users     4345 May 21 07:57  permisos.csv
drwx---r-x 16 redes users     4096 May 31 07:02  Python-3.8.10
-rw----r--  1 redes users 18433456 May  3  2021  Python-3.8.10.tar.xz

Seteamos los permisos por defecto de forma recursiva (Solo se aplica en directorios)

setfacl -R -d -m g::--- /home/redes/Desktop; setfacl -R -d -m g:group1:rwx /home/redes/Desktop; setfacl -R -d -m g:group2:r-x /home/redes/Desktop; setfacl -R -d -m g:group3:--- /home/redes/Desktop

ls -l /home/redes/Desktop
total 18124
-rwx---rwx   1 redes users      205 May 21 07:57  convert_to_csv.py
-rwx---rwx   1 redes users      443 May 21 08:07  ejecutar_permisos.sh
drwx---r-x+  4 redes users     4096 May 31 07:38  MartinezRincon-0d5ae8-main
-rw----rw-   1 redes users    82968 May 31 06:46  MartinezRincon-0d5ae8-main.zip
-rw----rw-   1 redes users    10282 May 21 06:50 'Permisos 2.0.xlsx'
-rw----r--   1 redes users     4345 May 21 07:57  permisos.csv
drwx---r-x+ 16 redes users     4096 May 31 07:02  Python-3.8.10
-rw----r--   1 redes users 18433456 May  3  2021  Python-3.8.10.tar.xz

Emuti

Sun, 01 Jun 2025 00:00:00 GMT

Video del flujo de uso

import YoutubeVideo from "@/components/YoutubeVideo.astro"

Software para testear NRG de una maquina

Guia Primer Uso
Manual de Usuario

⚙️ Guia Primer Uso

Requerimientos del Sistema

Se necesita tener python version mayor o igual a 3.8.10

Obtener el repositorio (Existen dos maneras)

Clonar el repositorio por medio de SSH o HTTPS
Descargar el .zip (luego descomprimirlo)

Instalación del entorno virtual (En caso de no tener permisos)

powershell -ExecutionPolicy Bypass -File .\setup.ps1

Ejecutar el programa Ejecutar el archivo main.py

python main.py

📝 Manual Usuario

Cargar Archivo

| Pantalla Principal | Elegir Archivo | | :---: | :---: | | | |

Seleccionamos un excel con el siguiente formato. (Tenes un excel base como ejemplo en la carpeta assets)

| SIMBOLO | SIMBOLO | SIMBOLO | SIMBOLO | SIMBOLO | R1 | R2 | R3 | R4 | R5 | | ------- | ------- | ------- | ------- | ------- | -- | -- | -- | -- | -- | | FG | FG | FG | FG | FG | 23 | 24 | 31 | 9 | 4 | | FG | FG | FG | FG | FG | 13 | 6 | 13 | 27 | 12 |

SIMBOLO: Es el simbolo que tiene el rodillo de la maquina.
R: Es el nro que representa el rodillo de la maquina.

Da igual si el excel tiene otros campos, solo es importante que tenga los solicitados.

Ingreso de Datos

import Table from "@/components/Table.astro"

📝Transformar TXT

Puede que ya tengamos un conjunto de datos en algun TXT con un formato especifico como por ejemplo para los Bonus. Entonces podemos transformar ese TXT a un excel con el formato que necesita el programa.

El texto se puede modificar de mejor manera con el visual studio code.

VsCodo Online

Una vez procesado el txt, ese mismo se puede usar para cargarlo en el programa.

Hope Trade

Sun, 01 Jun 2025 00:00:00 GMT

Proyecto de tradeo tipo Marketplace con donaciones.

Video explicando la primera parte del proyecto.

import YoutubeVideo from "@/components/YoutubeVideo.astro"

Administración de donaciones

Esta épica engloba todas las HU relacionadas con la gestión de las donaciones dentro del sistema. Esto incluye la capacidad de realizar donaciones con tarjeta, registrar donaciones en efectivo y donaciones de productos. También abarca los listados de donaciones, junto con la opción de ﬁltrado donaciones.

Título Como Usuario Owner quiero ver el listado de las donaciones registradas en el sistema para poder consultarlo y administrarlo.

Criterios de aceptación

Escenario 1: Éxito al mostrar donaciones Dado el usuario Owner con email "owner@gmail.com" que ha iniciado sesión y que existen donaciones Cuando selecciona la opción del menú "Listar Historial de Donaciones" Entonces el sistema muestra un listado con las donaciones.
Escenario 2: Éxito al mostrar Listado vacío de donaciones Dado el usuario Owner con email "owner@gmail.com" que ha iniciado sesión y que NO existen donaciones Cuando selecciona la opción del menú "Listar Historial de Donaciones" Entonces el sistema informa que "No existen donaciones realizados en el sistema."

Título

Como usuario colaborador o usuario owner Quiero registrar una donación de producto por parte de un usuario registrado o una persona no registrada Para que quede registrado en el sistema

Regla de negocio

Un usuario colaborador / Owner no puede realizar una donación.

Criterios de aceptación

Escenario 1: Éxito al registrar donación de producto donado por un usuario registrado Dado que un usuario colaborador con email "colaborador@gmail.com" que posee su sesión iniciada y el mail "general@gmail.com" el cual se encuentra registrado y pertenece a un usuario general Cuando selecciona la opción "Registrado" e ingresa email: "general@gmail.com", descripción: "Arroz" y selecciona la categoría del producto: "Comida" Entonces el sistema registra la donación del producto, notifica por email al usuario general y al owner, actualiza el historial de mis donaciones, actualiza el historial de todas las donaciones e informa el éxito de la operación.

Escenario 2: Éxito al registrar donación de producto donado por una persona no registrada Dado que un usuario colaborador con email "colaborador@gmail.com" que posee su sesión iniciada y el mail "general@gmail.com" el cual se encuentra registrado y pertenece a un usuario general Cuando selecciona la opción "No registrado" e ingresa email: "general@gmail.com", Nombre: "Pepe", Apellido: "Pérez", Descripción: "Arroz", selecciona la categoría del producto: "Comida". Entonces el sistema registra la donación del producto, notifica por email al donante y al owner, actualiza el historial de mis donaciones, actualiza el historial de todas las donaciones e informa el éxito de la operación.

Escenario 3: Fallo al registrar donación de producto por un usuario no registrado. Dado que un usuario colaborador con email "colaborador@gmail.com" que posee su sesión iniciada y el mail "general@gmail.com" el cual NO se encuentra registrado Cuando selecciona la opción "Registrado" e ingresa email: "general@gmail.com", descripción: "Arroz" y selecciona la categoría del producto: "Comida" Entonces el sistema informa "Usuario no registrado. Por favor, complete los datos requeridos." y no registra el producto.

Escenario 4: Fallo al registrar donación en efectivo por una persona con email registrado. Dado que un usuario colaborador con email "colaborador@gmail.com" que posee su sesión iniciada y el mail "general@gmail.com" el cual se encuentra registrado y pertenece a un usuario general Cuando selecciona la opción "No registrado" e ingresa email: "general@gmail.com", Nombre: "Pepe", Apellido: "Pérez", Descripción: "Arroz", selecciona la categoría del producto: "Comida". Entonces el sistema informa "El Usuario ya se encuentra registrado. Complete los campos como corresponde." y no registra el producto.

Escenario 5: Fallo al registrar donación de producto por un usuario colaborador. Dado que un usuario colaborador con email "colaborador@gmail.com" que posee su sesión iniciada y el mail "colaborador2@gmail.com" el cual se encuentra registrado y pertenece a un usuario colaborador Cuando selecciona la opción "No registrado" e ingresa email: "colaborador2@gmail.com" Nombre: "Pepe", Apellido: "Pérez", Descripción: "Arroz", selecciona la categoría del producto: "Comida". Entonces el sistema informa "El donante no puede ser ni Dueño, ni Colaborador. Complete los campos como corresponde." y no registra el producto.

Título Como Usuario general quiero ver mi historial de donaciones para tener un registro de las donaciones que realice

Criterios de aceptación

Escenario 1: Éxito al mostrar mis donaciones Dado el usuario general con email "general@gmail.com" que ha iniciado sesión y que realizo donaciones Cuando selecciona la opción del menú "Listar Mi Historial de Donaciones" Entonces el sistema muestra un listado con todas las donaciones del usuario.
Escenario 2: Éxito al mostrar Listado vacío de donaciones Dadoel usuario general con email "general2@gmail.com" que ha iniciado sesión y que NO realizo donaciones Cuando selecciona la opción del menú "Listar Mi Historial de Donaciones" Entonces el sistema informa que "No hay donaciones disponibles."

Título • Como usuario General • Quiero donar con tarjeta • Para colaborar con Caritas

Regla de negocio

• El usuario general DEBE ser titular de la tarjeta.

#Criterios de aceptación

• Escenario 1: Éxito al realizar la donación Dado el usuario general “Pérez Juan” que tiene la sesión iniciada, con una tarjeta valida que le pertenece, posee fondos y que hay conexión con el servidor bancario • Cuando ingresa monto: $1000, selecciona tarjeta “VISA”, Numero de tarjeta: “4970110000001029”, fecha de expiración “05/27”, código de seguridad: “111” y nombre del titular(Como aparece en la tarjeta): "Perez Juan" y presiona “Donar” Entonces el sistema registra el pago, notifica por email al usuario general y al owner, actualiza el historial de mis donaciones, actualiza el historial de todas las donaciones e informa el éxito de la operación.

• Escenario 2: Fallo al realizar la donación por fondos insuficientes Dado el usuario general “Pérez Juan” que tiene la sesión iniciada, con una tarjeta valida que le pertenece, NO posee fondos y que hay conexión con el servidor bancario • Cuando ingresa monto: $1000, selecciona tarjeta “VISA”, Numero de tarjeta: “4970110000001029”, fecha de expiración “05/27”, código de seguridad: “111” y nombre del titular(Como aparece en la tarjeta): "Perez Juan" y presiona “Donar” Entonces el sistema informa “El monto ingresado supera el saldo de la tarjeta.” Y no registra el pago.

• Escenario 3: Fallo al registrar donación por datos de la tarjeta inválidos Dado el usuario general “Pérez Juan” que tiene la sesión iniciada, con una tarjeta que le pertenece con código de seguridad "333" y que hay conexión con el servidor bancario • Cuando ingresa monto: $1000, selecciona tarjeta “VISA”, Numero de tarjeta: “4970110000001029”, fecha de expiración “05/27”, código de seguridad: “111” y nombre del titular(Como aparece en la tarjeta): "Perez Juan" y presiona “Donar” Entonces el sistema informa "Los datos de la tarjeta son inválidos." y no registra el pago.

• Escenario 4: Fallo al registrar donación, la tarjeta no le pertenece Dado el usuario general “Diaz Bruno” que tiene la sesión iniciada, con una tarjeta valida que NO le pertenece, el titular es “Perez Juan” y que hay conexión con el servidor bancario • Cuando ingresa monto: $1000, selecciona tarjeta “VISA”, Numero de tarjeta: “4970110000001029”, fecha de expiración “05/27”, código de seguridad: “111” y nombre del titular(Como aparece en la tarjeta): "Perez Juan" y presiona “Donar” Entonces el sistema informa “La donación debe hacerse con una tarjeta a su nombre” Y no registra el pago.

• Escenario 5: Fallo al registrar donación por error en la conexión con el servidor bancario Dado el usuario general “Pérez Juan” que tiene la sesión iniciada, con una tarjeta valida que le pertenece, posee fondos y que NO hay conexión con el servidor bancario • Cuando ingresa monto: $1000, selecciona tarjeta “VISA”, Numero de tarjeta: “4970110000001029”, fecha de expiración “05/27”, código de seguridad: “111” y nombre del titular(Como aparece en la tarjeta): "Perez Juan" y presiona “Donar” Entonces el sistema informa “Fallo la conexión con el banco.” Y no registra el pago.

Título

Como Usuario Owner quiero filtrar entre dos fechas y/o por tipo el listado de las donaciones registradas en el sistema para poder verificarlo según un tipo de filtrado, verlo y administrarlo.

Criterios de aceptación

Escenario 1: Éxito al mostrar Listado filtrado por tipo de donación entre dos fechas Dado el usuario owner con email "hopetrade08@gmail.com" que ha iniciado sesión, el tipo de donación "efectivo", la fecha de inicio "30/01/2024" que no es mayor a la fecha de fin, la fecha de fin: "30/02/2024" que no es futura al presente y que hay donaciones en efectivo en el rango de fechas. Cuando selecciona el tipo de donación "Efectivo", las fechas "30/01/2024" , "30/04/2024" y presiona "Filtrar por Fecha" Entonces el sistema muestra el listado de las donaciones pertenecientes al tipo de donación registradas entre las dos fechas.
Escenario 2: Éxito al mostrar listado filtrado vacío de donaciones por tipo de donación entre dos fechas Dado el usuario owner con email "owner@gmail.com" que ha iniciado sesión, el tipo de donación "efectivo", la fecha de inicio "30/01/2024" que no es mayor a la fecha de fin, la fecha de fin: "30/02/2024" que no es futura al presente y que NO hay registro de donaciones entre las fechas pertenecientes al tipo de donación. Cuando selecciona el tipo de donación "Efectivo", las fechas "30/01/2024" , "30/04/2024" y presiona "Filtrar por Fecha" Entonces el sistema informa que no existen coincidencias.
Escenario 3: Fallo listado filtrado por fecha futura al presente Dado el usuario owner con email "owner@gmail.com" que ha iniciado sesión, el tipo de donación "efectivo", la fecha de inicio "30/01/2024" que no es mayor a la fecha de fin, la fecha de fin: "30/02/2025" que es futura al presente Cuando selecciona el tipo de donación "Efectivo", las fechas "30/01/2024" , "30/02/2025" y presiona "Filtrar por Fecha" Entonces el sistema informa "La fecha no puede ser futura al presente."
Escenario 4: Fallo listado filtrado por fecha de inicio mayor a fecha de fin. Dado el usuario owner con email "owner@gmail.com" que ha iniciado sesión, el tipo de donación "efectivo", la fecha de inicio "30/04/2024" que ES mayor a la fecha de fin, la fecha de fin: "30/02/2024" Cuando selecciona el tipo de donación "Efectivo", las fechas "30/04/2024" , "30/02/2024" y presiona "Filtrar por Fecha" Entonces el sistema informa "La fecha inicial no puede ser mayor a la fecha final."

Título

Como usuario colaborador o usuario Owner Quiero registrar una donación en efectivo por parte de un usuario registrado o una persona no registrada Para que quede registrado en el sistema

Regla de negocio

Un usuario colaborador / Owner no puede realizar una donación.

Criterios de aceptación

Escenario 1: Éxito al registrar donación en efectivo donado por un usuario registrado Dado que un usuario colaborador con email "colaborador@gmail.com" que posee su sesión iniciada y el mail "general@gmail.com" el cual se encuentra registrado y pertenece a un usuario general Cuando selecciona la opción "Registrado" e ingresa email: "general@gmail.com" y monto de la donación: 1000 Entonces el sistema registra la donación en efectivo, notifica por email al usuario general y al owner, actualiza el historial de mis donaciones, actualiza el historial de todas las donaciones e informa el éxito de la operación.
Escenario 2: Éxito al registrar donación en efectivo donado por una persona no registrada Dado que un usuario colaborador con email "colaborador@gmail.com" que posee su sesión iniciada y el mail "general@gmail.com" el cual se encuentra registrado y pertenece a un usuario general Cuando selecciona la opción "No registrado" e ingresa email: "general@gmail.com", nombre: "Juan", apellido: "Martínez", teléfono: 221122112 y monto: 1000. Entonces el sistema registra la donación en efectivo, notifica por email al usuario general y al owner, actualiza el historial de mis donaciones, actualiza el historial de todas las donaciones e informa el éxito de la operación.
Escenario 3: Fallo al registrar donación en efectivo por un usuario no registrado. Dado que un usuario colaborador con email "colaborador@gmail.com" que posee su sesión iniciada y el mail "general@gmail.com" el cual NO se encuentra registrado Cuando selecciona la opción "Registrado" e ingresa email: "general@gmail.com" y monto de la donación: 1000 Entonces el sistema informa "El usuario no se encuentra registrado. Complete los campos como corresponde." y no registra el pago.
Escenario 4: Fallo al registrar donación en efectivo por una persona con email registrado. Dado que un usuario colaborador con email "colaborador@gmail.com" que posee su sesión iniciada y el mail "general@gmail.com" el cual se encuentra registrado y pertenece a un usuario general Cuando selecciona la opción "No registrado" e ingresa email: "general@gmail.com", nombre: "Juan", apellido: "Martínez", teléfono: 221122112 y monto de la donación: 1000 Entonces el sistema informa "El Usuario ya se encuentra registrado. Complete los campos como corresponde." y no registra el pago.
Escenario 5: Fallo al registrar donación en efectivo por un usuario colaborador. Dado que un usuario colaborador con email "colaborador@gmail.com" que posee su sesión iniciada y el mail "colaborador2@gmail.com" el cual se encuentra registrado y pertenece a un usuario colaborador Cuando selecciona la opción "Registrado" e ingresa email: "colaborador2@gmail.com" y monto de la donación: 1000 Entonces el sistema informa "El donante no puede ser ni Dueño, ni Colaborador. Complete los campos como corresponde." y no registra el pago.

Administración de intercambios

Esta épica engloba todas las HU relacionadas a la gestión de solicitudes de intercambio, desde la realización, selección, rechazo o conﬁrmación, ya sea por parte de un usuario en la página o de un colaborador en la ﬁlial a la hora de un intercambio.

Título

Como usuario general Quiero listar las ofertas enviadas Para consultar su estado

Criterios de aceptación

Escenario 1: Éxito al listar las ofertas enviadas Dado un usuario general con email general@gmail.com y ofertas enviadas que existen
Cuando presiona el botón "Listar Ofertas Enviadas" Entonces el sistema muestra el listado detallado con las ofertas enviadas
Escenario 2: Éxito al mostrar un listado vació de ofertas enviadas Dado un usuario general con email general@gmail.com y que no existen ofertas enviadas Cuando presiona el botón "Listar Ofertas Enviadas" Entonces El sistema informa que "No hay Ofertas de intercambios"

Título

Como usuario general Quiero listar las ofertas recibidas Para consultar su estado

Criterios de aceptación

Escenario 1: Éxito al listar las ofertas recibidas Dado un usuario general con email general@gmail.com y ofertas recibidas que existen
Cuando presiona el botón "Listar Ofertas Recibidas" Entonces el sistema muestra el listado detallado con las ofertas recibidas
Escenario 2: Éxito al mostrar un listado vació de ofertas recibidas Dado un usuario general con email general@gmail.com con un listado vació de ofertas recibidas Cuando presiona el botón "Listar Ofertas Recibidas" Entonces El sistema informa que "No hay Ofertas de intercambios"

Título

Como usuario general Quiero Rechazar la oferta recibida Para buscar otra oferta que me interese

Criterios de aceptación

Escenario 1: Éxito al rechazar la oferta recibida Dado un usuario general con email general@gmail.com, una oferta recibida y una descripción "No me interesa" Cuando presiona "Rechazar", "detalle el motivo": "No me interesa" Entonces el sistema informar "Oferta rechazada con éxito", cambia el estado de la oferta a rechazada, notifica por email al usuario solicitante y almacena la descripción del rechazo.

Título

Como usuario general Quiero ver el detalle de la oferta recibida Para determinar si la acepto o no

Criterios de aceptación

Escenario 1: Éxito al detallar oferta recibida en estado pendiente Dado un usuario general con email general@gmail.com y una oferta recibida Cuando selecciona la oferta en la lista de ofertas recibidas Entonces el sistema muestra la información detallada de la oferta recibida, su estado actual y las opciones para "Aceptar" , "Rechazar" y campo "detalle el motivo".
Escenario 2: Éxito al detallar oferta recibida Dado un usuario general con email general@gmail.com y una oferta recibida Cuando selecciona la oferta en la lista de ofertas recibidas Entonces el sistema muestra la información detallada de la oferta recibida y su estado actual

Título

Como usuario general Quiero aceptar la oferta recibida Para proceder al intercambio de los productos

Criterios de aceptación

Escenario 1: Éxito al aceptar la oferta recibida Dado un usuario general con email general@gmail.com y una oferta recibida Cuando presiona "Aceptar" Entonces el sistema informa "Oferta aceptada con éxito", cambia el estado de la oferta a aceptada, notifica por email al usuario solicitante y almacena el intercambio de productos.

Título

Como Usuario Colaborador o Usuario Owner quiero ver el listado de intercambios pendientes del día para poder confirmar o cancelar un intercambio.

Reglas de negocio

Criterios de aceptación

Escenario 1: Éxito al listar los intercambios pendientes del día Dado que el usuario owner con email owner@gmail.com e intercambios pendientes durante el día que existen Cuando presiona el botón "Listar Intercambios Pendientes" Entonces el sistema muestra el listado detallado y habilita las opciones para "Confirmar Intercambio", "Cancelar Intercambio" y el campo "detalle el motivo"
Escenario 2: Éxito al mostrar listado vacío de intercambios pendientes del día Dado que el usuario owner con email owner@gmail.com con un listado vacío de intercambios pendientes durante el día Cuando presiona el botón "Listar Intercambios Pendientes" Entonces El sistema informa que "No hay intercambios pendientes para el día de hoy."

Título Como usuario colaborador o owner Quiero confirmar un intercambio pendiente del día Para registrar la confirmación del intercambio realizado

Criterios de aceptación

Escenario 1: Éxito al confirmar el intercambio pendiente Dado un usuario colaborador con email colaborador@gmail.com y una oferta pendiente a intercambio Cuando selecciona "Confirmar intercambio" Entonces el sistema informa "Intercambio confirmado con éxito", cambia el estado de la oferta a finalizada, cambia la descripción de la oferta a "Intercambio confirmado con éxito", cambia la visibilidad de las publicaciones involucradas a "eliminada", notifica por email a los usuarios ofertante y solicitante, lo registra en el historial de intercambios y lo redirige a intercambios pendientes del día.

Título Como Usuario Colaborador o Usuario Owner quiero ver el listado del historial intercambios para ver los intercambios que se realizaron o no.

Criterios de aceptación

Escenario 1: Éxito al mostrar listado Dado que el usuario colaborador colaborador@gmail.com con una sesión iniciada y el listado de historial de intercambios no está vacío Cuando presiona el botón "Listar historial de intercambios" Entonces el sistema muestra en pantalla el listado de intercambios realizados
Escenario 2: Éxito al mostrar listado vacío Dado que el usuario colaborador colaborador@gmail.com con una sesión iniciada y el listado de historial de intercambios está vacío Cuando presiona el botón "Listar historial de intercambios" Entonces el sistema muestra "No existen intercambios realizados en el sistema".

Título Como usuario colaborador o usuario owner Quiero Cancelar un intercambio del día Para registrar la cancelación del intercambio no realizado

Criterios de aceptación

Escenario 1: Éxito al Cancelar el Intercambio pendiente Dado un usuario colaborador con email colaborador@gmail.com, una oferta pendiente a intercambio y una descripción "No estuvieron de Acuerdo" Cuando ingresa "detalle el motivo": "No estuvieron de acuerdo" y presiona "Cancelar intercambio" Entonces el sistema informa "Intercambio cancelado con éxito", cambia el estado de la oferta a finalizada, notifica por email a los usuarios ofertante y solicitante, almacena la descripción de la cancelación, lo registra en el historial de intercambios y lo redirige a intercambios pendientes del día.

Título

Como usuario general Quiero ver el detalle de la oferta enviada Para consultar su estado

Criterios de aceptación

Escenario 1: Éxito al detallar oferta enviada Dado un usuario general con email general@gmail.com y una oferta enviada Cuando selecciona la oferta en la lista de ofertas recibidas Entonces el sistema muestra la información detallada de la oferta enviada y su estado actual

Administración de publicaciones

Esta épica incluye todas las HU que facilitan el ciclo de vida completo de las publicaciones de intercambio en el sistema, desde la subida y modiﬁcación de visibilidad hasta la interacción y gestión de las mismas mediante listados, detalles, ofertas y comentarios.

Título Como Usuario General Quiero cambiar la visibilidad de una publicación Para usarla de diferentes maneras

Criterios de aceptación

Escenario 1: Éxito archivar una publicación publicada Dado que el usuario general con mail "general@gmail.com" en su publicación que existe y esta publicada Cuando presiona el botón "Archivar" Entonces el sistema cambia el estado de la publicación, la archiva e informa "La publicación se ha actualizado correctamente."
Escenario 2: Éxito al publicar una publicación archivada Dado que el usuario general con mail "general@gmail.com" en su publicación que existe y esta archivada Cuando presiona el botón "Publicar" Entonces el sistema cambia el estado de la publicación, la publica e informa "La publicación se ha actualizado correctamente."

Título Como Usuario General Quiero Editar una publicación Para actualizar los datos de la misma

Regla de negocio

Criterios de aceptación

Escenario 1: Edición Exitosa Dado que el usuario general con mail "general@gmail.com" en su publicación que existe Cuando presiona el botón de "Editar Publicación", "Nueva Descripción": "Estado Perfecto" y presiona el botón de "Confirmar". Entonces el sistema informa "La publicación se ha actualizado correctamente."

Título Como Usuario general Quiero listar mis publicaciones Para poder ver las publicaciones que he subido

Regla de negocio

Criterios de aceptación

Escenario 1: Éxito al listar mis Publicaciones Dado el usuario general "general@gmail.com" con sesión iniciada y con publicaciones subidas Cuando se presiona el botón "Listar Mis Publicaciones" Entonces el sistema muestra un listado de las publicaciones subidas por el usuario
Escenario 2: Éxito al mostrar un listado vacío de publicaciones Dado el usuario general general2@gmail.com con sesión iniciada y sin publicaciones subidas Cuando se presiona el botón "Listar Mis Publicaciones" Entonces El sistema muestra el mensaje 'No hay Publicaciones disponibles'

Título

Como usuario general o usuario owner o usuario colaborador
Quiero listar las publicaciones
Para conocerlas

Criterios de aceptación

Escenario 1: Éxito al mostrar las publicaciones Dado El Usuario General con Mail "general@gmail.com" y que existen publicaciones subidas Cuando se presiona el botón "Listar publicaciones" Entonces el sistema muestra un listado con las publicaciones publicas subidas por otros usuarios
Escenario 2: Éxito al mostrar un listado vacío de publicaciones
Dado El Usuario General con Mail "general@gmail.com" y no existen publicaciones subidas Cuando se presiona el botón "Listar publicaciones" Entonces El sistema muestra el mensaje 'No hay Publicaciones disponibles'

Título Como usuario general, Quiero Subir una Publicación, Para poder intercambiarlo en el futuro

Regla de negocio

La imagen tiene que ser en formato png o jpg
Nombre de la publicación único para el usuario

Criterios de aceptación

Escenario 1: Subida Exitosa de una Publicación Publica Dado: que la imagen tiene formato png y el Título "Cafetera" no pertenece a una publicación del usuario Cuando: Selecciona la imagen, ingresa Título: "Cafetera", Descripción: "En buen estado", Horarios Libres (opcional) : "de 13 a 18", selecciona la categoría "Electrodomésticos" y presiona el botón: "Publicar" Entonces: Sistema registra la publicación para el usuario como pública, informa "La publicación se ha subido correctamente." y lo redirige al listado de sus publicaciones
Escenario 2: Subida Exitosa de una Publicación Archivada Dado: que la imagen tiene formato jpg y el Título "Paquete de Arroz" no pertenece a una publicación del usuario Cuando: Selecciona la imagen, ingresa Título: "Paquete de Arroz", Descripción: "Largo Fino", Horarios Libres (opcional) : "de 10 a 18", selecciona la categoría "Comida" y presiona el botón: "Archivar" Entonces: Sistema registra la publicación para el usuario como archivada, informa "La publicación se ha subido correctamente." y lo redirige al listado de sus publicaciones
Escenario 3: Subida Fallida por formato invalido Dado: que la imagen tiene formato webp y el Título "Mesita de luz" no pertenece a una publicación del usuario Cuando: Selecciona la imagen, ingresa Título: "Mesita de luz", Descripción: "Barnizada", Horarios Libres (opcional) : "de 10 a 18", selecciona la categoría "Muebles" y presiona el botón: "Publicar" Entonces: Sistema informa "El archivo debe ser una imagen en formato JPG o PNG."
Escenario 4: Subida Fallida por Titulo ya registrado Dado: que la imagen tiene formato png y el Título "Cafetera" pertenece a una publicación del usuario Cuando: Selecciona la imagen, ingresa Título: "Cafetera", Descripción: "En regular estado", Horarios Libres (opcional) : "de 13 a 18", selecciona la categoría "Electrodomésticos" y presiona el botón: "Publicar" Entonces: Sistema informa "Ya tienes una publicación con el mismo título."

Título

Como usuario general Quiero comentar una publicación Para interactuar con otro usuario

Criterios de aceptación

Escenario 1: Éxito al comentar publicación ajena Dado un usuario general con email general@gmail.com y una publicación ajena que existe Cuando presiona el botón "Comentar", ingresa "Me interesa" y presiona el botón "Agregar Comentario" Entonces el sistema registra el comentario, informa "¡Comentario agregado con éxito!" y notifica por email al autor de la publicación

Como usuario general o usuario colaborador o usuario owner Quiero ver la información detallada de una publicación Para conocer más detalles sobre la misma

Reglas de negocio

Un comentario tiene solo una respuesta

Criterios de aceptación

Escenario 1: Éxito al detallar una publicación ajena sin comentarios siendo usuario general Dado un usuario general con email "general@gmail.com" que ha iniciado sesión y una publicación ajena que existe Cuando selecciona la publicación en la lista de publicaciones Entonces el sistema muestra la información detallada de la publicación, la sección de comentarios con un mensaje "No hay comentarios", la opción de Comentar y la opción de "Ofertar"
Escenario 2: Éxito al detallar una publicación propia sin comentarios Dado un usuario general con email "general@gmail.com" que ha iniciado sesión y una publicación propia que existe, Cuando selecciona una publicación en la lista de sus publicaciones Entonces el sistema muestra la información detallada de la publicación y habilita las opciones para "Archivar" o "Publicar" , "Eliminar" y "Editar Publicación", muestra la sección de comentarios con un mensaje "No hay comentarios"
Escenario 3: Éxito al detallar una publicación ajena con comentarios siendo usuario general Dado un usuario general con email "general@gmail.com" que ha iniciado sesión y una publicación ajena que existe Cuando selecciona la publicación en la lista de publicaciones Entonces el sistema muestra la información detallada de la publicación, la opción de "Ofertar" , la sección de comentarios y la opción de Comentar
Escenario 4: Éxito al detallar una publicación propia con comentarios Dado un usuario general con email "general@gmail.com" que ha iniciado sesión y una publicación propia que existe Cuando selecciona una publicación en la lista de sus publicaciones Entonces el sistema muestra la información detallada de la publicación y habilita las opciones para "Archivar" o "Publicar" , "Eliminar" y "Editar Publicación", muestra la sección de comentarios con la opción de Responder si corresponde
Escenario 5: Éxito al detallar una publicación con comentarios siendo owner Dado un usuario owner con email "owner@gmail.com" que ha iniciado sesión y una publicación que existe Cuando selecciona la publicación en la lista de publicaciones Entonces el sistema muestra la información detallada de la publicación, la sección de comentarios y habilita las opción para "Eliminar".
Escenario 6: Éxito al detallar una publicación sin comentarios siendo owner Dado un usuario owner con email "owner@gmail.com" que ha iniciado sesión y una publicación que existe Cuando selecciona la publicación en la lista de publicaciones Entonces el sistema muestra la información detallada de la publicación, la sección de comentarios con un mensaje "No hay comentarios" y habilita las opción para "Eliminar".

Título

Como usuario general Quiero responder un comentario Para interactuar con otro usuario

Criterios de aceptación

Escenario 1: Éxito al responder comentario Dado un usuario general con email general@gmail.com y un comentario en una publicación propia Cuando presiona el botón "Responder", ingresa "Gracias" y presiona el botón "Enviar Respuesta" Entonces el sistema registra la respuesta, informa "¡Respuesta enviada con exito! y notifica por email al autor del comentario

Título Como Usuario General Quiero Ofertar una publicación Para Intercambiar un producto que me guste

Regla de negocio

Tener al menos una publicación subida por parte del usuario general

Criterios de aceptación

Escenario 1: Oferta fallida por falta de publicaciones subidas.
Dado que el usuario general general@gmail.com no posee publicaciones subidas. Cuando toca la opción de ofertar Entonces El sistema muestra un mensaje "No tienes publicaciones para ofertar." y el usuario general es redirigido al listado de publicaciones.
Escenario 2: Oferta fallida por horario invalido Dado que el usuario general general@gmail.com y tiene al menos 1 publicación subida Cuando toca la opción de ofertar, selecciona una publicación propia, filial "La Plata", Fecha "1/1/2025" Hora "07:00" Entonces El sistema informa "El horario debe estar entre las 8 AM y las 7 PM.", y no se realiza la oferta.
Escenario 3: Oferta fallida por fecha invalida Dado que el usuario general generalCaritas@gmail.com y tiene al menos 1 publicación subida Cuando toca la opción de ofertar, selecciona una publicación propia, filial "La Plata", Fecha "01/06/2001" y Hora "15:00" Entonces El sistema informa "La fecha no puede ser anterior a la actual." y no se realiza la oferta.
Escenario 4: Oferta exitosa Dado que el usuario general general@gmail.com y tiene al menos 1 publicación subida Cuando el selecciona una publicación propia, filial "La Plata", Fecha "10/06/2024" y Hora "18:00" Entonces El sistema muestra un mensaje "Oferta realizada con éxito.", registra la oferta realizada al sistema, y envía una notificación al email sobre la oferta de intercambio al usuario ofertado. El Usuario general es redirigido al listado de publicaciones.
Escenario 5: Oferta fallida por repetir la oferta Dado que el usuario general general@gmail.com, tiene al menos 1 publicación subida, ya posee una oferta de intercambio similar realizada con el mismo producto ofertado y mismo ofrecido. Cuando toca la opción de ofertar, selecciona una publicación propia, filial "La Plata", Fecha "1/10/2025" Hora "09:00" Entonces El sistema redirige al usuario a la página de ofertas enviadas, informa "Ya existe una oferta similar, revise sus ofertas enviadas". Y no se realiza la oferta.
Escenario 6: Oferta fallida por oferta similar recibida Dado que el usuario general general2@gmail.com, tiene al menos 1 publicación subida, ya posee una oferta de intercambio similar recibida con los mismos productos. Cuando toca la opción de ofertar, selecciona una publicación propia, filial "La Plata", Fecha "1/10/2025" Hora "09:00" Entonces El sistema redirige al usuario a la página de ofertas recibidas, informa "Ya existe una oferta similar, revise sus ofertas recibidas". Y no se realiza la oferta.

Titulo

Como Usuario General
Quiero eliminar mi publicación
Para que no se encuentre en el sistema

Regla de Negocio

La publicación no debe tener ofertas recibidas pendientes
La publicación no debe tener una oferta aceptada

Criterios de aceptación

Escenario 1: Éxito al eliminar mi publicación sin ofertas pendientes y sin una oferta aceptada Dado que el usuario general con mail "general@gmail.com" en su publicación que existe, la cual no posee ofertas pendientes y no posee una oferta aceptada. Cuando presiona el botón de "Eliminar" y acepta la operación Entonces el sistema elimina la publicación, informa al usuario "La publicación ha sido eliminada correctamente." y redirecciona a sus publicaciones

Escenario 2: Fallo al eliminar mi publicación con ofertas pendientes Dado que el usuario general con mail "general@gmail.com" en su publicación que existe, la cual posee ofertas pendientes Cuando presiona el botón de "Eliminar" y acepta la operación Entonces el sistema informa al usuario "No Puedes Eliminar esta Publicacion ya que tenes ofertas pendientes." y redirecciona al listado de ofertas recibidas.

Escenario 3: Éxito al cancelar eliminar mi publicación Dado que el usuario general con mail "general@gmail.com" en su publicación que existe Cuando presiona el botón de "Eliminar" y cancela la operación Entonces el sistema cancela la operación

Titulo

Como usuario owner
Quiero eliminar una publicación que incumple las normas
Para que ya no se encuentre disponible

Reglas de Negocio

La publicación no debe tener ofertas con estado aceptada

Criterios de aceptación

Escenario 1: Éxito al eliminar publicación sin ofertas pendientes o aceptadas Dado El usuario owner con mail owner@gmail.com en una publicación que existe Cuando presiona el botón de Eliminar y confirma la operación Entonces el sistema elimina la publicación, redirige a la página principal , informa "La publicación ha sido eliminada correctamente" y notifica por email al usuario General que su publicación fue eliminada por un administrador.
Escenario 2: Éxito al eliminar publicación con ofertas pendientes Dado El Usuario owner con mail owner@gmail.com en una publicación que existe Cuando presionar el botón de Eliminar y confirma la operación Entonces el sistema cancela las ofertas recibidas o enviadas en estado pendiente, cambia el estado de la oferta a "cancelada" y la descripcion a "La oferta fue cancelada por la eliminacion de La publicacion (titulo de la publicacion)", notifica por email al usuario solicitante u ofertante (según corresponda) que la oferta fue cancelada, elimina la publicación, redirige a la página principal, informa "La publicación ha sido eliminada correctamente." y notifica por email al usuario General que su publicación fue eliminada por un administrador.
Escenario 3: Éxito al cancelar eliminar publicación
Dado El usuario owner con mail owner@gmail.com en una publicación que existe
Cuando presionar el botón de Eliminar y cancela la operación
Entonces el sistema cancela la operación.

Gestión de usuarios

Esta épica cubre todas las funciones vinculadas a la administración de usuarios y colaboradores en el sistema, incluyendo el registro, listado y eliminación de cuentas, así como la posibilidad de aplicar sanciones en caso de incumplimientos normativos.

Título

Como usuario owner Quiero registrar un colaborador Para habilitarle las funcionalidades correspondientes

Regla de negocio

El mail debe ser único en el sistema

Criterios de aceptación

Escenario 1: Éxito al registrar colaborador Dado el mail "gallardolucas003@gmail.com" el cual no se encuentra registrado previamente Cuando se ingresa Nombre: "Lucas", Apellido: "Gallardo" y el Email:"gallardolucas003@gmail.com" Entonces el sistema da de alta un nuevo colaborador e informa "Usuario registrado Correctamente!. Se ha enviado un correo electrónico con la contraseña" y lo redirige al listado de usuarios colaboradores
Escenario 2: Error al registrar colaborador Dado el mail "gallardolucas003@gmail.com" el cual se encuentra registrado previamente Cuando se ingresa Nombre: "Fabian", Apellido: "Martinez" y el Email:"gallardolucas003@gmail.com" Entonces el sistema informa "El mail ingresado ya se encuentra registrado." y lo redirige al listado de usuarios colaboradores

Título

Como usuario colaborador o usuario owner
Quiero ver los usuarios generales
Para tener un control de los mismos

Criterios de aceptación

Escenario 1: Éxito al listar usuarios Generales Dado El Usuario Owner con Mail owner@gmail.com y usuarios generales existentes Cuando se presiona el botón "Listar Usuarios" Entonces el sistema muestra un listado con los usuarios generales
Escenario 2: Éxito al mostrar un listado vacío de usuarios generales Dado El Usuario Owner con Mail owner@gmail.com y que no existen usuarios generales Cuando se presiona el botón "Listar Usuarios" Entonces El sistema informa que "No existen usuarios generales cargados en el sistema"

Título

Como usuario Owner
Quiero listar los usuarios colaboradores
Para mantener un control

Criterios de aceptación

Escenario 1: Éxito al mostrar usuarios colaboradores Dado El Usuario Owner con Mail owner@gmail.com y que existen usuarios colaboradores Cuando presiona el botón "Listar Colaboradores" Entonces el sistema muestra un listado con los usuarios colaboradores
Escenario 2: Listado vacío de usuarios colaboradores Dado El Usuario Owner con Mail owner@gmail.com y que no existen usuarios colaboradores Cuando presiona el botón "Listar Colaboradores" Entonces El sistema informa que "No existen usuarios colaboradores cargados en el sistema"

Título

Como Usuario Visitante
Quiero Registrarme
Para poder acceder a las funcionalidades del sistema

Reglas de negocio

El mail debe ser único en el sistema
El DNI debe ser único en el sistema
El usuario visitante debe ser mayor de edad
La contraseña debe tener mínimo 8 caracteres

Criterios de aceptación

Escenario 1: Registro Exitoso Dado el mail "prueba@gmail.com" el cual no se encuentra registrado previamente, DNI "42342521" el cual no se encuentra registrado previamente, fecha de nacimiento "01/01/2000" la cual pertenece a una persona mayor de edad y contraseña "contraprueba" la cual tiene mínimo 8 caracteres Cuando se ingresa el Nombre "Nombre1", Apellido "Apellido1", Email "prueba@gmail.com", Contraseña "contraprueba", DNI "42342521", Teléfono "22132131" y Fecha de Nacimiento "01/01/2000" Entonces El sistema da de alta un nuevo usuario, redirecciona al Iniciar sesión e informa "Fue registrado correctamente"
Escenario 2: Registro Fallido por mail ya registrado Dado el mail "prueba@gmail.com" el cual se encuentra registrado Cuando se ingresa el Nombre "Nombre2", Apellido "Apellido2", Email "prueba@gmail.com", Contraseña "contracualquiera", DNI "554353412", Teléfono "31214523" , Fecha de Nacimiento "01/01/2000" Entonces El sistema informa "Ya existe un usuario registrado con ese mail"
Escenario 3: Registro Fallido por dni ya registrado Dado el mail "pruebadni@gmail.com" el cual no se encuentra registrado previamente y el DNI "42342521" el cual se encuentra registrado previamente Cuando se ingresa el Nombre "Nombre3", Apellido "Apellido3", Email "pruebadni@gmail.com", Contraseña "contrarepetida", DNI "42342521", Teléfono "745345534", y fecha de nacimiento "01/01/2000" Entonces El sistema informa al usuario "Ya existe un usuario registrado con ese dni"
Escenario 4: Registro Fallido por Persona menor de edad Dado el mail "menor@gmail.com" el cual no se encuentra registrado previamente, DNI "98413292" el cual no se encuentra registrado previamente, fecha de nacimiento "08/08/2018" la cual no pertenece a una persona mayor de edad Cuando se ingresa el Nombre "Nombre4", Apellido "Apellido4", Email "menor@gmail.com", Contraseña "contramenor", DNI "98413292", Teléfono "4234321", y fecha de nacimiento "08/08/2018" Entonces El sistema informa al usuario "Debes tener al menos 18 años para registrarte."
Escenario 5: Registro Fallido por contraseña con menos de 8 caracteres Dado el mail "prueba2@gmail.com" el cual no se encuentra registrado previamente, DNI "31234324" el cual no se encuentra registrado previamente, fecha de nacimiento 01/01/2000 la cual pertenece a una persona mayor de edad y contraseña "hola" la cual tiene menos de 8 caracteres Cuando se ingresa el Nombre "Nombre5", Apellido "Apellido5" Email "prueba2@gmail.com", Contraseña "hola", DNI "31234324", Teléfono "4234321" y fecha de nacimiento "01/01/2000" Entonces El sistema informa que "La contraseña debe tener mínimo 8 caracteres"

Como Usuario Owner o Usuario Colaborador quiero filtrar a los usuarios generales por email mediante una cadena para realizar una búsqueda mas rápida

Reglas de negocio

Criterios de aceptación

Escenario 1: Éxito al filtrar por mail Dado que el usuario owner con email "owner@gmail.com" que ha iniciado sesión y hay usuarios generales con un mail que coincide con la cadena "general2" Cuando ingresa "Filtrar por email" : "general2" Entonces el sistema muestra el listado de usuarios generales que comiencen con la cadena "general2"
Escenario 2: Éxito al filtrar sin coincidencias. Dado que el usuario colaborador con email "colaborador@gmail.com" que ha iniciado sesión y no hay usuarios generales con un mail que coincide con la cadena "nuevo" Cuando ingresa "Filtrar por email" : "nuevo" Entonces El sistema muestra el mensaje 'No existen coincidencias'

Título

Como Usuario Owner quiero filtrar el listado de los usuarios colaboradores por email mediante una cadena para poder obtener un listado filtrado de los usuarios que coinciden con la cadena ingresada.

Reglas de negocio

Criterios de aceptación

Escenario 1: Filtrado de listado éxitoso Dado que el usuario owner con email "owner@gmail.com" que ha iniciado sesión y hay usuarios colaboradores con un mail que coincide con la cadena "colaborador2". Cuando ingresa "Filtrar por email" : "colaborador2" Entonces el sistema muestra el listado de usuarios colaboradores que comiencen con la cadena "colaborador2"
Escenario 2: Filtrado de listado éxitoso Dado que el Usuario Owner con email "owner@gmail.com" que ha iniciado sesión y no hay usuarios colaboradores con un mail que coincide con la cadena "austin" Cuando ingresa "Filtrar por email" : "austin" Entonces El sistema muestra el mensaje 'No existen coincidencias'

Título Como Usuario Colaborador o Usuario Owner Quiero penalizar a un usuario general Para darle una advertencia

Regla de negocio

El usuario debe tener menos de 3 penalizaciones.
El motivo no puede estar en blanco

Criterios de aceptación

Escenario 1: Éxito al penalizar usuario con menos de 2 penalizaciones Dado El Usuario Owner con Mail "hopetrade08@gmail.com", usuarios generales existentes y el usuario General "general@gmail.com" posee menos de 2 penalizaciones. Cuando selecciona al usuario "general@gmail.com", Motivo: "Ausencia en el intercambio" y presiona el botón "Penalizar" Entonces el sistema incrementa la cantidad de penalizaciones del usuario general reportado ,lo notifica al email que fue penalizado, informa "El usuario fue penalizado con éxito" y lo redirige al listado de usuarios generales
Escenario 2: Éxito al penalizar usuario con 2 penalizaciones DadoEl Usuario Owner con Mail "hopetrade08@gmail.com", usuarios generales existentes y el usuario General "general@gmail.com" posee 2 penalizaciones. Cuando selecciona al usuario "general@gmail.com", Motivo: "Otra Ausencia en el intercambio" y presiona el botón "Penalizar" Entonces el sistema elimina al usuario general, lo notifica por mail, elimina todas sus publicaciones, cancela todas las ofertas enviadas o recibidas en estado pendiente o aceptada, cambia el estado de las ofertas a "cancelada", junto con las descripciones, notifica por email a los usuarios solicitantes u ofertantes (según corresponda) de lo ocurrido, e informa "El usuario fue penalizado y eliminado con éxito".
Escenario 3: Éxito al cancelar operación Dado El Usuario Owner con Mail "hopetrade08@gmail.com", usuarios generales existentes y el usuario General "general2@gmail.com" posee menos de 3 penalizaciones. Cuando selecciona un usuario y presiona el botón de "Cerrar" Entonces el sistema cancela la operación.

Titulo

Como usuario owner
Quiero eliminar un usuario colaborador
Para que ya no se encuentre en el sistema

Criterios de aceptación

Escenario 1: Éxito al eliminar usuario colaborador Dado El Usuario Owner con Mail "hopetrade08@gmail.com" en el listado de colaboradores y que existen usuarios colaboradores Cuando selecciona un usuario y presiona el botón de "Eliminar" Entonces el sistema elimina al usuario colaborador e informa "Usuario colaborador eliminado correctamente"
Escenario 2: Éxito al cancelar la eliminación de usuario colaborador Dado El Usuario Owner con Mail "hopetrade08@gmail.com" en el listado de colaboradores y que existen usuarios colaboradores Cuando selecciona un usuario y presiona el botón de "Cerrar" Entonces el sistema cancela la operación.

Titulo

Como usuario owner
Quiero eliminar un usuario general
Para que ya no se encuentre en el sistema

Criterios de aceptación

Escenario 1: Éxito al eliminar Dado El Usuario Owner con Mail "hopetrade08@gmail.com" y hay usuarios generales existentes Cuando selecciona un usuario, Motivo: "Incumplimiento de las normas" y presiona el botón "Eliminar" Entonces el sistema elimina al usuario general, lo notifica por mail, elimina todas sus publicaciones, cancela todas las ofertas enviadas o recibidas en estado pendiente o aceptada, cambia el estado de las ofertas a "cancelada", junto con las descripciones, notifica por email a los usuarios solicitantes u ofertantes (según corresponda) de lo ocurrido, e informa "Usuario General eliminado correctamente".
Escenario 2: Éxito al cancelar la eliminación de usuario general Dado El Usuario Owner con Mail "hopetrade08@gmail.com" y hay usuarios generales existentes Cuando selecciona un usuario general y presiona el botón "Cerrar" Entonces el sistema cancela la operación.

Manejo de cuenta

Esta épica engloba todas las HU relacionadas a gestionar la cuenta de usuario en el sistema. Incluye iniciar y cerrar sesión, ver y editar el perﬁl del usuario, acceder al menú de opciones, y revisar las notiﬁcaciones y las ﬁliales disponibles.

Título Como usuario visitante o usuario general o usuario colaborador o usuario owner Quiero listar las filiales Para conocer su información

Criterios de aceptación

Escenario 1: Éxito al listar filiales Dado un usuario visitante que se encuentra en la pagina principal y un listado de filiales que existe Cuando presiona en el botón "Ver Filiales" Entonces el sistema muestra un listado de las filiales

Título

Como usuario general o usuario colaborador o usuario owner
Quiero ver mi Perfil
Para ver mis datos personales

Criterios de aceptación

Escenario: Éxito al mostrar perfil Dado El Usuario General con Mail "general@gmail.com" que ha iniciado sesión Cuando presiona el botón "Ver Perfil" Entonces el sistema muestra la información personal del usuario y el botón "Editar perfil"

Título

Como usuario general o usuario owner o usuario colaborador
Quiero editar mi perfil
Para cambiar mis datos de acceso

Reglas de Negocio

La contraseña debe tener mínimo 8 caracteres

Criterios de aceptación

Escenario 1: Éxito al Editar Perfil Dado El Usuario General con Mail "general@gmail.com" y la contraseña nueva "contranueva" la cual tiene mínimo 8 caracteres Cuando ingresa Contraseña Actual: "contrageneral", Nueva Contraseña: "contranueva" y presiona el botón "Actualizar" Entonces el sistema registra la contraseña e informa "¡Perfil actualizado correctamente!"
Escenario 2: Fallo al Editar Perfil por contraseña menor a 8 caracteres Dado El Usuario General con Mail "general@gmail.com" y la contraseña nueva "contra" la cual tiene menos 8 caracteres Cuando ingresa Contraseña Actual: "contranueva", Nueva Contraseña: "contra" y presiona el botón "Actualizar" Entonces el sistema informa "La contraseña debe tener mínimo 8 caracteres"
Escenario 3: Fallo al Editar Perfil por contraseña actual incorrecta Dado El Usuario General con Mail "general@gmail.com" y la contraseña nueva "contrafinal" la cual tiene mínimo 8 caracteres Cuando ingresa Contraseña Actual: "contrarara", Nueva Contraseña: "contrafinal" y presiona el botón "Actualizar" Entonces el sistema informa "Contraseña actual incorrecta. Inténtalo de nuevo."

Título Como usuario general o usuario owner o usuario colaborador Quiero cerrar sesión Para salir del sistema

Regla de negocio

Criterios de aceptación

Escenario: Éxito al cerrar sesión Dado el usuario general con email "general@gmail.com" que ha iniciado sesión Cuando presiona el botón "Cerrar Sesión" y confirma el cierre Entonces el sistema cierra la sesión del usuario, informa "Se ha cerrado la sesión correctamente." y lo redirecciona a la página principal
Escenario 2: Éxito al cancelar el cierre de sesión Dado el usuario general con email "general@gmail.com" que ha iniciado sesión Cuando presiona el botón "Cerrar Sesión" y cancela el cierre Entonces el sistema cancela la operación

Título

Como Usuario general o usuario owner o usuario colaborador
Quiero Iniciar Sesión
Para acceder al sistema

Criterios de aceptación

Escenario 1: Inicio de sesión exitoso como usuario general Dado Un Usuario General con el mail "general@gmail.com" el cual pertenece un usuario general y contraseña "contrageneral" la cual es valida Cuando se ingresa el mail "general@gmail.com" y la contraseña "contrageneral" Entonces el sistema habilita las funcionalidades de usuario general, informa "Inicio de sesión Exitoso" y lo redirige a la página principal
Escenario 2: Inicio de sesión exitoso como usuario colaborador Dado Un Usuario Colaborador con el mail "colaborador@gmail.com" el cual pertenece a un usuario colaborador y contraseña "contracolaborador" la cual es valida Cuando se ingresa el mail "colaborador@gmail.com" y la contraseña "contracolaborador" Entonces el sistema habilita las funcionalidades de usuario colaborador, informa "Inicio de sesión Exitoso" y lo redirige a la página principal
Escenario 3: Inicio de sesión exitoso como usuario owner Dado Un Usuario Owner con el mail "owner@gmail.com" el cual pertenece a un usuario owner y contraseña "contraowner" la cual es valida Cuando se ingresa el mail "owner@gmail.com" y la contraseña "contraowner" Entonces el sistema habilita las funcionalidades de usuario owner, informa "Inicio de sesión Exitoso" y y lo redirige a la página principal
Escenario 4: Inicio de sesión fallido por correo invalido Dado Un Usuario General con el mail "invalido@gmail.com" el cual no pertenece a un usuario general del sistema y contraseña "contrarandom" Cuando se ingresa mail "invalido@gmail.com" y contraseña "contrarandom" Entonces el sistema le informa "El mail o contraseña son incorrectos"
Escenario 5: Inicio de sesión fallido por contraseña invalida Dado Un Usuario General el mail "general@gmail.com" el cual pertenece a un usuario general del sistema y contraseña "contraivalida" la cual es invalida Cuando se ingresa mail "general@gmail.com" y contraseña "contraivalida" Entonces el sistema le informa "El mail o contraseña son incorrectos"

Título Como usuario visitante o usuario general o usuario colaborador o usuario owner Quiero Abrir el menú Para para seleccionar una opción

Criterios de aceptación

Escenario 1: Ingreso Al Menú Exitoso como Usuario Visitante Dado un usuario visitante que no ha iniciado sesión Cuando el Usuario Visitante presiona el botón para desplegar el menú Entonces El sistema muestra las opciones del Usuario Visitante
Escenario 2: Ingreso Al Menú Exitoso como Usuario General Dado un mail "general@gmail.com" que ha iniciado sesión Cuando presiona el botón para desplegar el menú Entonces El sistema muestra las opciones del Usuario General
Escenario 3: Ingreso Al Menú Exitoso como Usuario Colaborador Dado un mail colaborador@gmail.com que ha iniciado sesión Cuando presiona el botón para desplegar el menú Entonces El sistema muestra las opciones del Usuario Colaborador
Escenario 4: Ingreso Al Menú Exitoso como Usuario Owner Dado un mail owner@gmail.com que ha iniciado sesión Cuando el usuario Owner presiona el botón para desplegar el menú Entonces El sistema muestra las opciones del usuario Owner

Integrantes

Fabian Martinez Rincon | Lucia Lamella | Lucas Gallardo | Myles Barker --- | --- | --- | --- | | | @fabian-martinez-rincon | @luciana678 | @Lucas-Andres-GF | @Austin-Myles

Para Colaborar

Para asegurarnos de que estamos en la rama main, antes de crear una mara
```
git branch
```
Si ya creamos una rama y queremos ir a esa, usamos
```
git checkout {nombre-rama}
```

Si no existe la rama, la creamos con un nombre descriptivo

git branch {nombre-rama} o git checkout -b {nombre-rama}  //Para movernos despues de crearla

Una vez que estamos en la rama, hacemos un pull para asegurarnos de que estamos actualizados
```
git pull origin main
```

Hacemos la pull request

git add .
git commit -m "Mensaje descriptivo"
git push origin {nombre-rama}

Requirements

Python 3.8.10

Instalación

Paso 1 Creamos el entorno Virtual
```
python -m venv .venv
```
Paso 2 Activamos el entorno
```
.venv\Scripts\activate
```
Dependiendo el idioma
```
.venv/Scripts/activate
```

En caso de no tener permisos

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass

Instalamos las dependencias (Solo hace falta la primera vez)
```
pip install -r requirements.txt -r requirements-dev.txt
```
No hace falta
```
livetw init -d
livetw build
```

Ejecución

flask resetdb
flask seeddb

Para correr la aplicación

livetw dev

o los siguientes dos

flask run --debug
livetw dev --no-flask

Para configurar las variables de entorno, copiamos y renombramos el archivo .env.example a .env y configuramos las variables de entorno.

DB_PASS = "password_example"
DB_USER = "user_example"
DB_NAME = "database_example"
DB_HOST = "host_example"

Extensiones Recomendadas

Pretier - Code formatter
Headwind
Error Lens
Auto Close Tag
Auto Rename Tag
Image preview

Rutas para la primera demo

/eliminar_publicaciones
/eliminar_colaboradores
/eliminar_generales

1er Parcial Aspectos Legales

Fri, 02 May 2025 00:00:00 GMT

Evaluaciones

Bancos de Datos

1- ¿Cuál de los siguientes datos NO se encuentra dentro del ámbito de aplicación de la ley de Bancos de Datos?

[ ] Los datos médicos
[ ] Los datos de identidad mínimos de una persona
[ ] Los datos estadísticos

✅ Los datos estadísticos

Según lo establecido en la Ley 25.326:

Los datos disociados, como los estadísticos, no permiten identificar al titular, ya que fueron tratados para hacer imposible su vinculación con una persona determinada. Por ello, no se consideran datos personales y están excluidos del ámbito de aplicación de la ley.

En cambio:

Los datos médicos son datos sensibles y están expresamente regulados por la ley.
Los datos de identidad mínimos (nombre, domicilio, DNI, etc.) son datos personales de acceso público, también incluidos en la ley.

2- La obligación de recabar los datos personales previa autorización de su titular, está vinculada a qué principio

[ ] La licitud y buena fe
[ ] La Confidencialidad
[ ] La calidad de los datos

✅ La licitud y buena fe

De acuerdo con la Ley 25.326 y el art. 4.2 establece el:

"principio de licitud y lealtad en el tratamiento de datos personales", indicando que la recolección no puede hacerse por medios desleales o sin consentimiento expreso e informado del titular.

Este principio exige que el tratamiento de los datos sea legal y transparente, y que el consentimiento informado sea condición necesaria para la recolección de datos personales.

Las otras opciones:

Confidencialidad → se refiere a la obligación de guardar secreto sobre los datos recolectados (art. 10).
Calidad de los datos → se refiere a que los datos deben ser veraces, actualizados y pertinentes (art. 4.4).

3- ¿Cuál es el sistema de la ley de bancos de datos respecto a la responsabilidad administrativa?

[ ] No dice nada
[ ] Establece cuáles son las sanciones y delega en la autoridad de aplicación definir cuáles son las conductas prohibidas
[ ] Establece las conductas prohibidas y sus respectivas sanciones

❌ ESTA NO Establece las conductas prohibidas y sus respectivas sanciones

La Ley 25.326 no se limita solo a sancionar, sino que define claramente las conductas prohibidas (como la recolección de datos sensibles sin consentimiento, uso indebido, falta de inscripción del banco, cesión sin autorización, etc.) y establece el régimen sancionatorio correspondiente.

Además:

El artículo 32 modifica el Código Penal, incorporando el art. 157 bis, que penaliza la revelación indebida de datos cuando hay obligación de confidencialidad.
También se detallan infracciones administrativas y sus sanciones (multas, clausura, etc.) a través de la autoridad de aplicación.

Por lo tanto, no se delega totalmente en la autoridad, sino que la ley ya establece un marco normativo claro.

En la autoevaluación estaba mal

✅ Establece cuáles son las sanciones y delega en la autoridad de aplicación definir cuáles son las conductas prohibidas

Esto significa que, aunque la ley establece el régimen sancionatorio, las conductas prohibidas no están todas específicamente detalladas en el texto de la ley, sino que se delegan parcialmente en la autoridad de aplicación (la Agencia de Acceso a la Información Pública en Argentina) para su reglamentación o interpretación.

Mi error fue asumir que todas las conductas prohibidas estaban claramente definidas en la ley, cuando en realidad muchas quedan sujetas a regulación administrativa posterior.

4- Los datos sensibles

[ ] Están fuera del ámbito de aplicación de la ley
[ ] Pueden ser tratados siempre que exista un consentimiento informado del titular de los datos
[ ] Salvo excepciones no pueden ser recogidos ni tratados

✅ Salvo excepciones no pueden ser recogidos ni tratados

La Ley 25.326 establece en el artículo 7.2 que:

"Queda prohibida la formación de archivos, registros o bancos de datos que almacenen información que revele directa o indirectamente datos sensibles, salvo en los casos expresamente autorizados por la ley."

Los datos sensibles (como salud, vida sexual, origen étnico, religión, opiniones políticas, etc.) solo pueden ser tratados en casos excepcionales, como:

Fines estadísticos y disociados
Instituciones como iglesias o sindicatos, respecto de sus miembros
Profesionales de la salud, en el marco de su actividad
Razones de interés público debidamente justificadas

Por tanto, su tratamiento está prohibido de forma general y solo se permite en supuestos muy específicos.

5- ¿Cuál de las siguientes hipótesis es una excepción a la obligación de autorización para recabar los datos?

[ ] La contratación de un servicio que necesite acceder a estos datos para ser cumplido
[ ] La renuncia anticipada del titular de los datos
[ ] Que la conducta del titular de los datos permite inferir que autoriza la recolección

✅ La contratación de un servicio que necesite acceder a estos datos para ser cumplido

Según la Ley 25.326, artículo 5, existen excepciones a la obligación de contar con consentimiento previo para la recolección de datos. Una de ellas es:

“Cuando los datos se recaben en el ejercicio de funciones propias de los poderes del Estado o en virtud de una obligación legal o contractual del titular de los datos.”

Esto incluye los casos contractuales, como cuando alguien contrata un servicio y es necesario acceder a ciertos datos personales para cumplir con ese contrato (por ejemplo, nombre, dirección para entrega, etc.).

Las otras opciones son incorrectas porque:

La renuncia anticipada del titular no está prevista por la ley y no suprime sus derechos.
Inferir consentimiento por conducta está prohibido: el consentimiento debe ser libre, expreso y por escrito.

Aspectos Generales de la Ciencia Jurídica

Primera Clase: en ella veremos el concepto de derecho, la diferencia entre derecho objetivo y subjetivo, las fuentes del derecho y las distintas divisiones, que desde el punto de vista académico se han intentado

1- La ciencia jurídica comprende el conjunto organizado de normas emanadas por un órgano competente

[ ] Verdadero
[ ] Falso

✅ Verdadero ESTO ES MAS FALSO QUE LA MIERDA PERO BUENO

“el conjunto organizado de normas emanadas de un poder estatal competente, las cuales son percibidas por la población como obligatorias.”

Esa es justamente la definición que adopta la ciencia jurídica para estudiar el derecho objetivo dentro de un sistema legal específico (como el argentino), por lo tanto la afirmación es verdadera.

2- El derecho real establece una relación entre dos personas

[ ] Verdadero
[ ] Falso

✅ Falso

El derecho real no establece una relación entre dos personas, sino una relación directa entre una persona y una cosa (por ejemplo, la propiedad sobre un bien). Es un derecho que se ejerce erga omnes (frente a todos), y no entre partes específicas como sucede en los derechos personales u obligaciones.

Esto se diferencia de los derechos personales, que sí implican una relación entre personas, como un contrato donde una parte exige algo a otra.

3- El ejercicio de un derecho subjetivo siempre es lícito

[ ] Verdadero
[ ] Falso

El derecho subjetivo es la facultad que tiene una persona para exigir algo conforme a la ley. Surge del derecho objetivo y permite hacer valer un interés propio protegido jurídicamente.

✅ Falso

El ejercicio de un derecho subjetivo no siempre es lícito. Aunque el derecho reconoce ciertas facultades, su ejercicio está limitado por el principio de no abuso del derecho. Como vimos en el texto, si una persona ejerce un derecho en forma abusiva, más allá de los fines legítimos para los cuales fue otorgado, puede incurrir en responsabilidad.

➡️ Esta doctrina se consolidó con la idea de que los derechos no se ejercen en abstracto, sino en función de intereses jurídicamente tutelados.

COMO MIERDA ABUSAS DE UN DERECHO QUE MIERDA ESTA PASANDOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO ODIO ESTA MATERIA PROGRE

4- Cuando analizamos las fuentes del derecho, el decreto reglamentario de la ley de promoción de software es ley en sentido material pero no formal

[ ] Verdadero
[ ] Falso

✅ Verdadero

En el marco de las fuentes del derecho, una norma tiene valor de ley en sentido material cuando establece reglas generales y obligatorias, sin importar qué órgano la haya dictado. El decreto reglamentario de la ley de promoción de software es dictado por el Poder Ejecutivo, y si bien no es una ley formal (porque no proviene del Congreso), sí lo es en sentido material ya que tiene contenido normativo obligatorio.

Este concepto está claramente explicado en el material cuando se diferencia entre:

Ley formal: emanada del Congreso.
Ley material: cualquier norma obligatoria dictada por autoridad competente.

5- El objeto de normas supletorias son obligatorias si las partes guardan silencio al momento del contrato, pero pueden apartarse de lo previsto si así lo desean

[ ] Verdadero
[ ] Falso

Las normas supletorias son reglas legales que se aplican solo si las partes no acuerdan otra cosa. Se pueden modificar por voluntad de las partes.

✅ Verdadero

Las normas supletorias son aquellas que se aplican automáticamente si las partes no acuerdan otra cosa en un contrato. Como dice tu material:

"El acuerdo de voluntades se compone por lo que las partes expresamente acordaron más lo que la ley marca en caso de silencio."

Sin embargo, estas normas pueden ser dejadas de lado si las partes lo deciden expresamente, ya que no son imperativas. Es decir, son obligatorias solo si no se pacta lo contrario, y pueden ser sustituidas por la voluntad de las partes.

Estructura Constitucional

En esta unidad repasaremos algunos conceptos de derecho constitucional, en particular, la forma del estado y del gobierno y los límites que el derecho le impone al poder estatal.

1- El habeas corpus es

[ ] Un derecho constitucional contra las detenciones arbitrarias
[ ] Una garantía que protege la libertad ambulatoria
[ ] Una declaración de derechos humanos

El derecho constitucional es la rama del derecho que regula la estructura y el funcionamiento del Estado, definiendo cómo se organizan y limitan los poderes públicos (Ejecutivo, Legislativo y Judicial) y garantizando los derechos fundamentales de las personas. Su base es la Constitución Nacional, que establece las normas más importantes del país y asegura libertades como la igualdad ante la ley, la libertad de expresión y el derecho a la educación.

✅ Una garantía que protege la libertad ambulatoria

Según el texto que me compartiste, el habeas corpus es una garantía constitucional que tutela la libertad física o ambulatoria de una persona frente a detenciones o restricciones arbitrarias. Si bien puede considerarse un derecho constitucional, en sentido técnico y preciso es una garantía, es decir, un mecanismo procesal que permite proteger ese derecho.

2- Aparte del preámbulo el texto constitucional se divide en:

[ ] Dos partes: Declaraciones derechos y garantías y autoridades de la nación
[ ] Tres partes: Declaraciones derechos y garantías, autoridades de la nación y gobiernos provinciales
[ ] Cuatro partes: Declaraciones derechos y garantías y tres correspondiendo a cada poder del estado

✅ Dos partes: Declaraciones derechos y garantías y autoridades de la nación

Según el desarrollo teórico, el texto constitucional argentino —aparte del preámbulo— se divide en dos grandes secciones:

Parte dogmática: que contiene las declaraciones, derechos y garantías.
Parte orgánica: que regula la organización y funcionamiento de los poderes del Estado (autoridades de la Nación).

3- La monarquía es una forma

[ ] De nación
[ ] De estado
[ ] De gobierno

✅ De gobierno

Según el texto que compartiste, la monarquía se clasifica dentro de las formas de gobierno, ya que se refiere al modo en que se ejerce el poder sobre la población. Se contrapone a la república, y puede ser constitucional o absoluta, dependiendo del grado de poder del monarca.

4- La existencia del federalismo se relaciona

[ ] Con la preexistencia de los gobiernos locales, que retienen para sí las competencias no expresamente delegadas
[ ] La mayor descentralización de las facultades del estado en beneficio de los gobiernos locales
[ ] La existencia de provincias en un territorio

✅ Con la preexistencia de los gobiernos locales, que retienen para sí las competencias no expresamente delegadas

Según el texto, el federalismo argentino se basa en que las provincias son preexistentes a la Nación y, por lo tanto, toda facultad no delegada permanece en ellas, lo que implica una distribución de competencias en favor de los gobiernos locales. Esto es lo que distingue al federalismo de otras formas de organización estatal.

5- Un sistema de control constitucional difuso implica

[ ] Que cualquier juez puede declarar la inconstitucionalidad
[ ] Que la declaración se expande a los casos similares
[ ] Que tanto el poder ejecutivo como el judicial puede declararla

✅ Que cualquier juez puede declarar la inconstitucionalidad

En el sistema de control constitucional difuso, como el que rige en Argentina a nivel federal, todos los jueces tienen la facultad de declarar la inconstitucionalidad de una norma en un caso concreto. Esto lo diferencia del sistema concentrado, donde solo un tribunal específico tiene esa atribución.

Hechos y Actos Jurídicos

En esta clase analizaremos como el derecho aprehende los fenomenos externos y les da un significado jurídíco, Veremos el concepto de acto humano voluntario tanto ilicito como lícito y dentro de estos últimos, nos detendremos en aquellos que tienen la intención de generar relaciones jurídicas

1- La intervención de un oficial público le da carácter a un instrumento cuando

[ ] Lo realiza según la normativa y con las formalidades previstas para tal acto
[ ] Solo si el oficial público le otorga tal característica
[ ] Debe ser certificado por el Estado mediante su presentación ante la autoridad competente

[x] Lo realiza según la normativa y con las formalidades previstas para tal acto

La intervención del oficial público no es por sí sola suficiente para conferir carácter de instrumento público. Es necesario que se cumplan además las formalidades legales exigidas por el ordenamiento jurídico, tal como se establece en el desarrollo sobre los instrumentos públicos y el artículo 979 del Código Civil.

2- La fe pública otorgada al instrumento se extiende

[ ] A todo el contenido del instrumento
[ ] A lo percibido por el oficial público y a las manifestaciones de las partes
[ ] A lo percibido por el oficial público

✅ Respuesta correcta: A lo percibido por el oficial público

La fe pública del instrumento no se extiende a todo su contenido, sino solo a lo que el oficial público ha visto u oído directamente. Las manifestaciones de las partes hacen fe hasta prueba en contrario, mientras que el hecho de haberlas realizado ante el oficial sí tiene fe pública. Por lo tanto, la autenticidad del instrumento se limita a los hechos cumplidos ante el oficial público, según lo establece el texto.

3- Un hecho se comete con dolo eventual en el caso que el autor

[ ] Se represente el resultado de la acción y dirija sus acciones a su producción
[ ] Se represente el resultado y le resulte indiferente si se produce o no
[ ] No se presente ese resultado por negligencia o falta de cuidado

✅ Respuesta correcta: Se represente el resultado y le resulte indiferente si se produce o no

Según el texto, el dolo eventual se configura cuando hay representación del resultado, pero el autor no actúa directamente para causarlo, sino que le es indiferente si ocurre o no. Se diferencia del dolo directo (donde se busca el resultado) y de la culpa (donde no se representa el resultado por negligencia o imprudencia).

4- En un acto jurídico accesorio

[ ] La desaparición del accesorio implica la desaparición del principal
[ ] La desaparición del principal conlleva la del accesorio
[ ] Son independientes

✅ Respuesta correcta: La desaparición del principal conlleva la del accesorio

En los actos jurídicos, el accesorio depende del principal para su validez y existencia. Tal como se menciona en el texto, “la nulidad del contrato principal hace caer la garantía dada por la fianza”, es decir, si desaparece el acto principal, el accesorio también pierde efecto.

5- La violencia afecta a qué elemento de la voluntad

[ ] La libertad
[ ] La intención
[ ] El discernimiento

✅ Respuesta correcta: La libertad

Según el texto, la violencia como vicio de los actos jurídicos “se encuentra directamente relacionada con la libertad o por lo menos con su falta”, ya que impide que el autor del acto pueda decidir libremente si lo realiza o no.

Contratos Informaticos

Dentro de los actos jurídicos, los contratos permiten la creación y modificacion de relaciones personales entre las partes. En la presente unidad, veremos en primer término los contratos en general, para luego adentrarnos en la problemática de los contratos sobre sistemas de información.

1- Un contrato informático es

[ ] Un contrato sobre sistemas de información
[ ] Un contrato celebrado mediante una red abierta como internet
[ ] Un contrato celebrado por un sistema experto

[x] Un contrato sobre sistemas de información

Justificación: Según la definición de Mosset Iturraspe, un contrato informático es aquel mediante el cual se crean, modifican, transmiten o extinguen relaciones obligacionales sobre bienes y/o servicios informáticos. Estos bienes se integran generalmente en un sistema destinado a la gestión organizada de información. Por lo tanto, lo que caracteriza a este tipo de contrato es su objeto: los sistemas de información y no el medio por el que se celebra (como internet) ni el uso de inteligencia artificial.

2- Un sistema informático se define por

[ ] Las especificaciones técnicas
[ ] Las necesidades a satisfacer
[ ] El hardware entregado

[x] Las necesidades a satisfacer

En los contratos informáticos, el sistema se define como un conjunto de bienes organizados en función de un objetivo común, es decir, lo que define a un sistema informático es la función que debe cumplir según las necesidades del usuario. No basta con especificaciones técnicas o hardware entregado si no se satisface la necesidad planteada por el cliente. Esto fue claramente sostenido en el fallo “Sisteco S.A. c/ Sujoy”, donde se concluyó que el cumplimiento de la obligación del proveedor no se mide por la entrega física de elementos, sino por la adecuación del sistema a los fines previstos.

3- La entrega del sistema se produce

[ ] Cuando el mismo cumple con los test de funcionamiento
[ ] Con la instalación del equipo
[ ] Con la entrega física del material al cliente

[x] Cuando el mismo cumple con los test de funcionamiento

En los contratos informáticos, la entrega del sistema no se limita a la entrega física del hardware ni a su instalación, sino que se considera cumplida cuando el sistema pasa satisfactoriamente el test de aceptación. Este test consiste en una verificación funcional previamente acordada que demuestra que el sistema cumple con los requisitos y objetivos definidos. Por lo tanto, la entrega efectiva se da cuando el sistema funciona conforme a lo pactado, incluyendo su adecuación a las necesidades del usuario.

4- La obligación de consejo abarca

[ ] Los aspectos económicos y técnicos del proyecto
[ ] Todos los aspectos del proyecto
[ ] Solo los aspectos técnicos

[x] Solo los aspectos técnicos

Según el marco teórico sobre contratos informáticos, la obligación de consejo del proveedor se limita a los aspectos técnicos del sistema, como la configuración, compatibilidad, escalabilidad y adecuación a las necesidades funcionales del usuario. No abarca aspectos económicos ni decisiones empresariales, ya que estos exceden el rol técnico del proveedor y son responsabilidad del cliente o de consultores externos. Esto fue confirmado por la jurisprudencia en casos como “Cajus Face vs IBM”.

5- ¿Cuál de las siguientes sería una excepción a la obligación de consejo?

[ ] Que el cliente sea una empresa líder en su sector
[ ] El acuerdo de partes
[ ] La contratación de un consultor externo por parte del cliente

[x] La contratación de un consultor externo por parte del cliente

Según el contenido desarrollado sobre contratos informáticos, cuando el cliente contrata a un consultor especializado para definir el pliego de condiciones, la responsabilidad de asesoramiento se traslada de forma parcial o total al consultor. En ese caso, el proveedor ya no tiene el deber de interpretar directamente las necesidades del usuario, ya que se presume que fueron correctamente traducidas por el profesional contratado por este último. Esta posición fue sostenida por la jurisprudencia francesa en el caso "Ste. Sopresur N.C.R. vs Sté Groupe Lebrun".

Contratos Parte General

1) Todo contrato tiene efectos respecto de terceros

( ) Verdadero
( ) Falso

Respuesta: ( ) Falso

De acuerdo con el principio general del derecho contractual, los contratos solo producen efectos entre las partes que los celebran, no respecto de terceros. Esta regla está expresamente reconocida en el derecho argentino y es coherente con el principio de relatividad de los contratos.

Sin embargo, existen excepciones a este principio, como:

Contratos con cláusula a favor de terceros, como los seguros de vida.
Contratos que transfieren derechos reales, los cuales pueden ser oponibles a terceros.

Esto se encuentra desarrollado tanto en la doctrina como en la jurisprudencia y fue señalado en los materiales bajo estudio (como en el análisis sobre los sujetos en los contratos).

2) El contrato se perfecciona con la aceptación de la oferta

( ) Verdadero
( ) Falso

Respuesta: (✔) Verdadero

Según el Código Civil y Comercial argentino (art. 1148 y siguientes) y el material estudiado, el contrato se perfecciona cuando la oferta es aceptada en tiempo y forma. Es decir, cuando hay un acuerdo de voluntades entre dos o más partes sobre un objeto lícito, posible y determinado.

Este principio es esencial en la formación del contrato:

La oferta debe contener los elementos esenciales del negocio.
La aceptación debe ser lisa y llana, sin modificar los términos de la oferta.
El contrato queda perfeccionado en el momento del envío de la aceptación, salvo pacto en contrario (art. 1154).

3) Un contrato es un acto jurídico

( ) Verdadero
( ) Falso

Respuesta: (✔) Verdadero

Un contrato es, efectivamente, un acto jurídico porque cumple con todas las características de este tipo de actos: es un hecho voluntario, lícito y destinado a crear, modificar o extinguir derechos y obligaciones entre las partes (art. 944 del Código Civil).

En el marco de los contratos, se trata de un acto jurídico bilateral o plurilateral, ya que requiere el acuerdo de dos o más voluntades para su existencia.

4) Solo se pueden celebrar los contratos previstos por la ley

( ) Verdadero
( ) Falso

Respuesta: (✔) Falso

No es necesario que un contrato esté expresamente previsto por la ley para que sea válido. Existen contratos nominados (regulados por la ley) y contratos innominados, que surgen del principio de la autonomía de la voluntad.

Mientras no contravengan normas de orden público, la moral o las buenas costumbres, las partes pueden celebrar contratos atípicos o innominados, fijando libremente su contenido, según sus intereses y necesidades. Esto está reconocido tanto en la doctrina como en la jurisprudencia argentina.

5 El pacto comisorio resuelve el contrato en caso de incumplimiento

( ) Verdadero
( ) Falso

Respuesta: (✔) Verdadero

El pacto comisorio es una cláusula que permite resolver el contrato cuando una de las partes incumple sus obligaciones. Según el artículo 1204 del Código Civil argentino (reformado por la ley 17.711), puede ser:

Expreso, si las partes lo pactan explícitamente (no requiere intimación).
Tácito, si no se pactó expresamente, pero se aplica de todos modos, con la obligación de intimar al cumplimiento en un plazo mínimo de 15 días.

Una vez resuelto, el contrato se considera extinguido con efectos retroactivos, y puede dar lugar al reclamo de daños y perjuicios.

6) El contrato se perfecciona con la firma de las partes

( ) Verdadero
( ) Falso

Respuesta: (✘) Falso

El contrato se perfecciona con el acuerdo de voluntades, es decir, cuando hay aceptación de la oferta (art. 1154 del Código Civil). La firma no es un requisito esencial para todos los contratos; es solo una forma de exteriorizar ese consentimiento, especialmente en contratos escritos. En muchos casos, el contrato es válido aunque no haya sido firmado, siempre que haya consentimiento entre las partes y no se requiera una forma solemne para su validez.

7) Un contrato unilateral tiene una sola parte

( ) Verdadero
( ) Falso

Respuesta: (✘) Falso

Un contrato unilateral no implica que haya una sola parte, sino que solo una de las partes asume obligaciones. Siempre se requiere al menos dos partes para que exista un contrato (art. 1137 del Código Civil), pero en el contrato unilateral, solo una queda obligada. Ejemplo: una donación, donde el donante se obliga a entregar y el donatario no asume obligación alguna.

8) Un contrato de adhesión es una convención con cláusulas predispuestas

( ) Verdadero
( ) Falso

Respuesta: (✔) Verdadero

Un contrato de adhesión es aquel en el que las cláusulas están predispuestas por una de las partes (generalmente la más fuerte económicamente) y la otra parte solo puede aceptarlas o rechazarlas, sin posibilidad real de negociación. Este tipo de contratos es típico en servicios masivos como seguros, banca o telefonía.

9) Una aceptación que modifique la oferta implica una contraoferta

( ) Verdadero
( ) Falso

Respuesta: (✔) Verdadero

Según el Código Civil argentino (art. 1154), para que el contrato se perfeccione, la aceptación debe ser lisa y llana, es decir, no debe introducir modificaciones a la oferta. Si la aceptación altera alguno de sus términos, no constituye una aceptación propiamente dicha, sino que implica una nueva oferta o contraoferta, que deberá ser aceptada por quien realizó la oferta original.

10) El objeto de un contrato debe ser posible

( ) Verdadero
( ) Falso

Respuesta: (✔) Verdadero

Según el artículo 953 del Código Civil argentino, el objeto de los actos jurídicos —y por lo tanto, de los contratos— debe ser posible, lícito, y conforme a la moral y las buenas costumbres. Un objeto imposible (como obligarse a realizar una acción físicamente irrealizable) torna el contrato nulo, ya que no puede cumplirse válidamente.

Propiedad intelectual

En esta clase veremos como el derecho recepta el trabajo intelectual y cuales son las formas de reinvidicar como propios los contenidos (software, marcas, etc) generados por el profesional informático

1) El dominio público implica que los derechos de explotación económica terminan

( ) Verdadero
( ) Falso

✅ Respuesta: Verdadero

Según el texto, una vez vencido el plazo de protección (70 años desde la muerte del autor), la obra entra en dominio público, lo cual significa que los derechos patrimoniales (económicos) del autor quedan sin efecto, y su utilización pasa a ser libre para todos sin necesidad de autorización ni pago .

2) El software se protege mediante la ley de patentes de invención

( ) Verdadero
( ) Falso

❌ Respuesta: Falso

El software no se protege mediante la Ley de Patentes de Invención (Ley 24.481), sino que está expresamente incluido en la Ley 11.723 de Propiedad Intelectual como una obra literaria. Esta protección fue incorporada luego del fallo “Pellicori” y tiene respaldo en tratados internacionales como el acuerdo TRIPS.

3) Las marcas comerciales deben ser utilizadas en todas las categorías donde se anotan

( ) Verdadero
( ) Falso

✅ Respuesta: Falso

La ley no exige que las marcas se utilicen en todas las categorías donde se anotan. Basta con que se utilicen en al menos una de las categorías inscriptas para que puedan ser renovadas. Las marcas inscritas en categorías donde no se pretende usarlas se conocen como marcas de defensa, y su objetivo es evitar la dilución de la marca por uso de terceros en rubros distintos.

4) Toda obra registrada debe tener un mínimo de originalidad

( ) Verdadero
( ) Falso

✅ Respuesta: Verdadero

La ley exige que para que una obra sea protegida por derechos de autor, debe poseer un mínimo grado de originalidad. No se requiere una originalidad absoluta, pero sí debe haber un aporte personal del autor que diferencie la obra de otras preexistentes. Esto es esencial para que la obra pueda considerarse una creación protegible.

5) La protección ofrecida por la ley de derechos de autor es tecnológicamente neutra

( ) Verdadero
( ) Falso

✅ Respuesta: Verdadero

La ley 11.723 de propiedad intelectual, especialmente tras su reforma, establece una protección amplia y no taxativa que permite incluir nuevas formas de expresión como el software. Su redacción, en especial en el artículo 1, fue diseñada para abarcar toda producción científica, literaria o artística sin importar el medio o tecnología utilizada, lo que confirma su neutralidad tecnológica.

Primer Parcial Aspectos Legales

1) Que un sistema de control constitucional sea difuso significa

[ ] Que un cualquier juez puede decretar la inconstitucionalidad
[ ] Que los efectos de la declaración se extienden a casos similares
[ ] Que el planteo se puede producir en cualquier momento del proceso

[x] Que un cualquier juez puede decretar la inconstitucionalidad

Un sistema de control constitucional difuso implica que todos los jueces del país tienen la facultad de declarar la inconstitucionalidad de una norma en el caso concreto que estén resolviendo, a diferencia de un sistema concentrado, donde esa facultad está reservada a un tribunal específico (como una Corte Constitucional). ¿Querés que continúe con la siguiente pregunta?

2) La propiedad intelectual de un software se regula

[ ] Por la ley de derechos de autor
[ ] Por la ley de patentes de invención
[ ] Por una ley especial creada a tal fin

[x] Por la ley de derechos de autor

Según la Ley 11.723 de Propiedad Intelectual (modificada), el software está protegido como una obra literaria dentro del régimen de derechos de autor, y no por la ley de patentes ni por una ley especial creada a tal fin. ¿Seguimos con la siguiente?

3) Un sistema de información es una universalidad de bienes definida por

[ ] Los bienes ofrecidos
[ ] Las necesidades a satisfacer
[ ] El contenido del contrato

[x] Las necesidades a satisfacer

Un sistema de información se define como una universalidad de bienes cuya configuración depende de los objetivos y necesidades que debe satisfacer el usuario, no simplemente por los bienes ofrecidos ni por lo que se establezca en el contrato .

4) Por principio general, los contratos tienen el siguiente efecto respecto de los terceros

[ ] Son obligatorios, salvo pacto en contrario
[ ] Son obligatorios en los casos que se realizaron por instrumento público
[ ] No le son oponibles

[x] No le son oponibles

Por principio general, los contratos sólo producen efectos entre las partes que los celebran. Es decir, no son oponibles a terceros, salvo en casos excepcionales previstos por la ley.

5) La fe pública de un documento se extiende

[ ] A todo el contenido del documento
[ ] A lo manifestado por las partes
[ ] A lo percibido por el oficial público

[x] A lo percibido por el oficial público

La fe pública se extiende solo a lo que el oficial público ha percibido por sus sentidos o ha constatado personalmente, no a lo manifestado por las partes, ya que esas manifestaciones pueden ser falsas o inexactas y no están bajo control directo del oficial.

6) La obligación de consejo se extiende a qué aspectos del proceso

[ ] Los técnicos
[ ] Los técnicos y financieros
[ ] Todos los aspectos del proyecto

[x] Los técnicos

La obligación de consejo del proveedor en contratos informáticos se limita a los aspectos técnicos, relacionados con la funcionalidad, compatibilidad y adecuación del sistema a las necesidades del usuario. No abarca aspectos financieros o empresariales.

7) ¿Cuál de las siguientes características NO pertenece a las obligaciones personales?

[ ] Se establecen entre dos personas
[ ] Implican un hacer, un dar o un omitir
[ ] Se crean solo por ley

[x] Se crean solo por ley

Las obligaciones personales pueden originarse por ley, contrato, cuasicontrato, delito o cuasidelito, pero no se crean exclusivamente por ley, por lo que esta opción no pertenece a sus características.

8) Si una persona actúa con indiferencia respecto a la posibilidad de la producción de un resultado, estamos frente a un caso de

[ ] Dolo Eventual
[ ] Dolo Directo
[ ] Culpa con representación

[x] Dolo Eventual

El dolo eventual ocurre cuando una persona se representa la posibilidad del resultado dañoso y, aun así, actúa con indiferencia respecto a su producción. Es decir, no busca directamente el daño, pero lo acepta como posible consecuencia de su conducta.

9) Un contrato será bilateral cuando

[ ] Las partes ocupen en forma simultánea la posición de deudor y acreedor
[ ] Las obligaciones se puedan expresar en dinero
[ ] Su celebración implica la participación de dos o más partes

[x] Las partes ocupen en forma simultánea la posición de deudor y acreedor

Un contrato bilateral es aquel en el que ambas partes asumen obligaciones recíprocas, es decir, cada una es acreedora y deudora al mismo tiempo. Por ejemplo, en una compraventa, el vendedor debe entregar la cosa y el comprador pagar el precio.

10) Si un sistema de voto electrónico no permite acceder al código fuente ¿cuál de los requisitos estudiados se vería afectado directamente?

[ ] La universalidad
[ ] La seguridad
[ ] La transparencia

[x] La transparencia

Si no se puede acceder al código fuente de un sistema de voto electrónico, no se puede verificar cómo funciona internamente, lo que afecta directamente la transparencia del proceso electoral. La transparencia exige que tanto los ciudadanos como los especialistas puedan auditar el sistema para garantizar que funcione correctamente y sin manipulaciones.

Recuperatorio

1) Un elemento definitorio de los derechos reales es

[ ] La relación directa entre la cosa y el titular
[ ] Se crean solo por ley
[ ] Son oponibles a todos los sujetos
[ ] Todo lo anterior

[x] Todo lo anterior

Los derechos reales se caracterizan por:

La relación directa entre el titular y la cosa (ej. dominio, usufructo).
Se crean solo por ley, no por la voluntad de las partes.
Son oponibles a todos los sujetos (eficacia "erga omnes").

2) La fuerza física irresistible es un vicio de

[ ] La libertad
[ ] La intención
[ ] El discernimiento

[x] La libertad

Justificación: La fuerza física irresistible anula la libertad del sujeto para actuar, ya que lo obliga a ejecutar una acción contra su voluntad. Por eso, se considera un vicio de la libertad, no de la intención ni del discernimiento.

3) Los requisitos de un instrumento público son

[ ] La firma y la fecha cierta
[ ] La firma y el doble ejemplar
[ ] La fecha cierta y el doble ejemplar

[x] La firma y la fecha cierta

Un instrumento público debe reunir determinados requisitos formales para ser válido, y los esenciales son:

La firma del funcionario autorizado.
La fecha cierta, que le otorga autenticidad y fuerza probatoria frente a terceros.

4) El software se protege por la ley

[ ] De derechos de autor
[ ] De patentes y diseños industriales
[ ] De promoción de la sociedad del conocimiento

[x] De derechos de autor

Según la legislación argentina (Ley 11.723), el software está protegido como una obra intelectual bajo el régimen de derechos de autor, y no por el sistema de patentes o diseños industriales. Esta protección fue incorporada expresamente tras el fallo "Autodesk".

5) ¿Cuáles son los requisitos comunes a todos los sistemas de sufragio según los pactos internacionales?

[ ] La universalidad, la igualdad y la transparencia
[ ] La Universalidad, La Igualdad y La Seguridad
[ ] La Universalidad, La Igualdad y el Secreto

[x] La Universalidad, La Igualdad y el Secreto

Los pactos internacionales de derechos humanos, como el Pacto Internacional de Derechos Civiles y Políticos (art. 25), establecen que todo ciudadano debe gozar del derecho al voto mediante un sistema universal, igualitario y mediante voto secreto, garantizando la libre expresión de la voluntad del elector.

6) La obligación de consejo se extiende a qué aspectos del proyecto

[ ] A todos los aspectos del proyecto
[ ] Solo a los aspectos técnicos
[ ] A los aspectos técnicos y el posible beneficio económico del proyecto

[x] Solo a los aspectos técnicos

Según el análisis doctrinario y jurisprudencial, la obligación de consejo en los contratos informáticos recae exclusivamente sobre los aspectos técnicos del sistema contratado. No se extiende a evaluaciones económicas ni decisiones empresariales, ya que esas competencias corresponden al usuario o a sus asesores. Así lo reflejan tanto la jurisprudencia argentina (como en Sistex c/Oliva) como la francesa (como en Cajus Face vs IBM).

7) Un contrato unilateral tiene

[ ] Una parte
[ ] Por lo menos dos partes
[ ] Dos partes contratantes y un tercero que es el beneficiario de la prestación acordada

[x] Por lo menos dos partes

Un contrato unilateral tiene al menos dos partes, ya que todo contrato requiere el acuerdo entre dos o más personas. Lo que lo distingue es que solo una de las partes asume obligaciones, mientras la otra no tiene carga alguna. No debe confundirse con que haya una sola parte firmante o interviniente: siempre hay dos partes, aunque una no esté obligada.

8) El contrato comienza a existir con

[ ] La entrega del doble ejemplar
[ ] La firma
[ ] La aceptación de la oferta

[x] La aceptación de la oferta

Según el régimen general de los contratos, el contrato se perfecciona cuando la oferta es aceptada en tiempo y forma. La firma puede ser una forma de expresar esa aceptación, pero lo que da nacimiento al contrato como vínculo jurídico es el acuerdo de voluntades, es decir, la aceptación de la oferta.

9) Un contrato innominado es un contrato

[ ] Que está prohibido por la legislación vigente
[ ] Que no está previsto en la legislación vigente
[ ] Que tiene regulación supletoria en la legislación vigente

[x] Que no está previsto en la legislación vigente

Un contrato innominado es aquel que no tiene una regulación específica en la ley, a diferencia de los contratos nominados, que sí están tipificados (como compraventa, locación, etc.). Sin embargo, los contratos innominados son válidos si respetan los principios generales del derecho contractual, y su contenido se rige por la voluntad de las partes y por normas supletorias en caso de omisiones.

10) Según el moderno concepto de entrega, ¿cuándo se cumple con la entrega de un sistema informático?

[ ] Con la finalización de las pruebas de funcionamiento
[ ] Con la puesta en funcionamiento
[ ] Con la entrega física de los componentes

[x] Con la finalización de las pruebas de funcionamiento

Según el moderno concepto de entrega en los contratos informáticos, no basta con la entrega física ni con la instalación del sistema. La entrega se considera cumplida cuando el sistema supera el test de aceptación, es decir, cuando se verifica que funciona conforme a lo pactado y satisface las necesidades del usuario.

Autoevaluacion - Parcial de prueba

1) Un sistema de control constitucional difuso implica

[ ] Que cualquier juez puede declarar la inconstitucionalidad
[ ] Que la declaración se expande a los casos similares
[ ] Que tanto el poder ejecutivo como el judicial puede declararla

[x] Que cualquier juez puede declarar la inconstitucionalidad

En un sistema de control constitucional difuso, como el que rige en Argentina, cualquier juez tiene la facultad de declarar la inconstitucionalidad de una norma al resolver un caso concreto. Este control se da en el marco de un juicio y sus efectos se limitan a las partes (control "inter partes").

2) La existencia del federalismo se relaciona

[ ] Con la preexistencia de los gobiernos locales, que retienen para sí las competencias no expresamente delegadas
[ ] La mayor descentralización de las facultades del estado en beneficio de los gobiernos locales
[ ] La existencia de provincias en un territorio

[x] Con la preexistencia de los gobiernos locales, que retienen para sí las competencias no expresamente delegadas

El federalismo implica la existencia de gobiernos locales preexistentes (como las provincias en Argentina) que conservan autonomía y retienen las competencias no delegadas expresamente al gobierno nacional. Es un principio constitucional clave en sistemas federales.

3) La monarquía es una forma

[ ] De nación
[ ] De estado
[ ] De gobierno

[x] De gobierno

La monarquía es una forma de gobierno, ya que se refiere a cómo se organiza el poder en un Estado. Se contrapone a otras formas como la república. En cambio, "forma de Estado" alude a la organización territorial del poder (unitario, federal), y "forma de nación" no es una categoría jurídica.

4) La entrega del sistema se produce

[ ] Cuando el mismo cumple con los test de funcionamiento
[ ] Con la instalación del equipo
[ ] Con la entrega física del material al cliente

[x] Cuando el mismo cumple con los test de funcionamiento

Según el enfoque moderno sobre la entrega de sistemas informáticos, la entrega no se considera completada hasta que el sistema haya superado exitosamente las pruebas de funcionamiento. Esto garantiza que el producto cumple con las especificaciones pactadas y es apto para su uso previsto.

5) ¿Cuál de las siguientes sería una excepción a la obligación de consejo?

[ ] Que el cliente sea una empresa líder en su sector
[ ] El acuerdo de partes
[ ] La contratación de un consultor externo por parte del cliente

[x] La contratación de un consultor externo por parte del cliente

Cuando el cliente contrata a un consultor especializado, se entiende que ya cuenta con el conocimiento técnico necesario para evaluar el sistema. Esto disminuye o elimina la disparidad informativa entre las partes, lo que a su vez exime al proveedor de su obligación de consejo, tal como ha sido reconocido por la jurisprudencia francesa y nacional.

6) En un acto jurídico accesorio

[ ] La desaparición del accesorio implica la desaparición del principal
[ ] La desaparición del principal conlleva la del accesorio
[ ] Son independientes

[x] La desaparición del principal conlleva la del accesorio

Un acto jurídico accesorio está subordinado al principal y carece de autonomía propia. Si el acto principal desaparece o se extingue, el accesorio pierde su razón de ser y también se extingue. Un ejemplo clásico es la fianza, que depende de un contrato principal como el de alquiler.

7) La fe pública otorgada al instrumento se extiende

[ ] A todo el contenido del instrumento
[ ] A lo percibido por el oficial público y a las manifestaciones de las partes
[ ] A lo percibido por el oficial público

[x] A lo percibido por el oficial público

La fe pública que otorga un instrumento público se limita a lo que el oficial público percibe por sí mismo en el acto (por ejemplo, la presencia de las partes, sus firmas, fecha y lugar), pero no abarca las manifestaciones o declaraciones internas de las partes si no fueron directamente percibidas por él.

8) Un contrato unilateral tiene

[ ] Una parte
[ ] Por lo menos dos partes
[ ] Dos partes contratantes y un tercero que es el beneficiario de la prestación acordada

[x] Por lo menos dos partes

Un contrato unilateral requiere al menos dos partes para su celebración, ya que todo contrato implica un acuerdo entre partes. Lo que lo caracteriza como "unilateral" es que solo una de ellas asume obligaciones, mientras la otra no contrae ninguna.

9) La fuerza física irresistible es un vicio de

[ ] La libertad
[ ] La intención
[ ] El discernimiento

[x] La libertad

La fuerza física irresistible afecta la libertad, ya que impide que la persona actúe de manera voluntaria. Si alguien es forzado físicamente a realizar un acto, no está ejerciendo libremente su voluntad, lo que vicia el consentimiento.

10) La propiedad intelectual de un software se regula

[ ] Por la ley de derechos de autor
[ ] Por la ley de patentes de invención
[ ] Por una ley especial creada a tal fin

[x] Por la ley de derechos de autor

En Argentina, el software se encuentra protegido bajo la Ley 11.723 de Propiedad Intelectual, que fue modificada para incluir expresamente a los programas de computación fuente y objeto. Esta protección abarca tanto los derechos patrimoniales como los derechos morales del autor.

Autoevaluacion - Parcial de prueba 2

1) La monarquía es una forma

[ ] De nación
[ ] De estado
[ ] De gobierno

2) La existencia del federalismo se relaciona

[ ] Con la preexistencia de los gobiernos locales, que retienen para sí las competencias no expresamente delegadas
[ ] La mayor descentralización de las facultades del estado en beneficio de los gobiernos locales
[ ] La existencia de provincias en un territorio

3) Un contrato unilateral tiene

[ ] Una parte
[ ] Por lo menos dos partes
[ ] Dos partes contratantes y un tercero que es el beneficiario de la prestación acordada

4) La fuerza física irresistible es un vicio de

[ ] La libertad
[ ] La intención
[ ] El discernimiento

5) Un sistema informático se define por

[ ] Las especificaciones técnicas
[ ] Las necesidades a satisfacer
[ ] El hardware entregado

6) Según el moderno concepto de entrega, ¿cuándo se cumple con la entrega de un sistema informático?

[ ] Con la finalización de las pruebas de funcionamiento
[ ] Con la puesta en funcionamiento
[ ] Con la entrega física de los componentes

7) El contrato comienza a existir con

[ ] La entrega del doble ejemplar
[ ] La firma
[ ] La aceptación de la oferta

8) ¿Cuál de las siguientes características NO pertenece a las obligaciones personales?

[ ] Se establecen entre dos personas
[ ] Implican un hacer, un dar o un omitir
[ ] Se crean solo por ley

9) Que un sistema de control constitucional sea difuso significa

[ ] Que un cualquier juez puede decretar la inconstitucionalidad
[ ] Que los efectos de la declaración se extienden a casos similares
[ ] Que el planteo se puede producir en cualquier momento del proceso

10) Aparte del preámbulo el texto constitucional se divide en:

[ ] Dos partes: Declaraciones derechos y garantías y autoridades de la nación
[ ] Tres partes: Declaraciones derechos y garantías, autoridades de la nación y gobiernos provinciales
[ ] Cuatro partes: Declaraciones derechos y garantías y tres correspondiendo a cada poder del estado

Optimizando el CV

Sat, 26 Apr 2025 00:00:00 GMT

Objetivo

Mi objetivo con este blog es poder postularme a empresas grandes, estaba viendo que se usan principalmente los filtrso ATS. Voy a tratar de adaptarlo a este formato.

Un filtro ATS (por Applicant Tracking System) es un software que usan muchas empresas para filtrar y organizar currículums automáticamente cuando alguien aplica a un trabajo.

Su función principal es:

Leer los CVs que llegan.
Buscar palabras clave (por ejemplo, “Python”, “SQL”, “Data Engineer” si son requisitos del puesto).
Descartar los CVs que no cumplen ciertos criterios (como experiencia, estudios o habilidades específicas).
Ordenar los CVs que sí pasan, para que el reclutador vea primero los más relevantes.

Por eso, si un CV no está optimizado para ATS (por ejemplo, tiene formatos raros, imágenes, tablas complicadas o no usa las palabras clave adecuadas), puede ser rechazado antes de que un humano lo lea, aunque el candidato sea bueno.

Final Programación Concurrente

Wed, 12 Feb 2025 00:00:00 GMT

📌 Preguntas Practicas FIJAS

1) Calculos con Matrices
2) Cuales Cumplen con ASV
3) Cuales Cumplen con ASV 2
4) Numero de Mensajes y Granularidad
5) Numero de Mensajes y Granularidad 2
6) Indicar para cada item si son equivalentes
7) ¿Que valores quedan?
8) ¿Que valores quedan? 2
9) La Solución a un problema es paralelizada
10) La Solución a un problema es paralelizada 2
11) La Solución a un problema es paralelizada 3
12) La Solución a un problema es paralelizada 4
13) Suponga que el tiempo de ejecución de un algoritmo Secuencial
14) Suponga que el tiempo de ejecución de un algoritmo Secuencial 2
15) Suponga que el tiempo de ejecución de un algoritmo Secuencial 3
16) Calcular la suma de todos los valores
17) Token passing con mensajes asincrónicos

📢 Miralas de Reojo

1) Propuesta al problema de alocación SJN
2) “passing the condition” En Semaforos
3) Problema de Concurrencia
4) Problema de Concurrencia 2
5) Indique los posibles valores finales de x
6) Cuales valores de k son posibles

🚨 Rezar para que no Tomen

1) Resuelva con monitores
2) Protocolos de Acceso a la SC
3) Solución a la Criba
4) Transformar Solucion usando mensajes asincronicos
5) Problema de ordenar de menor a mayor un arreglo
6) Problema de ordenar de menor a mayor 2
7) Suponga que un proceso productor y n procesos consumidores
8) Implemente una butterfly barrier para 8 procesos
9) Suponga n^2 procesos organizados en forma de grilla cuadrada
10) Una imagen se encuentra representada por una matriz

Notas

Aprendes o te moris

0) Una imagen se encuentra representada por una matriz

Suponga que una imagen se encuentra representada por una matriz a (n×n), y que el valor de cada pixel es un número entero que es mantenido por un proceso distinto (es decir, el valor del píxel I,J está en el proceso P(I,J)). Cada proceso puede comunicarse solo con sus vecinos izquierdo, derecho, arriba y abajo. (Los procesos de las esquinas tienen solo 2 vecinos, y los otros bordes de la grilla tienen 3 vecinos).

a) Escriba un algoritmo Herbeat que calcule el máximo y el mínimo valor de los píxeles de la imagen. Al terminar el programa, cada proceso debe conocer ambos valores.

chan topologia[1:n](
    proceso_emisor : int;
    ya_conoce_todo : bool;
    topologia_conocida : [1:n,1:n] bool;
    valor_max : int;
    valor_min : int
);

process nodo[p = 1..n] {
    bool vecinos_directos[1:n];              # inicialmente vecinos[q] true si q es vecino de p
    bool vecinos_activos[1:n] = vecinos_directos;     # vecinos aún activos
    bool topologia_conocida[1:n,1:n] = ([n*n]false);  # vecinos conocidos (matriz de adyacencia)
    bool topologia_recibida[1:n,1:n];
    bool ya_conoce_todo = false;
    int proceso_emisor;
    bool vecino_listo;
    int valor_pixel_local, valor_max, valor_min;
    
    topologia_conocida[p,1..n] = vecinos_directos;          # llena la fila para los vecinos
    valor_max := valor_pixel_local; 
    valor_min := valor_pixel_local;                # miValor inicializado con el valor del píxel

    while (not ya_conoce_todo) {            # envía conocimiento local de la topología a sus vecinos
        for (vecino = 1 to n st vecinos_activos[vecino]) {
            send topologia[vecino](p, false, topologia_conocida, valor_max, valor_min);
        }

        for (vecino = 1 to n st vecinos_activos[vecino]) {
            receive topologia[p](proceso_emisor, vecino_listo, topologia_recibida, nuevoMax, nuevoMin);
            topologia_conocida = topologia_conocida or topologia_recibida;                  # hace OR con su top juntando la información
            if (nuevoMax > valor_max) valor_max := nuevoMax;    # actualiza los máximos y mínimos
            if (nuevoMin < valor_min) valor_min := nuevoMin;
            if (vecino_listo) vecinos_activos[proceso_emisor] = false;
        }

        if (todas las filas de topologia_conocida tienen 1 entry true) ya_conoce_todo = true;
    }

    # envía topología completa a todos sus vecinos aún activos
    for (vecino = 1 to n st vecinos_activos[vecino]) {
        send topologia[vecino](p, ya_conoce_todo, topologia_conocida, valor_max, valor_min);
    }

    # recibe un mensaje de cada uno para limpiar el canal
    for (vecino = 1 to n st vecinos_activos[vecino]) {
        receive topologia[p](proceso_emisor, ya_conoce_todo, topologia_recibida, nuevoMax, nuevoMin);
    }
}

Esto se tiene que consultar, porque la solución es mucho mas simple de la que esta aca

b) Analice la solución de desde el punto de vista del número de mensajes.

Si M es el numero maximo de vecinos que puede tener un nodo, y D es el diametro de la red, el número de mensajes maximo que pueden intercambiar es de 2n * m * (D+1). Esto es porque cada nodo ejecuta a lo sumo D-1 rondas, y en cada una de ellas manda 2 mensajes a sus m vecinos

1) Calcular la suma de todos los valores

Suponga que N procesos poseen inicialmente cada uno un valor. Se debe calcular la suma de todos los valores y al finalizar la computación todos deben conocer dicha suma.

Analice (desde el punto de vista del número de mensajes y la performance global) las soluciones posibles con memoria distribuida para arquitecturas en Estrella (centralizada), Anillo Circular, Totalmente Conectada y Árbol.

En este tipo de arquitectura todos los procesos (workers) envían su valor local al procesador central (coordinador), este suma los N datos y reenvía la información de la suma al resto de los procesos.
Por lo tanto se ejecutan 2(N-1) mensajes. Si el procesador central dispone de una primitiva broadcast, se reduce a N mensajes.

En cuanto a la performance global, los mensajes al coordinador se envían casi al mismo tiempo.
Estos se quedarán esperando hasta que el coordinador termine de computar la suma y envíe el resultado a todos.

chan canal_valor(INT);
canal_resultado[n](INT suma);

Process Coordinador[0]{              // coordinador, v está inicializado
    INT valor_local; 
    INT suma_total = 0;
    suma_total = suma_total + valor_local;

    for (i = 1 to n-1){
        receive canal_valor(valor_recibido);
        suma_total = suma_total + valor_recibido;
    }
    for (i = 1 to n-1)
        send canal_resultado[i](suma_total);
}

process Trabajador[i = 1 to n-1]{   // worker, v está inicializado
    INT valor_local;
    INT suma_total;
    send canal_valor(valor_local);
    receive canal_resultado[i](suma_total);
}

🧩 Supuestos

De nuevo usamos n = 4 procesos:

| Proceso | Rol | Valor local v[i] | |---------|------------|--------------------| | P[0] | Coordinador| 2 | | P[1] | Worker | 3 | | P[2] | Worker | 5 | | P[3] | Worker | 7 |

🎯 Objetivo

P[0] recibe los valores de todos los procesos.
Suma: 2 + 3 + 5 + 7 = 17.
Luego envía la suma global de vuelta a todos los workers.

🚀 Ejecución paso a paso

📨 Fase 1: Envío de los valores al coordinador

| Paso | Acción | |------|--------| | 1 | P[1] envía 3 a P[0] | | 2 | P[2] envía 5 a P[0] | | 3 | P[3] envía 7 a P[0] | | 4 | P[0] ya tiene su v = 2, recibe 3, 5, y 7, suma total = 17 |

📤 Fase 2: Coordinador difunde la suma

| Paso | Acción | |------|--------| | 5 | P[0] envía 17 a P[1] | | 6 | P[0] envía 17 a P[2] | | 7 | P[0] envía 17 a P[3] |

✅ Resultado final

| Proceso | Valor final conocido | |---------|----------------------| | P[0] | 17 (lo calculó) | | P[1] | 17 (lo recibió) | | P[2] | 17 (lo recibió) | | P[3] | 17 (lo recibió) |

💬 Observaciones

Total de mensajes: 2(n - 1) = 2(4 - 1) = 6 mensajes
Con broadcast: solo n = 4 mensajes (1 de cada worker al coordinador, 1 broadcast de vuelta).
Buena performance en tiempo, porque los workers envían todos al mismo tiempo.
Pérdida de paralelismo en el cómputo: solo el coordinador trabaja, los demás esperan.
Punto único de falla: si P[0] se cae, el sistema no funciona.

Se tiene un anillo donde P[i] recibe mensajes de P[i-1] y envía mensajes a P[i+1]. P[n-1] tiene como sucesor a P[0]. El primer proceso envía su valor local ya que es el único que conoce.

Este esquema consta de dos etapas:

Cada proceso recibe un valor y lo suma con su valor local, transmitiendo la suma local a su sucesor.
Todos reciben la suma global.

P[0] debe ser algo diferente para poder “arrancar” el procesamiento: debe enviar su valor local ya que es el único que conoce. Se requerirán 2(n-1) mensajes.

A diferencia de la solución centralizada, esta reduce los requerimientos de memoria por proceso pero tardara más en ejecutarse, por más que el número de mensajes requeridos sea el mismo. Esto se debe a que cada proceso debe esperar un valor para computar una suma parcial y luego enviársela al siguiente proceso; es decir, un proceso trabaja por vez, se pierde el paralelismo.

chan canal_suma[n](suma_parcial);

process p[0] {
    INT valor_local;
    INT suma_parcial = valor_local;
    send canal_suma[1](suma_parcial);
    receive canal_suma[0](suma_parcial);
    send canal_suma[1](suma_parcial);
}

process ProcesoAnillo[i = 1 to n-1] {
    INT valor_local;
    INT suma_parcial;
    receive canal_suma[i](suma_parcial);
    suma_parcial = suma_parcial + valor_local;
    siguiente = (i + 1) mod n
    send canal_suma[siguiente](suma_parcial);
    receive canal_suma[i](suma_parcial);
    if (i < n - 1)
        send canal_suma[i + 1](suma_parcial);
}

| Proceso | v[i] | |---------|--------| | P[0] | 2 | | P[1] | 3 | | P[2] | 5 | | P[3] | 7 |

El objetivo es que todos los procesos conozcan la suma total, que es 2 + 3 + 5 + 7 = 17.

🧠 Etapa 1: Suma parcial hacia adelante

| Paso | Acción | |------|--------| | 1 | P[0] envía 2 a P[1] | | 2 | P[1] recibe 2, suma su v=3, total = 5, envía 5 a P[2] | | 3 | P[2] recibe 5, suma su v=5, total = 10, envía 10 a P[3] | | 4 | P[3] recibe 10, suma su v=7, total = 17, envía 17 a P[0] |

🧠 Etapa 2: Difusión de la suma global

| Paso | Acción | |------|--------| | 5 | P[0] recibe 17 de P[3], reenvía 17 a P[1] | | 6 | P[1] recibe 17, reenvía 17 a P[2] | | 7 | P[2] recibe 17, reenvía 17 a P[3] | | 8 | P[3] recibe 17 |

✅ Resultado final

Todos los procesos conocen el valor total 17.

| Proceso | Valor recibido | |---------|----------------| | P[0] | 17 | | P[1] | 17 | | P[2] | 17 | | P[3] | 17 |

💬 Observaciones

Cantidad de mensajes: 2(n - 1) = 2(4 - 1) = 6 mensajes, como indica tu descripción.
Secuencialidad: cada proceso espera su turno para sumar → no hay paralelismo.
P[0] es especial, porque inicia la suma y también es el primero que difunde la suma global.

Todos los procesos ejecutan el mismo algoritmo. Existe un canal entre cada par de procesos.
Cada uno transmite su dato local v a los n-1 restantes. Luego recibe y procesa los n-1 datos que le faltan, de modo que en paralelo toda la arquitectura está calculando la suma total y tiene acceso a los n datos.

Se ejecutan n(n-1) mensajes. Si se dispone de una primitiva de broadcast, serán n mensajes.
Es la solución más corta y sencilla de programar, pero utiliza el mayor número de mensajes si no hay broadcast.

chan canal_valor[n](INT);

process Proceso[i=0 to n-1] {
    INT valor_local;
    INT valor_recibido
    INT suma_total = valor_local;
    
    for (int destino = 0 to n-1 st destino <> i)
        send canal_valor[destino](valor_local);
        
    for (int origen = 0 to n-1 st k <> i) {
        receive canal_valor[i](valor_recibido);
        suma_total = suma_total + valor_recibido;
    }
}

🧩 Supuestos

Usamos de nuevo n = 4 procesos y valores locales:

| Proceso | v[i] | |---------|--------| | P[0] | 2 | | P[1] | 3 | | P[2] | 5 | | P[3] | 7 |

🚀 ¿Qué hace cada proceso?

Cada proceso envía su valor a los otros 3 (n-1).
Luego, recibe los 3 valores que le faltan, y los suma.
Esto se hace en paralelo, es decir, todos los procesos trabajan al mismo tiempo.

📊 Ejecución paso a paso

Fase 1: Envío

| Proceso | Envía a... | Mensajes | |---------|------------------------|----------| | P[0] | P[1], P[2], P[3] | 3 | | P[1] | P[0], P[2], P[3] | 3 | | P[2] | P[0], P[1], P[3] | 3 | | P[3] | P[0], P[1], P[2] | 3 | | Total | | 12 mensajes |

Fase 2: Recepción y suma

Cada proceso recibe 3 valores y los suma con el propio:

| Proceso | Valores recibidos | Suma final | |---------|-------------------|------------| | P[0] | 3, 5, 7 | 2 + 3 + 5 + 7 = 17 | | P[1] | 2, 5, 7 | 3 + 2 + 5 + 7 = 17 | | P[2] | 2, 3, 7 | 5 + 2 + 3 + 7 = 17 | | P[3] | 2, 3, 5 | 7 + 2 + 3 + 5 = 17 |

✅ Resultado final

Todos conocen la suma global 17.

| Proceso | Suma calculada | |---------|----------------| | P[0] | 17 | | P[1] | 17 | | P[2] | 17 | | P[3] | 17 |

💬 Observaciones

Total de mensajes: n(n-1) = 4 × 3 = 12 mensajes
Todos trabajan en paralelo → alta velocidad
Pero: requiere muchos canales y mensajes
Si tuvieras broadcast, solo necesitarías n mensajes (1 por proceso).

Se tiene una red de procesadores (nodos) conectados por canales de comunicación bidireccionales. Cada nodo se comunica directamente con sus vecinos. Si un nodo quiere enviar un mensaje a toda la red, debería construir un árbol de expansión de la misma, poniéndose a él mismo como raíz.

El nodo raíz envía un mensaje por broadcast a todos los hijos, junto con el árbol construido. Cada nodo examina el árbol recibido para determinar los hijos a los cuales deben reenviar el mensaje, y así sucesivamente.

Se envían n - 1 mensajes, uno por cada padre/hijo del árbol.

🧩 Supuestos

Tenemos n = 7 nodos numerados del 0 al 6.
Se construye un árbol de expansión para propagar un mensaje, con el nodo 0 como raíz.
El árbol tiene esta estructura (por simplicidad):

🎯 Objetivo

Difundir un mensaje desde el nodo raíz (0) hacia todos los demás nodos usando el árbol.

🚀 Ejecución paso a paso

| Paso | Nodo emisor | Nodo receptor | Descripción | |------|-------------|----------------|-------------| | 1 | 0 | 1 | Nodo 0 envía a su hijo 1 | | 2 | 0 | 2 | Nodo 0 envía a su hijo 2 | | 3 | 0 | 3 | Nodo 0 envía a su hijo 3 | | 4 | 2 | 4 | Nodo 2 reenvía a su hijo 4 | | 5 | 3 | 5 | Nodo 3 reenvía a su hijo 5 | | 6 | 5 | 6 | Nodo 5 reenvía a su hijo 6 |

✅ Resultado final

Todos los nodos reciben el mensaje, usando solo n - 1 = 6 mensajes.

| Nodo | ¿Recibió el mensaje? | |------|------------------------| | 0 | Sí (es la raíz) | | 1 | Sí | | 2 | Sí | | 3 | Sí | | 4 | Sí | | 5 | Sí | | 6 | Sí |

💬 Observaciones

Mensajes totales: n - 1 = 6
Es la forma más eficiente si ya tenemos el árbol.
Permite paralelismo: varios nodos pueden reenviar a la vez.
Ideal para redes distribuidas con vecindades limitadas (no totalmente conectadas).
Si se necesita hacer una suma global, se puede hacer un recorrido postorden (bottom-up), y luego difundir el resultado (top-down).

2) Token passing con mensajes asincrónicos

Implemente una solución al problema de exclusión mutua distribuida entre N procesos utilizado un algoritmo de tipo token passing con mensajes asincrónicos.

El algoritmo de token passing, se basa en un tipo especial de mensaje o “token” que puede utilizarse para otorgar un permiso (control) o para recoger información global de la arquitectura distribuida.

Si User[1:n] son un conjunto de procesos de aplicación que contienen secciones críticas y no críticas. Hay que desarrollar los protocolos de interacción (E/S a las secciones críticas), asegurando exclusión mútua, no deadlock, evitar demoras innecesarias y eventualmente fairness.

Para no ocupar los procesos User en el manejo de los tokens, ideamos un proceso auxiliar (helper) por cada User, de modo de manejar la circulación de los tokens. Cuando helper[i] tiene el token adecuado, significa que User[i] tendrá prioridad para acceder a la sección crítica.

chan canal_token[n]() ;                   # para envío de tokens
chan canal_solicitud_entrada[n]()
chan canal_permiso_entrada[n]()
chan canal_salida_seccion_critica[n](); # para comunicación proceso-helper

process ProcesoHelper[i = 1..N] {
    while(true){
        receive canal_token[i](); //Recibe el token desde el proceso anterior

        if(!(empty(canal_solicitud_entrada[i]))){
            receive canal_solicitud_entrada[i](); // Atiende la solicitud
            send canal_permiso_entrada[i]();     // Le da permiso para entrar a SC
            receive canal_salida_seccion_critica[i](); // Espera a que salga
        }
        send canal_token[i MOD N + 1]();
    }
}

process ProcesoUsuario[i = 1..N] {
    while(true){
        send canal_solicitud_entrada[i]();
        receive canal_permiso_entrada[i]();
        ... sección crítica ...
        send canal_salida_seccion_critica[i]();
        ... sección no crítica ...
    }
}

Se asume que el primero ya tenga el token

Suponga que N Procesos

Suponga que N procesos poseen inicialmente cada uno un valor. Se debe calcular el promedio de todos los valores y al finalizar la computación todos deben conocer dicho promedio.

a) Describa conceptualmente las soluciones posibles con memoria distribuida para arquitecturas en estrella (centralizada), anillo circular, totalmente conectada y árbol.

Estrella (centralizada)

Cada proceso envía su valor al coordinador. Este los suma, divide por N para obtener el promedio y lo reenvía a todos.
Cantidad de mensajes: 2(N - 1), o N si hay broadcast.
Paralelismo solo en el envío inicial. El coordinador es cuello de botella y único punto de falla.

Anillo circular

Un proceso (ej. P0) inicia la suma parcial pasando su valor al siguiente. Cada proceso suma y reenvía. Al completar la vuelta, se divide entre N para obtener el promedio, que luego se difunde por el anillo.
Cantidad de mensajes: 2(N - 1). No hay paralelismo: cada proceso espera al anterior.

Totalmente conectada

Cada proceso envía su valor a todos los demás. Luego calcula localmente el promedio.
Cantidad de mensajes: N(N - 1), o N si hay broadcast.
Alta velocidad gracias al paralelismo completo, pero alto costo en comunicación.

Árbol

Se construye un árbol donde cada nodo envía su valor a su padre (bottom-up) para sumar. La raíz calcula el promedio dividiendo la suma por N, y luego lo difunde (top-down).
Cantidad de mensajes: 2(N - 1).
Hay cierto grado de paralelismo en ambas etapas (varios hijos pueden enviar al mismo tiempo).

b) Implemente al menos 2 de las soluciones.

Estrella (centralizada)

chan canal_valores(INT);
chan canal_promedios[n](REAL promedio);

process Coordinador[0]{              // Coordinador
    INT valor_local;
    INT suma_total  = valor_local;
    REAL promedio_global;
    
    for (i = 1 to n - 1) {
        INT valor_recibido;
        receive canal_valores(valor_recibido);
        suma = suma + valor_recibido;
    }
    promedio_global  = suma_total / n;
    for (i = 1 to n - 1)
        send canal_promedios[i](promedio_global);
}

process ProcesoTrabajador[i = 1 to n - 1]{ // Cada proceso envía su valor y recibe el promedio
    INT valor_local;
    REAL promedio_recibido;

    send canal_valores(valor_local);
    receive canal_promedios[i](promedio_recibido);
}

Anillo circular

chan canal_suma[n](INT suma_parcial);      // Para pasar sumas parciales en el anillo
chan canal_promedio[n](REAL promedio_global);  // Para difundir el promedio calculado

process ProcesoInicial[0] {
    INT valor_local
    INT suma_total  = valor_local;
    REAL promedio_calculado;

    // Fase 1
    send canal_suma[1](suma_total);

    //Fase 2
    receive canal_suma[0](suma_total);

    promedio_calculado  = suma_total / n;
    send canal_promedio[1](promedio_calculado);
}

process ProcesoAnillo[i = 1 to n - 1] {
    INT valor_local, 
    INT suma_total;
    REAL promedio_recibido;
    INT siguiente = (i + 1) mod n; // El siguiente proceso en el anillo

    // Fase 1: recibe suma parcial, acumula y reenvía
    receive canal_suma[i](suma_total);
    suma_total = suma_total + v;
    
    send canal_suma[siguiente](suma_total);

    // Fase 2: recibe el promedio y lo reenvía
    receive canal_promedio[i](promedio_recibido);
    if (i < n - 1)
        send canal_promedio[siguiente](promedio_recibido);
}

Totalmente conectada (simetrica)

chan canal_valores[n](INT valor_recibido); // Canal para intercambio de valores entre todos los procesos

process ProcesoSimetrico[i = 0 to n - 1] {
    INT valor_local  = ...;
    INT suma_total  = valor_local ;
    REAL promedio_local;

    // Envío mi valor_local a todos los demás procesos
    for (int destino = 0 to n - 1 st destino  <> i)
        send canal_valores[k](valor_local );

    // Recibo los valores de los demás procesos y acumulo la suma
    for (int origen = 0 to n - 1 st origen <> i) {
        INT valor_recibido
        receive canal_valores[i](valor_recibido);
        suma_total  = suma_total  + valor_recibido;
    }
    // Calculo el promedio de todos los valores
    promedio_local = suma_total  / n;
}

c) Para cada una de las soluciones (todas), calcule la cantidad de mensajes y el tiempo (considerando que eventualmente hay operaciones que pueden realizarse concurrentemente).

Instancie c) para N=4, N=8, N=16, N=32 y N=64. Analice la performance para cada caso y compare las soluciones.

Nota: puede suponer que cada una de las operaciones tarda una unidad de tiempo.

Estrella (centralizada)

Fórmula de mensajes: 2(n - 1) sin broadcast , n con broadcast
Fórmula de tiempo: Envío (1) + procesamiento (1) + difusión (1) = 3

Resultados:

N = 4 → Mensajes: 2(4 - 1) = 6, Tiempo: 3
N = 8 → Mensajes: 2(8 - 1) = 14, Tiempo: 3
N = 16 → Mensajes: 2(16 - 1) = 30, Tiempo: 3
N = 32 → Mensajes: 2(32 - 1) = 62, Tiempo: 3
N = 64 → Mensajes: 2(64 - 1) = 126, Tiempo: 3

Anillo circular

Fórmula de mensajes: 2(n - 1) (una vuelta para la suma + una vuelta para difusión)
Fórmula de tiempo: 2(n - 1) (no hay paralelismo)

Resultado

N = 4 → Mensajes: 2(4 - 1) = 6, Tiempo: 6
N = 8 → Mensajes: 2(8 - 1) = 14, Tiempo: 14
N = 16 → Mensajes: 2(16 - 1) = 30, Tiempo: 30
N = 32 → Mensajes: 2(32 - 1) = 62, Tiempo: 62
N = 64 → Mensajes: 2(64 - 1) = 126, Tiempo: 126

Totalmente conectada

Fórmula de mensajes: n(n - 1) sin broadcast n con broadcast
Fórmula de tiempo: Envío + recepción, ambos en paralelo = 2

Resultados:

N = 4 → Mensajes: 4 × (4 - 1) = 12, Tiempo: 2
N = 8 → Mensajes: 8 × (8 - 1) = 56, Tiempo: 2
N = 16 → Mensajes: 16 × (16 - 1) = 240, Tiempo: 2
N = 32 → Mensajes: 32 × (32 - 1) = 992, Tiempo: 2
N = 64 → Mensajes: 64 × (64 - 1) = 4032, Tiempo: 2

Árbol

Fórmula de mensajes: 2(n - 1) (una subida bottom-up + una bajada top-down)
Fórmula de tiempo: 2 × log₂(n) (dos recorridos del árbol)

Resultados: (Suavemente redondeado para log₂(n))

N = 4 → Mensajes: 2(4 - 1) = 6, Tiempo: 2 × 2 = 4
N = 8 → Mensajes: 2(8 - 1) = 14, Tiempo: 2 × 3 = 6
N = 16 → Mensajes: 2(16 - 1) = 30, Tiempo: 2 × 4 = 8
N = 32 → Mensajes: 2(32 - 1) = 62, Tiempo: 2 × 5 = 10
N = 64 → Mensajes: 2(64 - 1) = 126, Tiempo: 2 × 6 = 12

Suponga una ciudad representada por una matriz

Exclusión mutua distribuida

Implemente una solución al problema de exclusión mutua distribuida entre N procesos utilizando un algoritmo Token Passing con PMA.

Una ciudad representada por una matriz

Suponga una ciudad representada por una matriz A(n×n). De cada esquina x, y se conocen dos valores enteros que representan la cantidad de autos y motos que cruzaron en la última hora. Los valores de cada esquina son mantenidos por un proceso distinto P(x, y). Cada proceso puede comunicarse con sus vecinos izquierdo, derecho, arriba y abajo, y también con los de las 4 diagonales (los procesos de las esquinas tienen sólo 3 vecinos y los otros en los bordes de la grilla tienen 5 vecinos).

a) Escriba un algoritmo Heartbeat que calcule las esquinas donde cruzaron la mayor cantidad de autos y la menor cantidad de motos respectivamente, de forma que al terminar el programa, cada proceso conozca ambos valores.
Nota: Indicar qué tipo de pasajes de mensajes se va a utilizar. Justificar la elección.

b) Analizar desde el punto de vista de la cantidad de mensajes.

c) Analizar cómo podría mejorarse la cantidad de mensajes.

d) Analizar qué pasaría si no existieran las diagonales.

Exclusión mutua distribuida

Implemente una solución al problema de exclusión mutua distribuida entre N procesos utilizando un algoritmo token passing con mensajes asincrónicos.

Solución al problema del pruducto de matrices

Sea la siguiente solución al problema del producto de matrices de n×n con P procesos en paralelo con variables compartidas.

process worker [w = 1 to P] {  # strips en paralelo (p strips de n/P filas)
    int first = (w - 1) * n / P + 1;    # Primera fila del strip
    int last = first + n/P - 1;        # Última fila del strip
    for (i = first to last) {
        for (j = 1 to n) {
            c[i,j] = 0.0;
            for (k = 1 to n)
                c[i,j] = c[i,j] + a[i,k] * b[k,j];
        }
    }
}

Suponga n = 512 y cada procesador capaz de ejecutar un proceso.

a) Calcular cuántas asignaciones, sumas y productos se hacen secuencialmente (caso en que P=1), y cuántas se realizan en cada procesador en la solución paralela con P=8.

b) Si los procesadores P1 a P7 son idénticos, con tiempos de asignación 1, de suma 2 y de producto 3, y si el procesador P8 es 3 veces más lento, calcule cuánto tarda el proceso total concurrente.

c) ¿Cuál es el valor del speedup?

d) ¿Cómo modificaría el código para lograr un mejor speedup?

NOTA: para realizar los cálculos no tenga en cuenta las operaciones de asignación e incremento correspondientes a las sentencias for.

Defina los paradigmas de interacción

Defina los paradigmas de interacción entre procesos distribuidos heartbeat, servidores replicados y token passing.

Marque ventajas y desventajas en cada uno de ellos cuando se utiliza comunicación por mensajes sincrónicos o asincrónicos.

Suponga que N Procesos

Suponga que N procesos poseen inicialmente cada uno un valor. Se debe calcular el promedio de todos los valores y al finalizar la computación todos deben conocer dicho promedio.

a) Describa conceptualmente las soluciones posibles con memoria distribuida para arquitecturas en estrella (centralizada), anillo circular, totalmente conectada y árbol.

b) Implemente al menos 2 de las soluciones.

c) Para cada una de las soluciones (todas), calcule la cantidad de mensajes y el tiempo (considerando que eventualmente hay operaciones que pueden realizarse concurrentemente).
Instancie c) para N = 4, N = 8, N = 16, N = 32 y N = 64. Analice la performance para cada caso y compare las soluciones.

Nota: puede suponer que cada una de las operaciones tarda una unidad de tiempo.

Suponga que N Procesos

Suponga que N procesos poseen inicialmente cada uno un valor.
Se debe calcular el promedio de todos los valores y al finalizar la computación todos deben conocer dicho promedio.

a. Describa conceptualmente las soluciones posibles con memoria distribuida para arquitectura en
estrella (centralizada), anillo circular, totalmente conectada y árbol.

b. Implemente al menos 2 de las soluciones.

c. Para cada una de las soluciones (todas), calcule la cantidad de mensajes y el tiempo.
Instancie c) para N = 4, N = 8, N = 16, N = 32 y N = 64.
Analice la performance en cada caso y compare las soluciones.

NOTA: Puede suponer que cada una de las operaciones tarda una unidad de tiempo.

Suponga que N Procesos

Suponga que N procesos poseen inicialmente cada uno un valor. Se debe calcular la suma de todos los valores y al finalizar la computación todos deben conocer dicha suma.
Analice (desde el punto de vista del número de mensajes y la performance global) las soluciones posibles con memoria distribuida para arquitecturas en Estrella (centralizada), Anillo Circular, Totalmente Conectada y Árbol.
Definir conceptualmente y decir cantidad de mensajes de cada uno. Implementar dos de esos.

En la mesa de mayo eran los mismos ejercicios excepto el último: había que implementar heartbeat o passing the baton (se elegía uno de los dos).

Suponga que N Procesos

Implemente una solución al problema de exclusión mutua distribuida entre n procesos utilizando un algoritmo Token Passing con mensajes asincrónicos.

Suponga una ciudad representada por una matriz

Suponga una ciudad representada por una matriz A(n×n). De cada esquina x, y se conocen dos valores enteros que representan la cantidad de autos y motos que cruzaron en la última hora. Los valores de cada esquina son mantenidos por un proceso distinto P(x,y).
Cada proceso puede comunicarse con sus vecinos izquierdo, derecho, arriba y abajo, y también con los de las 4 diagonales (los procesos de las esquinas tienen solo 3 vecinos y los otros en los bordes de la grilla tienen 5 vecinos).

Suponga que N Procesos

Suponga que N procesos poseen inicialmente cada uno un valor.
Se debe calcular el promedio de todos los valores y al finalizar la computación todos deben conocer dicho promedio.

a. Describa conceptualmente las soluciones posibles con memoria distribuida para arquitectura en estrella (centralizada), anillo circular, totalmente conectada y árbol.

b. Implemente al menos 2 de las soluciones.

c. Para cada una de las soluciones (todas), calcule la cantidad de mensajes y el tiempo.
Instancie c) para N = 4, N = 8, N = 16, N = 32 y N = 64.
Analice la performance en cada caso y compare las soluciones.

NOTA: Puede suponer que cada una de las operaciones tarda una unidad de tiempo.

📌 Preguntas Practicas FIJAS

1) Calculos con Matrices

Sea la siguiente solución al problema del producto de matrices de nxn con P procesos trabajando en paralelo.

process worker[w = 1 to P] {        // strips en paralelo (P strips de n/P filas)
    int first = (w - 1) * n / P;    // Primera fila del strip
    int last  = first + n / P - 1;  // Última fila del strip

    for (i = first to last) {
        for (j = 0 to n - 1) {
            c[i,j] = 0.0;
            for (k = 0 to n - 1)
                c[i,j] = c[i,j] + a[i,k] * b[k,j];
        }
    }
}

a) Suponga que n = 128 y cada procesador es capaz de ejecutar un proceso. ¿Cuántas asignaciones, sumas y productos se hacen secuencialmente (caso en que P = 1)?

Asignaciones 128^3 + 128^2 -> 2.097.152 + 16.384 -> 2.113.536
Sumas 128^3 -> 2.097.152
Productos 128^3 -> 2.097.152

b) ¿Cuántas se realizan en cada procesador en la solución paralela con P = 8?

Strip 128/8 = 16 Filas por procesador (MIRA EL CODIGO O PEGO 👊)
Asignaciones 16 * 128^2 + 16 * 128 -> 262.144 + 2048 -> 264.192
Sumas 16 * 128^2 -> 262.144
Productos 16 * 128^2 -> 262.144

c) Si los procesadores P1 a P7 son iguales, y sus tiempos de asignación son 1, de suma 2 y de producto 3, y si P8 es 4 veces más lento,

¿Cuánto tarda el proceso total concurrente?

T(P1-P7) -> (264.192 * 1) + (262.144 * 2) + (262.144 * 3) -> 264.192 + 524.288 + 786.432 -> 1.574.912
T(P8) -> T(P1-P7) * 4 -> 1.574.912 * 4 -> 6.299.648 (El tiempo paralelo)

¿Cuál es el valor del speedup (Tiempo secuencial / Tiempo paralelo)?

Tiempo Total Secuencial = (2.113.536 * 1) + 2.097.152 * 2) + 2.097.152 * 3) -> 12.599.296
Speedup = T(secuencial) / T(paralelo) -> (12.599.296) / (6.299.648) -> 2.02

Modifique el código para lograr un mejor speedup. (Este punto no se como hacerlo) (Le tenemos que dejar la menor cantidad de filas posibles a P8 ya que tarda un 🥚)

Multiplo(7) mas cercano a 128 -> 126
Strip P8 -> 2 filas (128 - 126)
Strip P1-P7 -> 18 filas (126/7)

Calculamos los tiempos para P8 con la nueva distribución de filas:

Asignaciones 2 * 128^2 + 2 * 128 -> 32.768 + 256 -> 33.024
Sumas 2 * 128^2 -> 32.768
Productos 2 * 128^2 -> 32.768
T(P8) -> (33.024 * 1) + (32.768 * 2) + (32.768 * 3) -> 33.024 + 65.536 + 98.304 -> 196.864
T(P8) -> TP8 * 4 -> 196.864 * 4 -> 787.456

Calculamos el tiempo para P1-P7:

Asignaciones 18 * 128^2 + 18 * 128 -> 294.912 + 2.304 -> 297.216
Sumas 18 * 128^2 -> 294.912
Productos 18 * 128^2 -> 294.912
T(P1-P7) -> (297.216 * 1) + (294.912 * 2) + (294.912 * 3) -> 297.216 + 589.824 + 884.736 -> 1.771.776

Como el tiempo mas grande es el de T(P1-P7) el tiempo paralelo es: 1.771.776 y volvemos a calcular el speedup:

Speedup = T(secuencial) / T(paralelo) -> (12.599.296) / (1.771.776) -> 7.11

2) Cuales Cumplen con ASV

Dado el siguiente programa concurrente con memoria compartida:

x := 4; y := 2; z := 3;

co
   x := x - z;
   z := z * 2;
   y := z + 4
oc

Una asignación x := e cumple la propiedad de ASV si:

(1) e contiene a lo sumo una referencia crítica, y la variable x no es referenciada por otros procesos, o
(2) e no contiene ninguna referencia crítica, en cullo caso X puede ser leida por otros procesos

Referencia critica se da cuanto estas leyendo una variable que es modificada por otro proceso concurrente

a) ¿Cuáles de las asignaciones dentro de la sentencia co cumplen la propiedad de ASV? Justifique claramente.

| Instrucción | ¿Cumple_ASV? | Justificación | |------------------|--------------|--------------------------------------------------------------------------------| | X := X - Z | ✅ Sí | "e" tiene a lo sumo una referencia critica (X - Z), y la variable x no es referenciada en otros procesos (X) | | Z := Z * 2 | ✅ Sí | "e" no contiene niguna referencia critica (Z * 4), en cullo caso x puede ser leida por otros procesos (Z) | | Y := Z + 4 | ✅ Sí | "e" tiene a lo sumo 1 referencia critica (Z + 4), y la variable x no es referenciada por otros procesos (Y) |

b) Indique los resultados posibles de la ejecución. Justifique.

Cada tarea se ejecuta sin ninguna interrupción hasta que termina (Si una sentencia no es atómica se puede cortar su ejecución pero al cumplir ASV la ejecución no se ve afectada) y las llamamos T1, T2 y T3 respectivamente obtenemos el siguiente subconjunto de historias:

T1, T2, T3 => X=1, Z=6, y=10
T1, T3, T2 => X=1, Z=6, y=7
T2, T1, T3 => X=-2, Z=6, y=10
T2, T3, T1 => X=-2, Z=6, y=10
T3, T1, T2 => X=1, Z=6, y=7
T3, T2, T1 => X=-2, Z=6, y=7

Explicación:

El valor de Z es siempre el mismo ya que no posee ninguna referencia crítica.
Los valores de X e Y se ven afectados por la ejecución de T2 ya que sus resultados dependen de la referencia que hacen a la variable Z que es modificada.
Entonces, si T1 y T3 se ejecutan antes que T2 ambas usarán el valor inicial de Z que es 3 obteniendo los resultados X=1 e Y=7;
Ahora si T2 se ejecuta antes que las demás los resultados serán X=-2 e Y=10 y por último, tenemos los casos en que T2 se ejecuta en medio con T1 antes y T3 después o con T3 antes y T1 después.

3) Cuales Cumplen con ASV 2

Dado el siguiente programa concurrente con memoria compartida:

x = 3; y = 2; z = 5;

co
    x = y * z
    z = z * 2
    y = y + 2x
oc

a) ¿Cuáles de las asignaciones dentro de la sentencia co cumplen la propiedad de “A lo sumo una vez”? Justifique claramente.

| Instrucción | ¿Cumple_ASV? | Justificación | |------------------|--------------|--------------------------------------------------------------------------------| | X = Y * Z | ❌ No | "e" tiene dos referencias criticas (X - Z) | | Z = Z * 2 | ✅ Sí | "e" no contiene niguna referencia critica (Z * 2), en cullo caso x puede ser leida por otros procesos (Z) | | Y = Y + 2X | ❌ No | "e" tiene a lo sumo 1 referencia critica (Y + 2X), y la variable x es referenciada por otros procesos (Y) |

b) Indique los resultados posibles de la ejecución. Justifique.

A, B y C o A, C y B -> x = 10; z = 10; y = 22
C, B y A o B, C y A -> x = 80; z = 10; y = 8
C, A y B -> x = 40; z = 10; y = 8
B, A y C-> x = 20; z = 10; y = 42

Si se empieza a ejecutar A leyendo a y = 2, y en ese momento se ejecuta C leyendo a x = 3 (porque no terminó la asignación de A), y luego termina lo que falta de A y se ejecuta B:

x = 10; z = 10; y = 8

Si se empieza a ejecutar A leyendo a y = 2, y en ese momento se ejecuta C leyendo a x = 3 (porque no terminó la asignación de A), y luego se ejecuta B y lo que falta de A:

x = 20; z = 10; y = 8

4) Numero de Mensajes y Granularidad

Suponga los siguientes programas concurrentes. Asuma que “función” existe, y que los procesos son iniciados desde el programa principal.

chan canal (double);

process grano1 {
    int veces, i;
    double sum;

    for (veces = 1 to 10) {
        for (i = 1 to 10000)
            sum = sum + funcion(i);
        send canal(sum);
    }
}

process grano2 {
    int veces;
    double sum;

    for (veces = 1 to 10) {
        receive canal(sum);
        printf(sum);
    }
}

chan canal (double);

process grano1 {
    int veces, i;
    double sum;

    for (veces = 1 to 10000) {
        for (i = 1 to 10)
            sum = sum + i;
        send canal(sum);
    }
}

process grano2 {
    int veces;
    double sum;

    for (veces = 1 to 10000) {
        receive canal(sum);
        printf(sum);
    }
}

a) Analice desde el punto de vista del número de mensajes.

En P1 se envían solo 10 mensajes (uno por cada bloque de 10000), mientras que en P2 se envían 10000 mensajes (uno por cada bloque de 10), por lo que P1 es mucho más eficiente en términos de comunicación.

b) Analice desde el punto de vista de la granularidad de los procesos.

En P1, la comunicación es poco frecuente y el cómputo por mensaje es alto, por lo que tiene granularidad gruesa.
En P2, hay mucha más comunicación en menos tiempo, lo que implica granularidad fina, mayor concurrencia pero también más sobrecarga.

c) Cuál de los programas le parece más adecuado para ejecutar sobre una arquitectura de tipo cluster de PCs? Justifique.

La implementación más adecuada para este tipo de arquitecturas es P1, por ser de granularidad gruesa. Al tratarse de una arquitectura con memoria distribuida la comunicación entre los procesos es más costosa ya que cada proceso puede ejecutarse en computadores diferentes, por lo tanto sería más eficiente que la sobrecarga de comunicación sea lo más baja posible, y dicha característica la brinda la granularidad gruesa.

5) Numero de Mensajes y Granularidad 2

Suponga los siguientes programas concurrentes. Asuma que EOS es un valor especial que indica el fin de la secuencia de mensajes, y que los procesos son iniciados desde el programa principal.

chan canal (double);

process Genera {
    int fila, col;
    double sum;

    for (fila = 1 to 10000) {
        for (col = 1 to 10000)
            send canal(a(fila, col));
    }

    send canal(EOS);  // End of Stream
}

process Acumula {
    double valor, sumT;
    sumT = 0;

    receive canal(valor);
    while (valor <> EOS) {
        sumT = sumT + valor;
        receive canal(valor);
    }

    printf(sumT);
}

chan canal (double);

process Genera {
    int fila, col;
    double sum;

    for (fila = 1 to 10000) {
        sum = 0;
        for (col = 1 to 10000)
            sum = sum + a(fila, col);
        send canal(sum);
    }
    send canal(EOS);  // End of Stream
}

process Acumula {
    double valor, sumT;
    sumT = 0;
    receive canal(valor);
    while (valor <> EOS) {
        sumT = sumT + valor;
        receive canal(valor);
    }

    printf(sumT);
}

a) ¿Qué hacen los programas?
Ambos suman todos los elementos de una matriz 10000×10000, pero:

P1: Genera envía cada elemento (100M mensajes) y Acumula suma todo.
P2: Genera suma por fila y envía 1 valor por fila (10K mensajes); Acumula suma esos totales.

Conclusión: Hacen lo mismo, pero P2 es mucho más eficiente en comunicación y procesamiento.

b) Analice desde el punto de vista del número de mensajes.

Desde el punto de vista de los mensajes, P1 envía 100 millones y P2 solo 10000, por lo que P2 es mucho más eficiente en comunicación.

c) Analice desde el punto de vista de la granularidad de los procesos.

Desde el punto de vista de granularidad, P2 tiene un grano más grueso que P1 porque realiza más cómputo local y menos comunicación, lo que mejora la eficiencia.

La granularidad de una aplicación concurrente o paralela se refiere a la relación entre el tiempo dedicado al cómputo y el tiempo dedicado a la comunicación entre procesos o hilos.

Si una aplicación realiza mucho cómputo local antes de necesitar comunicarse, se dice que tiene grano grueso.
Si, por el contrario, realiza frecuentes comunicaciones con poco cómputo entre medio, se dice que tiene grano fino.

Esta característica es clave para el diseño y rendimiento de programas paralelos, ya que:

Grano grueso suele ser más eficiente en arquitecturas donde la comunicación es costosa.
Grano fino puede aprovechar mejor arquitecturas con alta velocidad de comunicación o memoria compartida eficiente.

🔧 Resumen:

La granularidad es la proporción entre el cómputo y la comunicación en una aplicación. Afecta cómo se adapta el programa a una arquitectura paralela, diferenciándose entre grano fino (más comunicación) y grano grueso (más procesamiento local).

d) ¿Cuál de los programas le parece más adecuado para ejecutar sobre una arquitectura de tipo cluster de PCs? Justifique.

P2, porque en clusters la comunicación es costosa y se prioriza el cómputo local.
P2 reduce drásticamente los mensajes (de 100M a 10K), adaptándose mejor al grano grueso que requieren estas arquitecturas.

6) Indicar para cada Item si son Equivalentes

Dados los siguientes dos segmentos de codigo, indicar para cada uno de los ítems si son equivalentes o no. Justificar cada caso (de ser necesario dar ejemplos).

...
int cant = 1000;

DO 
  (cant < -10); datos?(cant) → Sentencias1
▭ (cant > 10);  datos?(cant) → Sentencias2
▭ (INCOGNITA);  datos?(cant) → Sentencias3
END DO
...

...
int cant = 1000;

While (true) {
  IF (cant < -10); datos?(cant) → Sentencias1
  ▭  (cant > 10);  datos?(cant) → Sentencias2
  ▭  (INCOGNITA); datos?(cant) → Sentencias3
END IF}
...

Dado que ambos comienzan con cant = 1000, se ejecuta la rama (cant > 10). La diferencia clave está en el comportamiento ante guardas no habilitadas

En el Segmento 1 (DO), si ninguna guarda es verdadera, el ciclo termina.
En el Segmento 2 (while true), si ninguna guarda es verdadera, el programa se bloquea.

Para que sean equivalentes, debe haber una guarda siempre habilitada, como INCOGNITA.

a) INCOGNITA equivale a: (cant = 0) No son equivalentes si INCOGNITA solo cubre cant == 0, ya que valores como cant = 5 no están contemplados.
b) INCOGNITA equivale a: (cant > -100) Ambos segmentos son equivalentes si INCOGNITA ≡ (cant > -100), ya que siempre hay una guarda habilitada y el ciclo no se detiene.
c) INCOGNITA equivale a: ((cant > 0) or (cant < 0)) Ambos segmentos no son equivalentes porque con cant = 0 ninguna guarda se cumple: el DO finaliza, pero el while (true) queda bloqueado.
d) INCOGNITA equivale a: ((cant > -10) or (cant < 10)) Los segmentos no son equivalentes porque con cant = 10 o -10 ninguna guarda se cumple: el DO finaliza, pero el while (true) queda bloqueado.
e) INCOGNITA equivale a: ((cant >= -10) or (cant <= 10)) Con esta condición, los segmentos son equivalentes porque la guarda cubre todos los casos y garantiza que siempre haya al menos una rama habilitada.

7) ¿Que valores quedan?

4. Dado el siguiente bloque de código, indique para cada inciso qué valor queda en aux, o si el código queda bloqueado. Justifique sus respuestas.

aux := -1;
...
if (A == 0); P2?(aux) → aux = aux + 2;
▭ (A == 1); P3?(aux) → aux = aux + 5;
▭ (B == 0); P3?(aux) → aux = aux + 7;
end if;

i. Si el valor de A = 1 y B = 2 antes del if, y solo P2 envia el valor 6. >> Solo se habilita la rama (A == 1); P3?(aux), pero como P3 no envía ningún valor, el código queda bloqueado esperando recibir de P3.

ii. Si el valor de A = 0 y B = 2 antes del if, y solo P2 envia el valor 8. >> Se habilita la guarda (A == 0); P2?(aux) y como P2 envía 8, se recibe y se ejecuta aux = 8 + 2, resultando en aux = 10.

iii. Si el valor de A = 2 y B = 0 antes del if, y solo P3 envia el valor 6. >> iii. Se habilita la guarda (B == 0); P3?(aux) y como P3 envía 6, se recibe y se ejecuta aux = 6 + 7, dando como resultado aux = 13.

iv. Si el valor de A = 2 y B = 1 antes del if, y solo P3 envia el valor 9 >> Todas las guardas son falsas, por lo que el if no se ejecuta, el código no se bloquea y aux permanece en -1.

v. Si el valor de A = 1 y B = 0 antes del if, y solo P3 envia el valor 14 >> Las guardas (A == 1) y (B == 0) son verdaderas, ambas con P3?(aux), por lo que al recibir 14 se elige una de forma no determinista y aux será 19 (14+5) o 21 (14+7).

vi. Si el valor de A = 0 y B = 0 antes del if, P3 envia el valor 9 y P2 el valor 5. >> Las guardas (A == 0) y (B == 0) son verdaderas; como P2 envía 5 y P3 envía 9, se elige una rama al azar y aux será 7 (5+2) o 16 (9+7).

8) ¿Que valores quedan? 2

Dado el siguiente programa concurrente con memoria compartida, y suponiendo que todas las variables están inicializadas en 0 al empezar el programa y las instrucciones NO son atómicas. Para cada una de las opciones indique verdadero o falso.

En caso de ser verdadero indique el camino de ejecución para llegar a ese valor, y en caso de ser falso justifique claramente su respuesta.

if (x = 0) then
    y := 4 * x + 2;
    x := y + 2 + x;

if (x ≥ 0) then
    x := x + 1;

x := x * 8 + x * 2 + 1;

🔎 Probamos combinaciones buscando x = 9

❌ Caso 1: P1 completo → P2 → P3

// P1 ejecuta completo:
x = 0 → entra al if
y = 4*0 + 2 = 2
x = y + 2 + x = 2 + 2 + 0 = 4

// P2 ejecuta:
x = 4 + 1 = 5

// P3 ejecuta:
x = 10 * 5 + 1 = 51 → ❌ no es 9

❌ Caso 2: P2 → P3

// P2 ejecuta:
x = 0 + 1 = 1

// P3 ejecuta:
x = 10 * 1 + 1 = 11 → ❌

❌ Caso 3: P3 → P2

// P3 ejecuta:
x = 10 * 0 + 1 = 1

// P2 ejecuta:
x = 1 + 1 = 2 → ❌

❌ Caso 4: P3 con x = 2

// Supongamos que x llega a 2 por P2 → P2
x = 0 + 1 = 1
x = 1 + 1 = 2

// P3 ejecuta:
x = 10 * 2 + 1 = 21 → ❌

❌ Conclusión del inciso a)

✅ x = 9 no se puede alcanzar, porque:

P1 produce como mucho x = 4
P2 suma 1 cada vez
P3 hace x = 10 * x + 1, lo cual siempre da un número impar mayor (nunca 9)

✅ Respuesta final del inciso a):
FALSO – No existe ninguna secuencia de ejecución posible que lleve a x = 9.

✔️ Verdadero

Una posible traza:

P1 ejecuta parcialmente: y := 4 * 0 + 2 = 2
P3 ejecuta: x := 0 * 8 + 0 * 2 + 1 = 1
P2 ejecuta: x := 1 + 1 = 2
P1 finaliza: x := y + 2 + x = 2 + 2 + 2 = 6

Por lo tanto, es posible llegar a x = 6.

✔️ Verdadero

Una traza simple:

P2 ejecuta: x := 1
P3 ejecuta: x := 10 * 1 + 1 = 11

P1 no entra porque x ≠ 0.
Resultado final: x = 11 → válido.

✔️ Verdadero

Análisis por casos:

y = 0: si P1 no ejecuta el cuerpo del if (porque x ≠ 0 al momento de evaluarlo)
y = 2: si P1 ejecuta el if con x = 0, y aún no ha sido modificado
y = 6: si x = 1 al momento de ejecutar y := 4 * x + 2
y = 10: si x = 2 cuando se evalúa la asignación

Como la asignación de y depende directamente del valor de x, que puede ser modificado por otros procesos antes de ejecutarla, solo esos cuatro valores son posibles.

9) La solución a un problema es paralelizada

Suponga que la solución a un problema es paralelizada sobre p procesadores de dos maneras diferentes.

En un caso, el speedup (S) está regido por la función S=p-1 y
en el otro por la función S=p/2.

¿Cuál de las dos soluciones se comportará más eficientemente al crecer la cantidad de procesadores? Justifique claramente.

De las dos soluciones, la que tiene speedup S = p - 1 se comporta de forma más eficiente a medida que crece el número de procesadores.

Esto se debe a que el speedup ideal es S = p, y:

S = p - 1 crece casi linealmente y se acerca al ideal.
S = p / 2 crece más lentamente y siempre es la mitad del número de procesadores.

Si analizamos la eficiencia, que se define como:

E = S / p

E = (p - 1) / p -> Esta eficiencia tiende a 1 cuando p crece.
E = (p / 2) / p -> (p/2) / (p/1) -> (p * 1)/(2 * p) -> p/2p -> 1/2 -> La eficiencia es constante e igual al 50%, sin importar cuántos procesadores haya.

Por lo tanto, la solución con S = p - 1 es más eficiente, ya que utiliza mejor los procesadores disponibles.

Ahora suponga S = 1/p y S = 1/p^2

Ambos speedups disminuyen con más procesadores (son inversamente proporcionales).
Pero S = 1/p siempre es mayor que S = 1/(p^2).
Lo mismo ocurre con la eficiencia: 1/(p^2) decrece más lento que 1/(p^3).
Por eso, la solución con S = 1/p es más eficiente y escala mejor.

10) La solución a un problema es paralelizada 2

Suponga que la solución a un problema es paralelizada sobre p procesadores de dos maneras diferentes.

En un caso, el speedup (S) está regido por la función S=p/3
y en el otro por la función S=p-3.

¿Cuál de las dos soluciones se comportará más eficientemente al crecer la cantidad de procesadores? Justifique claramente.

Suponiendo el uso de 5 procesadores:

Opción 1: S = 5 / 3 ≈ 1.66
Opción 2: S = 5 − 3 = 2

En este caso, la segunda opción es más eficiente porque alcanza un mayor speedup.

Ahora, incrementamos la cantidad de procesadores suponemos 100 procesadores:

Solución 1 => S=100/3=33,33
Solución 2 => S=100-3=97

Podemos decir, que a medida que p tiende a infinito, para la solución 1 siempre el Speedup será la tercera parte en cambio para la solución 2 el valor "-3" se vuelve despreciable.

Por lo tanto la solución 2 es la que se comporta más eficientemente al crecer la cantidad de procesadores.

11) La solución a un problema es paralelizada 3

Suponga que la solución a un problema es paralelizada sobre p procesadores de dos maneras diferentes.

En un caso, el speedup(s) esta regido por la función S = p-4
y el otro por la función S = p/3 para p > 4.

¿Cuál de las dos soluciones se comportara más eficientemente al crecer la cantidad de procesadores?

A medida que p crece, la eficiencia de S = p − 4 se acerca a 1 (ideal).
La eficiencia de S = p / 3 es constante y baja (0.33), sin importar el valor de p.
Por eso, la función S = p − 4 se comporta mucho mejor para valores grandes de p.

12) La solución a un problema es paralelizada 4

Suponga que la solución a un problema es paralelizada sobre p procesadores de dos maneras diferentes.

En un caso, la eficiencia está regido por la función E = 1/p
y en el otro por la función E = 1/p^2.

¿Cuál de las dos soluciones se comportará más eficientemente al crecer la cantidad de procesadores? Justifique.

Claramente, a partir de p = 2, se observa que la eficiencia E₁ = 1/p es mayor que la eficiencia E₂ = 1/p². Analicemos algunos valores:

Para p = 1:
E₁ = 1/1 = 1 E₂ = 1/1 = 1
Para p = 2:
E₁ = 1/2 = 0.5 E₂ = 1/4 = 0.25
Para p = 3:
E₁ = 1/3 ≈ 0.33 E₂ = 1/9 ≈ 0.11

Como se puede apreciar, E₁ siempre es mayor que E₂ a partir de p = 2, y ambas eficiencias decrecen al aumentar el número de procesadores.

Conclusión:
La solución con E = 1/p se comporta más eficientemente que la de E = 1/p², ya que decrece más lentamente. Sin embargo, ninguna de las dos escala bien cuando p crece mucho, ya que ambas tienden a eficiencia cero.

| Procesadores (p) | E1 = 1/p | E2 = 1/p² | |------------------|----------|-----------| | 1 | 1.0000 | 1.0000 | | 2 | 0.5000 | 0.2500 | | 3 | 0.3333 | 0.1111 | | 4 | 0.2500 | 0.0625 | | 5 | 0.2000 | 0.0400 | | 10 | 0.1000 | 0.0100 | | 20 | 0.0500 | 0.0025 | | 50 | 0.0200 | 0.0004 | | 100 | 0.0100 | 0.0001 |

13) Suponga que el tiempo de ejecución de un algoritmo Secuencial

Suponga que el tiempo de ejecución de un algoritmo secuencial es de 1000 unidades de tiempo, de las cuales el 80% corresponden a código paralelizable.

¿Cuál es el límite en la mejora que puede obtenerse paralelizando el algoritmo?

Tenemos un programa que tarda 1000 unidades de tiempo si lo ejecutamos de forma secuencial (1 solo procesador), pero el 80% de ese tiempo es paralelizable.

80% de 1000 = 800 unidades de tiempo paralelizable
20% de 1000 = 200 unidades de tiempo secuencial

Ley de Andahl

T_Paralelo = Porcion_T_secuencial + (Porcion_T_paralelizable / p)

Si usamos 800 procesadores, el tiempo de ejecución de la parte paralelizable se reduce a 1 unidad de tiempo.

T_Paralelo = 200 + (800 / 800) -> 200 + 1 -> 201
Speedup = T_secuencial / T_paralelo -> 1000 / 201 ≈ 4.975

Conviene usar una cantidad mas chica de procesadores que pueden estar trabajando todo el tiempo

T_Paralelo = 200 + (800 / 5) = 200 + 160 = 360
Speedup = 1000 / 360 ≈ 2.778

14) Suponga que el tiempo de ejecución de un algoritmo Secuencial 2

Suponga que el tiempo de ejecución de un algoritmo secuencial es de 8000 unidades de tiempo, de las cuales solo el 90% corresponde a código paralelizable.

¿Cuál es el límite en la mejora que puede obtenerse paralelizando el algoritmo? Justifique.

T_Total = 8000 el 90% es paralelizable es decir 7200 y el 10% es secuencial es decir 800.

El mejor caso se da si usamos tantos procesadores como para la parte paralela tarde solo 1 unidad de tiempo (Es decir, 7200 procesadores para 7200 unidades paralelas).

T_Paralelo -> T_secuencial + T_paralelizable / p

T_Paralelo -> 800 + 7200 / 7200 -> 800 + 1 -> 801
Speedup = T_secuencial / T_Paralelo -> 8000 / 801 ≈ 9.99

El limite teorico de memoria es aproximadamente 10 veces mas rapido.

15) Suponga que el tiempo de ejecución de un algoritmo Secuencial 3

Suponga que el tiempo de ejecución de un algoritmo secuencial es de 10000 unidades de tiempo, de las cuales 95% corresponden a código paralelizable.

¿Cuál es el límite en la mejora que puede obtenerse paralelinzado el algoritmo?

El limite se alncaza cuando se utilizan 9500 procesadores (uno por cada unidad de tiempo paralelizable), lo que reduce el tiempo de ejecución de la parte paralela a 1 unidad de tiempo.

La parte secuencial, que no puede paralelizarse, tarda 500 unidades de tiempo.

T_Paralelo = T_secuencial + T_paralelizable / p

T_Paralelo = 500 + 9500 / 9500 -> 500 + 1 = 501
Speedup = T_secuencial_total / T_Paralelo = 10000 / 501 ≈ 19.96

Este resultado confirma la Ley de Amdahl, la cual establece que el límite de paralelización de un algoritmo no depende de cuántos procesadores se usen, sino de cuánta parte del código es secuencial.

📢 Miralas de Reojo

1) Propuesta al problema de alocación SJN

Sea la siguiente solución propuesta al problema de alocación SJN (Short Job Next):

Monitor SJN {
    Bool libre = true;
    Cond turno;

    Procedure request {
        If (not libre) wait (turno, tiempo);
        Libre = false;
    }

    Procedure release {
        Libre = true;
        Signal (turno);
    }
}

a) ¿Funciona correctamente con disciplina de señalización Signal and continue? Justifique.

No, la solución no funciona correctamente con la disciplina de señalización Signal and Continue (S&C).

Bajo esta disciplina, cuando un proceso realiza un signal, continúa ejecutando dentro del monitor, y el proceso que fue despertado es enviado a la cola de listos (ready queue) del sistema operativo. Esto implica que su reingreso al monitor depende de la política de planificación del sistema, y no se garantiza que sea el próximo en ejecutarse.

En consecuencia, un proceso con menor tiempo (según la política Shortest Job Next) podría quedar retrasado si otro proceso ingresa antes al monitor. Por lo tanto, el orden de ejecución no refleja necesariamente la prioridad establecida por el parámetro tiempo, y no se cumple el objetivo del SJN.

Respuesta de un random

Con S&C un proceso que es despertado para poder seguir ejecutando es pasado a la cola de ready en cuyo caso su orden de ejecución depende de la política que se utilice para ordenar los procesos en dicha cola. Puede ser que sea retrasado en esa cola permitiendo que otro proceso ejecute en el monitor antes que el por lo que podría no cumplirse el objetivo del SJN.

b) ¿Funciona correctamente con disciplina de señalización signal and wait? Justifique.

Sí, la solución funciona correctamente con la disciplina de señalización Signal and Wait (S&W).

En esta disciplina, cuando un proceso ejecuta un signal, cede inmediatamente el control del monitor al proceso que fue despertado, el cual continúa su ejecución justo después del wait. El proceso que hizo el signal pasa a la cola de listos y debe esperar su turno para volver a ingresar al monitor.

Esto garantiza que el proceso con menor tiempo (según la política Shortest Job Next) —que estaba esperando con prioridad— será efectivamente el próximo en acceder al recurso, evitando que otro proceso pueda adelantarse y violar el orden deseado.

Por lo tanto, la política SJN se respeta correctamente bajo Signal and Wait, ya que se mantiene el control sobre el orden de ejecución de los procesos en espera.

📘 Definiciones complementarias:

Signal and Continue: El proceso que ejecuta el signal continúa usando el monitor, mientras que el proceso despertado debe competir por reingresar al monitor.
Signal and Wait: El proceso que ejecuta el signal cede el monitor al proceso despertado, que continúa su ejecución justo después del wait.

| Aspecto | Signal and Continue (S&C) | Signal and Wait (S&W) | |-------------------------------------|-----------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------| | ¿Quién sigue ejecutando en el monitor después del signal? | El proceso que hizo el signal continúa. | El proceso que fue despertado entra inmediatamente al monitor. | | Estado del proceso despertado | Pasa a la cola de listos y debe competir por reingresar al monitor. | Continúa inmediatamente dentro del monitor (no compite por el acceso). | | Riesgo de pérdida de prioridad (SJN) | Alto: otro proceso puede ingresar antes que el de menor tiempo. | Nulo: se garantiza que el proceso con menor tiempo accede primero. | | ¿Se respeta la política SJN? | ❌ No: puede no ejecutarse el proceso con menor tiempo debido a la competencia externa. | ✅ Sí: el proceso con menor tiempo es el próximo en continuar. | | Uso recomendado en SJN | No recomendado, ya que puede romper la prioridad por tiempo. | Recomendado, ya que respeta el orden de espera basado en el tiempo. | | Control de acceso | Depende del planificador del sistema operativo. | Controlado directamente por el monitor y su lógica de sincronización. |

2) “passing the condition” En Semaforos

Utilice la técnica de “passing the condition” para implementar un semáforo fair usando monitores.

monitor Semaforo {
    int s = 1, espera = 0;
    cond pos;

    procedure P() {
        if (s == 0) {
            espera++;
            wait(pos);
        } else {
            s = s - 1;
        }
    };

    procedure V() {
        if (espera == 0) {
            s = s + 1;
        } else {
            espera--;
            signal(pos);
        }
    };
};

3) Problema de Concurrencia

Sea “ocupados” una variable entera inicializada en N que representa la cantidad de slots ocupados de un buffer, y sean P1 y P2 dos programas que se ejecutan de manera concurrente, donde cada una de las instrucciones que los componen son atómicas.

if (ocupados < N) then
begin
    buffer := elemento_a_agregar;
    ocupados := ocupados + 1;
end;

if (ocupados > 0) then
begin
    ocupados := ocupados - 1;
    elemento_a_sacar := buffer;
end;

¿El programa funciona correctamente para asegurar el manejo del buffer?

Si su respuesta es afirmativa justifique.
Sino, encuentre una secuencia de ejecución que lo verifique y escríbala, y además modifique la solución para que funcione correctamente (Suponga buffer, elemento_a_agregar y elemento_a_sacar variables declaradas).

No, el programa no funciona correctamente en un entorno concurrente.

🔍 Justificación con secuencia de ejecución:

Supongamos que el buffer está lleno (ocupados = N). En ese momento:

El proceso P2 evalúa if (ocupados > 0), lo cual es verdadero.
Luego, P2 ejecuta ocupados := ocupados - 1, pero aún no ha leído el dato del buffer.
Justo después, el proceso P1 evalúa su condición if (ocupados < N), que ahora también es verdadera, ya que P2 lo acaba de decrementar.
Entonces, P1 escribe en el buffer un nuevo valor, sobrescribiendo el dato que P2 todavía no alcanzó a leer.

⚠️ Como resultado, P2 pierde el dato original y lee un valor nuevo que no era el que debía consumir. Esto genera una condición de carrera (race condition) y un error de sincronización.

✅ Solución propuesta:

Para evitar este problema, es necesario postergar el decremento de ocupados en P2 hasta después de leer el valor del buffer, asegurando que el dato se consuma correctamente antes de liberar el espacio.

✔️ Código corregido de P2

if (ocupados > 0) then
begin
    elemento_a_sacar := buffer;
    ocupados := ocupados - 1;
end;

Con esta corrección, P1 no podrá ingresar hasta que P2 haya terminado de leer el valor, manteniendo la coherencia del estado del buffer.

🧠 Nota adicional:

Este tipo de errores son comunes cuando no se usa un mecanismo de sincronización explícito, como semáforos, monitores o exclusión mutua. En un sistema real, lo ideal sería proteger el acceso al buffer con algún tipo de región crítica o control de concurrencia.

4) Problema de Concurrencia 2

Sea “cantidad” una variable entera inicializada en 0 que representa la cantidad de elementos de un buffer, y sean P1 y P2 dos programas que se ejecutan de manera concurrente, donde cada una de las instrucciones que los componen son atómicas.

if (cantidad = 0) then
begin
    cantidad := cantidad + 1;
    buffer := elemento_a_agregar;
end;

if (cantidad > 0) then
begin
    elemento_a_sacar := buffer;
    cantidad := cantidad - 1;
end;

Además existen dos alumnos de concurrente que analizan el programa y opinan lo siguiente:

“Pepe: este programa funciona correctamente ya que las instrucciones son atómicas”.
“José: no Pepe estás equivocado, hay por lo menos una secuencia de ejecución en la cual funciona erróneamente”

¿Con cuál de los dos alumnos está de acuerdo? Si está de acuerdo con Pepe justifique su respuesta. Si está de acuerdo con José encuentre una secuencia de ejecución que verifique lo que José opina y escríbala, y modifique la solución para que funcione correctamente (Suponga buffer y elemento variables declaradas). (22-04-2009)

✅ Estoy de acuerdo con José.

Aunque las instrucciones sean atómicas, el programa no es seguro concurrentemente, ya que existen interleavings (intercalaciones de ejecución) posibles que generan un comportamiento incorrecto.

🔍 Ejemplo de secuencia de ejecución errónea:

El proceso P1 evalúa la condición if (cantidad = 0) → verdadera, y entra al begin.
P1 ejecuta la instrucción cantidad := cantidad + 1, pero aún no ha escrito en el buffer.
En ese momento, el proceso P1 se interrumpe, y P2 toma el control.
P2 evalúa if (cantidad > 0) → verdadera (porque cantidad ahora vale 1).
P2 ejecuta elemento_a_sacar := buffer, pero el buffer aún no fue actualizado por P1.
Como resultado, P2 lee un valor inválido o desactualizado del buffer.

⚠️ Problema identificado:

El hecho de que las instrucciones sean atómicas no garantiza la atomicidad de toda la sección crítica compuesta por múltiples instrucciones relacionadas entre sí.

✅ Modificación para que funcione correctamente:

Una forma de corregirlo es reordenar las instrucciones de P1, asegurando que el valor se escriba en el buffer antes de habilitar su lectura (es decir, antes de incrementar cantidad):

// P1 corregido:
if (cantidad = 0) then
begin
    buffer := elemento_a_agregar;
    cantidad := cantidad + 1;
end;

De este modo, si P2 observa que cantidad > 0, entonces es seguro asumir que el buffer ya contiene un valor válido para ser consumido.

🧠 Conclusión:

Estoy de acuerdo con José, porque:

El código original permite que P2 lea un valor inválido si se interrumpe a P1 en el momento inadecuado.
La solución requiere ajustar el orden de operaciones para garantizar consistencia en el acceso al buffer, incluso si cada instrucción individual es atómica.

5) Indique los posibles valores finales de x

Indique los posibles valores finales de x en el siguiente programa (justifique claramente su respuesta):

int x = 3;
sem s1 = 1, s2 = 0;

co
  // P1
  P(s1);              // Espera mutex
  x = x * x;          
  V(s1);              // Libera mutex

  // P2
  P(s2);              // Espera señal de P3
  P(s1);              // Espera mutex
  x = x * 3;
  V(s1);

  // P3
  P(s1);              // Espera mutex
  x = x - 2;
  V(s2);              // Señaliza a P2
  V(s1);
oc

s1 → mutex: puede pasar un solo proceso por vez.
s2 → semáforo de señalización: esperan señalización de un evento y pasa sólo uno.

Aunque se libere un semaforo, no tiene que volver a ejecutarse ya que no estamos en un while (Si un semaforo paso PASO)

| Orden de ejecución | Valor final de x | |--------------------------|--------------------| | P1 → P3 → P2 | 21 | | P3 → P2 → P1 | 9 | | P3 → P1 → P2 | 3 |

P1 y P3 comienzan esperando a s1. Por ser un mutex, sólo puede continuar uno de ellos y no será interrumpido por el otro hasta liberar a s1.

Primer resultado

Si comienza P1:

Asigna x=9
luego incrementa s1 permitiendo que continúe P3.
P3 asigna x=7 y señala s2.
Esto habilita a P2 que estaba esperando.
Si P2 continúa, intentará obtener s1 con lo cual se vuelve a bloquear volviendo el control a P3.
En cualquier caso, P3 libera a s1 y termina.
P2 es despertado, asigna x = 21 y termina.
Valor final x=21.

Segundo y Tercer resultado

Si comienza P3:

Asigna x = 1 y señala a s2.
Esto habilita a P2 que estaba esperando.
Si P2 continúa, intentará obtener s1 con lo cual se vuelve a bloquear volviendo el control a P3.
Cuando P3 libera a s1, P1 y P2 pueden competir por él:
- Si gana P1:
  - asigna x=1,
  - libera a s1 y termina;
  - finaliza P2 y asigna x = 3.
  - Valor final x=3.
- Si gana P2:
  - asigna x=3,
  - libera a s1 y termina;
  - finaliza P1 y asigna x = 9.
  - Valor final x = 9.

P2 nunca puede comenzar la historia ya que espera un semáforo de señalización que sólo P3 señala. Cualquier historia en la que P2 esté antes de P3 es inválida. En todas las historias los semáforos terminan con los mismos valores con los que están inicializados.

6) Cuales valores de k son posibles

c) Dado el siguiente programa concurrente indique cuáles valores de K son posibles al finalizar, y describa una secuencia de instrucciones para obtener dicho resultado:

Process P1 {
    for (i = 1 to K) {
        N = N + 1;
    }
}

Process P2 {
    for (i = 1 to K) {
        N = N + 1;
    }
}

i) 2K ii) 2K + 2
iii) K
iv) 2

// Ambos procesos ejecutan el mismo bucle:
for (i = 1 to K)
    N = N + 1;

✅ i) Valor final = 2K
Caso posible: ejecución secuencial sin interferencia.

Ejemplo (K = 3):

P1: N=0 -> 1 -> 2 -> 3
P2: N=3 -> 4 -> 5 -> 6
Resultado final: N = 6 = 2*K

❌ ii) Valor final = 2K + 2
Caso imposible.

Justificación:
Cada proceso ejecuta exactamente K incrementos. Como mucho se pueden hacer 2K sumas. No hay forma de hacer más sin ejecutar más iteraciones, lo cual no ocurre.

✅ iii) Valor final = K
Caso posible: interferencia total entre procesos. Se pisan las operaciones.

Ejemplo (K = 3):

N inicialmente = 0

Intercalado:
P1 lee N=0       // aún no actualiza
P2 lee N=0       // aún no actualiza
P1 escribe N=1
P2 escribe N=1   // pisa el valor anterior → se pierde un incremento

Repite este patrón durante las 3 iteraciones.

Resultado final: solo 3 incrementos efectivos → N = 3 = K

✅ iv) Valor final = 2
Caso posible: interferencia total y mal intercalado extremo.

Ejemplo (K = 3):

N = 0

P1 iteración 1: lee N=0
P2 iteración 1: lee N=0
P1 escribe N=1
P2 escribe N=1   → pisa a P1

P1 iteración 2: lee N=1
P2 iteración 2: lee N=1
P1 escribe N=2
P2 escribe N=2   → pisa a P1

Resultado final: N = 2

🚨 Rezar para que no Tomen

1) Resuelva con monitores

Resuelva con monitores el siguiente problema:
Tres clases de procesos comparten el acceso a una lista enlazada: searchers, inserters y deleters.

Los searchers sólo examinan la lista, y por lo tanto pueden ejecutar concurrentemente unos con otros.
Los inserters agregan nuevos ítems al final de la lista; las inserciones deben ser mutuamente exclusivas para evitar insertar dos ítems casi al mismo tiempo. Sin embargo, un insert puede hacerse en paralelo con uno o más searchers.
Por último, los deleters remueven ítems de cualquier lugar de la lista. A lo sumo un deleter puede acceder la lista a la vez, y el borrado también debe ser mutuamente exclusivo con searchers e inserters.

monitor Controlador_ListaEnlazada {
    int numSearchers = 0, numInserters = 0, numDeleters = 0;
    cond searchers, inserters, deleters;

    procedure pedir_Deleter() {
        while (numSearchers > 0 OR numInserters > 0 OR numDeleters > 0) {
            wait(deleters);
        }
        numDeleters = numDeleters + 1;
    }

    procedure liberar_Deleter() {
        numDeleters = numDeleters - 1;
        signal(inserters);
        signal(deleters);
        signal_all(searchers);
    }

    procedure pedir_Searcher() {
        while (numDeleters > 0) {
            wait(searchers);
        }
        numSearchers = numSearchers + 1;
    }

    procedure liberar_Searcher() {
        numSearchers = numSearchers - 1;
        if (numSearchers == 0 AND numInserters == 0) {
            signal(deleters);
        }
    }

    procedure pedir_Inserter() {
        while (numDeleters > 0 OR numInserters > 0) {
            wait(inserters);
        }
        numInserters = numInserters + 1;
    }

    procedure liberar_Inserter() {
        numInserters = numInserters - 1;
        signal(inserters);
        if (numSearchers == 0) {
            signal(deleters);
        }
    }
}

🧵 Procesos:

process Searchers[i = 1..S] {
    Controlador_ListaEnlazada.pedir_Searcher();
    <Realiza búsqueda en la lista>
    Controlador_ListaEnlazada.liberar_Searcher();
}

process Inserters[j = 1..I] {
    Controlador_ListaEnlazada.pedir_Inserter();
    <Inserta en la lista>
    Controlador_ListaEnlazada.liberar_Inserter();
}

process Deleters[k = 1..D] {
    Controlador_ListaEnlazada.pedir_Deleter();
    <Borra en la lista>
    Controlador_ListaEnlazada.liberar_Deleter();
}

🧠 Resumen: Monitor Controlador_ListaEnlazada

👥 Tipos de procesos:

Searchers: pueden acceder concurrentemente, salvo que haya un Deleter.
Inserters: acceden de a uno, pero pueden convivir con Searchers.
Deleters: requieren exclusión total (no pueden ejecutarse junto a ningún otro proceso).

🔒 Comportamiento de sincronización:

Searchers esperan si hay un Deleter.
Inserters esperan si hay otro Inserter o un Deleter.
Deleters esperan si hay cualquier otro proceso activo (Searcher o Inserter).
Al liberar, se despiertan procesos bloqueados según condiciones.

✅ ¿Funciona correctamente? Sí, el monitor implementa correctamente las restricciones de sincronización para los tres tipos de procesos. Asegura exclusión mutua, convivencia segura y respeta la lógica de prioridades.

2) Protocolos de Acceso a la SC

En los protocolos de acceso a sección crítica vistos en clase, cada proceso ejecuta el mismo algoritmo. Una manera alternativa de resolver el problema es usando un proceso coordinador. En este caso, cuando cada proceso SC[i] quiere entrar a su sección crítica le avisa al coordinador, y espera a que éste le dé permiso. Al terminar de ejecutar su sección crítica, el proceso SC[i] le avisa al coordinador.

Desarrolle protocolos para los procesos SC[i] y el coordinador usando sólo variables compartidas (no tenga en cuenta la propiedad de eventual entrada).

int aviso[1:N] = ([N] 0), permiso[1:N] = ([N] 0);

process SC[i = 1 to N] {
    SNC;

    // Protocolo de entrada
    permiso[i] = 1;
    while (aviso[i] == 0) skip;

    // Sección crítica
    SC;

    // Protocolo de salida
    aviso[i] = 0;
    SNC;
}

process Coordinador {
    int i = 1;
    while (true) {
        // Espera que algún proceso solicite permiso
        while (permiso[i] == 0)
            i = i mod N + 1;

        // Otorga permiso al proceso i
        permiso[i] = 0;
        aviso[i] = 1;

        // Espera a que el proceso libere la SC
        while (aviso[i] == 1) skip;
    }
}

3) Solución a la Criba

💀 Dudo mucho que tomen este ejercicio, lo pongo por las dudas

Describa la solución utilizando la criba de Eratóstenes al problema de hallar los primos entre 2 y n. ¿Cómo termina el algoritmo? ¿Qué modificaría para que no termine de esa manera?

La criba de Eratóstenes es un algoritmo clásico para determinar cuáles números en un rango son primos. Supongamos que queremos generar todos los primos entre 2 y n. Primero, escribimos una lista con todos los números:

2 3 4 5 6 7 ... n

Comenzando con el primer número no tachado en la lista, 2, recorremos la lista y borramos los múltiplos de ese número. Si n es impar, obtenemos la lista:

2 3 5 7 ... n

En este momento, los números borrados no son primos; los números que quedan todavía son candidatos a ser primos. Pasamos al próximo número, 3, y repetimos el anterior proceso borrando los múltiplos de 3. Si seguimos este proceso hasta que todo número fue considerado, los números que quedan en la lista final serán todos los primos entre 2 y n.

Para solucionar este problema de forma paralela podemos emplear un pipeline de procesos filtro.

Cada filtro recibe una serie de números de su predecesor y envía una serie de números a su sucesor.
El primer número que recibe un filtro es el próximo primo más grande;
Le pasa a su sucesor todos los números que no son múltiplos del primero.

El siguiente es el algoritmo pipeline para la generación de números primos.

Por cada canal, el primer número es primo y todos los otros números no son múltiplo de ningún primo menor que el primer número:

Process Criba[1]
{
    int p = 2;

    for [i = 3 to n by 2] 
        Criba[2] ! (i);
}

Process Criba[i = 2 to L]
{
    int p, proximo;

    Criba[i-1] ? p;
    do Criba[i-1] ? (proximo) →
        if ((proximo MOD p) <> 0) →
            Criba[i+1] ! (proximo);
        fi
    od
}

El primer proceso, Criba[1], envía todos los números impares desde 3 a n a Criba[2].
Cada uno de los otros procesos recibe una serie de números de su predecesor.
El primer número p que recibe el proceso Criba[i] es el i-ésimo primo.
Cada Criba[i] subsecuentemente pasa todos los otros números que recibe que no son múltiplos de su primo p.
El número total L de procesos Cribe debe ser lo suficientemente grande para garantizar que todos los primos hasta n son generados. Por ejemplo, hay 25 primos menores que 100;
el porcentaje decrece para valores crecientes de n.

El programa anterior termina en deadlock, ya que no hay forma de saber cuál es el último número de la secuencia y cada proceso queda esperando un próximo número que no llega.

Podemos fácilmente modificarlo para que termine normalmente usando centinelas, es decir que al final de los streams de entrada son marcados por un centinela

# EOS: End Of Stream (-1 indica fin del flujo)

Process Criba[1] {
    int p = 2;

    # Enviar todos los números impares desde 3 hasta n a Criba[2]
    for [i = 3 to n by 2]
        Criba[2] ! i;

    # Enviar fin de flujo
    Criba[2] ! -1;
}

Process Criba[i = 2 to L] {
    int p, proximo;
    boolean seguir = true;

    # Recibe el primer número (primo)
    Criba[i-1] ? p;

    do (seguir);
        # Recibe siguiente candidato
        Criba[i-1] ? proximo ->

        if (proximo = -1) {
            seguir = false;
            Criba[i+1] ! -1;   # Propaga EOS al siguiente proceso
        }
        else if ((proximo MOD p) <> 0) {
            Criba[i+1] ! proximo;  # Si no es múltiplo, lo pasa
        }
    od
}

4) Transformar Solucion usando mensajes asincronicos

Dada la siguiente solución con monitores al problema de alocación de un recurso con múltiples unidades, transforme la misma en una solución utilizando mensajes asincrónicos.

Monitor Alocador_Recurso {
    INT disponible = MAXUNIDADES;
    SET unidades = valores iniciales;
    COND libre;   // TRUE cuando hay recursos

    procedure adquirir(INT id) {
        if (disponible == 0)
            wait(libre);
        else {
            disponible = disponible - 1;
            remove(unidades, id);
        }
    }

    procedure liberar(INT id) {
        insert(unidades, id);
        if (empty(libre))
            disponible := disponible + 1;
        else
            signal(libre);
    }
}

type clase_op = enum(adquirir, liberar);
chan request(int idCliente, claseOp oper, int idUnidad);
chan respuesta[n](int id_unidad);

Process Administrador_Recurso {
    int disponible = MAXUNIDADES;
    set unidades = valor inicial disponible;
    queue pendientes;

    while (true) {
        receive request(idCliente, oper, id_unidad);

        if (oper == adquirir) {
            if (disponible > 0) {
                disponible = disponible - 1;
                remove(unidades, id_unidad);
                send respuesta[idCliente](id_unidad);
            } else {
                insert(pendientes, idCliente);
            }
        } else {
            if (empty(pendientes)) {
                disponible = disponible + 1;
                insert(unidades, id_unidad);
            } else {
                remove(pendientes, idCliente);
                send respuesta[idCliente](id_unidad);
            }
        }
    }
}
// Fin del proceso Administrador_Recurso

Process Cliente[i = 1 to n] {
    int id_unidad;

    send request(i, adquirir, 0);
    receive respuesta[i](id_unidad);

    // Usa la unidad

    send request(i, liberar, id_unidad);
}

🧠 1. Modelo de comunicación

Monitores utilizan una comunicación directa entre procesos a través de procedimientos compartidos. El proceso cliente entra al monitor, ejecuta adquirir() o liberar(), y bloquea su ejecución si no puede continuar (por ejemplo, si no hay recursos).
Mensajes asincrónicos, en cambio, se basan en comunicación por paso de mensajes. El cliente envía un mensaje al administrador (request) y luego espera la respuesta por otro canal (respuesta[i]). No hay acceso directo a las variables compartidas; todo se coordina mediante mensajes.

🔁 2. Sincronización y control de acceso

En el monitor, la sincronización es implícita: si disponible == 0, el proceso ejecuta wait(libre) y queda suspendido automáticamente hasta que otro proceso haga signal(libre) al liberar un recurso.
En la versión con mensajes, no hay suspensión automática. El administrador debe mantener una cola de espera (pendientes) y decidir manualmente a quién responder y cuándo. Si alguien libera una unidad y hay clientes esperando, el administrador desencola y responde explícitamente.

🔐 3. Visibilidad y consistencia del estado

En el monitor, los procesos tienen acceso directo a las variables disponible, unidades, etc., pero solo uno a la vez, garantizando exclusión mutua.
Con mensajes asincrónicos, solo el administrador conoce y modifica el estado global. Los clientes no ven directamente cuántos recursos quedan; solo saben si obtuvieron uno o no, cuando reciben la respuesta.

🧩 4. Modelo de espera

En monitores, la espera se maneja con wait y signal, que pueden funcionar según dos disciplinas:
- Signal and Wait (el proceso que señala cede el monitor al despertado)
- Signal and Continue (el proceso que señala continúa)
En mensajes, la espera es activa y manual: el cliente se bloquea esperando una respuesta, y el administrador debe tener lógica para enviarle esa respuesta cuando le toque.

⚙️ 5. Aplicabilidad según arquitectura

Los monitores son más adecuados para sistemas centralizados o con memoria compartida, ya que dependen de sincronización interna y acceso directo a variables.
Los mensajes asincrónicos son ideales en sistemas distribuidos o clusters, donde no existe memoria compartida y cada proceso corre en su propio nodo. Permiten separar cómputo y comunicación y escalar fácilmente.

💬 Ejemplo concreto

Supongamos que hay 3 unidades disponibles, y 5 procesos piden recursos.

En el monitor, los 3 primeros entran y adquieren recursos; los otros 2 quedan bloqueados con wait(libre) hasta que alguien libere. Luego, liberar() hace signal() y despierta a uno.
En la versión con mensajes, los 3 primeros reciben respuesta del administrador inmediatamente. Los otros 2 son enviados a la cola pendientes, y recién serán atendidos cuando un recurso sea liberado y el administrador procese esa cola.

✅ Conclusión

El uso de monitores es más directo y automatizado, pero menos flexible fuera de sistemas con memoria compartida.
El enfoque de mensajes asincrónicos permite mayor control y distribución, pero requiere manejar manualmente colas, lógica de respuesta y sincronización, lo cual lo hace más complejo pero también más escalable.

5) Problema de ordenar de menor a mayor un arreglo

Sea el problema de ordenar de menor a mayor un arreglo de A[1..n]

Process P1
{
    int nuevo, a1[1:n/2];
    const mayor = n/2;

    // ordenar a1 en orden no decreciente
    P2 ! (a1[mayor]);
    P2 ? (nuevo);

    do a1[mayor] > nuevo →
        // poner nuevo en el lugar correcto
        // en a1, descartando 
        // el viejo a1[mayor]
        P2 ! (a1[mayor]);
        P2 ? (nuevo);
    od
}

Process P2
{
    int nuevo, a2[1:n/2];
    const menor = 1;

    // ordenar a2 en orden no decreciente
    P1 ? (nuevo);
    P1 ! (a2[menor]);

    do a2[menor] < nuevo →
        // poner nuevo en el lugar correcto
        // en a2, descartando
        // el viejo a2[menor]
        P1 ? (nuevo);
        P1 ! (a2[menor]);
    od
}

Mejor caso:
En el escenario más favorable, los arreglos ya están correctamente distribuidos:

Los n/2 valores más pequeños están en el proceso P1.
Los n/2 valores más grandes están en P2.

Como los extremos (mayor de a1 y menor de a2) ya están en orden, los procesos solo necesitan hacer una comparación inicial y confirmar que no hay que intercambiar nada.

Resultado: Solo se envían 2 mensajes:

P1 envía su mayor a P2.
P2 responde con su menor a P1.

🧪 Ejemplo con n = 6 (a1 y a2 de tamaño 3)

Supongamos:

P1: a1 = [1, 2, 3]     (valores más chicos)
P2: a2 = [4, 5, 6]     (valores más grandes)

Proceso:
- 1) P1 envía el mayor de a1: 3
- 2) P2 envía el menor de a2: 4
- 3) P1 verifica: 3 < 4 ✅, así que todo está ordenado
✅ Resultado:
- Se intercambian 2 mensajes: 3 →, 4 →
- No se modifica nada

Peor caso:

En el peor de los casos, todos los elementos están en el proceso equivocado:

Es decir, los mayores están en P1 y los menores en P2.

Esto obligará a intercambiar completamente los n/2 elementos entre ambos procesos.
Cada valor necesita un mensaje de ida y uno de vuelta, ya que el intercambio es coordinado y requiere validación mutua.

Resultado: Se intercambian n mensajes:

n/2 valores de P1 a P2
n/2 valores de P2 a P1 → total: (n/2) * 2 = n mensajes

Supongamos:

P1: a1 = [6, 5, 4]     (valores grandes, mal ubicados)
P2: a2 = [3, 2, 1]     (valores chicos, mal ubicados)

Proceso:
- P1 envía su mayor 6, P2 su menor 1
- Ambos comparan y detectan que los elementos están desordenados, por lo tanto empiezan a intercambiar valores de uno en uno.
Intercambios:
- 1. 6 ↔ 1
- 1. 5 ↔ 2
- 1. 4 ↔ 3

Cada par requiere 2 mensajes (ida y vuelta).

✅ Resultado:

Se hacen 3 intercambios
Se envían 6 mensajes (3 * 2)

📊 Resumen final:

| Caso | Cantidad de mensajes | Explicación breve | |-------------|----------------------|---------------------------------------------------------| | Mejor caso | 2 | Solo se comparan los extremos, no se intercambia nada | | Peor caso | n | Se intercambian todos los valores (n/2 * 2 = n) |

3. Utilice la idea de 1), extienda la solución a K procesos, con n/k valores c/u (“odd-even-exchange sort”).

Asumimos que existen n procesos P[1:n] y que n es par. Cada proceso ejecuta una serie de rondas. En las rondas impares, los procesos impares P[odd] intercambian valores con el siguiente proceso impar P[odd+1] si el valor esta fuera de orden. En rondas pares, los procesos pares P[even] intercambia valores con el siguiente proceso par P[even+1] si los valores estan fuera de orden. P[1] y P[n] no hacen nada en las rondas pares.

process Proc[i = 1..k] {
    int a[1..n/k];        // subarreglo local ordenado
    int dato;
    const min = 1;
    const max = n/k;

    ordenar_localmente(a);  // ordenar el arreglo local al iniciar

    for ronda = 1 to k {

        // Si la ronda y el índice tienen la misma paridad: proceso actúa como EMISOR
        if (i mod 2 == ronda mod 2 and i < k) {
            // Enviar el mayor valor local al vecino derecho
            send(proc[i+1], a[max]);
            receive(proc[i+1], dato);

            while (a[max] > dato) {
                // Insertar el dato recibido ordenadamente en 'a', descartando el mayor
                insertar_en_orden(a, dato);
                send(proc[i+1], a[max]);
                receive(proc[i+1], dato);
            }
        }

        // Si la ronda y el índice tienen distinta paridad: proceso actúa como RECEPTOR
        if (i mod 2 != ronda mod 2 and i > 1) {
            receive(proc[i-1], dato);
            send(proc[i-1], a[min]);

            while (a[min] < dato) {
                // Insertar el dato recibido ordenadamente en 'a', descartando el menor
                insertar_en_orden(a, dato);
                receive(proc[i-1], dato);
                send(proc[i-1], a[min]);
            }
        }
    }
}

Lo de abajo no hace falta pero es para probar

Con k = 4 procesos y n = 8 valores, llevando las rondas hasta que los valores queden totalmente ordenados globalmente.

Configuración inicial

Cada proceso tiene 2 elementos (n/k = 2), ordenados localmente:

| Proceso | Valores iniciales | |---------|-------------------| | P1 | [8, 9] | | P2 | [5, 7] | | P3 | [3, 6] | | P4 | [1, 4] |

Rondas del algoritmo (hasta que esté ordenado)

| Ronda | Procesos activos | Cambios realizados | Estado final por proceso | |-------|------------------|------------------------------------------------------------------------------------------------------------|---------------------------------------------------| | 0 | — | — | P1: [8, 9], P2: [5, 7], P3: [3, 6], P4: [1, 4] | | 1 | P1↔P2, P3↔P4 | P1⇄P2: 9⇄5 → P1: [5, 8], P2: [7, 9]P3⇄P4: 6⇄1 → P3: [1, 3], P4: [4, 6] | P1: [5, 8], P2: [7, 9], P3: [1, 3], P4: [4, 6] | | 2 | P2↔P3 | 9⇄1 → P2: [1, 7], P3: [3, 9] | P1: [5, 8], P2: [1, 7], P3: [3, 9], P4: [4, 6] | | 3 | P1↔P2, P3↔P4 | 8⇄1 → P1: [1, 5], P2: [7, 8]; 9⇄4 → P3: [3, 4], P4: [6, 9] | P1: [1, 5], P2: [7, 8], P3: [3, 4], P4: [6, 9] | | 4 | P2↔P3 | 8⇄3 → P2: [3, 7], P3: [4, 8] | P1: [1, 5], P2: [3, 7], P3: [4, 8], P4: [6, 9] | | 5 | P1↔P2, P3↔P4 | 5⇄3 → P1: [1, 3], P2: [5, 7]; 8⇄6 → P3: [4, 6], P4: [8, 9] | P1: [1, 3], P2: [5, 7], P3: [4, 6], P4: [8, 9] | | 6 | P2↔P3 | 7⇄4 → P2: [4, 5], P3: [6, 7] | P1: [1, 3], P2: [4, 5], P3: [6, 7], P4: [8, 9] | | 7 | P1↔P2, P3↔P4 | No intercambios necesarios (valores ya ordenados) | P1: [1, 3], P2: [4, 5], P3: [6, 7], P4: [8, 9] |

P1: [1, 3]
P2: [4, 5]
P3: [6, 7]
P4: [8, 9]
→ Resultado final: [1, 3, 4, 5, 6, 7, 8, 9]

El arreglo quedó completamente ordenado tras 7 rondas, que coincide con el peor caso esperado (hasta k rondas).

b. ¿Cuántos mensajes intercambian en 3) en el mejor caso? ¿Y en el peor de los casos?

Si cada proceso ejecuta suficientes rondas para garantizar que la lista estará ordenada (en general, al menos k rondas), en el k-proceso, cada uno intercambia hasta (n/k)+1 mensajes por ronda. El algoritmo requiere hasta k^2 * (n/k+1).

Se puede usar un proceso coordinador al cual todos los procesos le envían en cada ronda si realizaron algún cambio o no.

Si al recibir todos los mensajes el coordinador detecta que ninguno cambio nada les comunica que terminaron.

Esto agrega overhead de mensajes ya que se envían mensajes al coordinador y desde el coordinador. Con n procesos tenemos un overhead de 2*k mensajes en cada ronda.

Nota: Utilice un mecanismo de pasaje de mensajes, justifique la elección del mismo.

PMS es más adecuado en este caso porque los procesos deben sincronizar de a pares en cada ronda por lo que PMA no sería tan útil para la resolución de este problema ya que se necesitaría implementar una barrera simétrica para sincronizar los procesos de cada etapa.

6) Problema de ordenar de menor a mayor 2

Suponga los siguientes métodos de ordenación de menor a mayor para n valores (n par y potencia de 2), utilizando pasaje de mensajes:

1) Un pipeline de filtros. El primero hace input de los valores de a uno por vez, mantiene el mínimo y le pasa los otros al siguiente. Cada filtro hace lo mismo: recibe un stream de valores desde el predecesor, mantiene el más chico y pasa los otros al sucesor.
2) Una red de procesos filtro (como la de la figura).
3) Odd/even exchange sort. Hay n procesos P[1:n], Cada uno ejecuta una serie de rondas. En las rondas “impares”, los procesos con número impar P[impar] intercambian valores con P[impar+1]. En las rondas “pares”, los procesos con número par P[par] intercambian valores con P[par+1] (P[1] y P[n] no hacen nada en las rondas “pares”). En cada caso, si los números están desordenados actualizan su valor con el recibido.

Asuma que cada proceso tiene almacenamiento local sólo para dos valores (el próximo y el mantenido hasta ese momento).

a) ¿Cuántos procesos son necesarios en 1 y 2? Justifique.

Para la alternativa del pipeline de filtros, se requieren n procesos, ya que cada uno actúa como un filtro que retiene el valor mínimo recibido hasta el momento y envía los valores mayores al siguiente. Como se desea ordenar n elementos y cada proceso retiene uno, se necesitan n procesos para que todos los valores queden almacenados, uno en cada proceso, en orden ascendente.

En cambio, para la alternativa de la red de procesos filtro (basada en una estructura de árbol binario), se necesitan n - 1 procesos. Esto se debe a que los valores iniciales están en las hojas del árbol (hay n hojas), y los nodos internos se encargan de ir fusionando pares de valores o secuencias. En un árbol binario completo con n hojas, hay exactamente n - 1 nodos internos. Por lo tanto, se requieren n - 1 procesos de merge para combinar todos los valores en una única secuencia ordenada.

Perfecto, Fabián. A continuación te doy un ejemplo para cada alternativa (pipeline de filtros y red de merges) con n = 4 valores (potencia de 2) y su tabla de ejecución correspondiente para que visualices cómo se comportan ambos métodos.

📌 Ejemplo 1: Pipeline de filtros

Idea: Cada proceso filtra el mínimo de los valores que recibe y pasa el resto al siguiente.

Valores iniciales: 6, 2, 8, 4 (se envían en ese orden)

Estructura:

Entrada → P1 → P2 → P3 → P4

Tabla de ejecución

| Paso | Valor recibido | P1 | P2 | P3 | P4 | |------|----------------|----------|----------|----------|----------| | 1 | 6 | 6 | — | — | — | | 2 | 2 | 2 (↓6) | 6 | — | — | | 3 | 8 | 2 (↓8) | 6 (↓8) | 8 | — | | 4 | 4 | 2 (↓4) | 4 (↓6) | 6 (↓8) | 8 |

Resultado final:
P1: 2
P2: 4
P3: 6
P4: 8
→ [2, 4, 6, 8] (ordenado)

Procesos necesarios: 4 (uno por cada valor)

📌 Ejemplo 2: Red de merges (filtros)

Idea: Se usan procesos que combinan pares de valores en orden. Cada proceso mergea dos entradas ordenadas y produce una salida ordenada.

Valores iniciales (en hojas):
Entrada a M1: 6 y 2
Entrada a M2: 8 y 4

Estructura:

Nivel 0:      6     2       8     4
               \   /         \   /
Nivel 1:         M1           M2
                  \         /
Nivel 2:             M3

Tabla de ejecución

| Merge | Entrada izq | Entrada der | Salida ordenada | |-------|-------------|-------------|------------------| | M1 | 6 | 2 | [2, 6] | | M2 | 8 | 4 | [4, 8] | | M3 | [2, 6] | [4, 8] | [2, 4, 6, 8] |

Procesos necesarios:

3 merges → n − 1 = 3 procesos

📋 Comparación en tabla

| Método | Valores iniciales | Nº de procesos | Resultado final | Observaciones | |----------------------|-------------------|----------------|---------------------|---------------------------------------------| | Pipeline de filtros | 6, 2, 8, 4 | 4 | [2, 4, 6, 8] | Cada proceso retiene uno; paso a paso | | Red de merges | 6, 2, 8, 4 | 3 | [2, 4, 6, 8] | Requiere mergear en árbol binario completo |

b) ¿Cuántos mensajes envía cada algoritmo para ordenar los valores? Justifique.

📌 Pipeline

A cada proceso se le asigna un número del 1 al n, y los valores se envían uno por uno al primer proceso.

El proceso 1 recibe n valores, se queda con el menor y envía n−1 al proceso 2.
El proceso 2 recibe n−1 valores, se queda con el menor y envía n−2 al proceso 3.
...
El proceso n recibe 1 valor y no envía ninguno.

La cantidad total de mensajes enviados entre procesos es:

A esto se le suman n mensajes EOS (End Of Stream), ya que cada proceso necesita saber cuándo detenerse. Por lo tanto:

📌 Red de procesos filtro (merge tree)

En este caso, con n valores a ordenar y una red de log₂(n) niveles, la cantidad de mensajes de combinación es:

Esto incluye las comparaciones y fusiones realizadas en cada nivel del árbol.

Además, se deben sumar:

n mensajes para enviar los valores desde los nodos hoja (datos iniciales).
n − 1 mensajes EOS desde los nodos internos al superior para finalizar.

📌 Odd/Even Exchange Sort

Si cada proceso ejecuta suficientes rondas para garantizar el orden (en general, hasta k rondas con k procesos), entonces en cada ronda cada proceso intercambia hasta:

Cada intercambio requiere dos mensajes (ida y vuelta), y se repite durante k rondas, así que el total de mensajes es:

Resumen de todos los resultados

En el Pipeline, cada proceso filtra y pasa el resto, por lo que la cantidad de mensajes crece cuadráticamente.
En la Red de filtros (árbol de merges), el ordenamiento sigue una estructura logarítmica. Muy eficiente para merges en paralelo.
En el Odd/Even, el ordenamiento depende de la cantidad de rondas (k), y aunque es simple de implementar, puede requerir muchos mensajes si los datos están muy desordenados.

c) ¿En cada caso, cuáles mensajes pueden ser enviados en paralelo (asumiendo que existe el hardware apropiado) y cuáles son enviados secuencialmente? Justifique.

Pipeline de filtros:
Una vez que el pipeline está lleno, es posible enviar mensajes en paralelo entre todos los procesos del pipeline. Cada proceso está recibiendo, procesando y enviando valores simultáneamente. Por lo tanto, en un instante dado, pueden enviarse en paralelo hasta n mensajes (uno por cada proceso). Al inicio y al final, el envío es más secuencial, pero en régimen estable, el flujo es completamente paralelo.
Red de procesos filtro (merge tree):
En esta estructura, los mensajes pueden enviarse en paralelo a nivel de cada capa del árbol. Cada proceso del mismo nivel actúa de forma independiente, por lo que se pueden enviar hasta n / 2, n / 4, ..., 1 mensajes en paralelo según el nivel. El envío entre niveles debe ser secuencial (los procesos de un nivel deben esperar los resultados del anterior).
Odd/Even Exchange Sort:
En cada ronda (par o impar), todos los procesos que participan pueden enviar mensajes en paralelo. Por ejemplo, en una ronda impar, todos los procesos con índice impar se comunican simultáneamente con sus vecinos. Por lo tanto, en cada ronda puede haber hasta n/2 mensajes en paralelo.

📋 Comparación: Paralelismo en el envío de mensajes

| Método | Paralelismo posible | Secuencialidad obligatoria | Observaciones clave | |--------------------------|--------------------------------------------|--------------------------------------------------|----------------------------------------------------------------------| | Pipeline de filtros | Hasta n mensajes por instante (una vez lleno) | Inicio (pipeline vacío) y último paso | Cada proceso recibe, filtra y reenvía simultáneamente | | Red de merges (filtros) | Hasta n / 2, n / 4, ..., 1 por nivel del árbol | Entre niveles del árbol | Dentro de un mismo nivel: procesos trabajan en paralelo | | Odd/Even Exchange Sort | Hasta n / 2 mensajes por ronda | Rondas ejecutadas secuencialmente | En cada ronda, procesos con mismo tipo (par/impar) se comunican |

d) ¿Cuál es el tiempo total de ejecución de cada algoritmo? Asuma que cada operación de comparación o de envío de mensaje toma 1 una unidad de tiempo. Justifique.

📌 Algoritmo 1: Pipeline de filtros

Cada mensaje enviado implica una comparación y luego el envío (2 unidades de tiempo).

En el punto (a) se determinó que se envían

Por lo tanto, el tiempo total es:

Entonces:

📌 Algoritmo 2: Red de procesos filtro (árbol de merges)

Cada mensaje también implica 1 comparación y 1 envío → 2 unidades por mensaje.

Ya vimos que se envían

Entonces:

📌 Algoritmo 3: Odd/Even Exchange Sort

En cada ronda, cada proceso:
- Hace una comparación (1)
- Envía un mensaje (1)
- Recibe un mensaje (1)
- Asigna/intercambia valores (1)
  → Total = 4 unidades por proceso por ronda
En el peor caso, se necesitan hasta n rondas.
Entonces:

Acomodando la tabla final

7) Suponga que un proceso productor y `n` procesos consumidores

(Broadcast atómico). Suponga que un proceso productor y n procesos consumidores comparten un buffer unitario. El productor deposita mensajes en el buffer y los consumidores los retiran. Cada mensaje depositado por el productor tiene que ser retirado por los n consumidores antes de que el productor pueda depositar otro mensaje en el buffer.

sem depositar := 1;
sem retirar := 1;
sem consumi[n] := ([n] 0);
int cant_consumido := ([n] 0);
T buffer;

process productor {
    while (true) {
        P(depositar);
        buffer := generarDato();     // Devuelve un entero para el buffer
        cant_consumido := 0;
        for i to n do
            V(consumi[i]);
    }
}

process consumidor[i = 1..n] {
    T dato;
    while (true) {
        P(consumi[i]);              // Espero que el dato esté en el buffer
        P(retirar);                 // Espero para tener acceso al buffer
        dato := buffer;
        cant_consumido++;
        if (cant_consumido == n)
            V(depositar);
        V(retirar);
    }
}

🎯 Objetivo

El productor debe generar un dato y colocarlo en un buffer compartido.
Cada consumidor debe leer ese dato una única vez.
Solo cuando todos lo hayan leído, el productor podrá colocar un nuevo dato.

🧩 Supuestos para el ejemplo

Hay n = 2 consumidores: C1 y C2
El buffer inicialmente está vacío
El productor genera números enteros: 1, 2, 3, etc.

🔄 Ejecución paso a paso

🔹 Estado inicial

| Variable | Valor inicial | |------------------|---------------| | depositar | 1 | | retirar | 1 | | consumi[1] | 0 | | consumi[2] | 0 | | cant_consumido | 0 | | buffer | vacío |

⏱ Paso 1: El productor genera un dato

P(depositar) → pasa (vale 1)
buffer := generarDato() → 1
cant_consumido := 0
V(consumi[1]) → consumi[1] = 1
V(consumi[2]) → consumi[2] = 1

🔁 El productor queda esperando a que los 2 consumidores consuman antes de generar otro dato.

⏱ Paso 2: El consumidor 1 consume

P(consumi[1]) → pasa
P(retirar) → pasa (vale 1)
dato := buffer = 1
cant_consumido := 1
cant_consumido != n → no hace nada
V(retirar) → retirar = 1

⏱ Paso 3: El consumidor 2 consume

P(consumi[2]) → pasa
P(retirar) → pasa
dato := buffer = 1
cant_consumido := 2
cant_consumido == n → entonces V(depositar) → ahora el productor puede seguir
V(retirar)

⏱ Paso 4: El productor continúa

P(depositar) → pasa (porque fue liberado)
buffer := 2
cant_consumido := 0
V(consumi[1]), V(consumi[2]) → y sigue el ciclo

✅ Garantías del algoritmo

| Propiedad | Cumple | |-----------------------------|--------| | Exclusión mutua en acceso | ✅ | | Cada consumidor lee una vez | ✅ | | Productor espera a todos | ✅ | | No hay pérdida de datos | ✅ |

b) Suponga que el buffer tiene b slots. El productor puede depositar mensaje sólo en slots vacíos y cada mensaje tiene que ser recibido por los n consumidores antes de que el slot pueda ser reusado. Además, cada consumidor debe recibir los mensajes en el orden en que fueron depositados (note que los distintos consumidores pueden recibir los mensajes en distintos momentos siempre que los reciban en orden).

Extienda la respuesta dada en a) para resolver este problema más general.

sem retirar[tamBuffer] := 1;              // semáforo para cada slot del buffer
sem consumir[n] := ([n] 0);
int cant_consumido[tamBuffer] := ([n] 0);
T buffer[tamBuffer];

process productor {
    int posLibre := 0;                   // Siguiente posición libre del buffer (productor)
    while(true){
        P(depositar);
        buffer[posLibre] := generarDato();     // Devuelve dato tipo T para el buffer
        cant_consumido[posLibre] := 0;
        for i to n do
            V(consumir[i]);
        posLibre := (posLibre + 1) mod n;
    }
}

process consumidor[i: 1..n] {
    int post_actual := 0;               // Slot del que debe consumir
    T dato;
    while(true){
        P(consumir[i]);
        P(retirar[post_actual]);        // Espera por un slot en particular
        dato := buffer[post_actual]; // El acceso de esta manera no se encuentra en la imagen pero supongo que esta bien
        cant_consumido[post_actual]++;
        if (cant_consumido[post_actual] == n)
            V(depositar);
        V(retirar[post_actual]);
        post_actual := (post_actual + 1) mod n;
    }
}

🧩 Supuestos del ejemplo

tamBuffer = 2 → hay dos slots: buffer[0] y buffer[1]
n = 2 → hay dos consumidores: C1 y C2
buffer[i] contiene datos generados por el productor
Cada dato debe ser consumido por ambos consumidores antes de poder sobrescribir el slot
Los consumidores deben leer los datos en orden

🔁 Estado inicial

| Variable / Recurso | Valor inicial | |----------------------------|----------------------| | buffer | [_, _] | | cant_consumido[0] | 0 | | cant_consumido[1] | 0 | | retirar[0], retirar[1] | 1 | | consumir[1], consumir[2] | 0 (esperando dato) | | posLibre (productor) | 0 | | post_actual (consumidores)| 0 |

⏱ Paso 1: El productor genera el primer dato

P(depositar) → OK
buffer[0] := generarDato() → 10
cant_consumido[0] := 0
V(consumir[1]), V(consumir[2])
posLibre := 1 (próximo slot)

⏱ Paso 2: Ambos consumidores empiezan a consumir buffer[0] (dato 10)

Consumer 1:

P(consumir[1])
P(retirar[0]) → OK
dato := buffer[0] → 10
cant_consumido[0] := 1
V(retirar[0]) (libera acceso al slot)
post_actual := 1

Consumer 2:

P(consumir[2])
P(retirar[0]) → OK
dato := buffer[0] → 10
cant_consumido[0] := 2
cant_consumido[0] == n → V(depositar) → libera al productor
V(retirar[0])
post_actual := 1

⏱ Paso 3: El productor genera el segundo dato

P(depositar) → OK (fue liberado)
buffer[1] := generarDato() → 20
cant_consumido[1] := 0
V(consumir[1]), V(consumir[2])
posLibre := 0

⏱ Paso 4: Ambos consumidores consumen buffer[1] (dato 20)

Consumer 1:

P(consumir[1])
P(retirar[1])
dato := buffer[1] → 20
cant_consumido[1] := 1
V(retirar[1])
post_actual := 0

Consumer 2:

P(consumir[2])
P(retirar[1])
dato := buffer[1] → 20
cant_consumido[1] := 2
V(depositar) (productor puede continuar)
V(retirar[1])
post_actual := 0

🔁 Y así continúa el ciclo...

✅ Propiedades garantizadas

| Propiedad | ¿Cumple? | |----------------------------------------|----------| | Exclusión mutua en el buffer por slot | ✅ | | Orden de consumo por slot | ✅ | | Reutilización del slot solo tras n lecturas | ✅ | | Independencia de tiempo entre consumidores | ✅ | | Fairness (todos acceden eventualmente) | ✅ |

8) Implemente una butterfly barrier para 8 procesos

Implemente una butterfly barrier para 8 procesos usando variables compartidas.

Una butterfly barrier tiene log2(n) etapas.
Cada Worker sincroniza con un Worker distinto en cada etapa.
En particular, en la etapa s un Worker sincroniza con un Worker a distancia 2^(s-1).

Se usan distintas variables flag para cada barrera de dos procesos.

Cuando cada Worker pasó a través de log2(n) etapas, todos los Workers deben haber arribado a la barrera y por lo tanto todos pueden seguir.
Esto es porque cada Worker ha sincronizado directa o indirectamente con cada uno de los otros.

Diagrama (sincronizaciones por etapa)

Workers     1   2   3   4   5   6   7   8

Etapa 1     └───┘   └───┘   └───┘   └───┘

Etapa 2     └─────────┘   └─────────┘

Etapa 3     └───────────────────────┘

Codigo

int N = 8;
int E = log(N);
int arribo[1:N] = ([N] 0);

process Worker[i = 1 to N] {
    int j;
    int resto;
    int distancia;

    while (true) {
        // Sección de código anterior a la barrera.

        // --- Inicio de la barrera butterfly ---
        for (etapa = 1; etapa <= E; etapa++) {
            distancia = 2 ^ (etapa - 1);           // distancia = 2^(etapa-1)
            resto = i mod 2 ^ etapa;

            if (resto == 0 || resto > distancia)   // define si sincroniza con i+dist o i-dist
                distancia = -distancia;

            j = i + distancia;

            while (arribo[i] == 1) skip;           // espera a que su flag esté en 0
            arribo[i] = 1;                         // indica que llegó

            while (arribo[j] == 0) skip;           // espera a su par
            arribo[j] = 0;                         // limpia la flag del otro
        }
        // --- Fin de la barrera butterfly ---

        // Sección de código posterior a la barrera.
    }
}

Este no me quedo del todo claro pero bueno

9) Suponga `n^2` procesos organizados en forma de grilla cuadrada

Suponga n^2 procesos organizados en forma de grilla cuadrada. Cada proceso puede comunicarse solo con los vecinos izquierdo, derecho, de arriba y de abajo (los procesos de las esquinas tienen solo 2 vecinos, y los otros en los bordes de la grilla tienen 3 vecinos). Cada proceso tiene inicialmente un valor local v.

a) Escriba un algoritmo heartbeat que calcule el máximo y el mínimo de los n2 valores. Al terminar el programa, cada proceso debe conocer ambos valores. (Nota: no es necesario que el algoritmo esté optimizado).

Chan valores[1:n; 1:n](int);

Process P[i = 1 to n, j = 1 to n] {
    Int v;
    Int Nuevo, minimo = v, maximo = v;
    Int cantVecinos;
    Vecinos[1..cantVecinos];

    For (k = 1 to cantGeneraciones) {
        For (p = 1 to cantVecinos) {
            Send valores[vecinos[p].fila, vecinos[p].columna](v);
        }

        For (p = 1 to cantVecinos) {
            Receive valores[i, j](nuevo);
            if (nuevo < minimo)
                minimo = nuevo;
            if (nuevo > maximo)
                maximo = nuevo;
        }
    }
}

🎯 Supongamos 3 procesos: A, B, C

A --- B --- C

A tiene valor 5
B tiene valor 2
C tiene valor 8

Cada uno está conectado con sus vecinos inmediatos.

🧪 Generación 1: Intercambio de valores

1. A envía 5 a B
1. B envía 2 a A y C
1. C envía 8 a B

     [5]        [2]        [8]
      A  <-->   B   <-->   C

🔍 ¿Qué recibe cada uno?

| Proceso | Recibe de | Valores recibidos | Nuevo mínimo | Nuevo máximo | |---------|-----------|-------------------|---------------|---------------| | A | B | [2] | 2 | 5 | | B | A, C | [5, 8] | 2 | 8 | | C | B | [2] | 2 | 8 |

✅ Resultado final (después de 1 ronda)

A: mínimo = 2, máximo = 5  
B: mínimo = 2, máximo = 8  
C: mínimo = 2, máximo = 8

Si hacemos otra ronda, A también recibirá el 8 (a través de B), y entonces todos tendrán:

mínimo = 2, máximo = 8

📌 Esto mismo pasa en grillas grandes: con varias generaciones, los valores extremos se difunden.

b) Analice la solución desde el punto de vista del número de mensajes.

En cada ronda, los procesos envían mensajes a sus vecinos. Dependiendo de su posición en la grilla, cada proceso tiene distinta cantidad de vecinos:

🔹 Esquinas (4 procesos)

Cada uno tiene 2 vecinos → envía 2 mensajes por ronda

Total por todas las rondas:

4 procesos * 2 mensajes * (n-1) rondas * 2 (envío y recepción)  
= 4 * 2 * (n - 1) * 2  
= (n - 1) * 16 mensajes

🔹 Bordes (sin esquinas) → hay 4 lados con (n - 2) procesos cada uno

Cada uno tiene 3 vecinos → envía 3 mensajes por ronda

Total:

(n - 2) * 4 procesos * 3 mensajes * (n - 1) rondas * 2  
= (n - 2) * 4 * 3 * (n - 1) * 2  
= (n - 1)(n - 2) * 12 mensajes

🔹 Internos → (n - 2) × (n - 2) procesos

Cada uno tiene 4 vecinos → envía 4 mensajes por ronda

Total:

(n - 2)^2 * 4 mensajes * (n - 1) rondas * 2  
= (n - 2)^2 * (n - 1) * 8 mensajes

Este punto se podria mejorar

c) ¿Puede realizar alguna mejora para reducir el número de mensajes?

No, no es posible reducir el número de mensajes, ya que no existe una forma de saber con certeza cuándo un proceso ha recibido el valor mínimo o máximo global.
Por lo tanto, para garantizar que todos los procesos lleguen a conocer los valores extremos, es necesario ejecutar las (n - 1) × 2 generaciones completas.

Voy a rezar por que no tomen esta wea

Preguntas Teoricas Comunes

Pregunta 1 Ventajas y Desventajas

3- Defina los paradigmas de interacción entre procesos distribuidos token passing, servidores replicados y prueba-eco. Marque ventajas y desventajas en cada uno de ellos cuando se utiliza comunicación por mensajes sincrónicos o asincrónicos.

Es un esquema donde un mensaje especial (token) circula entre los procesos. Solo el que tiene el token puede ejecutar una acción crítica, como entrar a la sección crítica o tomar decisiones.

Ejemplo: exclusión mutua distribuida, detección de terminación.

Ventajas: simple de implementar, no necesita reloj ni identificadores globales, funciona bien en topologías como anillo.

Desventajas: si se pierde el token el sistema se bloquea; no hay paralelismo (solo trabaja quien tiene el token); puede haber demoras innecesarias.

Mejor comunicación: asincrónica, porque permite circulación sin bloqueo. Se adapta bien a arquitecturas de memoria distribuida (AMP).

Varios procesos replican un recurso compartido (archivo, base de datos) para brindar alta disponibilidad y tolerancia a fallos. A los clientes les parece que hay un único servidor.

Ejemplo: mozos en el problema de los filósofos, sistemas de archivos distribuidos.

Ventajas: mayor disponibilidad, tolerancia a fallos, mejora el rendimiento si se balancean bien los pedidos.

Desventajas: mantener la consistencia entre réplicas es complejo; puede haber conflictos si dos servidores procesan escrituras en paralelo.

Mejor comunicación: asincrónica (evita bloquear al cliente), ideal en AMP. En SMP es más difícil porque hay que mantener varios canales y controlarlos.

Un nodo envía mensajes “probe” a sus vecinos; cuando todos responden con “eco”, el emisor sabe que se llegó a todos. Sirve para explorar redes desconocidas o detectar nodos activos.

Ejemplo: descubrimiento de topología en redes móviles o dinámicas.

Ventajas: útil sin conocer la red; robusto frente a cambios; permite diseminar o recolectar información.

Desventajas: puede generar muchos mensajes; necesita control para evitar ciclos o duplicación.

Mejor comunicación: asincrónica, ideal en AMP por su descentralización y tolerancia a variaciones en la red.

Finales

Final de Arquitectura de Computadoras

Thu, 06 Feb 2025 00:00:00 GMT

Clases

Link de donde me mire todas las clases Drive

Esto ya es lo ultimo para el final (Me queda este y el de concurrente y termino el Analista Programador Universitario). A meterle!!!

@carolina

Parametros e Interrupciones

Via registros:

Para pasar los parametros se usan los registros del procesador. Su principal limitación son los registros disponibles, es importante documentar cuales son los registros que estamos usando para evitar conflictos

Via Memoria

Los parametros se almacenan en un area difinida en la memoria RAM, es util cuando se deben pasar grandes cantidades de datos, pero es dificil de estandarizar.

Via PILA/STACK

Los parametros se colocan en la pila. Es el metodo mas utilizado, no depende ni de la memoria ni de los registros, hay que saber bien como utilizarlo ya que la pila es usada tanto por el sistema como por los programas del usuario.

Tambien puede tocar la siguiente pregunta: Explique los métodos de pasaje de argumentos a procedimientos o funciones.

Las interrupciones multiples es cuando se reciben varias interrupciones al mismo tiempo. Son 3 caracteristicas

Prioridad de interrupciones:

Las interrupciones suelen tener una prioridad. Esto permite que el sistema decidir cual interrupcion debe manejar primero en caso de que ocurran multiples interrupciones.

Mascara de Interrupciones:

Algunos sistemas permiten desactivar temporalmente interrupciones (GENERALMENTE LAS DE MENOR PRIORIDAD) Utilizando las mascaras de interrupciones, esto ayuda a que las interrupciones de mayor prioridad no sean interrumpidad con las de mayor prioridad.

Gerarquia de interrupciones: Enmascarables y no Enmascarables, Enmascarables pueden ser ignoradas (de baja prioridad) y las no Enmascarables no se pueden ignorar y son de alta prioridad

Nivel de anidación:

El sistema debe ser capa de manejar nivel de anidación. Si esta atendiendo una interrupcion y ocurre otra de mayor prioridad la interrupcion actual se suspende temporalmente, el sistema atiende la nueva interrupcion y al finalizar regresan para continuar con la interrupcion inicial.

Tratamiento: Se puede atender una interrupcion e inhabilitar a las demas con el uso de mascaras de interrupciones, de esta manera las interrupciones se maneja de forma secuencial. (Esto no me quedo claro 😕)
Tambien Es posible asignar prioridades a las interrupciones. Dependiendo del nivel de prioridad el sistema debe respetar su atención.
Si se esta manejado una interrupcion de menor prioridad y llega una de mayor prioridad se debe atender primero la de mayor prioridad. Una vez finalizada el procesador retoma la atención de la interrupcion previa.

1. Generar la interrupción: Un disposito del sistema detecta un evento que requiere atención, por lo que se genera una señal de interrupción.
1. Interrupcion del procesador: Cuando se genera una interrupción, el procesador suspende temporalmente su ejecución
1. Guardado de contexto: Antes de manejar la interrupción el procesador guarda el estado actual del programa en ejecución, el contador de programa, registros y otros datos relevantes.
1. Rutina de manejo de interrupciones: El controlador de interrupciones (PIC) determina cual es la interrupción y proporciona un puntero al procesador para buscar en la tabla de vectores la dirección en donde se encuentra la rutina de la interrupción.
1. Ejecución de la rutina de manejo: El procesador comienza a ejecutar la rutina de manejo de interrupcion que corresponde, una vez finalizada la rutina el control es devuelto al punto del programa en donde se detuvo inicialmente.
1. Restauración del estado/contexto: Despues de que se maneja la interrupción el procesador restaura el estado previo/guardado (Los registros y la dirección del programa (PC)), permitiendo que el programa restaure su estado original/inicial antes de que ocurra la interrupción.
1. Continuación de la ejecución: Con el contexto restaurado, el programa original continuo su ejecución en el punto en donde se interrumpio

Se genera una interrupción de un dispositivo externo o una señal de sofware, el pic recibe esa interrupción y la clasifica segun la prioridad que tenga, le avisa al procesador/CPU que hay una interrupción que tiene que se atendida, por la linea (IntR).
La CPU al finalizar la instrucción actual, responde al PIC que acepta la interrupción por la linea (INTA), Solicitando el puntero para acceder a la tabla de vectores.
El PIC le manda al puntero que corresponde a esa interrupción y la CPU lo usa para acceder a la tabla de interrupciones que tiene la dirección donde se encuentra la rutina de servicio de esa interrupción.
La CPU guarda su contexto actual (Contador de programa, registros, etc). Ejecuta la rutina del manejo de la interrupción y una vez finalizada, se le manda un señal al PIC de fin de interrupción (EOI) el PIC actualiza sus registros y puede anteder otras interrupciones.
La CPU restaura el contexto previo que tenia antes de anteder a la interrupcion y continua la ejecución

Formas de finalización

Subritina: finalizan con la instrucción de retorno RET
Gestor de interrupciones: Finaliza con la instrucción IRET

Contexto de finalización:

Subrutina: El contexto (Dirección de retorno, en algunos casos registros). Es gestionado por el programador y almacenado en la pila antes de la llamada a la subrutina. Al finalizar Se restaura manualmente desde la pila para volver al programa principal.
Gestión de interrupciones: El contexto completo del programa interrumpido (contador del programa, registros, etc) es automaticamente guardado y restaurado por el hardware al inicio y al final del gestor de interrupciones respectivamente.

Continuación del flujo de la interrupción:

Subrutina: Al retornar el programa principal continua su ejecución en la linea posterior a la instrucción de llamada.
El gestor de interrupciones: Una vez restaurado el contexto, la CPU reanuda automaticamente la ejecución del programa interrumpido desde el punto exacto en donde ocurrio la interrupción.

EOI: Fin de interrupción
IMR: Mascara de interrupciones, Permite habilitar o deshabilitar ciertas interrupciones
IRR: Petición de interrupción, identifica que interrupción tiene una solicitud de petición para ser antendida.
ISR: Interrupción de servicio, indica cual es la interrupción que esta siendo atendida.
INT0..INT7: Registros relacionados con el vector de interrupciones

Tema Segmentación de Cause

Es la forma de organizar el hardware de la CPU para realizar mas de una operacion al mismo tiempo. Divide el proceso de ejecución de las instrucciones en etapas, permitiendo que se ejecuten de manera simultanea.

El rendimiento es la mejora de eficiencia del procesador al ejecutar varias interrupciones al mismo tiempo, dividiendo el proceso en varias etapas. Cada etapa trabaja en una parte diferente de una instrucción, lo que permite que varias instrucción se ejecuten de manera concurrente. Esto reduce el nro de ciclos de reloj necesarios para ejecutar instrucciones y aumentar el rendimiento.

Sin enbargo existen riesgos como la dependencia de datos o saltos condicionales que pueden interrumpir el flujo y reducir la eficiencia. El rendimiento mejora cuando el procesador maneja bien estos riesgos, pudiendo manejar mas interrupciones en menos tiempo.

Se podria consultar

Problema: Los riesgos por transferencia de control ocurren cuando el flujo del programa se ve alterado por las instrucciones de salto (Condicionales o incondicionales). Esto genera insertidumbre sobre que instrucción se tiene que seguir. Si ya se cargaron instrucciones incorrectas, debe descartarse lo que causa desperdicios de ciclos y penalización de rendimiento, Posibles soluciones:

Tecnicas de Software

Salto retardado: En la tecnica del salto retardado, el compilador reorganiza las instrucciones para que siempre alla algo que ejecutar despues del salto. Si no es posible agrega la instrucción NOP

Tecnicas de hardware

Detención del cause: Cuando se encuentra una interrupción de salto el procesador detiene temporalmente la ejecución hasta que se resuelva si se toma o no el salto. Esto evita que se ejecuten instrucciones incorrectas pero genera un retraso en el flujo de instrucciones

Adelantar la resolución de los saltos a la etapa de codificación. En la etapa de codificación se identifica si la instrucción corresponde a un salto, la condición del salto se evalua mediante un restador y la dirección de destino de salto se calcula usando un sumador. Esto se debe a la toma de desiciones sobre el flujo de ejecución.

Predicción de salto: El procesador intenta predecir si el salto sera tomado o no, para seguir ejecutando instrucciones mientras se confirma la condición del salto. Hay dos tipos de predicciones, estan las estaticas y las dinamicas

Estaticas: La predicción es fija, por ejemplo siempre se decide si se toman los saltos o no se toman
Dinamica: Se basa en el historial de ejecuciones anteriores de la misma instrucción de salto. Ejemplo: Tabla de historias de salto o buffer de destino (Branch Target Buffer)

1. Mejora el rendimiento: La ejecución en paralelo acelera la velocidad de la ejecución de las instrucciones.
1. Aprovechamiento de recurso: mientras una unidad de ejecución realiza una operación, las etapas anteriores y posteriores pueden estar ocupadas con otras instrucciones, permitiendo un uso mas completo de las unidades funcionales.
1. Mayor paralelismo: Como varias instrucciones se ejecutan al mismo tiempo, la segmentación de Causa aumenta el nivel de paralelismo a nivel de instrucciones en el procesador.
1. Reducción del ciclo de reloj por instrucción: Reduce el tiempo necesario para ejecutar una instrucción completa al dividirla en etapas mas pequeñas.
1. Mejora de la predicción de salto: Tecnica que usa el procesador para anticipar si una instrucción de salto condicional se va a tomar o no, antes de que se evalue dicha condición. Esto ayuda a que el procesador siga trabajando sin detenerse mientras espera esa respuesta, evitante retrasos en el flujo de ejecución del programa.

RAW: Una instrucción necesita leer que aun no ha sido escrita por una instrucción.
WAW: Dos instrucciones intantan escribir en el mismo lugar, pero deben hacerlo en orden distintos.
WAR: Una instrucción quiere escribir en un dato que otra esta leyendo.

1. Dependencia de datos: Cuando una instrucción depende del resultado de la instrucción anterior que todavia no ha completado su etapa de ejecución. Tipos: RAW, WAW, WAR
1. Dependencias Estructurales: Cuando dos o mas instrucciones compiten por el mismo recurso en una etapa especifica del cause.
1. Dependencia de Control (Saltos): Ocurre cuando hay instrucciones de salto y el procesador no sabe que instrucción ejecutar hasta que no termina de evaluar la condición de salto. Esto podria insterrumpir el flujo del cause porque el procesador debe esperar el resultado de la condición para poder seguir.

7.2) ¿Que retardo produce cada una?

NO SABEMOS QUE RETARDO EN CUANTO A TIMPO | SIN CONTESTAR

Taxonomia Flynn

Las 4 principales variantes de taxonomia flynn son:

1. SISD (Single Instruction Single Data): Una sola unidad de procesamiento que ejecuta una secuencia de instrucciones, opera sobre un unico conjunto de datos en cada ciclo de reloj
1. SIMD (Single Instruction Multiple Data) Una unica instrucción se aplica simultaneamente a multiples conjuntos de datos. Esto permite que varias unidades de procesamiento ejecutan la misma operación en paralelo sobre diferentes datos al mismo tiempo.
1. MISD (Multiple Instruction Single Data): Multiples secuencias de instrucciones se ejecutan en paralelo en un solo conjunto de datos.
1. MIMD (Multiple Instruction Multiple Data): Multiples unidades de procesamientos que ejecutan diferentes instrucciones sobre diferentes conjuntos de datos al mismo tiempo.

Los SMP se caracterizan por su arquitectura de memoria compartida, donde multiples procesadores comparten el mismo espacio de memoria y recursos, esto permite que todos los procesadores accedan a la memoria y a los recursos de manera igualitaria, la comunicación entre los procesadores es directa a traves de la memoria compartida, facilitando el intercambio de datos. La ventajas de los SMP es que son mas faciles de configurar, necesitan menos espacio fisico, necesitan menos energia y son plataformas estables y bien establecidas.

Los Cluster estan compuestos por nodos independietes interconectados por una red, cada uno tiene su memoria y recurso, la comunicación se comunica mediante la red lo que puede generar latencia. Los Cluster ofrecen escalabilidad horizontal al permitir añadir mas nodos para aumentar la capacidad de procesamiento.

MIMD: Multiples unidades de procesamientos que ejecutan diferentes instrucciones sobre diferentes conjuntos de datos al mismo tiempo. FIN

Procesadores super escalares y Super segmentado

1. Captación simultánea de múltiples instrucciones: Se buscan varias instrucciones al mismo tiempo para mejorar el rendimiento mediante el paralelismo.
2. Gestión de dependencias de datos: Se usan técnicas como el renombre de registros para evitar conflictos entre instrucciones que dependen de resultados previos.
3. Ejecución paralela de múltiples instrucciones: Se inician múltiples instrucciones a la vez, usando diferentes unidades funcionales para ejecutarlas simultáneamente.
4. Recursos adecuados para ejecución en paralelo: Tienen múltiples unidades de ejecución, para manejar múltiples instrucciones en paralelo.
5. Entrega de resultados en orden: Aunque las instrucciones se ejecutan fuera de orden, los resultados se entregan en el orden correcto para mantener la coherencia del programa.

Políticas:

1. Emisión y finalización en orden: Las instrucciones se emiten y ejecutan en el mismo orden en que aparecen en el programa. Si una instrucción no puede ejecutarse porque espera un operando, el procesador se detiene hasta que pueda continuar.
2. Emisión en orden y finalización desordenado: Las instrucciones se emiten en el mismo orden en que aparecen en el programa, pero pueden ejecutarse en cualquier orden si no tienen dependencias entre sí. Si una instrucción no puede ejecutarse aún, el procesador busca otras instrucciones posteriores que sí puedan ejecutarse antes, optimizando el uso de los recursos.
3. Emisión y Ejecución desordenada: El procesador puede emitir y ejecutar instrucciones en cualquier orden, garantizando que el resultado final sea el mismo que en una ejecución secuencial. Para evitar los problemas de dependencias, se usa la técnica de renombre de registros que evitar los conflictos con los registros intermedios.

ACA ELEGI UNA DE LAS 3 QUE MAS TE CONVENGA Y JUSTIFICALA (CHAT GPT :v )

1. Dependecia de datos verdadera: Cuando una instrucción necesita el resultado de una instrucción previa antes de poder ejecutarse.
1. Dependencia relativa del procesamiento: Se refiere a las restricciones impuestas por el orden en que se deben emitir y ejecutar las instrucciones en un procesador.
1. Conflicto en los recursos: Cuando múltiples instrucciones compiten por un mismo recurso al mismo tiempo.
1. Dependencia de salida: Cuando dos instrucciones intentan escribir en el mismo registro.
1. Antidependencia: Cuando una instrucción quiere escribir en un registro que todavía está siendo usada por otra instrucción previa.

Es resolver problemas de dependencia entre instrucciones que intentan usar los mismos registros. Esto permite una ejecucion más eficiente y paralela de instrucciones.

El paralelismo es la capacidad de un sistema para ejecutar múltiples operaciones al mismo tiempo, en lugar de procesarlas de manera secuencial.

El paralelismo de una maquina depende:

1. Numero de instrucciones captadas por ciclo: Cuantas más instrucciones se puedan decodificar y enviar al procesador en cada ciclo de reloj , mayor va a ser el aprovechamiento del paralelismo a nivel de instrucción.
1. Número de unidades funcionales: A mayor número de unidades funcionales logra que más instrucciones se procesen en paralelo, siempre que sean independientes entre sí.
1. Mecanismo de localización de instrucciones independientes: El procesador detecta las instrucciones que puedan ejecutarse en paralelo sin violar dependencias de datos o de control. Usando técnicas como el renombre de registros, predicción de saltos y la ejecución fuera de orden.

Memoria

Funciona gracias al principio de localidad de referencia basado en 2 tipos de acceso a memoria:

Localidad Temporal: hace referencia a que los elementos de memoria que fueron recientemente referenciados (como datos e instrucciones) se vuelvan a referenciar en el futuro cercano.
Localidad Espacial: hace referencia a que si un elemento de memoria fue referenciado, es probable que otros elementos cuyas direcciones están cercanas también sean referenciados.

Acierto

Escritura inmediata (write-through): Cada escritura en caché se refleja inmediatamente en la memoria principal, por lo que se mantiene la coherencia de datos en todo momento, suele combinarse con la técnica no-write-allocate.
Postescritura (write-back): Las actualizaciones se hacen en la cache y se marca un bit de “actualizar o sucio”. Cuando el bloque se saca de la cache se chequea ese bit si está activo, se escribe ese bloque en la memoria principal. Esto puede producir que la memoria principal tenga informacion errónea durante un tiempo. Suele combinarse con la técnica write-allocate.

Fallo

Write Allocate: la informacion se lleva de memoria principal a la cache y se sobrescribe sobre ella , por lo que se puede alterar la coherencia de datos hasta que haya un remplazo de memoria principal.
No write Allocate: El bloque no se lleva a la memoria cache ,se escribe directamente en memoria principal.

Tener varios niveles de caché (L1, L2, L3) mejora el rendimiento al reducir la latencia y aprovechar la localidad temporal y espacial, optimizando el acceso. Además, permite un balance entre capacidad y velocidad. Sin embargo, aumenta la complejidad del diseño, incrementa los costos y el consumo de energía, y requiere mecanismos de coherencia entre niveles que pueden afectar el rendimiento.

1. DIRECTA: cada bloque de la memoria principal se mapea a una única línea en la caché. la dirección de memoria se divide en 3 campos para determinar en qué línea de caché se almacena el bloque de datos correspondiente.
2. ASOCIATIVA: cada bloque de memoria principal puede cargarse en cualquier línea de la cache. La lógica del control de la cache interpreta una dirección de memoria como una etiqueta y un campo de palabras.
3. ASOCIATIVA POR CONJUNTO: la cache se divide en v conjuntos, cada uno con k líneas. La lógica de control de la cache interpreta una dirección de memoria como 3 campos: etiqueta, conjunto y palabra.

DIRECTA: cada bloque de la memoria principal se mapea a una única línea en la caché.
ASOCIATIVA: cada bloque de memoria principal puede cargarse en cualquier línea de la cache.
ASOCIATIVA POR CONJUNTO: Un bloque puede almacenarse en un conjunto restringido de la cache.

1.El tamaño de la cache

No se puede determinar un tamaño fijo optimo, pero a mayor tamaño se necesitas más circuitos para su gestión, las caches más grandes suelen ser un poco más lentas y su tamaño está limitado por el espacio disponible en el chip y las tarjetas.

2.Funcion de correspondencia

Define cómo se asignan los bloques de memoria en la caché.

DIRECTA: cada bloque puede ir solo a una línea especifica.
ASOCIATIVA: cualquier bloque puede ir a cualquier línea.
ASOCIATIVA POR CONJUNTO: los bloques se asignas a un conjunto de líneas específicas.

3.Algoritmo de sustitución

Decide qué bloque se reemplaza cuando la caché está llena.

LRU: se remplaza el bloque menos usado recientemente.
LFU: se remplaza el bloque menos accedido.
FIFO: se remplaza el bloque más antiguo.
ALEATORIA: Se reemplaza un bloque al azar.

4.Politica de escritura

Cuando se debe reemplazar un bloque de la caché, si se ha realizado algún cambio en una línea de caché, es necesario escribir esos datos modificados en la memoria principal antes de hacer el reemplazo.

Escritura inmediata: Cada escritura en caché se refleja inmediatamente en la memoria principal.
Postescritura: Las actualizaciones se hacen en la cache y luego se sobrescriben en la memoria principal cuando el bloque se remplaza.

5.Tamaño de línea: Define cuántas palabras o bytes conforman un bloque en la caché.

A Líneas más grandes se reducen la cantidad de accesos a la memoria principal, pero pueden generar desperdicio de almacenamiento si los datos no se utilizan completamente.

6.Numero de caches

El diseño de caché en un sistema de cómputo puede abordarse desde dos perspectivas:'

1.Número de niveles de caché (caché multinivel vs. caché de un solo nivel)

Caché de un solo nivel (L1 única):Es la primera y única caché entre el procesador y la memoria principal. Su acceso es rápido, pero si la información no está en caché, se debe ir directamente a la RAM, aumentando la latencia.
Caché multinivel (L1, L2, L3): Divide la caché en varios niveles, cada uno con diferentes tamaños y velocidades.
- L1: Más rápida pero pequeña (cercana al procesador).
- L2: Más grande que L1, pero más lenta.
- L3: Mayor capacidad, compartida entre núcleos del procesador en muchos casos. Reduce la cantidad de accesos a la memoria RAM, mejorando el rendimiento.

2.Organización de la caché (unificada vs. separada):

Caché unificada: Almacena tanto instrucciones como datos en una única caché.
Cache separada: Se divide en caché de instrucciones y caché de datos. Evita conflictos cuando el procesador necesita acceder a instrucciones y datos simultáneamente. Mejora el rendimiento en procesadores con segmentación de instrucciones.

Para mejorar el tiempo de acceso medio en la memoria caché, es necesario optimizar los siguientes parámetros:

1.Tamaño de la caché: Aumentarlo puede reducir fallos, pero si es demasiado grande, puede volverse más lenta. Se debe encontrar un equilibrio.
2.Función de correspondencia: Usar asociatividad por conjuntos en lugar de mapeo directo reduce colisiones y mejora la tasa de aciertos.
3.Tamaño de bloque: Un tamaño adecuado minimiza reemplazos innecesarios y mejora la localidad espacial.
4.Algoritmo de reemplazo: LRU (menos recientemente usado) es eficiente, pero puede ser costoso en hardware. Alternativas como FIFO o reemplazo aleatorio pueden simplificar la implementación.
5.Política de escritura: Write-back en lugar de write-through reduce accesos innecesarios a la memoria principal.
6.Cachés multinivel: Usar una caché L2 o L3 de mayor tamaño y menor velocidad que L1 ayuda a reducir la frecuencia de accesos a la RAM.
7.Separación de instrucciones y datos: Evita competencia por el acceso y mejora el rendimiento en arquitecturas segmentadas.

Modulo de E/S y DMA

Conexión del sistema: el módulo de E/S se conecta con el resto del computador a través de las líneas del bus del sistema (datos, dirección, control).
Registro de Datos y estados:
- Registro de datos: almacena temporalmente los datos que entran o salen de los dispositivos.
- Registro de estado: indica el estado actual del dispositivo ( listo, ocupado, error). Puede funcionar también como registro de control para recibir instrucciones del procesador.
Interacción con CPU: La CPU utiliza las líneas de control para enviar ordenes al módulo E/S por ejemplo leer datos o escribir en un dispositivo.
Reconocimiento de direcciones: el módulo reconoce una dirección única para identificar que dispositivo controla. Si controla varios tiene un conjunto único de direcciones.
Interfaz específica para dispositivos: Contiene la lógica necesaria para comunicarse directamente con cada uno de los dispositivos conectados.

Puede verse afectado, ya que si se realizan operaciones sobre un dato, este se actualiza en cache y si no se vacía la memoria antes de que un dispositivo intente accederlo, se podría estar usando un valor erróneo y viceversa.

El Acceso Directo a Memoria permite que un dispositivo periférico acceda a memoria principal (RAM) directamente sin la intervención de la CPU. El DMA acelera la transferencia de datos entre la memoria y los dispositivos periféricos, lo que libera recursos de la CPU para otras tareas. Las características funcionales del DMA incluyen varias etapas de transferencia:

Solicitud

La primera etapa implica que un dispositivo periférico envíe una solicitud de acceso a la memoria al controlador DMA. Esta solicitud incluye información sobre la dirección de memoria de origen y destino, la cantidad de datos a transferir y el sentido de la transferencia. Selección del Canal DMA: Los sistemas informáticos pueden tener múltiples canales, cada uno dedicado a un tipo específico de dispositivo o función. En esta etapa, el sistema debe asignar el canal DMA a la solicitud entrante.

Configuración

Una vez seleccionado el canal DMA, se configura para que coincida con los requisitos de la transferencia de datos. Esto incluye la configuración de las direcciones de inicio y finalización en la memoria, el tamaño de la transferencia y otras características relevantes.

Acceso Directo:

El controlador DMA se comunica directamente con la memoria principal y el dispositivo periférico para iniciar la transferencia de datos. La CPU no participa en la transferencia en sí, lo que permite que la CPU realice otras tareas mientras se lleva a cabo la transferencia.

Transferencia de Datos:

El controlador DMA transfiere datos entre la memoria y el dispositivo periférico utilizando el canal DMA configurado previamente. La transferencia puede ser en una dirección o bidireccional.

Finalización

Cuando se completa la transferencia, el controlador DMA notifica al dispositivo periférico y actualiza cualquier estado relevante. La CPU puede ser notificada de la finalización de la transferencia mediante una interrupción o un mecanismo similar.

Liberación del Canal DMA

Después de completar la transferencia, el canal DMA se libera para su uso posterior. Esto permite que otros dispositivos o solicitudes utilicen el canal DMA según sea necesario.

inicia una operación de E/S (como leer o escribir datos en un dispositivo de almacenamiento, por ejemplo), y luego espera a que el dispositivo de E/S termine la operación antes de continuar con su ejecución. En este modelo, el procesador se "bloquea" o "espera" mientras la operación de E/S se lleva a cabo.

Funcionamiento paso a paso:

Iniciar la operación de E/S: El procesador envía una solicitud al dispositivo de E/S para realizar una operación específica (por ejemplo, leer un bloque de datos de un disco duro o escribir datos en una impresora).
Espera de respuesta: Una vez que el procesador emite la solicitud de E/S, espera que el dispositivo termine la operación. Durante este tiempo, el procesador no realiza ninguna otra tarea, ya que está esperando que se complete la operación solicitada.
Polling: El procesador revisa periódicamente el estado del dispositivo de E/S para determinar si la operación ha finalizado. Esto es menos eficiente que el uso de interrupciones.
Procesamiento de los datos: Después de que el dispositivo ha terminado la operación, y el procesador ha recibido la respuesta el procesador puede procesar los datos que fueron leídos o verificar que los datos fueron escritos correctamente.

El controlador de DMA recibe el control del sistema cedido por el procesador, para transferir datos a y desde memoria a través del bus del sistema.

Para hacerlo, el DMAC debe utilizarlo sólo cuando el procesador no lo necesita, o forzar al procesador a que suspenda temporalmente su funcionamiento, a esto se lo conoce como robo de ciclo.

Cuando el procesador desea leer o escribir un bloque de datos, envía una orden al módulo de DMA, incluyendo:

Si se solicita una lectura o una escritura.
La dirección del dispositivo de E/S en cuestión, indicada a través de las líneas de datos.
La posición inicial de memoria a partir de donde se lee o se escribe, indicada a través del bus de datos y almacenada por el DMAC en su registro de direcciones.
El número de palabras a leer o escribir, indicado a través de las líneas de datos y almacenado en el registro de cuenta de datos.

El procesador continúa su trabajo y el DMAC transfiere el bloque completo de datos, palabra a palabra, directamente desde o hacia la memoria. Cuando la transferencia ha terminado, el DMAC envía una señal de interrupción al procesador.

Buses

1) Tipos de buses

Dedicado: El bus esta permanentemente asignado a una función o a un subconjunto especifico de componentes dentro del sistemas.
Multiplexado: Utiliza las mismas lineas de comunicación para diferentes funciones o componentes en diferentes momentos

2) Metodo de arbitraje

Centralizado: Un dispositivo o unidad de control se encarga de gestionar el acceso al buss, asignado el tiempo de uso a cada componente
Distribuido: Cada modulo o componente tiene su propia logica para acceder al buss y los modulos colaboran para compartir los recursos

3) Temporización

Sincronica: El funcionamiento del bus esta cordinado por un reloj y todos los elementos del bus dependen de este.
Asincronica: Los eventos del buss no dependen de un reloj central sino que son impulsadas por eventos previos y señales de control

4) Anchura de buss

La anchura de bus se refiere al nro de lineas que tiene el bus, lo que determina la cantidad de información que puede tranmitirse simultaneamente.

En el buss de datos, la anchura indica cuantos bits se pueden transferir de manera paralela
En el bus de direcciones la anchura determina el tamaño de memoria que se puede direccionar.

5) Tipo de transferencia de datos

Transferencia de escritura: El bus permite que el maestro envie datos al exclavo
Transferencia de lectura: El esclavo envia datos al maestro.

Algunos buses permiten operaciones combinadas como:

1. Lectura-Modificación-Lectura: Una lectura seguida de una escritura en la misma dirección
1. Lectura-Despues-Escritura: Una escritura seguida de una lectura en la misma dirección

Ademas, algunos buses permiten transferencias de bloques de datos donde multiples datos se transfieren en un solo ciclo

Maquina/Arquitectura

Que elementos componen una maquina con arquitectura Von Newman descrir funcion de cada componente

Unidad Central de Procesamiento (CPU):

Es el componente principal encargado de ejecutar las instrucciones del programa. Se divide en:

Unidad de Control (CU): Coordina la ejecución de instrucciones, decodificándolas y enviando señales de control a los demás componentes.
Unidad Aritmético-Lógica (ALU): Realiza operaciones matemáticas y lógicas.
Registros: Pequeñas unidades de almacenamiento dentro de la CPU que guardan datos temporales y direcciones.

Memoria Principal:

Almacena datos e instrucciones de los programas en ejecución. Es de acceso aleatorio (RAM), lo que permite una lectura y escritura rápida por parte del procesador.

Bus de Datos, Dirección y Control:

Permiten la comunicación entre los componentes de la máquina.

Bus de Datos: Transporta los datos entre la memoria, la CPU y los dispositivos de entrada/salida.
Bus de Direcciones: Indica la ubicación de los datos en la memoria.
Bus de Control: Transporta señales de control que coordinan el funcionamiento de los demás buses y dispositivos.

Unidad de Entrada/Salida (E/S):

Permite la interacción entre la computadora y el usuario o dispositivos externos. Incluye teclados, pantallas, discos duros, impresoras, entre otros.

Finales

Practica 10 Redes | Enlace

Tue, 07 May 2024 00:00:00 GMT

Indice

Ejercicio 1
Ejercicio 2
Ejercicio 3
Ejercicio 4
Ejercicio 5
Ejercicio 6
Ejercicio 7
Ejercicio 8
Ejercicio 9
Ejercicio 10
Ejercicio 11
Ejercicio 12
Ejercicio 13

Ejercicio 1

¿Qué función cumple la capa de enlace? Indique qué servicios presta esta capa.

La capa de enlace de datos, también conocida como capa 2 del Modelo OSI (Open Systems Interconnection), es fundamental en el proceso de comunicación en redes de computadoras. Su principal función es proporcionar medios para que los datos se transfieran de manera confiable entre dispositivos adyacentes conectados a la misma red física, como un enlace Ethernet o una conexión Wi-Fi. Aquí detallo las funciones y servicios principales que presta esta capa:

Funciones de la Capa de Enlace de Datos

Control de Acceso al Medio (MAC):
- Definición: Gestiona cómo los dispositivos en la misma red física acceden al medio compartido de comunicación.
- Importancia: Evita colisiones y sobrecarga de la red gestionando cuándo y cómo los dispositivos pueden transmitir datos.
Detección y corrección de errores:
- Definición: Identifica y, en algunos casos, corrige errores que ocurren en el nivel físico (capa 1).
- Mecanismo: Utiliza técnicas como el chequeo de paridad, checksums y código de corrección de errores para asegurar que los datos recibidos son correctos y completos.
Encapsulamiento de tramas:
- Definición: Encapsula paquetes de la capa de red en tramas agregando encabezados y trailers necesarios para el procesamiento en la capa de enlace.
- Componentes: Los encabezados y trailers típicamente incluyen direcciones de origen y destino, información de control, y a menudo checksums para error checking.
Control de Flujo:
- Definición: Regula la velocidad de transmisión de datos para evitar que el emisor sobrecargue al receptor.
- Métodos: Puede implementarse mediante mecanismos de retroalimentación entre emisor y receptor, como en el protocolo Ethernet.
Delimitación de tramas:
- Definición: Determina dónde comienza y termina cada trama, lo cual es esencial para la correcta extracción y procesamiento de los datos.
- Métodos: Uso de secuencias especiales de bytes que no se encuentran en los datos normales para señalar límites de tramas.

Servicios Prestados por la Capa de Enlace de Datos

Confiabilidad de la Transmisión: Asegura que los datos transmitidos lleguen sin errores, en secuencia y sin pérdidas ni duplicaciones.
Interconexión de Redes: Facilita la interconexión entre diferentes tecnologías de red física mediante adaptaciones en el enlace de datos.
Control de Topología: Gestiona cómo los dispositivos están organizados y comunican en la red, ayudando a organizar y optimizar la estructura de la red.
Gestión: Proporciona medios para diagnosticar problemas y administrar el rendimiento de la red en la capa de enlace.

Conclusión

La capa de enlace de datos es crucial en la arquitectura de red, proporcionando la base para una comunicación fiable y efectiva entre dispositivos en la misma red. Esta capa asegura que, pese a las imperfecciones del medio físico y las limitaciones de los dispositivos, la comunicación pueda llevarse a cabo de manera eficiente y controlada.

Ejercicio 2

Compare los servicios de la capa de enlace con los de la capa de transporte.

La comparación entre los servicios de la capa de enlace de datos (capa 2 del modelo OSI) y la capa de transporte (capa 4 del modelo OSI) revela diferencias clave en sus funciones, objetivos y ámbitos de operación dentro de una red. Aunque ambas capas proporcionan servicios críticos para la entrega de datos, lo hacen en diferentes etapas del proceso de comunicación y con diferentes enfoques.

Capa de Enlace de Datos (Capa 2)

Objetivos y Funciones:

Proporciona comunicación entre dispositivos adyacentes ubicados en la misma red local o enlace.
Control de acceso al medio (MAC): Gestiona cómo los dispositivos acceden al medio físico compartido para evitar colisiones.
Encapsulamiento de datos: Empaqueta los datos de la capa de red en tramas, agregando encabezados y colas con direcciones físicas, control de errores y control de flujo.
Detección y corrección de errores: Utiliza métodos como el CRC (Cyclic Redundancy Check) para detectar errores en los datos recibidos.
Control de flujo: Evita que el emisor sobrecargue al receptor en el mismo enlace.
Funciona en una única red de enlace, no enruta ni proporciona entrega de datos entre diferentes redes.

Capa de Transporte (Capa 4)

Objetivos y Funciones:

Proporciona comunicación de host a host, abstrayendo los detalles de las capas de red subyacentes para aplicaciones en diferentes hosts.
Segmentación y reensamblaje de datos: Divide los mensajes de aplicación en segmentos más pequeños en el emisor y los reensambla en el receptor.
Control de conexión: Administra las conexiones de datos end-to-end, asegurando que sean confiables (como en TCP) o no confiables pero rápidas (como en UDP).
Control de flujo y control de congestión: Regula la cantidad de datos que pueden ser enviados y ajusta esta cantidad según la capacidad del canal y el estado de la red para prevenir la congestión.
Multiplexación y desmultiplexación: Utiliza puertos para dirigir segmentos a las aplicaciones correctas en los hosts.
Opera a través de múltiples redes: Facilita la entrega de datos a través de internetworks, proporcionando funcionalidad independiente de la estructura de red subyacente.

Comparación de Servicios

Ámbito de operación: La capa de enlace se centra en la comunicación entre nodos que están físicamente conectados o en la misma red local, mientras que la capa de transporte proporciona comunicación entre procesos de aplicación en diferentes hosts que pueden estar en redes remotas.
Confiabilidad: Ambas capas pueden proporcionar detección de errores, pero la capa de transporte tiene capacidades adicionales como la recuperación de errores y el control de congestión, diseñadas para garantizar una entrega de datos fiable y eficiente a través de múltiples redes y enlaces.
Encapsulamiento: La capa de enlace encapsula paquetes en tramas, mientras que la capa de transporte encapsula mensajes de aplicación en segmentos o datagramas.
Control de flujo: Mientras que la capa de enlace gestiona el control de flujo para prevenir la sobrecarga en un enlace específico, la capa de transporte lo gestiona de extremo a extremo entre los hosts finales.

Conclusión

Aunque ambas capas contribuyen a la funcionalidad general de las redes y comparten algunas funciones como el control de flujo y la detección de errores, se dirigen a diferentes aspectos del proceso de comunicación en red. La capa de enlace facilita la comunicación directa entre dispositivos conectados localmente, mientras que la capa de transporte proporciona servicios de comunicación host-to-host a nivel de aplicación, asegurando que los datos se entreguen de manera eficiente y confiable a través de complejas topologías de red.

Ejercicio 3

Direccionamiento Ethernet:

¿Cómo se identifican dos máquinas en una red Ethernet?
¿Cómo se llaman y qué características poseen estas direcciones?
¿Cuál es la dirección de broadcast en la capa de enlace? ¿Qué función cumple?

En una red Ethernet, el direccionamiento y la identificación de dispositivos siguen un esquema estructurado que facilita la comunicación entre máquinas dentro de la misma red local. A continuación, te explico detalladamente cómo se identifican las máquinas en una red Ethernet, las características de las direcciones utilizadas, y el propósito y función de la dirección de broadcast en la capa de enlace.

¿Cómo se identifican dos máquinas en una red Ethernet?

Direcciones MAC (Media Access Control):
- Cada dispositivo en una red Ethernet tiene una dirección MAC única, que es utilizada para identificar físicamente cada máquina en la red. Esta dirección es esencial para la comunicación en la capa de enlace de datos.

¿Cómo se llaman y qué características poseen estas direcciones?

Características de las Direcciones MAC:
- Longitud: Una dirección MAC consta de 48 bits (6 bytes).
- Formato: Típicamente representada en hexadecimal, dividida en seis grupos de dos dígitos separados por dos puntos o guiones (por ejemplo, 01:23:45:67:89:AB).
- Asignación: Los primeros tres bytes (24 bits) son conocidos como el identificador de organización único (OUI) y son asignados por la IEEE a los fabricantes. Los siguientes tres bytes son asignados por el fabricante y aseguran que cada tarjeta de red tenga una dirección única.
- Tipos:
  - Unicast: La dirección representa a un solo dispositivo. Las comunicaciones dirigidas a una dirección unicast solo están destinadas a ese dispositivo específico.
  - Multicast: La dirección representa a un grupo de dispositivos. Las comunicaciones enviadas a una dirección multicast son recibidas por todos los dispositivos que son parte de ese grupo multicast.
  - Broadcast: Una dirección especial que permite la comunicación con todos los dispositivos en la red local.

¿Cuál es la dirección de broadcast en la capa de enlace? ¿Qué función cumple?

Dirección de Broadcast en Ethernet:
- Dirección: La dirección de broadcast en Ethernet es FF:FF:FF:FF:FF:FF. Esta dirección es reconocida por todos los dispositivos en una red Ethernet.
- Función:
  - Alcance a Todos los Dispositivos: Cualquier trama enviada a esta dirección será recibida y procesada por todos los dispositivos en la red local. Esto es útil para enviar anuncios o consultas que deben ser escuchados por todos los dispositivos simultáneamente.
  - Inicialización y Configuración: Frecuentemente utilizada para protocolos de configuración inicial como DHCP, donde una máquina cliente envía una trama de broadcast para encontrar servidores DHCP sin saber sus direcciones IP específicas.

Conclusión

Las direcciones MAC son fundamentales para el funcionamiento de las redes Ethernet, proporcionando un método estándar para identificar físicamente cada dispositivo en una red. Las direcciones de broadcast, en particular, desempeñan un papel crucial al permitir comunicaciones a todos los dispositivos de la red simultáneamente, facilitando tanto la configuración de la red como la difusión de información vital a todas las máquinas conectadas.

Ejercicio 4

Sobre los dispositivos de capa de enlace:

Enumere dispositivos de capa de enlace y explique sus diferencias.
¿Qué es una colisión?
¿Qué dispositivos dividen dominios de broadcast?
¿Qué dispositivos dividen dominios de colisión?

Los dispositivos de la capa de enlace de datos juegan un papel esencial en la gestión del tráfico, la detección y prevención de errores, y el control de acceso en redes de computadoras. A continuación, te explico los dispositivos comúnmente utilizados en esta capa, las diferencias entre ellos, y también abordaré conceptos adicionales como colisiones, dominios de broadcast y de colisión.

Dispositivos de Capa de Enlace y sus Diferencias

Hub:
- Tipo: Dispositivo pasivo (a veces activo).
- Función: Conecta múltiples dispositivos Ethernet en una red y retransmite los datos recibidos a todos los otros puertos, sin procesar ni filtrar el tráfico.
- Características: Opera en un solo dominio de colisión y broadcast, lo que significa que cualquier paquete enviado por un dispositivo es recibido por todos los demás dispositivos conectados al hub.
Switch:
- Tipo: Dispositivo activo.
- Función: Conecta múltiples dispositivos y filtra y reenvía los datos a los puertos específicos donde están conectados los dispositivos de destino.
- Características: Reduce los dominios de colisión al crear un dominio de colisión separado para cada puerto, pero todos los puertos permanecen en el mismo dominio de broadcast.
Puente:
- Tipo: Dispositivo de red que se utiliza para dividir una red más grande en segmentos más pequeños, interconectando redes separadas para actuar como una única red.
- Función: Filtra el tráfico entre dos segmentos de red basándose en las direcciones MAC para reducir las colisiones y mejorar la eficiencia.
- Características: Opera en dos dominios de colisión diferentes pero puede extender el dominio de broadcast a través de ambos segmentos de red.

¿Qué es una Colisión?

Definición: Una colisión en una red Ethernet ocurre cuando dos o más dispositivos intentan enviar paquetes simultáneamente en el mismo segmento de red o canal de comunicación compartido. Las colisiones degradan el rendimiento de la red porque los paquetes involucrados en la colisión deben ser retransmitidos.
Detección: Las redes Ethernet usan el método de acceso CSMA/CD (Carrier Sense Multiple Access with Collision Detection) para detectar colisiones y manejar la retransmisión de datos.

¿Qué dispositivos dividen dominios de broadcast?

Router:
- Función: Divide dominios de broadcast al no reenviar paquetes de broadcast entre interfaces. Cada interfaz del router es un dominio de broadcast separado.
- Impacto: Los routers ayudan a limitar el tráfico de broadcast, reduciendo así la carga en la red y mejorando el rendimiento.

¿Qué dispositivos dividen dominios de colisión?

Switches y Puentes:
- Función: Ambos dispositivos reducen el tamaño de los dominios de colisión. Un switch crea un dominio de colisión separado para cada uno de sus puertos, mientras que un puente puede dividir una red en múltiples segmentos más pequeños, cada uno con su propio dominio de colisión.
- Impacto: La división de dominios de colisión mejora el rendimiento de la red al reducir el número de dispositivos que compiten por el medio de transmisión, lo que resulta en menos colisiones y retransmisiones.

Cada uno de estos dispositivos desempeña roles cruciales en la optimización y administración de la red, asegurando que los datos se transmitan de manera eficiente y segura dentro de diversos entornos de red.

Ejercicio 5

Describa el algoritmo de acceso al medio en Ethernet. ¿Es orientado a la conexión?

El algoritmo de acceso al medio en Ethernet, conocido como CSMA/CD (Carrier Sense Multiple Access with Collision Detection), es fundamental para regular cómo los dispositivos en una red Ethernet compiten y acceden al medio compartido para enviar datos. A continuación, te describo detalladamente este algoritmo y aclaro si es o no orientado a la conexión.

Descripción del Algoritmo CSMA/CD

CSMA/CD se utiliza en redes Ethernet que operan en un entorno de medio compartido, típicamente utilizando cable coaxial o en segmentos de red donde múltiples dispositivos pueden acceder al mismo cable físico. El proceso de CSMA/CD incluye varios pasos:

Escuchar el Medio (Carrier Sense):
- Función: Antes de enviar datos, un dispositivo debe "escuchar" el medio para detectar si otro dispositivo está transmitiendo (si el medio está "ocupado").
- Acción: Si el medio está ocupado, el dispositivo esperará hasta que esté libre para evitar colisiones de datos.
Transmitir Datos:
- Función: Una vez que el medio está libre, el dispositivo comienza a transmitir los datos.
- Acción: Durante la transmisión, el dispositivo continúa monitoreando el medio para asegurarse de que no se produzcan colisiones.
Detección de Colisiones (Collision Detection):
- Función: Si dos dispositivos comienzan a transmitir simultáneamente, sus señales se superpondrán y distorsionarán, causando una colisión.
- Acción: Cada dispositivo que detecta una colisión deja de transmitir inmediatamente y envía una señal de jam (interferencia) para asegurar que todos los dispositivos en la red sean conscientes de la colisión.
Retraso Aleatorio (Backoff Algorithm):
- Función: Después de una colisión, cada dispositivo espera un período de tiempo aleatorio antes de intentar retransmitir, reduciendo la probabilidad de colisiones repetidas.
- Acción: El tiempo de espera se determina usando el algoritmo de backoff exponencial, que aumenta el rango de espera con cada colisión sucesiva.
Intento de Retransmisión:
- Función: Después del retraso, el proceso comienza de nuevo desde el paso 1, escuchando el medio antes de intentar transmitir nuevamente.

¿Es CSMA/CD Orientado a la Conexión?

No, CSMA/CD no es orientado a la conexión. Es un protocolo de acceso al medio que no establece una conexión previa o un canal dedicado entre los dispositivos antes de la transmisión de datos. Funciona en un entorno de difusión donde cada paquete se envía independientemente sin una sesión o conexión preestablecida.

Conclusión

CSMA/CD es un método eficiente para gestionar el acceso a un medio de red compartido en ambientes Ethernet, especialmente diseñado para prevenir y gestionar colisiones en redes de área local (LAN). La ausencia de una orientación a la conexión significa que es más flexible y escalable en ambientes donde múltiples dispositivos necesitan comunicarse de manera intermitente y espontánea sin una coordinación o negociación previa constante.

Ejercicio 6

¿Cuál es la finalidad del protocolo ARP?

El protocolo ARP (Address Resolution Protocol) desempeña un papel fundamental en las redes de computadoras, específicamente en las redes que operan bajo el protocolo de Internet (IP). Su función principal es mapear direcciones de red de protocolo de nivel superior (como las direcciones IP en una red IPv4) a direcciones de nivel de enlace de datos físicos (como las direcciones MAC en redes Ethernet). Aquí te explico detalladamente la finalidad y el funcionamiento del protocolo ARP.

Finalidad del Protocolo ARP

Resolución de Direcciones:
- Propósito: ARP traduce direcciones IP, que son utilizadas para la capa de red, a direcciones MAC, que son necesarias para la capa de enlace de datos. Esta traducción es esencial para el funcionamiento de la mayoría de las redes LAN que usan IP sobre Ethernet.
- Necesidad: En una red típica, los dispositivos se comunican a través de IP, pero las comunicaciones dentro de la red local (como Ethernet) requieren conocer la dirección MAC del dispositivo de destino para poder enviar los datos de manera efectiva.
Funcionamiento del Protocolo ARP:
- Descubrimiento ARP: Cuando un dispositivo necesita comunicarse con otro dispositivo en la misma red local y conoce la dirección IP pero no la dirección MAC, envía un mensaje ARP broadcast a todos los dispositivos en la red local. Este mensaje pregunta: "¿Quién tiene esta dirección IP? Envíame tu dirección MAC".
- Respuesta ARP: El dispositivo que tiene la dirección IP solicitada responde con un mensaje ARP unicast al solicitante, proporcionando su dirección MAC.
- Caché ARP: Los dispositivos suelen almacenar las respuestas ARP en una tabla de caché ARP local para reducir la necesidad de futuras solicitudes ARP y mejorar la eficiencia de la red.

Importancia de ARP en las Redes

Interoperabilidad: ARP permite la interoperabilidad entre la capa de red y la capa de enlace de datos, lo que es crucial para la transmisión de paquetes dentro de las redes locales como Ethernet.
Automatización: Ofrece un método automático para la resolución de direcciones que es transparente para el usuario y las aplicaciones, lo que simplifica la configuración de la red y la gestión.
Soporte para Redes Dinámicas: Facilita la comunicación en redes dinámicas donde los dispositivos pueden cambiarse, agregarse o eliminarse con frecuencia, asegurando que las direcciones MAC se actualicen según sea necesario.

Vulnerabilidades de ARP

ARP Spoofing/Poisoning: A pesar de su utilidad, ARP no tiene mecanismos de autenticación, lo que lo hace vulnerable a ataques donde un atacante puede responder a solicitudes ARP con su propia dirección MAC para interceptar el tráfico de red o realizar ataques man-in-the-middle.

Conclusión

La finalidad de ARP es esencial para la conexión y la eficiencia de las redes IP sobre tecnologías de enlace de datos como Ethernet, proporcionando la vinculación necesaria entre direcciones IP y direcciones MAC. Sin embargo, es importante ser consciente de sus limitaciones de seguridad y tomar medidas apropiadas para proteger las redes contra posibles ataques relacionados con ARP.

Ejercicio 7

Investigue los comandos arp e ip neigh. Inicie una topología con CORE, cree una máquina y utilice en ella los comandos anteriores para:

Listar las entradas en la tabla ARP.
Borrar una entrada en la tabla de ARP.
Agregar una entrada estática en la tabla de ARP.

Finalidad del Protocolo ARP

Resolución de Direcciones:
- Propósito: ARP traduce direcciones IP, que son utilizadas para la capa de red, a direcciones MAC, que son necesarias para la capa de enlace de datos. Esta traducción es esencial para el funcionamiento de la mayoría de las redes LAN que usan IP sobre Ethernet.
- Necesidad: En una red típica, los dispositivos se comunican a través de IP, pero las comunicaciones dentro de la red local (como Ethernet) requieren conocer la dirección MAC del dispositivo de destino para poder enviar los datos de manera efectiva.
Funcionamiento del Protocolo ARP:
- Descubrimiento ARP: Cuando un dispositivo necesita comunicarse con otro dispositivo en la misma red local y conoce la dirección IP pero no la dirección MAC, envía un mensaje ARP broadcast a todos los dispositivos en la red local. Este mensaje pregunta: "¿Quién tiene esta dirección IP? Envíame tu dirección MAC".
- Respuesta ARP: El dispositivo que tiene la dirección IP solicitada responde con un mensaje ARP unicast al solicitante, proporcionando su dirección MAC.
- Caché ARP: Los dispositivos suelen almacenar las respuestas ARP en una tabla de caché ARP local para reducir la necesidad de futuras solicitudes ARP y mejorar la eficiencia de la red.

Importancia de ARP en las Redes

Interoperabilidad: ARP permite la interoperabilidad entre la capa de red y la capa de enlace de datos, lo que es crucial para la transmisión de paquetes dentro de las redes locales como Ethernet.
Automatización: Ofrece un método automático para la resolución de direcciones que es transparente para el usuario y las aplicaciones, lo que simplifica la configuración de la red y la gestión.
Soporte para Redes Dinámicas: Facilita la comunicación en redes dinámicas donde los dispositivos pueden cambiarse, agregarse o eliminarse con frecuencia, asegurando que las direcciones MAC se actualicen según sea necesario.

Vulnerabilidades de ARP

ARP Spoofing/Poisoning: A pesar de su utilidad, ARP no tiene mecanismos de autenticación, lo que lo hace vulnerable a ataques donde un atacante puede responder a solicitudes ARP con su propia dirección MAC para interceptar el tráfico de red o realizar ataques man-in-the-middle.

Conclusión

Ejercicio 8

Ejercicio 9

Ejercicio 10

Ejercicio 11

Ejercicio 12

Ejercicio 13

Practica 2 Redes | HTTP

Tue, 07 May 2024 00:00:00 GMT

Introducción

Ejercicio 1

La función de la capa de aplicación en las redes de computadoras es proporcionar servicios de comunicación a los usuarios y a las aplicaciones. Esta capa incluye las propias aplicaciones que utilizan la red, como navegadores web, clientes de correo electrónico y aplicaciones de mensajería instantánea. En el contexto de Machine to Machine (M2M), la capa de aplicación facilita la comunicación entre máquinas sin intervención humana.

Además, la capa de aplicación actúa como una interfaz entre el usuario o las aplicaciones/servicios y la red. Es responsable de la definición del formato de los mensajes, de establecer las reglas para el intercambio de mensajes y de asegurar que los mensajes se transmitan de manera que cumplan con los requisitos de la aplicación. También se encarga de la conversión y codificación de datos, la compresión y descompresión, y el cifrado y descifrado, integrando funciones de lo que en el modelo OSI corresponden a las capas de Aplicación, Presentación y Sesión.

Ejercicio 2

¿Cómo podrían hacerlo si están en diferentes máquinas?

A través de la red: Utilizan la comunicación de red, intercambiando mensajes a través de un protocolo de la capa de aplicación adecuado (como HTTP, FTP, SMTP, etc.). Cada proceso utiliza un socket, que es un punto final de comunicación que proporciona la puerta de enlace para enviar y recibir datos. Los sockets se basan en la dirección IP de la máquina y un número de puerto específico para identificar el proceso de destino, permitiendo que los procesos en diferentes hosts se comuniquen entre sí a través de la red.

Y si están en la misma máquina, ¿qué alternativas existen?

Comunicación entre procesos (IPC): Pueden utilizar varios mecanismos de IPC proporcionados por el sistema operativo, tales como:

Pipes (tuberías): Permiten la comunicación secuencial entre procesos, donde la salida de un proceso se convierte en la entrada del otro.
Memoria compartida: Permite a múltiples procesos acceder a una sección común de la memoria RAM para intercambiar datos de manera rápida.
Sockets de dominio UNIX: Son similares a los sockets de red, pero están diseñados para la comunicación entre procesos en la misma máquina, ofreciendo una manera eficiente de intercambio de datos.
Señales: Son mensajes asincrónicos enviados a un proceso para indicar la ocurrencia de un evento específico.
Semáforos y mutexes: Se utilizan para manejar el acceso concurrente a recursos compartidos, como la memoria.
Colas de mensajes: Permiten el intercambio de mensajes entre procesos, donde los mensajes se almacenan en una cola hasta que el proceso receptor está listo para procesarlos.

Ejercicio 3

El modelo Cliente/Servidor es una arquitectura de red donde el servidor es una máquina que proporciona servicios o recursos, mientras que el cliente es una máquina o proceso que solicita esos servicios o recursos. En este modelo, el servidor está siempre activo, escuchando las solicitudes de los clientes. Cuando recibe una solicitud, el servidor la procesa y luego envía una respuesta de vuelta al cliente. Los clientes pueden conectarse o desconectarse de la red en cualquier momento y pueden tener direcciones IP dinámicas. En esta arquitectura, los clientes no se comunican directamente entre sí.

Ejemplo en la “vida cotidiana”: Un ejemplo cotidiano podría ser un usuario navegando en internet; el navegador actúa como el cliente y el servidor web como el servidor. El usuario (a través del navegador) solicita una página web (cliente) y el servidor web responde enviando los archivos de esa página web al navegador.

Ejemplo de un sistema informático: En el contexto de los sistemas informáticos, un ejemplo típico es el servicio de correo electrónico, donde un servidor de correo maneja y almacena los correos electrónicos, mientras que el cliente de correo electrónico (como Microsoft Outlook o Mozilla Thunderbird) permite al usuario enviar y recibir correos electrónicos.

Otros modelos de comunicación:

Peer-to-Peer (P2P): En este modelo, cada nodo o participante actúa tanto como cliente como servidor. Los nodos se comunican directamente entre sí sin la necesidad de un servidor central. Esto se utiliza comúnmente en la compartición de archivos y redes de comunicación descentralizadas.
Modelo Híbrido: Combina elementos del modelo Cliente/Servidor y P2P. Por ejemplo, en las redes de mensajería instantánea, la detección y localización de presencia de los usuarios puede ser centralizada (cliente/servidor), pero la conversación puede ocurrir directamente entre los usuarios (P2P).
Modelo de Publicación/Suscripción: En este modelo, los clientes se suscriben a un tema y reciben actualizaciones automáticamente de un servidor cuando hay nuevos contenidos o mensajes relacionados con ese tema. Esto es común en sistemas de mensajería y notificaciones en tiempo real.

Ejercicio 4

Un "Agente de Usuario" o "User Agent" se refiere a cualquier software que actúa en nombre de un usuario. La función principal de un agente de usuario es servir como intermediario entre el usuario y las aplicaciones de red, facilitando la interacción del usuario con la red o los servicios de Internet.

Las funcionalidades de un agente de usuario incluyen:

Interfaz de Usuario: Proporciona una interfaz a través de la cual los usuarios pueden interactuar con las aplicaciones de la red. Por ejemplo, un navegador web ofrece una interfaz gráfica donde los usuarios pueden ingresar URLs, ver páginas web y interactuar con elementos en línea.
Comunicación de Red: Maneja la comunicación entre el dispositivo del usuario y la red. Esto incluye la creación de solicitudes de red según las acciones del usuario, el envío de estas solicitudes al servidor correspondiente, y la recepción y procesamiento de las respuestas.
Interpretación de Contenidos: Interpreta y presenta los datos recibidos de la red al usuario de una manera entendible y utilizable. Por ejemplo, un navegador web interpreta el HTML, CSS y JavaScript de una página web y los presenta visualmente al usuario.
Gestión de Sesiones: Mantiene la información de estado durante la interacción del usuario con las aplicaciones de red. Esto puede incluir la gestión de cookies, autenticaciones y otras informaciones de sesión.
Seguridad: Implementa medidas de seguridad para proteger la información del usuario durante la comunicación en la red. Esto puede incluir el cifrado de datos, la verificación de la autenticidad de los sitios web y la protección contra malware.
Almacenamiento y Caché: Almacena datos localmente para mejorar el rendimiento y la eficiencia de las solicitudes de red, utilizando técnicas como el almacenamiento en caché de páginas web previamente visitadas.

Ejemplos de agentes de usuario incluyen navegadores web, clientes de correo electrónico, y aplicaciones de mensajería instantánea. En la práctica, el término "user agent" se utiliza a menudo específicamente para referirse al navegador web del usuario.

Ejercicio 5

HTML: Es un lenguaje de marcado utilizado para crear y estructurar páginas web. HTML utiliza etiquetas y atributos para definir cómo se muestra el contenido en un navegador web, como textos, imágenes, enlaces, tablas, listas, etc. HTML se ocupa de la presentación y la estructura del contenido en la web.
HTTP: Es un protocolo de la capa de aplicación utilizado para la transmisión de documentos hipermedia, como HTML. Es el fundamento de cualquier intercambio de datos en la Web y es un protocolo basado en solicitudes y respuestas entre clientes (por ejemplo, un navegador web) y servidores (el lugar donde se aloja la página web). HTTP define cómo se deben transmitir los mensajes y los datos entre cliente y servidor.

En cuanto a la entidad donde se ubicaría HTML, este se sitúa en la capa de aplicación del modelo TCP/IP o en las capas de presentación y aplicación del modelo OSI, ya que está directamente relacionado con la forma en que se presentan los datos al usuario final en aplicaciones de red, específicamente en navegadores web.

Ejercicio 6

HTTP tiene definido un formato de mensaje para los requerimientos y las respuestas.

Ejercicio 6.A)

En HTTP, los mensajes de requerimiento y respuesta se diferencian principalmente por la línea de inicio, que es la primera línea del mensaje HTTP.

Requerimiento (Request):

Línea de inicio: Compuesta por el método HTTP, la URI (Uniform Resource Identifier) solicitada, y la versión de HTTP.

Ejemplo

Ejemplo de una línea de inicio de un requerimiento: GET /index.html HTTP/1.1. Aquí, GET es el método HTTP, /index.html es la URI solicitada, y HTTP/1.1 es la versión del protocolo HTTP utilizada.

Esto se puede ver, cuando hacemos un curl con el parametro -v, que nos muestra la información de la petición y la respuesta.

redes@debian:~$ curl -v www.redes.unlp.edu.ar
*   Trying 172.28.0.50:80...
* Connected to www.redes.unlp.edu.ar (172.28.0.50) port 80 (#0)
> GET / HTTP/1.1
> Host: www.redes.unlp.edu.ar
> User-Agent: curl/7.74.0
> Accept: */*
>

Métodos HTTP comunes: GET (solicitar datos), POST (enviar datos para procesamiento), PUT (actualizar recursos), DELETE (eliminar recursos), entre otros.

Respuesta (Response):

Línea de inicio: Incluye la versión de HTTP utilizada, el código de estado, y una frase descriptiva que explica el código.

Ejemplo de una línea de inicio de respuesta: HTTP/1.1 200 OK. En este caso, HTTP/1.1 indica la versión, 200 es el código de estado que significa éxito, y OK es la descripción del código de estado.

Códigos de estado: Van desde respuestas informativas (100-199), éxitos (200-299), redirecciones (300-399), errores del cliente (400-499) hasta errores del servidor (500-599).

* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< Date: Sat, 13 Apr 2024 16:37:30 GMT
< Server: Apache/2.4.56 (Unix)
< Last-Modified: Sun, 19 Mar 2023 19:04:46 GMT
< ETag: "1322-5f7457bd64f80"
< Accept-Ranges: bytes
< Content-Length: 4898
< Content-Type: text/html
< 
<!DOCTYPE html>
<html lang="en">

# Continua  la pagina pero no lo pongo porque es demasiado largo

El formato detallado de los mensajes HTTP tanto para los requerimientos como para las respuestas incluye varios componentes además de la línea de inicio:

Cabeceras (Headers): Pares clave-valor que llevan información adicional sobre el mensaje HTTP. Son fundamentales para el funcionamiento del protocolo y permiten una gran variedad de funcionalidades.
- Ejemplos de cabeceras en requerimientos: User-Agent (tipo de navegador), Accept (tipos de contenido que el cliente puede procesar), Content-Type (tipo de datos en el cuerpo del mensaje), Authorization (credenciales de autenticación).
- Ejemplos de cabeceras en respuestas: Content-Type (tipo de contenido del cuerpo de respuesta), Set-Cookie (enviar cookies al cliente), Cache-Control (directivas de caché), WWW-Authenticate (indica método de autenticación requerido).
Cuerpo (Body): Opcional en algunos tipos de mensajes, contiene los datos transmitidos. En los requerimientos puede incluir datos a ser procesados por el servidor (como en POST), y en las respuestas usualmente lleva el recurso solicitado o un mensaje de error.

Las cabeceras HTTP cumplen roles cruciales en la funcionalidad del protocolo:

Negociación de contenido: Permite que el cliente y el servidor seleccionen el formato más adecuado para los datos que se intercambian, basándose en capacidades o preferencias.
Control de caché: Define políticas para el almacenamiento en caché de recursos, lo que puede reducir la carga en los servidores y acelerar la carga de páginas en el cliente.
Autenticación y control de acceso: Proveen mecanismos para que los servidores identifiquen y autoricen a los usuarios, asegurando que solo los usuarios autorizados puedan acceder a ciertos recursos.
Manejo de sesiones: Aunque HTTP es un protocolo sin estado, las cabeceras como Cookie y Set-Cookie permiten la creación de sesiones, manteniendo el estado a través de múltiples interacciones consecutivas.
Información sobre el estado de la conexión: Como Keep-Alive para mantener la conexión abierta y reutilizarla para futuras solicitudes, reduciendo la latencia y la sobrecarga en la creación de conexiones.

Estos componentes permiten que HTTP sea un protocolo flexible y poderoso, adecuado para las diversas necesidades del mundo web moderno.

Ejercicio 6.B)

El formato de un mensaje HTTP, ya sea un mensaje de requerimiento (solicitud) o un mensaje de respuesta, está compuesto de la siguiente manera:

Formato de los Mensajes de Requerimiento HTTP:

Línea de Inicio: Esta es la primera línea de la solicitud y contiene:
- Método HTTP: El método de solicitud (GET, POST, PUT, DELETE, etc.).
- URI: El identificador del recurso solicitado.
- Versión de HTTP: La versión del protocolo HTTP utilizada (usualmente HTTP/1.1 o HTTP/2).
Ejemplo:
```
GET /index.html HTTP/1.1
```
Cabeceras de Requerimiento: Siguen a la línea de inicio y se componen de pares clave-valor que proporcionan más detalles sobre la solicitud. Incluyen información sobre el navegador (User-Agent), las cookies (Cookie), tipos de contenido que se pueden manejar (Accept), y muchas otras.

Ejemplo:
```
Host: www.ejemplo.com
User-Agent: curl/7.74.0
Accept: text/html,application/xhtml+xml
```
Cuerpo del Mensaje: Opcional y solo utilizado en algunos métodos como POST o PUT. Contiene los datos que se envían al servidor.

Ejemplo (cuerpo de una solicitud POST):
```
name=usuario&password=clave
```

Formato de los Mensajes de Respuesta HTTP:

Línea de Inicio: Similar a la solicitud, pero para respuestas. Contiene:
- Versión de HTTP: La versión del protocolo HTTP utilizada.
- Código de Estado: Un número de tres dígitos que indica el resultado de la solicitud.
- Frase de Razón: Descripción textual del código de estado.
Ejemplo:
```
HTTP/1.1 200 OK
```
Cabeceras de Respuesta: Pares clave-valor que proporcionan información adicional sobre la respuesta, como el tipo de contenido (Content-Type), longitud del contenido (Content-Length), y la gestión de la caché (Cache-Control).

Ejemplo:
```
Content-Type: text/html
Content-Length: 3495
```
Cuerpo del Mensaje: Opcional, dependiendo del código de estado y el método HTTP utilizado. Si la respuesta contiene datos (como una página web o datos de una API), estos se incluyen aquí.

Ejemplo (cuerpo de una respuesta con HTML):
```
<html>
<head>
  <title>Ejemplo</title>
</head>
<body>
  <p>Hola, mundo!</p>
</body>
</html>
```

Suponga que desea enviar un requerimiento con la versión de HTTP 1.1 desde curl/7.74.0 a un sitio de ejemplo como www.misitio.com para obtener el recurso /index.html. En base a lo indicado,

curl -v -H "User-Agent: curl/7.74.0" -H "Accept: text/html" http://www.misitio.com/index.html

*   Trying 108.61.73.182:80...
* Connected to www.misitio.com (108.61.73.182) port 80 (#0)
> GET /index.html HTTP/1.1
> Host: www.misitio.com
> User-Agent: curl/7.74.0
> Accept: text/html
> 
* Mark bundle as not supporting multiuse
< HTTP/1.1 301 Moved Permanently
< Server: nginx/1.14.2
< Date: Sat, 13 Apr 2024 16:53:57 GMT
< Content-Type: text/html
< Content-Length: 185
< Connection: keep-alive
< Location: https://www.misitio.com/index.html
< 
<html>
<head><title>301 Moved Permanently</title></head>
<body bgcolor="white">
<center><h1>301 Moved Permanently</h1></center>
<hr><center>nginx/1.14.2</center>
</body>
</html>
* Connection #0 to host www.misitio.com left intact

El resultado del comando curl que has ejecutado indica que el recurso /index.html del sitio www.misitio.com se ha movido permanentemente a una nueva ubicación. Analicemos en detalle lo que ha sucedido en cada paso:

Intento de conexión y solicitud GET:

*   Trying 108.61.73.182:80...
* Connected to www.misitio.com (108.61.73.182) port 80 (#0)
> GET /index.html HTTP/1.1
> Host: www.misitio.com
> User-Agent: curl/7.74.0
> Accept: text/html

Trying 108.61.73.182:80...: curl intenta conectar al servidor en la dirección IP 108.61.73.182 en el puerto estándar de HTTP, que es el 80.
Connected to www.misitio.com (108.61.73.182) port 80 (#0): La conexión se ha establecido con éxito.
GET /index.html HTTP/1.1: Se envía la solicitud GET para obtener el recurso /index.html utilizando HTTP/1.1.
Host: www.misitio.com: El encabezado Host indica el dominio al que se está haciendo la solicitud.
User-Agent: curl/7.74.0: El User-Agent es curl versión 7.74.0, que es la herramienta utilizada para hacer la solicitud.
Accept: text/html: El cliente (curl) acepta respuestas de tipo text/html.

Respuesta del servidor:

< HTTP/1.1 301 Moved Permanently
< Server: nginx/1.14.2
< Date: Sat, 13 Apr 2024 16:53:57 GMT
< Content-Type: text/html
< Content-Length: 185
< Connection: keep-alive
< Location: https://www.misitio.com/index.html

HTTP/1.1 301 Moved Permanently: El código de estado 301 y el mensaje Moved Permanently indican que el recurso ha sido movido de manera permanente a otra URL.
Server: nginx/1.14.2: El servidor que maneja la solicitud es nginx versión 1.14.2.
Date: La fecha y hora de la respuesta.
Content-Type: text/html: El tipo de contenido de la respuesta es HTML.
Content-Length: 185: El cuerpo de la respuesta contiene 185 bytes.
Connection: keep-alive: La conexión se mantiene abierta para posibles solicitudes futuras.
Location: https://www.misitio.com/index.html: El encabezado Location indica la nueva URL a la que se ha movido el recurso.

Cuerpo de la respuesta:

<html>
<head><title>301 Moved Permanently</title></head>
<body bgcolor="white">
<center><h1>301 Moved Permanently</h1></center>
<hr><center>nginx/1.14.2</center>
</body>
</html>

Este es el cuerpo de la respuesta, que es una página HTML simple que indica que el documento se ha movido permanentemente.

Mantenimiento de la conexión:

* Connection #0 to host www.misitio.com left intact

La conexión entre curl y el servidor se mantiene intacta después de la transacción.

Conclusión:

La solicitud HTTP original se ha redirigido a una nueva URL que utiliza HTTPS (https://www.misitio.com/index.html). Deberías seguir esta nueva URL para obtener el recurso deseado. Si deseas que curl siga automáticamente la redirección y obtenga el recurso, puedes agregar la opción -L a tu comando curl:

curl -v https://www.misitio.com/index.html

La opción -L instruirá a curl para que siga cualquier redirección HTTP hasta que alcance el recurso final o hasta que se exceda el número máximo de redirecciones permitidas.

Queda para preguntar porque es un re quilombo

Ejercicio 7

El comando curl es una herramienta de línea de comandos utilizada para transferir datos desde o hacia un servidor. Se utiliza para trabajar con diversos protocolos, incluidos HTTP, HTTPS, FTP, SMTP, entre otros. curl es útil para probar, depurar y trabajar con API web o servicios de red.

-I (o --head): Este parámetro se utiliza para hacer una solicitud HTTP HEAD, lo que significa que curl recuperará solo los encabezados de una respuesta HTTP. Es útil para ver metadatos de la respuesta como el tipo de contenido, estado, cookies, y otros encabezados de respuesta sin descargar todo el cuerpo del documento.
-H (o --header): Este parámetro permite al usuario pasar encabezados adicionales en la solicitud HTTP. Por ejemplo, puede ser utilizado para incluir encabezados de autenticación, indicar el tipo de contenido que se está enviando o cualquier otro encabezado HTTP personalizado necesario para la solicitud.
-X (o --request): Este parámetro se utiliza para especificar un método de solicitud HTTP personalizado cuando se comunica con el servidor HTTP. Los valores comunes incluyen GET, POST, PUT, DELETE, etc. Por defecto, curl realiza una solicitud GET, pero con -X puedes cambiar el tipo de solicitud según sea necesario.
-s (o --silent): Este parámetro se usa para hacer que curl sea silencioso o discreto durante su operación. Cuando se utiliza, curl no mostrará la barra de progreso, pero aún proporcionará el resultado final. Es útil para scripts o para cuando se desea un resultado limpio sin información adicional de progreso o errores.

Estos parámetros permiten a los usuarios de curl personalizar sus solicitudes HTTP de diversas maneras para satisfacer diferentes necesidades de prueba y comunicación con servidores web y servicios en línea.

Ejercicio 8

Ejecute el comando curl sin ningún parámetro adicional y acceda a www.redes.unlp.edu.ar. Luego responda:

Resultado

Ejercicio 8.A)

Cuando ejecutas el comando curl sin ningún parámetro adicional accediendo a www.redes.unlp.edu.ar, estás realizando un solo requerimiento HTTP GET hacia el servidor. Este requerimiento pide al servidor que devuelva el contenido completo de la página principal del sitio.

Para ver todos los requerimientos que tu navegador realizaría normalmente al visitar una página web (como cargas de imágenes, CSS, JavaScript, etc.), necesitarías una herramienta que analice el contenido de la página y realice las solicitudes adicionales correspondientes. curl por sí solo no realiza este tipo de análisis y seguimiento de contenidos. Por defecto, curl solo hace una petición para el recurso específico que le indiques, generalmente el documento HTML principal.

Sin embargo, puedes utilizar curl para descargar los recursos individuales si conoces sus URLs exactas. Para hacer un seguimiento de todas las peticiones que un navegador haría, necesitarías una herramienta más avanzada que pueda interpretar HTML y realizar las peticiones adicionales, como un navegador en modo headless o una herramienta de línea de comandos como wget con ciertas opciones activadas.

Aquí tienes algunas maneras en las que puedes aproximarte a este proceso:

Descarga recursiva con wget: Puedes usar wget para descargar recursivamente todos los recursos de una página web. Esto es más cercano a lo que hace un navegador:

wget -r -l1 -p -k -E http://www.redes.unlp.edu.ar

Este comando intentará descargar la página principal y todos los recursos necesarios para su visualización, como CSS, JavaScript e imágenes. Las opciones son:

-r: Recursivo.
-l1: Profundidad de nivel 1.
-p: Descarga todos los recursos necesarios para mostrar la página HTML.
-k: Convierte los enlaces para que funcionen localmente.
-E: Asegura que los archivos HTML tengan la extensión .html.

curl www.redes.unlp.edu.ar > index.html

Esta imagen la dejo por aca solo para no perderla

Ejercicio 8.B)

<link href="./bootstrap/css/bootstrap.css" rel="stylesheet">: El atributo href en un elemento link generalmente se utiliza para enlazar hojas de estilo externas a la página HTML. Aquí, href apunta a la ubicación de una hoja de estilo CSS que el navegador debería cargar y aplicar a la página.
<img src="image.jpg" alt="Descripción">: Aunque en tu ejemplo no tienes un tag img explícito, típicamente el atributo src (similar en propósito al href para los elementos img) indica la ubicación de una imagen que debe ser mostrada en la página. El navegador solicita y muestra la imagen desde esta ubicación.

Ejercicio 8.C)

¿alcanza con realizar un único requerimiento?

Para visualizar completamente una página web como en un navegador, no es suficiente con realizar un único requerimiento (como lo hace curl por defecto).

¿Cuántos requerimientos serían necesarios para obtener una página que tiene dos CSS, dos Javascript y tres imágenes?

La página principal puede contener referencias a otros recursos como hojas de estilo CSS, scripts de JavaScript, imágenes, etc. Cada uno de estos recursos requerirá de su propio requerimiento HTTP para ser recuperado. Por lo tanto, para una página que tiene dos CSS, dos Javascript y tres imágenes, se necesitarían, en total, siete requerimientos HTTP adicionales además del requerimiento inicial para la página HTML.

Diferencie como funcionaría un navegador respecto al comando curl ejecutado previamente

Un navegador automáticamente realiza todos estos requerimientos adicionales cuando carga una página, interpretando el HTML, descubriendo los recursos necesarios y solicitándolos al servidor. Por el contrario, el comando curl ejecutado anteriormente solo hace el requerimiento inicial y recupera el HTML, pero no carga ni interpreta los recursos adicionales. Por eso, si abres el HTML guardado localmente sin los recursos adicionales, la página podría no verse como se espera.

Ejercicio 9

Ejecute a continuación los siguientes comandos:

curl -v -s www.redes.unlp.edu.ar > /dev/null

*   Trying 172.28.0.50:80...
* Connected to www.redes.unlp.edu.ar (172.28.0.50) port 80 (#0)
> GET / HTTP/1.1
> Host: www.redes.unlp.edu.ar
> User-Agent: curl/7.74.0
> Accept: */*
> 
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< Date: Sat, 13 Apr 2024 17:12:55 GMT
< Server: Apache/2.4.56 (Unix)
< Last-Modified: Sun, 19 Mar 2023 19:04:46 GMT
< ETag: "1322-5f7457bd64f80"
< Accept-Ranges: bytes
< Content-Length: 4898
< Content-Type: text/html
< 
{ [4898 bytes data]
* Connection #0 to host www.redes.unlp.edu.ar left intac

curl -I -v -s www.redes.unlp.edu.ar

*   Trying 172.28.0.50:80...
* Connected to www.redes.unlp.edu.ar (172.28.0.50) port 80 (#0)
> HEAD / HTTP/1.1
> Host: www.redes.unlp.edu.ar
> User-Agent: curl/7.74.0
> Accept: */*
> 
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
HTTP/1.1 200 OK
< Date: Sat, 13 Apr 2024 17:13:25 GMT
Date: Sat, 13 Apr 2024 17:13:25 GMT
< Server: Apache/2.4.56 (Unix)
Server: Apache/2.4.56 (Unix)
< Last-Modified: Sun, 19 Mar 2023 19:04:46 GMT
Last-Modified: Sun, 19 Mar 2023 19:04:46 GMT
< ETag: "1322-5f7457bd64f80"
ETag: "1322-5f7457bd64f80"
< Accept-Ranges: bytes
Accept-Ranges: bytes
< Content-Length: 4898
Content-Length: 4898
< Content-Type: text/html
Content-Type: text/html

< 
* Connection #0 to host www.redes.unlp.edu.ar left intact

Ejercicio 9.A)

curl -v -s www.redes.unlp.edu.ar > /dev/null:
- -v activa el modo verboso, que muestra la solicitud y la respuesta detalladas en la terminal.
- -s silencia la barra de progreso de curl.
- Redirige la salida del contenido (el cuerpo de la respuesta) a /dev/null, que es una ubicación en sistemas tipo Unix que descarta toda la información escrita en ella.
- La solicitud realizada es un método GET, que solicita el contenido del recurso.
curl -I -v -s www.redes.unlp.edu.ar:
- Incluye la opción -I, que modifica la solicitud para usar el método HEAD en lugar de GET. El método HEAD solicita solo las cabeceras HTTP de la respuesta, sin el cuerpo del mensaje.
- Al igual que el primer comando, -v activa el modo verboso y -s silencia la barra de progreso.
- No hay redirección del cuerpo del mensaje porque el método HEAD no retorna un cuerpo en la respuesta.

La principal diferencia es que el primer comando realiza una solicitud GET y descarta el cuerpo de la respuesta, mientras que el segundo realiza una solicitud HEAD y no recibe ni necesita descartar ningún cuerpo de respuesta.

Ejercicio 9.B)

Si se quita la redirección a /dev/null del primer comando, el cuerpo de la respuesta del servidor (que es el contenido de la página web solicitada) se mostrará en la terminal en lugar de ser descartado. Esto podría generar mucho texto en la terminal si la página solicitada tiene un contenido extenso.

En el segundo comando, la redirección a /dev/null no es necesaria porque el método HEAD no devuelve un cuerpo en la respuesta, por lo que no hay contenido para mostrar o descartar.

Ejercicio 9.C)

En ambos casos, la cantidad de cabeceras en el requerimiento es la misma:

Host: el host solicitado.
User-Agent: identifica el cliente que hace la solicitud.
Accept: los tipos de contenido que el cliente acepta.

La respuesta en ambos comandos también contiene el mismo número de cabeceras, que proporcionan información sobre:

HTTP/1.1 200 OK: el estado de la respuesta.
Date: la fecha y hora del servidor.
Server: el software del servidor.
Last-Modified: cuándo se modificó por última vez el contenido solicitado.
ETag: un identificador único para la versión específica del recurso.
Accept-Ranges: si el servidor acepta solicitudes de rango.
Content-Length: la longitud del contenido en bytes.
Content-Type: el tipo de contenido del recurso.

En resumen, el número de cabeceras que viajan en la respuesta es el mismo en ambos comandos. La diferencia principal entre los comandos es si el cuerpo de la respuesta se descarta (GET con redirección a /dev/null) o simplemente no se solicita (HEAD).

Ejercicio 10

La cabecera Date en los mensajes HTTP indica la fecha y la hora en la que el mensaje fue generado por el servidor. La fecha y la hora están siempre expresadas en formato GMT (Greenwich Mean Time), según lo establecido por el protocolo HTTP.

Por ejemplo:

Date: Sat, 13 Apr 2024 17:12:55 GMT

Funciones de la cabecera Date:

Sincronización: Ayuda a sincronizar la hora entre el servidor y el cliente. Aunque los clientes no necesariamente ajustan su hora basándose en esta cabecera, proporciona un contexto temporal para la respuesta. Esto es especialmente útil para gestionar la caché de los recursos, comparar con las cabeceras de modificación y controlar la frescura de la información.
Validación: En combinación con otras cabeceras como Last-Modified o ETag, la cabecera Date puede usarse para validar la caché. Esto puede determinar si el contenido almacenado en la caché del cliente todavía está actualizado o si necesita ser refrescado.
Seguridad: Proporciona un punto de referencia temporal para la autenticación y las firmas digitales. Por ejemplo, los tokens de autenticación pueden incluir un sello de tiempo para limitar su validez.
Condiciones para solicitudes subsecuentes: Las cabeceras como If-Modified-Since o If-Unmodified-Since pueden utilizar la fecha y hora del servidor para hacer solicitudes condicionales, basándose en cuándo se generó el último mensaje conocido por el cliente.

En resumen, la cabecera Date es un componente estándar en las respuestas HTTP que brinda una marca de tiempo oficial del servidor para el mensaje de respuesta. Es útil para los procesos de gestión de caché, seguridad y sincronización de tiempos en la comunicación entre clientes y servidores.

Ejercicio 11

En HTTP, la forma en que un cliente sabe que ha recibido todo el objeto solicitado completamente varía entre las versiones HTTP/1.0 y HTTP/1.1 debido a las diferencias en cómo gestionan las conexiones y transmiten los datos.

En HTTP/1.0, la forma principal de determinar que todo el objeto solicitado ha sido completamente recibido es a través del cierre de la conexión TCP por parte del servidor. HTTP/1.0 no tiene un mecanismo estándar para mantener la conexión abierta después de que se haya enviado una respuesta; por lo tanto, una vez que el servidor termina de enviar los datos, cierra la conexión. Cuando el cliente detecta que la conexión se ha cerrado, sabe que ha recibido toda la respuesta. Sin embargo, este enfoque tiene varias desventajas, como la necesidad de abrir una nueva conexión TCP para cada solicitud, lo que aumenta la latencia y reduce la eficiencia de la red.

HTTP/1.1 introduce varias mejoras para superar las limitaciones de HTTP/1.0, incluyendo el concepto de conexiones persistentes. En HTTP/1.1, las conexiones se mantienen abiertas por defecto, lo que permite enviar múltiples solicitudes y respuestas a través de la misma conexión TCP. Esto plantea la pregunta de cómo el cliente sabe cuándo ha recibido una respuesta completa sin el cierre de la conexión como indicador.

En HTTP/1.1, esto se logra principalmente a través de dos mecanismos:

La cabecera Content-Length: Cuando el servidor incluye la cabecera Content-Length en la respuesta, especifica la longitud exacta del cuerpo de la respuesta en bytes. El cliente usa este valor para determinar cuántos bytes necesita leer del cuerpo de la respuesta, independientemente de si la conexión se mantiene abierta para futuras solicitudes.
Transfer-Encoding chunked: En casos donde el servidor no puede determinar el tamaño total del contenido de antemano (por ejemplo, para contenido generado dinámicamente), puede utilizar la codificación de transferencia "chunked". Esto implica enviar el cuerpo de la respuesta en una serie de segmentos (chunks), cada uno precedido por su tamaño. El final de la respuesta se indica mediante un segmento de tamaño cero, seguido por los encabezados finales (si los hay) y una línea en blanco. Esto permite al cliente saber que ha recibido todo el objeto solicitado, incluso sin una longitud de contenido predeterminada.

Estos mecanismos permiten una transferencia de datos más eficiente y la reutilización de conexiones, mejorando el rendimiento general de la comunicación HTTP en la versión 1.1 respecto a la 1.0.

Ejercicio 12

Los códigos de retorno de un servidor web, también conocidos como códigos de estado HTTP, están definidos y clasificados en varias RFC, principalmente en la RFC 7231, que es parte de la serie de documentos que actualizan y definen el protocolo HTTP/1.1. Estos códigos se clasifican en cinco categorías principales:

1xx (Respuestas informativas): Indican que la solicitud fue recibida y el proceso continúa.
2xx (Respuestas exitosas): Indican que la solicitud fue recibida correctamente, entendida y aceptada.
3xx (Redirecciones): Indican que se deben tomar más acciones para completar la solicitud.
4xx (Errores del cliente): Indican que hubo un error y la solicitud no puede ser procesada debido a algo que se percibe como un error del cliente (por ejemplo, URL mal formada, falta de autenticación).
5xx (Errores del servidor): Indican que el servidor falló al intentar procesar una solicitud válida.

Ambas partes, el cliente y el servidor, están interesadas en los códigos de retorno:

Cliente: Necesita entender los códigos de estado para saber cómo proceder después de hacer una solicitud. Por ejemplo, si recibe un 200 OK, sabe que la solicitud fue exitosa; si recibe un 404 Not Found, sabe que el recurso solicitado no existe; si recibe un 301 Moved Permanently, sabe que debe realizar una nueva solicitud al URL proporcionado en la respuesta.
Servidor: Debe enviar el código de estado adecuado como parte de su respuesta para comunicar el resultado de la solicitud al cliente. Esto es crucial para el correcto funcionamiento del protocolo HTTP y para proporcionar una experiencia de usuario adecuada.

Sí, es muy útil que esta información esté detallada y clasificada en la RFC por varias razones:

Estándar Global: Proporciona un conjunto estándar de códigos de estado que pueden ser utilizados e interpretados de manera coherente por todos los servidores y clientes web en todo el mundo.
Desarrollo y Depuración: Ayuda a los desarrolladores a entender cómo deben programar sus aplicaciones cliente y servidor para manejar diferentes situaciones. También facilita la depuración al proporcionar una explicación clara de por qué una solicitud puede haber fallado.
Interoperabilidad: Asegura que diferentes aplicaciones y servicios web puedan trabajar juntos de manera efectiva, ya que todos siguen las mismas reglas para interpretar los códigos de estado.

En resumen, la clasificación y el detalle de los códigos de retorno en la RFC son fundamentales para la interoperabilidad de la web, permitiendo que clientes y servidores se comuniquen y entiendan entre sí de manera efectiva.

Ejercicio 13

Utilizando curl, realice un requerimiento con el método HEAD al sitio www.redes.unlp.edu.ar e indique:

redes@debian:~$ curl -I http://unlp.edu.ar
HTTP/1.1 301 Moved Permanently
Server: nginx/1.18.0
Date: Sat, 13 Apr 2024 17:23:56 GMT
Content-Type: text/html
Content-Length: 169
Connection: keep-alive
Location: https://unlp.edu.ar/

Ejercicio 13 A)

La primera línea de la respuesta HTTP/1.1 301 Moved Permanently indica que:

HTTP/1.1: Es la versión del protocolo HTTP que el servidor está utilizando para responder.
301: Es el código de estado HTTP que informa que el recurso solicitado ha sido movido a otra URL de forma permanente.
Moved Permanently: Es la frase de razón asociada con el código de estado 301, que proporciona una explicación textual del código de estado para la claridad humana.

Ejercicio 13 B)

La respuesta muestra 6 encabezados, que son:

Server: Información sobre el servidor web.
Date: Fecha y hora en que se generó la respuesta.
Content-Type: Tipo de contenido de la respuesta.
Content-Length: Longitud del contenido de la respuesta.
Connection: Gestión de la conexión.
Location: La nueva URL a la que se ha movido el recurso solicitado.

Ejercicio 13 C)

El servidor web que está sirviendo la página es nginx/1.18.0. Esto se indica en el encabezado Server.

Ejercicio 13 D)

El acceso a la página solicitada no fue exitoso en términos de recuperar el recurso originalmente solicitado; en cambio, se informa al cliente de que el recurso se ha movido a una nueva ubicación permanente, que es https://unlp.edu.ar/. Esto significa que la solicitud inicial de la página condujo a una redirección.

Ejercicio 13 E)

La información proporcionada no incluye cuándo fue la última vez que se modificó la página. El encabezado Last-Modified, que generalmente proporciona esta información, no está presente en la respuesta. Sin embargo, la presencia de un código de estado 301 sugiere que la URL original ha cambiado de ubicación, por lo que la "última modificación" puede referirse a cuando se realizó el cambio en la URL en lugar del contenido de la página en sí. En este caso, para obtener información sobre la última modificación del contenido real, tendrías que seguir la redirección a la nueva URL y realizar otra solicitud, posiblemente con el método GET, para obtener los encabezados relevantes.

curl -I https://unlp.edu.ar/

HTTP/2 200 
server: nginx/1.18.0
date: Sat, 13 Apr 2024 17:30:17 GMT
content-type: text/html; charset=UTF-8
link: <https://unlp.edu.ar/wp-json/>; rel="https://api.w.org/"
link: <https://unlp.edu.ar/wp-json/wp/v2/pages/390>; rel="alternate"; type="application/json"
link: <https://unlp.edu.ar/>; rel=shortlink
x-cacheable: YES:Forced
x-varnish: 312546773
age: 0
via: 1.1 varnish (Varnish/7.0)

Respuesta HTTP

HTTP/2 200:

HTTP/2: Es la versión del protocolo HTTP que el servidor está utilizando para responder. HTTP/2 es una mejora significativa con respecto a HTTP/1.1 en términos de eficiencia, velocidad y seguridad.
200: Es el código de estado HTTP que indica que la solicitud ha sido exitosa y que el servidor ha encontrado, entendido y aceptado la solicitud, y ha devuelto un recurso como respuesta.

Encabezados de respuesta

server: nginx/1.18.0: El servidor web que atiende la solicitud es Nginx versión 1.18.0.
date: Sat, 13 Apr 2024 17:30:17 GMT: Fecha y hora en que el servidor envió la respuesta.
content-type: text/html; charset=UTF-8: El tipo de contenido de la respuesta es HTML y está codificado en UTF-8.
link: Encabezados que establecen enlaces a la API de WordPress y a otras URL relacionadas con la API. Estos también proporcionan una URL corta para la página.
x-cacheable: YES:Forced: Indica que la respuesta puede ser almacenada en caché y ha sido marcada para el almacenamiento en caché forzado.
x-varnish: 312546773: Indica un identificador único para la transacción de Varnish Cache, que es un software acelerador de aplicaciones web.
age: 0: El tiempo en segundos desde que el objeto fue almacenado en caché.
via: 1.1 varnish (Varnish/7.0): Información sobre los proxies o gateways intermedios por los que pasó la respuesta, indicando que Varnish Cache ha sido utilizado.

No se proporciona un encabezado Last-Modified, por lo que no podemos determinar a partir de esta respuesta cuándo fue la última vez que se modificó el recurso. Tampoco se incluye un encabezado ETag, que a veces se utiliza junto con Last-Modified para el control de caché y la validación condicional.

Ejercicio 13 D)

Solicite la página nuevamente con curl usando GET, pero esta vez indique que quiere obtenerla sólo si la misma fue modificada en una fecha posterior a la que efectivamente fue modificada.

¿Cómo lo hace?

¿Qué resultado obtuvo?

¿Puede explicar para qué sirve?

Pasaron cosas

Ejercicio 14

Utilizando curl, acceda al sitio www.redes.unlp.edu.ar/restringido/index.php y siga las instrucciones y las pistas que vaya recibiendo hasta obtener la respuesta final. Será de utilidad para resolver este ejercicio poder analizar tanto el contenido de cada página como los encabezados

curl www.redes.unlp.edu.ar/restringido/index.php

curl www.redes.unlp.edu.ar/obtener-usuario.php

curl -H "Usuario-Redes: obtener" www.redes.unlp.edu.ar/obtener-usuario.php

Authorization: Basic {credenciales_codificadas_en_base64}

Las "credenciales_codificadas_en_base64" son simplemente el nombre de usuario y la contraseña concatenados con un dos puntos (:) entre ellos, luego todo esto codificado en base64. Para el usuario "redes" y la contraseña "RYC", esto sería:

Concatenar usuario y contraseña con un dos puntos: redes:RYC.
Codificar este string en base64. Puedes hacer esto en una terminal Linux usando el comando: echo -n 'redes:RYC' | base64. Asegúrate de incluir la opción -n para echo para evitar que se añada un salto de línea al final del string antes de codificarlo.

echo -n 'redes:RYC' | base64

cmVkZXM6UllD

Una vez que tienes la cadena codificada en base64, puedes hacer la solicitud con curl de la siguiente manera:

curl -H "Authorization: Basic cmVkZXM6UllD" www.redes.unlp.edu.ar/obtener-usuario.php

curl -I -H "Authorization: Basic cmVkZXM6UllD" www.redes.unlp.edu.ar/obtener-usuario.php

curl -H "Authorization: Basic cmVkZXM6UllD" www.redes.unlp.edu.ar/the-end.php

Ejercicio 15

Utilizando la VM, realice las siguientes pruebas:

Parte a

Ejecute el comando

curl www.redes.unlp.edu.ar/extras/prueba-http-1-0.txt

Y copie la salida completa (incluyendo los dos saltos de linea del final).

Parte b

Desde la consola ejecute el comando.

telnet www.redes.unlp.edu.ar 80

Y luego pegue el contenido que tiene almacenado en el portapapeles.

telnet www.redes.unlp.edu.ar 80

redes@debian:~$ telnet www.redes.unlp.edu.ar 80
Trying 172.28.0.50...
Connected to www.redes.unlp.edu.ar.
Escape character is '^]'.
GET /http/HTTP-1.1/ HTTP/1.0
User-Agent: curl/7.38.0
Host: www.redes.unlp.edu.ar
Accept: */*



HTTP/1.1 200 OK
Date: Tue, 26 Mar 2024 01:39:42 GMT
Server: Apache/2.4.56 (Unix)
Last-Modified: Sun, 19 Mar 2023 19:04:46 GMT
ETag: "760-5f7457bd64f80"
Accept-Ranges: bytes
Content-Length: 1888
Connection: close
Content-Type: text/html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Protocolo HTTP: versiones</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="description" content="">
    <meta name="author" content="">

    <!-- Le styles -->
    <link href="../../bootstrap/css/bootstrap.css" rel="stylesheet">
    <link href="../../css/style.css" rel="stylesheet">
    <link href="../../bootstrap/css/bootstrap-responsive.css" rel="stylesheet">

    <!-- HTML5 shim, for IE6-8 support of HTML5 elements -->
    <!--[if lt IE 9]>
      <script src="./bootstrap/js/html5shiv.js"></script>
    <![endif]-->
  </head>

  <body>


    <div id="wrap">
        
    <div class="navbar navbar-inverse navbar-fixed-top">
      <div class="navbar-inner">
        <div class="container">
          <a class="brand" href="../../index.html"><i class="icon-home icon-white"></i></a>
          <a class="brand" href="https://catedras.info.unlp.edu.ar" target="_blank">Redes y Comunicaciones</a>
          <a class="brand" href="http://www.info.unlp.edu.ar" target="_blank">Facultad de Inform&aacute;tica</a>
          <a class="brand" href="http://www.unlp.edu.ar" target="_blank">UNLP</a>
        </div>
      </div>
    </div>

    <div class="container">
    <h1>Ejemplo del protocolo HTTP 1.1</h1>
    <p>
        Esta p&aacute;gina se visualiza utilizando HTTP 1.1. Utilizando el capturador de paquetes analice cuantos flujos utiliza el navegador para visualizar la p&aacute;gina con sus im&aacute;genes en contraposici&oacute;n con el protocolo HTTP/1.0.
    </p>
    </p>
    <h2>Imagen de ejemplo</h2>
    <img src="13532-tuxkiller03green.png" width="800px"/>
    </div> 
    
    
    </div>
    <div id="footer">
      <div class="container">
        <p class="muted credit">Redes y Comunicaciones</p>
      </div>
    </div>
  </body>
</html>
Connection closed by foreign host.

La salida del comando telnet que has ejecutado muestra una sesión típica de comunicación HTTP entre tu cliente (en este caso, la sesión Telnet que está simulando un navegador) y el servidor web en www.redes.unlp.edu.ar.

Aquí te explico lo que ocurrió luego de hacerlo:

Establecimiento de la conexión:
- Trying 172.28.0.50...: Intenta conectarse al servidor.
- Connected to www.redes.unlp.edu.ar.: Se estableció la conexión con éxito.
- Escape character is '^]'.: Indica que puedes presionar Ctrl+] para entrar en el modo de comando Telnet.
Envío de la solicitud HTTP:
- A través de Telnet, enviaste manualmente una solicitud HTTP al servidor. La solicitud incluye:
  - Línea de solicitud: GET /http/HTTP-1.1/ HTTP/1.0, que solicita el recurso /http/HTTP-1.1/ utilizando el protocolo HTTP versión 1.0.
  - Encabezados de solicitud: Incluyen User-Agent, que identifica el cliente que hace la solicitud; Host, que especifica el dominio al que se está haciendo la solicitud; y Accept, que indica los tipos de contenido que el cliente está dispuesto a recibir.
Respuesta del servidor:
- El servidor responde con la versión del protocolo HTTP/1.1 y el código de estado 200 OK, indicando que la solicitud ha sido exitosa.
- Los encabezados de respuesta incluyen información como la fecha, el servidor, la última modificación del contenido, el rango de aceptación de bytes, la longitud del contenido y el tipo de contenido.
- La conexión se cierra después de enviar la respuesta, como lo indica Connection: close, que es el comportamiento esperado cuando un cliente HTTP/1.0 realiza una solicitud.
Contenido HTML:
- Después de los encabezados, el servidor devuelve el cuerpo de la respuesta, que es un documento HTML. Este documento contiene la estructura de una página web típica, incluidos elementos como links a hojas de estilo CSS y scripts, así como contenido textual e imágenes.
Cierre de la conexión:
- Connection closed by foreign host.: El servidor cierra la conexión después de enviar la respuesta completa. Esto es típico de las conexiones HTTP/1.0, donde cada solicitud y respuesta requieren una nueva conexión.

Lo que ocurrió después de pegar el contenido en Telnet es que el servidor procesó tu solicitud HTTP y te devolvió una respuesta que incluía el contenido HTML para el recurso solicitado. La conexión se cerró después, siguiendo el modelo de "una solicitud, una respuesta" de HTTP/1.0.

Parte c

Repita el proceso anterior, pero copiando la salida del recurso /extras/prueba-http-1-1.txt. Verifique que debería poder pegar varias veces el mismo contenido sin tener que ejecutar telnet nuevamente.

curl www.redes.unlp.edu.ar/extras/prueba-http-1-1.txt

Es lo mismo pero podes ingresar varios inputs

Ejercicio 16

En base a lo obtenido en el ejercicio anterior, responda:

En HTTP/1.0, cada conexión se cierra después de que se envía una sola respuesta. Esto significa que cada vez que un cliente necesita enviar una nueva solicitud HTTP, debe establecer una nueva conexión TCP. Este es un proceso relativamente lento y ineficiente porque el establecimiento de una conexión TCP requiere varios pasos (el proceso de "handshake" o saludo).

En cambio, en HTTP/1.1, se introdujo el concepto de "conexiones persistentes", que permiten que varias solicitudes y respuestas se envíen a través de la misma conexión TCP. Esto reduce la sobrecarga asociada con el establecimiento de nuevas conexiones y hace que la comunicación sea más eficiente. Por defecto, las conexiones en HTTP/1.1 son persistentes a menos que se especifique lo contrario

Estás iniciando una conexión manual a un servidor web y escribiendo directamente solicitudes HTTP en la terminal. En el contexto de HTTP/1.1, si envías varias solicitudes a través de una sesión de telnet, el servidor mantiene la conexión abierta, permitiéndote enviar varias solicitudes y recibir sus respectivas respuestas sin necesidad de reconectar cada vez.

curl por defecto hace una sola solicitud y cierra la conexión (a menos que se especifique lo contrario con opciones como --keepalive). curl es más automatizado y manejable para solicitudes únicas, mientras que con telnet estás manejando la conexión manualmente, lo que te permite ver el comportamiento de la conexión persistente en HTTP/1.1.

Observe la definición de método y recurso en la RFC. Luego responda

Get

Preguntar

La diferencia principal es que con HTTP/1.0, la conexión se cierra después de cada respuesta, mientras que con HTTP/1.1, la conexión se mantiene abierta para solicitudes adicionales.

Esto se debe al diseño de los protocolos: HTTP/1.1 fue diseñado para ser más eficiente al permitir múltiples transacciones por conexión, reduciendo la sobrecarga de la conexión.

HTTP/1.1 es más eficiente en términos de uso de la red debido a las conexiones persistentes.

Piense en el ejercicio donde analizó la cantidad de requerimientos necesarios para obtener una página con estilos, javascripts e imágenes.

Las conexiones persistentes (HTTP/1.1) pueden aumentar el uso de recursos del servidor porque las conexiones se mantienen abiertas más tiempo. Esto podría ser un problema para servidores con alto tráfico o recursos limitados. Sin embargo, en general, los beneficios en términos de eficiencia y rendimiento suelen superar estos inconvenientes.

Ejercicio 17

En el siguiente ejercicio veremos la diferencia entre los métodos POST y GET. Para ello, será necesario utilizar la VM y la herramienta Wireshark. Antes de iniciar considere:

Capture los paquetes utilizando la interfaz con IP 172.28.0.1. (Menú Capture->Options. Luego seleccione la interfaz correspondiente y presione Start).

Para que el analizador de red sólo nos muestre los mensajes del protocolo http introduciremos la cadena ‘http’ (sin las comillas) en la ventana de especificación de filtros de visualización (display-filter).

Si no hiciéramos esto veríamos todo el tráfico que es capaz de capturar nuestra placa de red. De los paquetes que son capturados, aquel que esté seleccionado será mostrado en forma detallada en la sección que está justo debajo. Como sólo estamos interesados en http ocultaremos toda la información que no es relevante para esta práctica (Información de trama, Ethernet, IP y TCP). Desplegar la información correspondiente al protocolo HTTP bajo la leyenda “Hypertext Transfer Protocol”

Para borrar la cache del navegador, deberá ir al menu “Herramientas->Borrar historial reciente”.

Alternativamente puede utilizar Ctrl+F5 en el navegador para forzar la petición HTTP evitando el uso de caché del navegador.

En caso de querer ver de forma simplificada el contenido de una comunicación http, utilice el botón derecho sobre un paquete HTTP perteneciente al flujo capturado y seleccione la opción Follow TCP Stream.

Parte a

Abra un navegador e ingrese a la URL: www.redes.unlp.edu.ar e ingrese al link en la sección Capa de Aplicación llamado Métodos HTTP. En la página mostrada se visualizan dos nuevos links llamados: Método GET y Método POST. Ambos muestran un formulario como el siguiente:

Analice el código HTML.

Utilizando el analizador de paquetes Wireshark capture los paquetes enviados y recibidos al presionar el botón Enviar.

¿Qué diferencias detectó en los mensajes enviados por el cliente?

¿Observó alguna diferencia en el browser si se utiliza un mensaje u otro?

Lo pude resolver en Blog usando Wireshark

Ejercicio 18

El principal uso de Set-Cookie (que el servidor utiliza para enviar cookies al cliente) y Cookie (que el cliente utiliza para enviar cookies de vuelta al servidor) en HTTP es para la gestión del estado de la sesión. Esto incluye mantener a los usuarios autenticados, rastrear preferencias del usuario, gestionar carritos de compras en sitios de comercio electrónico, y más. Las cookies permiten que la información persista entre diferentes solicitudes HTTP en un protocolo que por diseño es sin estado.

Ejercicio 19

Protocolo basado en texto: Este tipo de protocolo utiliza texto legible por humanos para la comunicación entre dispositivos o programas. Los mensajes se componen de texto claro, lo que facilita su lectura y depuración sin necesidad de herramientas adicionales. Sin embargo, este tipo de protocolos puede resultar menos eficiente en términos de tamaño del mensaje y velocidad de procesamiento. Ejemplos incluyen HTTP/1.0 y HTTP/1.1.
Protocolo binario: Este tipo de protocolo utiliza estructuras de datos binarias para la comunicación. Los mensajes son compactos y están diseñados para ser procesados rápidamente por la máquina, pero no son legibles directamente por los humanos. Los protocolos binarios suelen ser más eficientes en términos de rendimiento y tamaño de mensaje que los basados en texto, pero pueden ser más difíciles de depurar sin herramientas especiales. Un ejemplo común es el Protocolo de Control de Transmisión (TCP) a nivel de transporte.

HTTP/1.0 y HTTP/1.1: Estas versiones de HTTP son protocolos basados en texto. Utilizan texto claro para definir las solicitudes y respuestas, incluyendo métodos, URI, cabeceras y cuerpos del mensaje. Esto los hace fáciles de leer y escribir para los humanos, pero potencialmente más grandes en tamaño y más lentos de procesar que los mensajes binarios debido a la sobrecarga del texto.
HTTP/2: A diferencia de sus predecesores, HTTP/2 es un protocolo principalmente binario. Aunque las solicitudes y respuestas HTTP siguen conceptualmente el mismo formato (métodos, cabeceras, cuerpos), en HTTP/2 estas son codificadas en estructuras binarias llamadas "frames". Esto permite un envío más eficiente, como la compresión de cabeceras y la multiplexación (enviar múltiples solicitudes y respuestas en paralelo a través de la misma conexión). Aunque los mensajes en HTTP/2 son binarios, las cabeceras y otros elementos todavía pueden representarse y enviarse en un formato legible por humanos cuando se visualizan a través de herramientas de depuración.

Ejercicio 20

Responder las siguientes preguntas:

Parte a

¿Qué función cumple la cabecera Host en HTTP 1.1?

¿Existía en HTTP 1.0?

¿Qué sucede en HTTP/2?

Parte b

¿Cómo quedaría en HTTP/2 el siguiente pedido realizado en HTTP/1.1 si se está usando https?

GET /index.php HTTP/1.1
Host: www.info.unlp.edu.ar

Ejercicio Parcial

curl -X ?? www.redes.unlp.edu.ar/??

Resultado

> HEAD /metodos/ HTTP/??
> Host: www.redes.unlp.edu.ar
> User-Agent: curl/7.54.0
< HTTP/?? 200 OK
< Server: nginx/1.4.6 (Ubuntu)
< Date: Wed, 31 Jan 2018 22:22:22 GMT
< Last-Modified: Sat, 20 Jan 2018 13:02:41 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: close

La versión de HTTP que probablemente esté utilizando el servidor es HTTP/1.1, como se indica en la línea de respuesta < HTTP/1.1 200 OK. HTTP/1.1 es una versión común que soporta características como la conexión persistente y el host virtual, lo cual es indicado por el uso de la cabecera Host.

El método que se está utilizando es HEAD.

Este método es utilizado para recuperar las cabeceras que un GET habría obtenido, pero sin el cuerpo del mensaje, es decir, no retorna el recurso completo, solo los metadatos del recurso. Es útil para obtener información sobre el recurso sin descargar todo el contenido.

El recurso solicitado es /metodos/ en el host www.redes.unlp.edu.ar. Esta es una URI que probablemente apunta a un directorio o sección específica en el servidor web de redes.unlp.edu.ar.

Sí, el método funcionó correctamente. Esto se evidencia por el código de estado 200 OK en la respuesta del servidor, que indica que la solicitud fue exitosa y que el servidor pudo responder adecuadamente a la solicitud HEAD.

Si la solicitud hubiera llevado un encabezado que diga: If-Modified-Since: Sat, 20 Jan 2018 13:02:41 GMT

Si la solicitud incluyera el encabezado If-Modified-Since: Sat, 20 Jan 2018 13:02:41 GMT, la respuesta del servidor web habría dependido de si el recurso fue modificado después de esa fecha y hora:

Si el recurso no fue modificado después de Sat, 20 Jan 2018 13:02:41 GMT, el servidor habría respondido con un código 304 Not Modified. Esto indica que no hay necesidad de retransmitir el recurso porque la copia que el cliente tiene en caché todavía es válida.
Si el recurso fue modificado después de esa fecha y hora, el servidor habría respondido con 200 OK y habría enviado los metadatos actualizados (o el contenido completo si se hubiera utilizado GET).

En el caso de recibir un 304 Not Modified, el navegador habría utilizado la versión en caché del recurso, ahorrando ancho de banda y mejorando la velocidad de carga al no tener que descargar nuevamente el recurso completo.

Cuestionario

Pregunta 1

Indicar de forma breve la diferencia entre el método GET y el PUT

El get es para solicitar datos de un recurso (una url por ejemplo)
Put se usa para enviar datos al servido

Pregunta 2

Indicar cuales características mejoran el rendimiento de HTTP

Seleccione una o más de una:

a) Uso de SSL
b) Compresión de headers ✔️
c) Pipelining ✔️
d) Conexiones persistentes ✔️
e) Binary Framing ✔️

Las respuestas correctas son: Pipelining, Conexiones persistentes, Compresión de headers, Binary Framing

Pregunta 3

En HTTP 1.0 no se pueden usar conexiones persistentes

Seleccione una:

Verdadero
Falso ✔️

Pregunta 4

Los códigos HTTP 3XX están relacionados con re direcciones

Seleccione una:

Verdadero ✔️
Falso

Pregunta 5

HTTP no mantiene estados, por más que tenga conexiones persistentes

Seleccione una:

Verdadero ✔️
Falso

Curl

curl -O www.redes.unlp.edu.ar/restringido/index.php
curl -o file.html www.redes.unlp.edu.ar/
curl -I www.redes.unlp.edu.ar/
curl -H "Authorization: Basic cmVkZXM6UllD" www.redes.unlp.edu.ar/restringido/index.php
curl -I -L http://unlp.edu.ar
curl -u redes:RYC www.redes.unlp.edu.ar/restringido/index.php
curl -X POST http://www.redes.unlp.edu.ar/http/metodos-lectura-valores.php
curl -v -I http://www.redes.unlp.edu.ar
curl -s http://www.redes.unlp.edu.ar1

Descarga el Recurso de la URL

curl -O www.redes.unlp.edu.ar/restringido/index.php

Descargamos La Pagina y le asignamos el nombre `file.html`

curl -o file.html  www.redes.unlp.edu.ar/

Realiza una solicitud HTTP HEAD

curl -I  www.redes.unlp.edu.ar/

Añade un encabezado adicional de autentificación

curl -H "Authorization: Basic cmVkZXM6UllD" www.redes.unlp.edu.ar/restringido/index.php

User-Agent: Mozilla/5.0 Modifica el agente de usuario para simular solicitudes desde diferentes navegadores o dispositivos.
Cache-Control: no-cache Puedes controlar o probar cómo una página web responde a diferentes directivas de caché.
Accept: application/jsonEspecificar qué tipos de contenido estás dispuesto a recibir. Por ejemplo, solicitar específicamente contenido en formato JSON.
Accept-Language: esSolicitar una página en un idioma específico.
Cookie: name=valueEnviar cookies específicas en la solicitud, lo cual puede ser necesario para acceder a contenido que requiere de sesión o preferencias de usuario.
Referer: http://www.otroejemplo.comSimular el origen de una solicitud mediante el encabezado Referer. Esto puede ser útil para pruebas o para acceder a recursos que requieren un referer específico.
Accept-Encoding: gzip, deflateIndicar al servidor que puedes recibir contenido codificado (por ejemplo, comprimido con gzip), lo cual puede mejorar la eficiencia de la transferencia de datos.

Sigue redireccionamientos HTTP.

curl no sigue redireccionamientos por defecto.

curl -I -L http://unlp.edu.ar

Para autenticación básica HTTP.

usuario:contraseña: redes:RYC

curl -u redes:RYC www.redes.unlp.edu.ar/restringido/index.php

Post usando el curl

Mira, antes de poder hacer un post (por lo que tengo entendido) necesitas mirar el formulario y ver que nombre tienen los campos del mismo para poder insertar los datos.

curl http://www.redes.unlp.edu.ar/http/metodo-post.html

Si te pinta se lo podes pasar a chat-gpt el resultado y seguro te devuelve un comando como el siguiente

curl -X POST http://www.redes.unlp.edu.ar/http/metodos-lectura-valores.php \
-d "form_nombre=Juan" \
-d "form_apellido=Perez" \
-d "form_mail=juan.perez@email.com" \
-d "form_sexo=sexo_masc" \
-d "form_pass=contraseña123" \
-d "form_confirma_mail=on"

La opción -d se usa para enviar datos. Si tienes múltiples campos, puedes repetir -d para cada par clave-valor.
Para campos de texto (input type="text"), simplemente envía el texto que deseas ingresar.
Para botones de radio (input type="radio"), envía el valor del botón que deseas que esté seleccionado.
Para checkboxes (input type="checkbox"), solo necesitas incluir el campo si deseas que esté marcado, generalmente asignándole el valor on. Si no lo incluyes, es como si no estuviera marcado.
La contraseña debe ser enviada como texto plano en este tipo de solicitud, lo cual puede ser un riesgo de seguridad si la conexión no está cifrada. Asegúrate de que estás usando HTTPS para proteger la información sensible.
Este comando asume que todos los campos son necesarios. Si alguno es opcional, puedes omitirlo según lo que requiera el formulario.

Una vez que lo realizamos lo podemos chequear de la siguiente forma:

curl -o file2.html -X POST http://www.redes.unlp.edu.ar/http/metodos-lectura-valores.php \
-d "form_nombre=Juan" \
-d "form_apellido=Perez" \
-d "form_mail=juan.perez@email.com" \
-d "form_sexo=sexo_masc" \
-d "form_pass=contraseña123" \
-d "form_confirma_mail=on"

Para obtener solo los encabezados (HEAD request) de una respuesta de manera detallada (verbose)

curl -v -I http://www.redes.unlp.edu.ar

Este comando es útil para inspeccionar encabezados de respuesta como Content-Type, Content-Length, Server, Last-Modified y cualquier cookie o política de seguridad aplicada.

El comando curl -v -I http://www.redes.unlp.edu.ar que ejecutaste realiza una solicitud HTTP HEAD a la URL especificada y muestra una salida detallada (verbose) del proceso. Aquí te explico cada parte de la salida:

Inicio de la Conexión

Trying 172.28.0.50:80...: curl intenta establecer una conexión TCP al servidor en la dirección IP 172.28.0.50 en el puerto 80, que es el puerto estándar para el protocolo HTTP.
Connected to www.redes.unlp.edu.ar (172.28.0.50) port 80 (#0): La conexión TCP ha sido establecida exitosamente al servidor en la dirección IP y puerto especificados.

Envío de la Solicitud HEAD

HEAD / HTTP/1.1: curl envía una solicitud HEAD al servidor. Una solicitud HEAD es similar a GET, pero el servidor devuelve solo los encabezados y no el cuerpo del documento. Esto es útil para obtener metadatos sin descargar todo el contenido.
Host: www.redes.unlp.edu.ar: Especifica el host al que se está haciendo la solicitud. Es necesario para servidores que alojan múltiples dominios (hosting virtual).
User-Agent: curl/7.74.0: Identifica el agente del usuario que realiza la solicitud. En este caso, es curl con su versión.
Accept: */*: Indica que el cliente aceptará cualquier tipo de contenido como respuesta.

Respuesta del Servidor

HTTP/1.1 200 OK: El servidor responde con un código de estado 200, lo que indica que la solicitud ha sido procesada con éxito.
Date: Sun, 31 Mar 2024 17:07:45 GMT: La fecha y hora en que la respuesta fue enviada.
Server: Apache/2.4.56 (Unix): Información sobre el software del servidor que está manejando la solicitud.
Last-Modified: Sun, 19 Mar 2023 19:04:46 GMT: La última vez que el recurso solicitado fue modificado.
ETag: "1322-5f7457bd64f80": Un identificador único asignado al contenido actual del recurso, que puede ser utilizado para futuras solicitudes condicionales (cache validation).
Accept-Ranges: bytes: Indica que el servidor acepta solicitudes de rangos de bytes, lo cual es útil para reanudar descargas interrumpidas o para descargar partes de un contenido.
Content-Length: 4898: El tamaño en bytes del cuerpo del documento que habría sido enviado en una solicitud GET.
Content-Type: text/html: El tipo de contenido que habría sido devuelto, en este caso text/html.

Finalización de la Conexión

* Connection #0 to host www.redes.unlp.edu.ar left intact: Indica que la conexión con el servidor se ha dejado intacta después de la respuesta. En el caso de las solicitudes HEAD, como no hay cuerpo de respuesta, la conexión se puede reutilizar para futuras solicitudes.

Este desglose te muestra cómo curl establece una conexión, envía una solicitud, recibe y muestra la respuesta del servidor, proporcionando una visión detallada del intercambio de datos entre el cliente y el servidor web.

Modo Silencioso

curl -s http://www.redes.unlp.edu.ar1

El parámetro -s en curl se utiliza para activar el modo "silencioso" o "silencio". Cuando se utiliza este parámetro, curl no muestra el indicador de progreso ni los errores que normalmente se imprimirían en la terminal durante la ejecución del comando. Esto hace que -s sea especialmente útil en scripts o cuando deseas capturar la salida de curl sin incluir información adicional que normalmente se muestra.

Aquí tienes un ejemplo básico de cómo se vería un comando curl sin el parámetro -s:

curl http://www.ejemplo.com

Al ejecutar este comando, dependiendo de la configuración y el contexto, curl podría mostrar el progreso de la descarga, lo cual incluiría información sobre la cantidad de datos transferidos y la velocidad de transferencia. Si hubiera algún problema con la solicitud, como una URL no válida o problemas de conexión, curl también mostraría mensajes de error en la salida estándar.

Ahora, veamos cómo se utilizaría el parámetro -s:

curl -s http://www.ejemplo.com

Al agregar -s, curl ejecuta la solicitud sin mostrar ningún mensaje de progreso o error. La única salida en la terminal será el contenido obtenido de http://www.ejemplo.com, si la solicitud fue exitosa.

Usos adicionales y combinaciones

A menudo, el parámetro -s se combina con otros para lograr comportamientos específicos:

-S (--show-error): Muestra el mensaje de error en caso de fallo, incluso en modo silencioso. Es útil cuando quieres un entorno silencioso pero aún necesitas capturar errores.
```
curl -s -S http://www.ejemplo.com
```
-o (--output): Especifica un archivo donde guardar la salida en lugar de imprimirla en la terminal.
```
curl -s -o ejemplo.html http://www.ejemplo.com
```
Aquí, la combinación de -s y -o significa que curl no mostrará progreso ni errores (salvo que también uses -S), y guardará el contenido de la página en ejemplo.html.

El modo silencioso es especialmente valioso en scripts donde solo te interesa el resultado de la operación curl y deseas evitar salidas innecesarias que podrían obstruir el flujo normal o el procesamiento de la salida. También es útil cuando se integra curl en aplicaciones que invocan comandos externos y donde el manejo de la salida se realiza a través de la captura y análisis de la misma por la aplicación.

Ejercicio de Parcial

curl -X ?? www.redes.unlp.edu.ar/??
> HEAD /metodos/ HTTP/??
> Host: www.redes.unlp.edu.ar
> User-Agent: curl/7.54.0
< HTTP/?? 200 OK
< Server: nginx/1.4.6 (Ubuntu)
< Date: Wed, 31 Jan 2018 22:22:22 GMT
< Last-Modified: Sat, 20 Jan 2018 13:02:41 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: close

a. ¿Qué versión de HTTP podría estar utilizando el servidor?

La versión de HTTP que el servidor está utilizando no se especifica directamente en el fragmento que proporcionaste, pero dado que la respuesta incluye un código de estado HTTP sin una versión específica en la línea de estado (< HTTP/?? 200 OK), podemos inferir que se omitió por simplicidad en el ejemplo. Sin embargo, podemos hacer una suposición educada de que se trata de HTTP/1.1, ya que es la versión más comúnmente utilizada que soporta encabezados como "Host" y un comportamiento de conexión como el descrito. HTTP/2 cambiaría significativamente la forma en que se formatea la respuesta (es decir, es binario), y la solicitud no parece estar utilizando la sintaxis específica de HTTP/2.

b. ¿Qué método está utilizando? Dicho método, ¿retorna el recurso completo solicitado?

El método que se está utilizando es HEAD, como se indica en la primera línea de la solicitud (HEAD /metodos/ HTTP/??). El método HEAD solicita los encabezados de respuesta que se enviarían para una solicitud GET al mismo recurso, pero sin incluir el cuerpo del recurso en la respuesta. Por lo tanto, no, el método HEAD no retorna el recurso completo solicitado, solo los metadatos asociados con el recurso.

c. ¿Cuál es el recurso solicitado?

El recurso solicitado parece ser /metodos/, como se indica en la línea de solicitud. Hay una pequeña confusión en la forma en que se formatea la solicitud (/metodos/ HTTP/??), lo cual sugiere un error tipográfico o una omisión intencional de la versión de HTTP. Normalmente, se esperaría algo como HEAD /metodos/ HTTP/1.1.

d. ¿El método funcionó correctamente?

Sí, el método funcionó correctamente. La respuesta del servidor indica un código de estado 200 OK, lo que significa que la solicitud se procesó con éxito y los metadatos del recurso están siendo devueltos en los encabezados.

e. Si la solicitud hubiera llevado un encabezado que diga: If-Modified-Since: Sat, 20 Jan 2018 13:02:41 GMT ¿Cuál habría sido la respuesta del servidor web? ¿Qué habría hecho el navegador en este caso?

Si la solicitud incluyera el encabezado If-Modified-Since: Sat, 20 Jan 2018 13:02:41 GMT, y el recurso no se ha modificado desde esa fecha y hora (lo cual es cierto basado en el encabezado Last-Modified de la respuesta), el servidor habría respondido con un código de estado 304 Not Modified. Esto indica al cliente que la versión del recurso que tiene en caché sigue siendo válida y puede ser reutilizada.

En este caso, el navegador no descargaría el recurso nuevamente; en su lugar, utilizaría la versión que ya tiene en su caché, mejorando la eficiencia al reducir la necesidad de transferir datos innecesariamente.

Wireshark

Nos vamos a basar en un ejercicio para redes que se me complico bastante

No te asustes, es solo para ver la ip de las interfaces

Hubo una pregunta que me solicitaba buscar el trafico de la interfaz y solo me habian dado la IP por eso este quilombo

lo (Loopback Interface): Permite a la máquina comunicarse consigo misma. Es utilizado principalmente para pruebas y desarrollo.
enp0s3 (Ethernet Interface): Esta es tu interfaz de red principal conectada a la red externa, probablemente a través de Ethernet o una conexión similar.
br-c8ee5a5c812e (Network Bridge): Utilizado para conectar dos redes, común en ambientes de virtualización como Docker, permitiendo que los contenedores se comuniquen entre sí y con el host.
docker0: Un puente de red creado por Docker. Normalmente se utiliza para la comunicación de red entre los contenedores Docker y el host del sistema.
vethXXXXX (Virtual Ethernet Devices): Estos son dispositivos de red virtuales utilizados por Docker para conectar contenedores individuales al puente de Docker o a otros dispositivos de red.

Cada entrada muestra el estado de la interfaz, configuraciones como MTU (Maximum Transmission Unit), y direcciones IP asignadas. Las interfaces veth están asociadas con entornos de red específicos, típicamente contenedores Docker, lo que permite su aislamiento y gestión de red independiente.

El comando netstat -i muestra la tabla de interfaces de red del kernel. Para cada interfaz, indica:

MTU (Maximum Transmission Unit): El tamaño máximo de paquete que la interfaz puede manejar.
RX-OK: Número de paquetes recibidos correctamente.
RX-ERR: Número de paquetes recibidos con errores.
RX-DRP: Número de paquetes recibidos descartados.
RX-OVR: Número de errores de desbordamiento en la recepción.
TX-OK: Número de paquetes enviados correctamente.
TX-ERR: Número de paquetes enviados con errores.
TX-DRP: Número de paquetes enviados descartados.
TX-OVR: Número de errores de desbordamiento en el envío.
Flg (Flags): Indica el estado de la interfaz (B: broadcast, M: multicast, R: running, U: up, L: loopback).

Todo lo anterior fue para poder entrar a wireshark (saber la interfaz de la `IP`)

Tenemos que abrir Wireshark usando sudo, sino, no captura el trafico. Y en otra terminal usamos curl sobre algo.

IMPORTANTE: Para que te funcione tenes que estar ejecutando curls constantemente o cuando desees ver la respuesta en otra terminal.

Por ejemplo

curl https://www.google.com

este usamos en la catedra

curl www.redes.unlp.edu.ar

curl -I www.redes.unlp.edu.ar

La captura de pantalla muestra una sesión de Wireshark, una herramienta utilizada para analizar el tráfico de red. En ella, podemos ver varios paquetes de datos intercambiados entre dispositivos en la red:

Paquetes DNS (Domain Name System): Estos paquetes se utilizan para la resolución de nombres de dominio. Por ejemplo, convertir "www.redes.unlp.edu.ar" en una dirección IP.
Paquetes TCP (Transmission Control Protocol): Muestran la comunicación entre dos dispositivos, incluidos los detalles de la conexión como sincronización (SYN), acuse de recibo (ACK), y finalización (FIN).
Paquetes HTTP (Hypertext Transfer Protocol): Son solicitudes y respuestas de datos web, como solicitudes de páginas web (indicado por GET) y respuestas del servidor (HTTP/1.1 200 OK indica una respuesta exitosa).
Paquetes ARP (Address Resolution Protocol): Se utilizan para mapear una dirección IP a una dirección MAC en la red local.

Cada fila representa un paquete diferente, y las columnas proporcionan información como el tiempo, las direcciones de origen y destino, el protocolo utilizado y una breve descripción del contenido del paquete.

Filtramos por http

Podemos ver el resultado haciendo click derecho y dandole a follow TCP stream

Si uso el metodo get sobre el formulario de una pagina puedo ver la respuesta

curl -X POST -d "form_nombre=Fabian&form_apellido=Martinez" www.redes.unlp.edu.ar

Creo que la cosa esa no funciono, probamos con este

curl -X POST -d "Nombre=Juan&Apellido=Perez&Email=juan.perez@example.com&Sexo=Masculino&Contrasena=miContrasena&Recibir=on" http://www.redes.unlp.edu.ar/http/metodo-post.html

Tengo que preguntar porque creo que esta mal

Practica 3 Redes | DNS

Tue, 07 May 2024 00:00:00 GMT

Introducción

El Sistema de Nombres de Dominio (DNS) traduce nombres de dominio amigables para el humano (como "www.example.com") a direcciones IP numéricas (como "192.0.2.1") que las computadoras utilizan para identificar entre sí en la red.

El objetivo del DNS es permitir a las personas acceder a sitios web utilizando nombres de dominio fáciles de recordar en lugar de las complicadas direcciones IP, facilitando así la navegación en internet. Funciona a través de una red distribuida de servidores que resuelven nombres de dominio a direcciones IP.

Un servidor raíz (root server) en el contexto del Sistema de Nombres de Dominio (DNS) es uno de los servidores DNS clave que contienen las direcciones de los servidores de nombres para todos los dominios de nivel superior (TLDs) como .com, .org, .net, .gov, entre otros. Los servidores raíz son una parte crítica de la infraestructura de Internet porque son la primera parada en la resolución de nombres de dominio cuando la información no está ya en la caché del servidor DNS local.

Existen 13 servidores raíz, identificados por las letras A a M. Cada uno de estos servidores raíz opera en múltiples ubicaciones geográficas utilizando tecnología de Anycast para proporcionar estabilidad y redundancia.

Cómo Ver un Ejemplo de Servidor Raíz Usando Comandos

Puedes utilizar el comando dig para consultar los servidores raíz y ver cómo responden con la lista de servidores de nombres para los TLDs. Aquí te muestro cómo hacerlo:

Listar todos los servidores raíz DNS:
```
dig NS .
```
Este comando te mostrará la lista de los servidores de nombres raíz. La respuesta de dig incluirá una sección ANSWER que lista los nombres de los servidores raíz y sus direcciones IP correspondientes.
Seleccionar un servidor raíz y hacer una consulta directa: Para ilustrar, vamos a seleccionar el servidor raíz a.root-servers.net para obtener más información sobre el dominio TLD .com.
```
dig @a.root-servers.net com NS
```
Este comando consulta directamente al servidor raíz A para los servidores de nombres que administran el TLD .com. La opción @ en dig se usa para especificar el servidor DNS que quieres consultar directamente.

Ejemplo Práctico en el Terminal

Supongamos que ejecutas los siguientes comandos en tu terminal:

dig NS .

Este comando podría devolver algo como:

; <<>> DiG 9.10.6 <<>> NS .
;; global options: +cmd
.			518400	IN	NS	a.root-servers.net.
.			518400	IN	NS	b.root-servers.net.
.			518400	IN	NS	c.root-servers.net.
...

Luego, al consultar directamente al servidor raíz A para el TLD .com:

dig @a.root-servers.net com NS

Podrías recibir una respuesta como:

; <<>> DiG 9.10.6 <<>> @a.root-servers.net com NS
; (1 server found)
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 43521
;; flags: qr rd; QUERY: 1, ANSWER: 0, AUTHORITY: 13, ADDITIONAL: 14
;; QUESTION SECTION:
;com.				IN	NS

;; AUTHORITY SECTION:
com.			172800	IN	NS	a.gtld-servers.net.
com.			172800	IN	NS	b.gtld-servers.net.
com.			172800	IN	NS	c.gtld-servers.net.
...

Este ejemplo muestra cómo los servidores raíz dirigen las consultas hacia los servidores de nombres específicos para los TLDs, facilitando así la resolución de nombres en toda la red global de Internet.

Un Generic Top-Level Domain (gTLD) es una categoría de dominios de nivel superior en el Sistema de Nombres de Dominio (DNS) de Internet que no está asociada con un país específico. Los gTLDs son uno de los tipos de dominios más reconocidos y utilizados en Internet. Están destinados a usos generales por comunidades de usuarios, generalmente organizados por tema o tipo de entidad, a diferencia de los ccTLDs (Country Code Top-Level Domains) que están específicamente asociados a países o territorios.

Características de los gTLDs

Generalidad: Como su nombre lo indica, los gTLDs son genéricos, lo que significa que están destinados a un amplio uso por parte de la población de Internet sin restricciones específicas basadas en la geografía.
Diversidad: Los gTLDs abarcan una amplia gama de nombres que reflejan diferentes tipos de organizaciones, actividades comerciales, aplicaciones y grupos de usuarios. Incluyen dominios como .com, .org, .net, .info, .biz, y muchos otros.
Administración: Los gTLDs son supervisados por la ICANN (Internet Corporation for Assigned Names and Numbers), que es responsable de la gestión del espacio de nombres DNS, la asignación de espacio de direcciones IP, la asignación de identificadores de protocolo, y la gestión del sistema de servidores raíz.

Ejemplos de gTLDs

.com: Inicialmente destinado para entidades comerciales, es ahora el gTLD más ampliamente utilizado y puede ser registrado por cualquier persona o entidad.
.org: Destinado originalmente para organizaciones que no encajaban en ninguna otra categoría (como las no comerciales y las sin fines de lucro), también es ampliamente utilizado por escuelas, comunidades, proyectos, y grupos personales.
.net: Originalmente para organizaciones involucradas en tecnologías de redes, como proveedores de Internet y otras infraestructuras de red, aunque ahora está abierto a cualquier persona.
.info: Uno de los primeros gTLDs introducidos que estaba destinado para sitios de información, pero no tiene restricciones de uso.
.biz: Diseñado para uso comercial (negocios), como una alternativa a .com.

Nuevos gTLDs

Con el programa de Nuevos gTLDs que la ICANN comenzó en 2012, se han introducido cientos de nuevos gTLDs para proporcionar mayor diversidad y opciones en el espacio de nombres de Internet. Estos incluyen dominios como .photography, .guru, .club, y .city, entre otros. Estos nuevos gTLDs permiten una mayor personalización y especificidad en los nombres de dominio, facilitando que las empresas y particulares elijan nombres que están más estrechamente alineados con sus actividades o intereses.

En resumen, los gTLDs son una parte esencial de la estructura de DNS, proporcionando un marco para clasificar y organizar los nombres de dominio de Internet. Con la expansión de los gTLDs, el paisaje de Internet sigue evolucionando, ofreciendo más opciones y oportunidades para la personalización y la innovación en el espacio en línea.

Una respuesta autoritativa en el contexto del Sistema de Nombres de Dominio (DNS) es una respuesta que proviene directamente de un servidor DNS que tiene autoridad sobre el dominio específico que está siendo consultado. Es decir, el servidor DNS que responde tiene datos directos y oficiales sobre los registros DNS del dominio, sin necesidad de referirse a otro servidor DNS para obtener esa información.

Características de una Respuesta Autoritativa

Exactitud: La respuesta proviene de un servidor que gestiona directamente los registros del dominio, lo que garantiza que la información es exacta y actualizada.
Directa: No depende de la información almacenada en caché o proporcionada por servidores intermedios.
Flag AA (Authoritative Answer): En los resultados de consultas DNS, la respuesta autoritativa está marcada con un flag AA (Authoritative Answer) que indica que la respuesta proviene de un servidor con autoridad sobre el dominio.

Ejemplo Práctico Usando `dig`

Para ilustrar una respuesta autoritativa, podemos usar el comando dig para consultar un servidor de nombres específico que es autoritativo para un dominio. Vamos a tomar como ejemplo el dominio "example.com", consultando directamente a uno de sus servidores DNS autoritativos:

Encontrar el servidor de nombres autoritativo:

Primero, encontramos los servidores de nombres para el dominio "example.com".
```
dig NS example.com
```
Supongamos que esto devuelve ns1.example.com como uno de los servidores de nombres autoritativos.
Consultar directamente al servidor autoritativo:

Luego, hacemos una consulta directa a ns1.example.com para obtener un registro específico (por ejemplo, un registro A para "www.example.com"):
```
dig @ns1.example.com www.example.com A
```
En esta consulta, @ns1.example.com especifica que queremos que dig consulte directamente a ese servidor de nombres. La respuesta que recibamos tendrá el flag AA establecido, indicando que es una respuesta autoritativa.

Verificación del Flag Autoritativo

Cuando usas dig, puedes verificar si una respuesta es autoritativa observando el campo de flags en la salida. Busca aa en la línea de flags, lo cual está presente cuando la respuesta es autoritativa.

;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

En este ejemplo, aa indica que la respuesta es autoritativa.

Importancia de las Respuestas Autoritativas

Las respuestas autoritativas son cruciales para la integridad y la confiabilidad del DNS. Aseguran que la información que recibe un usuario o un sistema sobre un dominio es precisa y proviene de una fuente fiable y controlada, lo cual es especialmente importante para operaciones críticas como la configuración de servicios en línea, seguridad y correo electrónico.

En resumen, las respuestas autoritativas del DNS son fundamentales para el funcionamiento correcto y seguro de Internet, y herramientas como dig te permiten verificar y entender cómo se resuelven estas consultas en la práctica.

En el Sistema de Nombres de Dominio (DNS), las consultas pueden procesarse de dos formas principales: recursiva e iterativa. Estas dos modalidades difieren en cómo un servidor DNS maneja las solicitudes de resolución de nombres de dominio cuando no tiene la información requerida en su caché.

Consulta DNS Recursiva

En una consulta DNS recursiva, el cliente (generalmente el sistema operativo del dispositivo del usuario o el resolver de DNS del ISP) pide a un servidor DNS que resuelva un nombre de dominio y le devuelva la respuesta definitiva. El cliente espera que el servidor maneje completamente la resolución del nombre:

Responsabilidad Total: Si el servidor DNS recursivo no tiene la información requerida ya en su caché, asume la responsabilidad de obtener esa información. No devuelve el control al cliente hasta que ha resuelto la dirección o determinado que no puede hacerlo.
Proceso de Resolución: El servidor DNS recursivo consultará otros servidores DNS en nombre del cliente. Comenzará por los servidores raíz, seguirá con los servidores de nombres de dominios de nivel superior (TLDs), y continuará hasta llegar a los servidores DNS autoritativos para el dominio específico en cuestión.
Ventajas: Proporciona una experiencia simplificada al cliente, ya que solo requiere una solicitud y espera una respuesta, sin necesidad de realizar seguimientos adicionales.

Consulta DNS Iterativa

En una consulta DNS iterativa, el servidor DNS no resuelve completamente la solicitud por sí solo. En cambio, proporciona al cliente la mejor respuesta que tiene y, si es necesario, direcciones de otros servidores DNS que pueden saber más:

Responsabilidad Parcial: Cuando un cliente hace una consulta iterativa a un servidor DNS y este servidor no tiene la respuesta en su caché, este responderá con la dirección de un servidor DNS que esté más cerca de la respuesta. El cliente es responsable de consultar al siguiente servidor recomendado.
Proceso de Resolución: El servidor DNS proporciona referencias a otros servidores DNS (por ejemplo, un servidor raíz DNS dirá al cliente que consulte a un servidor DNS específico de un TLD). El cliente sigue consultando a cada servidor recomendado hasta que obtiene la respuesta final o agota las opciones.
Ventajas: Reduce la carga en cada servidor DNS individual, ya que cada servidor no tiene que completar la resolución completa por cuenta propia. Permite a los clientes controlar el proceso de resolución y gestionar el tiempo de espera y las respuestas fallidas de manera más directa.

Ejemplo Ilustrativo con Comandos

Si quisieras ver cómo funcionan estas consultas en la práctica, podrías usar herramientas como dig en un sistema Linux o macOS, o nslookup en Windows. Por ejemplo, con dig:

# Ejemplo de consulta recursiva (por defecto con dig)
dig www.example.com

# Ejemplo de consulta iterativa
dig +trace www.example.com

En el caso de dig +trace, dig realiza una simulación de una consulta iterativa mostrando cada paso del proceso, desde los servidores raíz hasta los servidores autoritativos para el dominio. Esto ilustra cómo un cliente podría manejar una consulta iterativa.

Conclusión

La elección entre consultas recursivas e iterativas depende de las necesidades de configuración del sistema, las preferencias de administración de red y los requisitos de desempeño y seguridad. Las consultas recursivas simplifican la resolución para los clientes, mientras que las iterativas ofrecen mayor control y potencialmente reducen la carga sobre los servidores DNS individuales.

PARA PARA, TODAVIA NO PROBAMOS LOS COMANDOS

dig www.redes.unlp.edu.ar

; <<>> DiG 9.16.27-Debian <<>> www.redes.unlp.edu.ar
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 4692
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 2d4327c415909aa401000000661b3ae6a70f3f8d9d721ca0 (good)
;; QUESTION SECTION:
;www.redes.unlp.edu.ar.		IN	A

;; ANSWER SECTION:
www.redes.unlp.edu.ar.	300	IN	A	172.28.0.50

;; Query time: 4 msec
;; SERVER: 172.28.0.29#53(172.28.0.29)
;; WHEN: Sat Apr 13 23:09:42 -03 2024
;; MSG SIZE  rcvd: 94

La salida del comando dig que ejecutaste para la dirección www.redes.unlp.edu.ar muestra varios componentes del proceso de resolución DNS y provee información detallada sobre la consulta. Aquí te explico cada parte de la salida para entender mejor lo que está sucediendo:

HEADER Section

opcode: QUERY: Esto indica que el tipo de operación solicitada fue una consulta.
status: NOERROR: Indica que la consulta se completó sin errores.
id: 4692: Es un identificador único de la transacción DNS. Utilizado para emparejar respuestas con solicitudes.
flags:
- qr (Query Response): Indica que esta es una respuesta a una consulta.
- aa (Authoritative Answer): Significa que el servidor que respondió tiene autoridad sobre el dominio, ofreciendo una respuesta autoritativa.
- rd (Recursion Desired): Muestra que el cliente solicitó que el servidor realice una búsqueda recursiva.
- ra (Recursion Available): Indica que el servidor puede hacer consultas recursivas.

OPT PSEUDOSECTION

EDNS (Extension Mechanisms for DNS) version: 0: Esto es una extensión de DNS que permite funcionalidades adicionales.
udp: 1232: El tamaño máximo del mensaje UDP que el servidor DNS puede manejar.
COOKIE: Es una extensión de seguridad para autenticar y autorizar la transacción DNS.

QUESTION SECTION

;www.redes.unlp.edu.ar. IN A: Esto muestra la pregunta realizada, que busca el registro A (dirección IPv4) para www.redes.unlp.edu.ar.

ANSWER SECTION

www.redes.unlp.edu.ar. 300 IN A 172.28.0.50: Esta es la respuesta, mostrando que www.redes.unlp.edu.ar está asociado con la dirección IP 172.28.0.50. El 300 es el TTL (Time to Live), que indica en segundos cuánto tiempo puede ser cacheada esta respuesta antes de requerir una actualización.

Additional Information

Query time: 4 msec: Tiempo que tomó realizar la consulta, en este caso, 4 milisegundos.
SERVER: 172.28.0.29#53(172.28.0.29): Dirección IP y puerto del servidor DNS que respondió a la consulta.
WHEN: Fecha y hora en la que se realizó la consulta.
MSG SIZE rcvd: 94: Tamaño del mensaje de respuesta recibido en bytes.

Resumen

El comando dig ejecutado realizó correctamente la consulta DNS para el dominio www.redes.unlp.edu.ar y obtuvo una respuesta autoritativa indicando que la dirección IP asociada con este dominio es 172.28.0.50. La consulta fue resuelta rápidamente (en 4 milisegundos) y la respuesta incluye detalles de configuración EDNS y medidas de seguridad como cookies de DNS. Esto demuestra que el servidor DNS configurado está funcionando correctamente y puede resolver consultas para el dominio especificado de manera eficaz y segura.

NOS QUEDA EL ITERATIVO

dig +trace www.redes.unlp.edu.ar

; <<>> DiG 9.16.27-Debian <<>> +trace www.redes.unlp.edu.ar
;; global options: +cmd
.			516425	IN	NS	m.root-servers.net.
.			516425	IN	NS	c.root-servers.net.
.			516425	IN	NS	i.root-servers.net.
.			516425	IN	NS	b.root-servers.net.
.			516425	IN	NS	d.root-servers.net.
.			516425	IN	NS	g.root-servers.net.
.			516425	IN	NS	a.root-servers.net.
.			516425	IN	NS	e.root-servers.net.
.			516425	IN	NS	h.root-servers.net.
.			516425	IN	NS	k.root-servers.net.
.			516425	IN	NS	l.root-servers.net.
.			516425	IN	NS	f.root-servers.net.
.			516425	IN	NS	j.root-servers.net.
.			516425	IN	RRSIG	NS 8 0 518400 20240426170000 20240413160000 5613 . b76jdsKNW1pvIKErb2EuvBW2DmpfBhRXB5PPKV1kwvHbgkib2JTPt51i 0DDpwaxJR7I/soLWEDJOGGwzx33AYXqhXLhQGlGxwvpEq4a9tV8sEJg7 FttTjkCW/wJnN1wFWxlTjy4u/E7bO/hzw4/mjdz3orLBPT7V0ydgiT7o xxPZDD0DDQ7eXdAFs9eEQs2RTwJWqgi2q49DA3ZxelxpdB7no5TI4VKM HIv0GGWWNWimRybEWV8sy6Rvx6CYHNIMKjAqAUzpf5oF78Q5prgo22Ro EGKWPIcaxU+57t+uZGZCwCG3uUuafbiOoOpS8+WiEWBiz5vel64iCNvH pCiqUA==
;; Received 1137 bytes from 172.28.0.29#53(172.28.0.29) in 0 ms

ar.			172800	IN	NS	a.lactld.org.
ar.			172800	IN	NS	c.dns.ar.
ar.			172800	IN	NS	d.dns.ar.
ar.			172800	IN	NS	e.dns.ar.
ar.			172800	IN	NS	f.dns.ar.
ar.			172800	IN	NS	ar.cctld.authdns.ripe.net.
ar.			86400	IN	DS	19606 8 2 4415CF1A2CF10DE94B92BC020F21D1BF4163B2E90F2A6F6A5D2A1740 339D566C
ar.			86400	IN	RRSIG	DS 8 1 86400 20240426170000 20240413160000 5613 . MGenw6Ik9gXDyLJNfh3kipGhjOcpGBSvWAdsWG4ydh5eq1HTJIGqxxKR mOiJuLG/Kw4ajwi5Htc6R0E+5pIa1QYwo6SWN6soZcwmwPzdJD41rOwH 85JPHqTTcbGZYGAk8SlD5xC4/eeRavK+mWZWmRWvkZrlOPpecNCtqkVZ Fs3xY/tEAjXhmXTNi8trm1qTMaCX4sqtJeJZyKihqXjJShAYXWyPoQF0 GyazHaNKOgV/prLq1pkaoqnexjM+v+KbWcAMo4eKic2F/3OjaRPes2yh ZduGH2cHCglPGm5pS/O4VHDiMVeEBj1RYydk+/XhgQWEAWscDQ13ASLk c4ZPIA==
;; Received 784 bytes from 199.7.83.42#53(l.root-servers.net) in 64 ms

unlp.edu.ar.		3600	IN	NS	ns1.riu.edu.ar.
unlp.edu.ar.		3600	IN	NS	unlp.unlp.edu.ar.
unlp.edu.ar.		3600	IN	NS	anubis.unlp.edu.ar.
unlp.edu.ar.		3600	IN	DS	13327 5 1 D56823AE3C414F9190D84EE063606918D04513D9
unlp.edu.ar.		3600	IN	DS	13327 5 2 898DC7FBFC8837E7F3AD30400354D54FE28FD94FBC5B7793CB88CF88 9B6AB63C
unlp.edu.ar.		3600	IN	RRSIG	DS 8 3 3600 20240509012234 20240408030001 30010 edu.ar. T1tr8uhwz8jGTXcMw0heD18gJ1SUa9SbBziwwzy2X8CRF7VOLGLQZwcE 0hC4G0Lr3adTa7mMdQzlgZxPzqQBt/6Qq+S5c/U1XhSd7QNyn8nm99kJ G+6z81qPZ7ybR9tN9M9OBMIt7lo6q/+5WL14cU3RSpjox7/v+BsLmXwb 7QQ=
;; Received 539 bytes from 200.108.148.50#53(c.dns.ar) in 128 ms

unlp.edu.ar.		3600	IN	SOA	anubis.unlp.edu.ar. root.anubis.unlp.edu.ar. 2024032620 28800 900 1209600 3600
unlp.edu.ar.		3600	IN	RRSIG	SOA 5 3 7200 20240514010002 20240414010002 44211 unlp.edu.ar. IdFIg5I8Tsqnbvqf0GU350BLHh5XdFuzxFMk+7R3ffnJ9SGir4NTWzFP 4e5UNJ2w1odTJGoeJohYsSgOBwoo5zy/1i6AqTlcQNbGdhwQi8ckc7dc MjAnosXYSlhySIUSn44bTNhKeS1mkNU4FwNiLNoZvzvimiM9xsCyL5j0 Hac=
unlp.edu.ar.		3600	IN	NSEC	_acme-challenge.unlp.edu.ar. A NS SOA MX TXT AAAA RRSIG NSEC DNSKEY
unlp.edu.ar.		3600	IN	RRSIG	NSEC 5 3 3600 20240425232106 20240326232106 44211 unlp.edu.ar. dokCs3L9XAyMGrlu1aAx01QvR7/aDnSzW1zJfWa2RlRnOpr9eWwQEyaN MzHzy4qqDsBMfDKk8wg5dqnRCR8AZiXtu+l6YX2L1bJbcBfF9ULZ6wOU mmRRsV3Wxa9KCf3ZyYdm4qoZZGnqTjfBvKJpnkC2/1EPQkslPzeo9jFV BkU=
www.reddemuseos.unlp.edu.ar. 3600 IN	NSEC	rediab.unlp.edu.ar. A RRSIG NSEC
www.reddemuseos.unlp.edu.ar. 3600 IN	RRSIG	NSEC 5 5 3600 20240425232106 20240326232106 44211 unlp.edu.ar. XESIof48Fv+GVXbRH+VnICQEX+WzmGlcVroawei/9oW2tO7t/iVFpqno Nk/xd/Jels87TfWv6x7CJoDSN/fo5mhBaOieG+c+pdw9Ow6LQKcUPqYo Z5fa3E/DjuLZjVKaNEXL9+21Fmd1adGm7ot8RTkEfJJNI0bIAzOtPCbr ct4=
;; Received 767 bytes from 170.210.0.18#53(ns1.riu.edu.ar) in 8 ms

El comando dig +trace www.redes.unlp.edu.ar que has ejecutado realiza una traza de la ruta que toma una consulta DNS desde los servidores raíz del DNS hasta los servidores específicos que manejan el registro de www.redes.unlp.edu.ar. Este comando es extremadamente útil para entender el proceso de resolución DNS y para identificar posibles problemas de configuración en la ruta de resolución de nombres. Aquí está la desglose de la salida proporcionada:

Etapas de la Traza DNS

Servidores Raíz:
- La consulta comienza en los servidores raíz (.root-servers.net). Estos son los servidores más altos en la jerarquía DNS y tienen la responsabilidad de referir las consultas hacia los servidores de nombres de los dominios de nivel superior (TLDs) correspondientes.
- Los servidores raíz proporcionan las direcciones de los servidores de nombres para el TLD .ar, que es relevante para este dominio.
Servidores TLD para .ar:
- Los servidores para el TLD .ar, como a.lactld.org y otros servidores dns.ar, reciben la consulta de los servidores raíz.
- Estos servidores de TLD son responsables de administrar todos los dominios que terminan en .ar y proporcionan las direcciones de los servidores de nombres específicos para el dominio unlp.edu.ar.
Servidores de nombres para unlp.edu.ar:
- La consulta llega luego a los servidores de nombres específicos para unlp.edu.ar (ns1.riu.edu.ar, unlp.unlp.edu.ar, y anubis.unlp.edu.ar).
- Estos servidores son los que realmente tienen la información autoritativa sobre subdominios dentro de unlp.edu.ar, incluyendo www.redes.unlp.edu.ar.

Detalles Importantes de la Salida

Información de Seguridad (DNSSEC):
- DS (Delegation Signer) y RRSIG (Resource Record Signature) son registros relacionados con DNSSEC, que es un conjunto de extensiones de seguridad para proteger la información proporcionada por el DNS.
- Estos registros son usados para verificar la integridad y autenticidad de las respuestas DNS, previniendo ataques como envenenamiento de caché y spoofing.
SOA (Start of Authority):
- Este registro aparece en la respuesta para unlp.edu.ar y contiene información administrativa sobre la zona, incluyendo el servidor primario, el contacto de correo electrónico, y varios temporizadores que afectan la operación del nombre de dominio.
NSEC (Next Secure Record):
- Este es otro registro relacionado con DNSSEC, utilizado para proporcionar prueba de inexistencia de un registro DNS y para listar los tipos de registros existentes en un dominio.

Conclusión

La salida del comando dig +trace muestra el camino completo que recorre una consulta DNS, desde los servidores raíz hasta los servidores autoritativos que finalmente contienen la información sobre el dominio solicitado. Observar estos pasos ayuda a comprender cómo se estructura y se administra el espacio de nombres global de Internet y también es vital para la resolución de problemas y la garantía de la configuración correcta del DNS.

En el contexto del Sistema de Nombres de Dominio (DNS), un resolver es un componente crucial que actúa como intermediario entre el usuario y los servidores DNS complejos para traducir los nombres de dominio en direcciones IP. El resolver, también conocido como "cliente DNS", es esencial para el funcionamiento diario de Internet, permitiendo a los usuarios acceder a los recursos web mediante nombres de dominio legibles por humanos en lugar de las direcciones IP numéricas.

Funciones del Resolver

Interpretación de Solicitudes: Cuando escribes una URL en tu navegador, esta solicitud es recibida por el resolver DNS de tu sistema o red. El resolver interpreta y procesa esta solicitud para determinar cómo obtener la dirección IP asociada con el nombre de dominio.
Caché de Resultados: Para mejorar la eficiencia y reducir la carga en la red, el resolver almacena respuestas recientes en su caché. Si un nombre de dominio ha sido resuelto recientemente y la respuesta aún es válida según su Time To Live (TTL), el resolver puede devolver la dirección IP desde su caché sin necesidad de hacer más consultas externas.
Consulta Recursiva: Si la respuesta no está en la caché, el resolver puede actuar de manera recursiva. Esto significa que consultará otros servidores DNS en nombre del usuario para resolver el nombre de dominio de manera completa y transparente. Comienza con los servidores raíz, luego pasa a los servidores de los TLD (Top-Level Domain), y finalmente a los servidores de nombres autoritativos para el dominio específico, hasta obtener la información necesaria.
Manejo de Fallos y Errores: El resolver gestiona la lógica necesaria para manejar fallos en la red o respuestas erróneas de los servidores DNS, intentando diferentes servidores o métodos alternativos hasta resolver la solicitud de manera satisfactoria.

Tipos de Resolvers

Stub Resolver: Este tipo de resolver realiza funciones básicas y se encuentra típicamente en sistemas operativos de clientes. Generalmente envía consultas a un servidor DNS más equipado y no realiza el seguimiento completo de la consulta desde los servidores raíz hasta los autoritativos.
Recursive Resolver: Un resolver recursivo, como los que operan los proveedores de servicios de internet (ISP) o servicios DNS públicos (como Google DNS, Cloudflare, etc.), realiza consultas completas partiendo de los servidores raíz hasta los servidores autoritativos para el dominio solicitado. Estos resolvers tienen la capacidad de manejar completamente el proceso de resolución DNS, almacenando caché y realizando consultas recursivas según sea necesario.

Importancia del Resolver

La funcionalidad del resolver es esencial para la experiencia del usuario en Internet, ya que permite acceder a sitios web y otros recursos en línea mediante nombres de dominio fáciles de recordar en lugar de direcciones IP complejas. Además, al manejar eficientemente las consultas DNS, los resolvers contribuyen significativamente a la reducción del tráfico innecesario en la red y a la mejora general del rendimiento de Internet.

En resumen, el resolver DNS es una pieza fundamental de la infraestructura de Internet que facilita la comunicación entre los nombres de dominio y las direcciones IP, garantizando que los usuarios puedan acceder a los recursos de Internet de manera rápida y confiable.

Describa para qué se utilizan los siguientes tipos de registros de DNS:

Asocia un nombre de dominio con una dirección IPv4. Este registro se utiliza para traducir nombres de dominio a sus correspondientes direcciones IP para que los navegadores puedan encontrar y acceder a los sitios web.

Indica el servidor de correo que debe ser utilizado para entregar el correo electrónico a un dominio. Este registro es esencial para la configuración del correo electrónico y dirige el correo entrante a los servidores de correo adecuados.

Realiza la función opuesta a la de los registros A y AAAA; asocia una dirección IP con un nombre de dominio canónico. Se utiliza principalmente para la resolución inversa de DNS, es decir, cuando se traduce una dirección IP en un nombre de dominio.

Similar al registro A, pero se utiliza para asociar un nombre de dominio con una dirección IPv6.

Proporciona información sobre los servicios disponibles en un dominio. Especifica el nombre de host y el puerto para servicios específicos (como VoIP o mensajería instantánea), permitiendo a los dominios definir la localización de servidores y servicios específicos.

Especifica los servidores DNS autorizados para un dominio. Estos servidores DNS son los que contienen los registros DNS de ese dominio y pueden responder consultas relativas a él.

Permite que un dominio se asocie con otro nombre de dominio, el "nombre canónico". Se utiliza para apuntar varios nombres de dominio a un mismo lugar, facilitando la gestión de sitios que pueden ser accedidos mediante múltiples nombres.

Contiene información esencial sobre el dominio y la zona, como el servidor DNS principal, el correo electrónico del administrador, el intervalo de actualización y la caducidad. Es el registro inicial de cualquier zona de DNS y establece la autoridad del dominio.

Permite que los administradores inserten texto arbitrario en un registro DNS. Comúnmente se utiliza para verificar la propiedad del dominio, implementar políticas de seguridad del correo electrónico como SPF (Sender Policy Framework) y DKIM (DomainKeys Identified Mail), y otras aplicaciones que requieren leer datos en forma de texto de los registros DNS.

Ejercicio 7

Redundancia y Alta Disponibilidad: La presencia de múltiples servidores DNS asegura que si uno falla debido a problemas técnicos, mantenimiento o ataques de denegación de servicio (DDoS), otro puede continuar resolviendo las solicitudes de nombres de dominio, manteniendo el sitio web o servicio accesible para los usuarios.
Balanceo de carga: Distribuir las solicitudes entre varios servidores DNS puede ayudar a manejar mejor el volumen de tráfico, evitando la sobrecarga en un único servidor y mejorando el tiempo de respuesta para las solicitudes de los usuarios.
Resiliencia ante ataques: Tener múltiples servidores DNS, idealmente en diferentes ubicaciones geográficas, puede ofrecer una mejor protección contra ataques dirigidos. Si un servidor es atacado, los otros pueden seguir funcionando, minimizando el impacto del ataque.
Mejora del rendimiento y la velocidad de respuesta: La presencia de servidores DNS en diferentes ubicaciones geográficas puede reducir la latencia al responder solicitudes de usuarios cercanos a esos servidores, mejorando así la experiencia general del usuario al acceder a un dominio.
Descentralización: La distribución de los servidores DNS contribuye a la descentralización de la infraestructura de Internet, haciéndola menos vulnerable a fallos o ataques que podrían afectar a un punto centralizado.

En resumen, tener múltiples servidores DNS mejora la robustez, seguridad y eficiencia del sistema de nombres de dominio en Internet, contribuyendo a una experiencia de usuario más fiable y rápida.

Cuando un dominio cuenta con más de un servidor, uno de ellos es el primario (o maestro) y todos los demás son los secundarios (o esclavos).

La configuración de servidores DNS primarios (maestros) y secundarios (esclavos) se utiliza para la gestión eficaz de los registros DNS y para asegurar la redundancia y consistencia de la información de dominio a través de Internet.

Sincronización y Consistencia de Datos: El servidor DNS primario mantiene la versión autoritativa de los registros de zona del dominio. Cualquier cambio en la configuración del DNS, como añadir o modificar registros A, MX, CNAME, etc., se realiza primero en el servidor primario. Los servidores secundarios luego sincronizan estos cambios desde el primario, asegurando que todos los servidores proporcionen respuestas consistentes a las consultas DNS.
Redundancia y Disponibilidad: Al tener múltiples servidores DNS secundarios, se garantiza que si el servidor primario falla o se vuelve inaccesible, los servidores secundarios pueden continuar respondiendo las consultas DNS, manteniendo la disponibilidad del servicio o sitio web asociado al dominio. Esto es crucial para la alta disponibilidad y la resistencia a fallos.
Distribución de Carga: Los servidores secundarios también ayudan a distribuir la carga de las solicitudes DNS, especialmente para sitios web de alto tráfico. Al distribuir las consultas entre varios servidores, se reduce la carga en el servidor primario y se mejora el tiempo de respuesta para los usuarios finales.
Seguridad: En algunos casos, mantener los servidores secundarios puede aumentar la seguridad. Por ejemplo, se puede configurar el servidor primario en una red segura, no accesible directamente desde Internet, y solo permitir que los servidores secundarios, ubicados en diferentes redes, sincronicen los datos y respondan a las solicitudes externas.
Eficiencia en la Actualización de Datos: Al realizar cambios solo en el servidor primario, se simplifica la administración de los registros DNS. Los servidores secundarios automáticamente obtienen y replican estos cambios a través de un proceso llamado transferencia de zona, lo que facilita la gestión de los registros DNS para los administradores.

Esta estructura de primario-secundario asegura que los cambios se propaguen de manera controlada y eficiente a través de la infraestructura de DNS, manteniendo la integridad y la disponibilidad de los datos críticos para el funcionamiento de Internet.

El mecanismo de transferencia de zona en DNS es un proceso por el cual los registros DNS de una zona específica son copiados (transferidos) de un servidor DNS autoritativo (el servidor primario o maestro) a otro servidor DNS (el servidor secundario o esclavo). Este proceso se realiza para asegurar que los servidores secundarios tengan una copia exacta y actualizada de los registros DNS mantenidos por el servidor primario.

La finalidad principal de la transferencia de zona es:

Redundancia y Disponibilidad: Garantizar que múltiples servidores DNS puedan responder a las consultas sobre un dominio, incluso si el servidor primario está inaccesible debido a mantenimiento, fallas o ataques. Esto mejora la disponibilidad y la resiliencia del sistema DNS.
Consistencia de Datos: Asegurar que todos los servidores secundarios tengan la misma información DNS que el servidor primario, manteniendo la consistencia de los datos a través de la red. Esto es crucial para evitar conflictos o respuestas incorrectas a las consultas DNS.
Balanceo de Carga: Distribuir las consultas DNS entre varios servidores para manejar eficientemente el tráfico y reducir la carga en cualquier servidor individual. Esto puede mejorar el rendimiento general del sistema DNS y reducir los tiempos de respuesta para los usuarios finales.

La transferencia de zona puede ocurrir de dos formas: transferencia completa de zona (AXFR), donde todos los registros de la zona son transferidos en su totalidad, o transferencia incremental de zona (IXFR), donde solo se transfieren los cambios realizados desde la última transferencia. Esto último ayuda a optimizar el ancho de banda y los recursos al minimizar la cantidad de datos transferidos entre servidores.

Ejercicio 10

Imagine que usted es el administrador del dominio de DNS de la UNLP (unlp.edu.ar). A su vez, cada facultad de la UNLP cuenta con un administrador que gestiona su propio dominio (por ejemplo, en el caso dela Facultad de Informática se trata de info.unlp.edu.ar).

Suponga que se crea una nueva facultad, Facultad de Redes, cuyo dominio será redes.unlp.edu.ar, y el administrador le indica que quiere poder manejar su propio dominio.

(Pista: investigue en qué consiste la delegación de dominios).

Para permitir que el administrador de la Facultad de Redes gestione el dominio redes.unlp.edu.ar de forma independiente, debería realizar una delegación de dominio. La delegación de dominio es un proceso en el sistema de nombres de dominio (DNS) por el cual la autoridad administrativa y de gestión de un subdominio se transfiere del administrador del dominio principal a otro servidor DNS, que generalmente es controlado por una organización o individuo diferente. En este caso, del dominio unlp.edu.ar al nuevo subdominio redes.unlp.edu.ar. Aquí están los pasos a seguir:

Crear registros NS en el dominio principal: Debes agregar registros del tipo NS (Name Server) en la zona DNS de unlp.edu.ar para el subdominio redes.unlp.edu.ar. Estos registros NS indicarán los servidores DNS que tienen autoridad sobre el subdominio redes.unlp.edu.ar. Por ejemplo:
```
redes.unlp.edu.ar. IN NS ns1.redes.unlp.edu.ar.
redes.unlp.edu.ar. IN NS ns2.redes.unlp.edu.ar.
```
Especificar los servidores DNS para el subdominio: Debes configurar o asegurarte de que los servidores DNS especificados en los registros NS (en este ejemplo, ns1.redes.unlp.edu.ar y ns2.redes.unlp.edu.ar) estén configurados correctamente para servir el subdominio redes.unlp.edu.ar. Esto implica configurar una nueva zona DNS en estos servidores para redes.unlp.edu.ar.
Agregar registros A para los servidores DNS del subdominio: Si los servidores DNS del subdominio (ns1.redes.unlp.edu.ar, ns2.redes.unlp.edu.ar) no tienen aún una dirección IP asignada visible globalmente, necesitas agregar registros A en la zona DNS de unlp.edu.ar para resolver estas direcciones. Por ejemplo:
```
ns1.redes.unlp.edu.ar. IN A 192.0.2.1
ns2.redes.unlp.edu.ar. IN A 192.0.2.2
```
Configuración de la zona para el subdominio: En los servidores DNS del subdominio, se debe configurar una zona para redes.unlp.edu.ar. Esta configuración incluirá todos los registros DNS necesarios para el subdominio, como registros A, MX, TXT, etc., permitiendo al administrador de la Facultad de Redes gestionar estos registros de forma independiente.

Al completar estos pasos, habrás delegado con éxito la gestión del subdominio redes.unlp.edu.ar al administrador de la Facultad de Redes, permitiéndole controlar completamente los registros DNS dentro de su propio subdominio. Es crucial asegurarse de que todos los servidores DNS involucrados estén configurados correctamente y sincronizados para garantizar la resolución de nombres eficaz y sin interrupciones dentro del subdominio delegado.

Ejercicio 11

En la VM, utilice el comando dig para obtener la dirección IP del host www.redes.unlp.edu.ar y responda:

dig www.redes.unlp.edu.ar

; <<>> DiG 9.16.27-Debian <<>> www.redes.unlp.edu.ar
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 27770
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: b5db6c2a4993909e01000000661bf3b5c1b1ba1391d7a26a (good)
;; QUESTION SECTION:
;www.redes.unlp.edu.ar.		IN	A

;; ANSWER SECTION:
www.redes.unlp.edu.ar.	300	IN	A	172.28.0.50

;; Query time: 0 msec
;; SERVER: 172.28.0.29#53(172.28.0.29)
;; WHEN: Sun Apr 14 12:18:13 -03 2024
;; MSG SIZE  rcvd: 94

Sí, la solicitud fue recursiva. Esto se puede determinar observando el flag rd (Recursion Desired) en la sección de flags del encabezado de la respuesta. Este flag indica que el cliente (en este caso, el comando dig) solicitó que el servidor DNS realice una resolución recursiva si no tenía la respuesta disponible inmediatamente en su caché.
```
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
```
- rd (Recursion Desired): Este flag está presente y marcado, lo que significa que se solicitó una resolución recursiva.

La respuesta fue autoritativa, lo cual se deduce del flag aa (Authoritative Answer). Este flag indica que la respuesta proviene de un servidor que tiene autoridad directa sobre el dominio en cuestión, en este caso, www.redes.unlp.edu.ar.
- aa (Authoritative Answer): Este flag está presente y marcado, indicando que el servidor que respondió lo hizo con autoridad, es decir, que posee y gestiona directamente los registros DNS de este dominio.

Otros Detalles

qr (Query Response): Este flag indica que el mensaje es una respuesta a una consulta (en lugar de una consulta por sí misma).
ra (Recursion Available): Este flag muestra que el servidor DNS es capaz de realizar consultas recursivas, aunque en este caso, dado que la respuesta fue autoritativa y directa, probablemente no se utilizó la recursión más allá del servidor consultado inicialmente.

Conclusión

En resumen:

La solicitud fue recursiva porque se solicitó con el flag rd habilitado.
La respuesta fue autoritativa y directa, como lo indica el flag aa, lo que significa que el servidor que respondió tenía una respuesta directa y definitiva para la consulta, sin necesidad de consultar a otros servidores.

Estos detalles son clave para entender cómo operan las solicitudes y respuestas en el sistema DNS, proporcionando visibilidad sobre el comportamiento tanto del cliente como del servidor en el proceso de resolución de nombres de dominio.

La dirección IP del resolver que se utilizó para responder a tu consulta está indicada en la salida bajo la línea SERVER:. Aquí está el extracto relevante de tu comando dig:

;; SERVER: 172.28.0.29#53(172.28.0.29)

Desglose de la Línea

172.28.0.29: Esta es la dirección IP del resolver. Este servidor es el que efectivamente respondió a tu consulta DNS.
#53: Este número después del signo # representa el puerto utilizado por el servidor DNS. El puerto 53 es el puerto estándar utilizado para protocolos DNS.

En DNS, cuando realizas una consulta utilizando herramientas como dig, el servidor que responde puede ser un servidor configurado en tus ajustes de red como el servidor DNS predeterminado, o puede ser un servidor DNS intermedio si estás utilizando una red que redirige las consultas DNS, como una red corporativa o de una universidad.

El servidor listado en la línea SERVER: de la salida de dig es el último servidor que procesó la consulta y devolvió el resultado. Esto indica que fue el servidor de nombres (resolver) activo que resolvió tu petición, ya sea devolviendo un resultado desde su caché o realizando su propia consulta recursiva en la red, según sea necesario.

dig MX www.redes.unlp.edu.ar

; <<>> DiG 9.16.27-Debian <<>> MX www.redes.unlp.edu.ar
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 20927
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 2a33e83611c202e201000000661bfc44e3dbcfb90ebb03ec (good)
;; QUESTION SECTION:
;www.redes.unlp.edu.ar.		IN	MX

;; AUTHORITY SECTION:
redes.unlp.edu.ar.	86400	IN	SOA	ns-sv-b.redes.unlp.edu.ar. root.redes.unlp.edu.ar. 2020031700 604800 86400 2419200 86400

;; Query time: 0 msec
;; SERVER: 172.28.0.29#53(172.28.0.29)
;; WHEN: Sun Apr 14 12:54:44 -03 2024
;; MSG SIZE  rcvd: 127

Mira, la cosa esta no posee registros MX, solo posee un registro SOA, hacemos la consulta nuevamente pero esta vez a un servidor DNS diferente.

dig MX redes.unlp.edu.ar

; <<>> DiG 9.16.27-Debian <<>> MX redes.unlp.edu.ar
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 20370
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 3

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 3961424363e0639101000000661bff479d6a617ac86c0482 (good)
;; QUESTION SECTION:
;redes.unlp.edu.ar.		IN	MX

;; ANSWER SECTION:
redes.unlp.edu.ar.	86400	IN	MX	10 mail2.redes.unlp.edu.ar.
redes.unlp.edu.ar.	86400	IN	MX	5 mail.redes.unlp.edu.ar.

;; ADDITIONAL SECTION:
mail.redes.unlp.edu.ar.	86400	IN	A	172.28.0.90
mail2.redes.unlp.edu.ar. 86400	IN	A	172.28.0.91

;; Query time: 0 msec
;; SERVER: 172.28.0.29#53(172.28.0.29)
;; WHEN: Sun Apr 14 13:07:35 -03 2024
;; MSG SIZE  rcvd: 149

ANSWER SECTION

redes.unlp.edu.ar. 86400 IN MX 10 mail2.redes.unlp.edu.ar.
- Prioridad: 10
- Servidor de correo: mail2.redes.unlp.edu.ar
redes.unlp.edu.ar. 86400 IN MX 5 mail.redes.unlp.edu.ar.
- Prioridad: 5
- Servidor de correo: mail.redes.unlp.edu.ar

Estos registros indican que hay dos servidores de correo configurados para el dominio, con diferentes prioridades. El número de prioridad indica cuál servidor debería ser contactado primero, con un número más bajo indicando mayor prioridad.

ADDITIONAL SECTION

Aquí se proporcionan las direcciones IP para ambos servidores de correo, facilitando la conexión directa sin necesidad de resolver nuevamente estos nombres:
- mail.redes.unlp.edu.ar. 86400 IN A 172.28.0.90
- mail2.redes.unlp.edu.ar. 86400 IN A 172.28.0.91

La existencia de más de un servidor de correo (en este caso, mail y mail2) proporciona redundancia y mejora la fiabilidad del sistema de correo electrónico. En caso de que el servidor principal (mail.redes.unlp.edu.ar) falle o esté inaccesible por mantenimiento u otras razones, el tráfico de correo puede ser dirigido automáticamente al servidor secundario (mail2.redes.unlp.edu.ar).

Los números entre MX y el nombre del servidor son las prioridades de los servidores de correo. El servidor con la prioridad más baja (en este caso, 5 para mail.redes.unlp.edu.ar) es el preferido y debe ser contactado primero. El servidor con una prioridad más alta (10 para mail2.redes.unlp.edu.ar) actúa como respaldo y se utiliza cuando el principal no está disponible.

El correo destinado a redes.unlp.edu.ar se entregará primero a mail.redes.unlp.edu.ar, ya que tiene la prioridad más alta (más baja numéricamente, es decir, 5).

Si mail.redes.unlp.edu.ar está caído, no responde o no puede manejar más tráfico, entonces el correo se entregará al servidor mail2.redes.unlp.edu.ar, que tiene una prioridad de 10. Esto garantiza que aún en caso de fallo, el correo pueda ser recibido y gestionado adecuadamente.

Este sistema de prioridades y múltiples servidores de correo asegura la continuidad del servicio de correo electrónico, crucial para las operaciones diarias de cualquier organización, especialmente en un entorno académico como una universidad.

dig NS redes.unlp.edu.ar

; <<>> DiG 9.16.27-Debian <<>> NS redes.unlp.edu.ar
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 55280
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 3

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 429a78e30a5755ad01000000661c04936178753028e756f4 (good)
;; QUESTION SECTION:
;redes.unlp.edu.ar.		IN	NS

;; ANSWER SECTION:
redes.unlp.edu.ar.	86400	IN	NS	ns-sv-a.redes.unlp.edu.ar.
redes.unlp.edu.ar.	86400	IN	NS	ns-sv-b.redes.unlp.edu.ar.

;; ADDITIONAL SECTION:
ns-sv-a.redes.unlp.edu.ar. 604800 IN	A	172.28.0.30
ns-sv-b.redes.unlp.edu.ar. 604800 IN	A	172.28.0.29

;; Query time: 0 msec
;; SERVER: 172.28.0.29#53(172.28.0.29)
;; WHEN: Sun Apr 14 13:30:11 -03 2024
;; MSG SIZE  rcvd: 150

Detalles de la Respuesta

ANSWER SECTION:

redes.unlp.edu.ar. 86400 IN NS ns-sv-a.redes.unlp.edu.ar.
redes.unlp.edu.ar. 86400 IN NS ns-sv-b.redes.unlp.edu.ar.
- Estos registros indican que los servidores de nombres para el dominio redes.unlp.edu.ar son ns-sv-a.redes.unlp.edu.ar y ns-sv-b.redes.unlp.edu.ar.
- 86400 es el TTL (Time to Live) en segundos, que dicta cuánto tiempo estos registros pueden ser almacenados en la caché por otros servidores antes de necesitar ser refrescados.

ADDITIONAL SECTION:

ns-sv-a.redes.unlp.edu.ar. 604800 IN A 172.28.0.30
ns-sv-b.redes.unlp.edu.ar. 604800 IN A 172.28.0.29
- Estos registros proporcionan las direcciones IP asociadas a cada uno de los servidores de nombres, permitiendo que cualquier entidad que necesite resolver nombres bajo redes.unlp.edu.ar se comunique directamente con estos servidores.
- 604800 segundos es el TTL para estos registros IP, indicando cuánto tiempo pueden ser cacheados.

Interpretación de los Flags

qr (Query Response): Indica que la respuesta es a una consulta.
aa (Authoritative Answer): El servidor que respondió tiene autoridad directa sobre el dominio, lo que significa que las respuestas son definitivas y no derivadas de otro servidor.
rd (Recursion Desired): La solicitud inicial pedía que el servidor realice recursión si era necesario.
ra (Recursion Available): El servidor está capacitado para realizar recursión, aunque en este caso, dio una respuesta directa y autoritativa.

Conclusión

Los servidores de DNS para redes.unlp.edu.ar son:

ns-sv-a.redes.unlp.edu.ar con dirección IP 172.28.0.30
ns-sv-b.redes.unlp.edu.ar con dirección IP 172.28.0.29

Estos servidores están configurados para manejar todas las consultas DNS relacionadas con el dominio redes.unlp.edu.ar. La configuración con dos servidores de nombres mejora la redundancia y la fiabilidad, asegurando que si uno de los servidores tiene problemas, el otro puede continuar manejando las solicitudes sin interrupción del servicio. Además, la respuesta autoritativa confirma que estos servidores son la fuente definitiva de información DNS para este dominio, lo cual es esencial para operaciones seguras y eficientes dentro de la red de la universidad.

Observe la información que obtuvo al consultar por los servidores de DNS del dominio. En base a la salida,

Con la información proporcionada por una consulta DNS estándar como la que se muestra en los resultados de dig, no es posible determinar cuál de los servidores de nombres es el primario (maestro) y cuál es el secundario (esclavo). Los registros NS simplemente enumeran los servidores de nombres que son autoritativos para el dominio, sin indicar su rol dentro de la configuración maestro-esclavo.

En la configuración de DNS tradicional, el servidor primario es donde se realizan los cambios y actualizaciones de los registros DNS, y estos cambios se replican luego a los servidores secundarios. Sin embargo, esta información de rol es parte de la configuración interna del sistema DNS y no se transmite en las respuestas a las consultas DNS realizadas por los clientes o resolvers.

Para determinar cuál es el servidor primario, normalmente se requiere acceso al servidor DNS autoritativo y a su configuración o a la interfaz de administración del proveedor de DNS donde se maneja el dominio. A veces, por convención, los nombres de los servidores de nombres pueden dar una pista (como ns1 sugiriendo que podría ser el primario), pero esto no es una regla fiable y puede ser engañoso.

En la sección "ANSWER SECTION", el primer campo después del SOA es el servidor de nombres principal o primario para el dominio redes.unlp.edu.ar. Según la salida proporcionada, el servidor DNS primario es ns-sv-b.redes.unlp.edu.ar.

El número de serie en el registro SOA es 2020031700. La convención de numeración puede variar, pero comúnmente sigue un patrón de AAAAMMDDnn, donde AAAA es el año, MM es el mes, DD es el día y nn es un número de revisión. Este número se actualiza cada vez que se hace un cambio significativo en la zona DNS. Es importante para la replicación de la zona hacia los servidores secundarios, ya que los servidores secundarios comparan el número de serie con el que tienen localmente para decidir si necesitan actualizar su copia de la zona.

El segundo campo es root.redes.unlp.edu.ar. y es la dirección de contacto para el administrador de la zona DNS. Normalmente se utiliza en la forma de un correo electrónico, donde el primer punto (.) se reemplaza por una arroba (@) y los demás puntos se interpretan normalmente. Por ejemplo, root@redes.unlp.edu.ar.

Resumen

A partir de la consulta SOA, se ha identificado ns-sv-b.redes.unlp.edu.ar como el servidor de DNS primario. El número de serie sigue una convención de fecha y revisión y es crucial para controlar la sincronización de los registros entre los servidores DNS primarios y secundarios. El segundo campo del registro SOA proporciona información de contacto del administrador de la zona, y el TTL de caché negativa ayuda a gestionar la caché de respuestas negativas en los resolvers de DNS.

El registro TXT en DNS es utilizado para insertar cualquier texto en el sistema de nombres de dominio. Aquí hay varios propósitos comunes para los registros TXT:

Verificación de Propiedad: Servicios como Google Search Console o proveedores de servicios de correo electrónico usan registros TXT para verificar la propiedad de un dominio.
Políticas de Seguridad de Correo Electrónico: Se usan para SPF (Sender Policy Framework), que ayuda a prevenir el spoofing de correo electrónico al especificar qué servidores están autorizados a enviar correo en nombre del dominio. También se utilizan para DKIM (DomainKeys Identified Mail), que permite la verificación de la identidad del remitente y para DMARC (Domain-based Message Authentication, Reporting, and Conformance), que es una política de autenticación de correo electrónico.
Información General: Pueden contener información general sobre el dominio o indicaciones técnicas para los administradores de sistemas.

En el resultado del dig que has proporcionado, se muestra que no hay un registro TXT para el dominio redes.unlp.edu.ar, lo que se evidencia por ANSWER: 0. Esto significa que no se han definido registros TXT o no están disponibles públicamente. La sección de "AUTHORITY SECTION" contiene un registro SOA, que es típico cuando no hay registros del tipo consultado pero se muestra la autoridad para el dominio.

Parte g

Utilizando dig, solicite la transferencia de zona de redes.unlp.edu.ar, analice la salida y responda.

dig @ns-sv-a.redes.unlp.edu.ar redes.unlp.edu.ar AXFR

dig @ns-sv-b.redes.unlp.edu.ar redes.unlp.edu.ar AXFR

La salida proporcionada es el resultado de una transferencia de zona exitosa para el dominio redes.unlp.edu.ar utilizando el comando dig. La transferencia de zona (AXFR) es un tipo de consulta DNS que solicita una copia completa de todos los registros de una zona de un servidor DNS. Aquí desglosamos la información proporcionada:

SOA Record: El registro de Start of Authority (SOA) al principio y al final de la transferencia de zona indica la autoridad y la versión de la zona DNS. Contiene:
- El servidor DNS principal (ns-sv-b.redes.unlp.edu.ar).
- La dirección de correo electrónico del administrador (root.redes.unlp.edu.ar, reemplazando el primer punto con @).
- El número de serie (2020031700) que se actualiza cada vez que la zona cambia.
- El intervalo de refresco (604800 segundos, o una semana).
- El intervalo de reintento (86400 segundos, o un día).
- El tiempo de expiración (2419200 segundos, o cuatro semanas).
- El TTL por defecto (86400 segundos, o un día), que se aplica a los registros en ausencia de un TTL específico.
NS Records: Listan los servidores de nombres autorizados (ns-sv-a.redes.unlp.edu.ar y ns-sv-b.redes.unlp.edu.ar) para el dominio.
MX Records: Especifican los servidores de correo (mail.redes.unlp.edu.ar y mail2.redes.unlp.edu.ar) y sus prioridades (5 y 10 respectivamente), que se utilizan para dirigir el correo electrónico.
CNAME Record: Muestra un alias (ftp.redes.unlp.edu.ar) que apunta a otro dominio (www.redes.unlp.edu.ar).
A Records: Asocian subdominios con direcciones IP específicas (mail.redes.unlp.edu.ar a 172.28.0.90, por ejemplo).
TXT Record: Contiene texto arbitrario asociado con el dominio (saludo.redes.unlp.edu.ar tiene el texto "HOLA").
Additional NS Records: Proporcionan más servidores de nombres para subdominios específicos (practica.redes.unlp.edu.ar tiene sus propios NS y A records).

La presencia de dos registros SOA al principio y al final de la lista es estándar en las transferencias de zona AXFR, indicando el comienzo y el fin de la transferencia.

Query time: Muestra el tiempo que tardó la consulta en completarse, que es de 4 milisegundos, lo que indica una respuesta rápida.
SERVER: Indica el servidor de DNS que respondió a la consulta.
WHEN: Muestra cuándo se realizó la consulta.
XFR size: Informa sobre el tamaño de la transferencia, que en este caso incluyó 17 registros, con un tamaño total de 441 bytes.

La finalidad de esta transferencia es sincronizar los registros de zona entre el servidor DNS principal y los secundarios. En un entorno de producción, las transferencias de zona suelen estar restringidas a los servidores que han sido explícitamente autorizados para recibir estos datos, con el fin de proteger contra el acceso no autorizado a la configuración del dominio.

¿Qué significan los números que aparecen antes de la palabra IN?

Los números que aparecen antes de la palabra "IN" en una salida de dig corresponden al TTL (Time To Live) de ese registro específico. El TTL es un valor en segundos que indica cuánto tiempo debe un servidor DNS cachear la respuesta antes de volver a consultar al servidor DNS autoritativo para una actualización. Es una forma de gestionar el rendimiento y la carga en los servidores DNS, equilibrando la actualización oportuna de la información con la necesidad de reducir el tráfico DNS en la red.

Por ejemplo, un TTL de 86400 significa que una vez que un resolver DNS ha consultado ese registro, puede guardar la respuesta en su caché y no necesita realizar otra consulta para ese registro durante los próximos 86400 segundos, o 24 horas.

En el registro SOA, el TTL es de 86400 segundos, y para los registros A de los servidores de nombres (ns-sv-a y ns-sv-b), es de 604800 segundos, o 7 días.

¿Cuál es su finalidad?

Su finalidad es mejorar la eficiencia del sistema DNS reduciendo el número de consultas necesarias para la misma información y asegurando que los datos no válidos o antiguos se eliminen de las cachés en un período razonable.

¿Cuántos registros NS observa?

En cuanto a la cantidad de registros NS, se observan dos registros NS:

ns-sv-a.redes.unlp.edu.ar
ns-sv-b.redes.unlp.edu.ar

Estos son los servidores de nombres que están autorizados a responder por el dominio redes.unlp.edu.ar. Estos registros son fundamentales para el proceso de resolución de DNS, ya que dirigen a los clientes a los servidores que tienen la información autoritativa sobre el dominio en cuestión.

Compare la respuesta con los servidores de DNS del dominio redes.unlp.edu.ar que dio anteriormente.

¿Puede explicar a qué se debe la diferencia y qué significa?

Consultar

Parte h

Consulte por el registro A de www.redes.unlp.edu.ar y luego por el registro A de www.practica.redes.unlp.edu.ar.

Observe los TTL de ambos. Repita la operación y compare el valor de los TTL de cada uno respecto de la respuesta anterior.

Las imágenes que proporcionaste muestran los resultados de dos consultas dig para los registros A de www.redes.unlp.edu.ar y www.practica.redes.unlp.edu.ar.

En la primera imagen, la consulta para www.redes.unlp.edu.ar muestra un TTL de 300 segundos. Esto indica que la dirección IP 172.28.0.50 puede ser almacenada en caché por un resolver DNS durante 5 minutos antes de necesitar una nueva resolución.

La segunda imagen, muestra la consulta para www.practica.redes.unlp.edu.ar con un TTL de 56 segundos, significando que la dirección IP 172.28.0.10 puede ser almacenada en caché durante 56 segundos.

Si repites las consultas después de un intervalo de tiempo y observas los TTL en las respuestas, deberías ver que los TTL han disminuido en la cantidad de segundos que han pasado desde la consulta anterior. Esto refleja el tiempo restante que un resolver DNS puede mantener la respuesta en caché antes de requerir una actualización.

La diferencia en los TTL entre www.redes.unlp.edu.ar y www.practica.redes.unlp.edu.ar indica posiblemente que www.practica podría cambiar más frecuentemente o que es un subdominio con menos tráfico, donde mantener la información en caché por un tiempo más corto no impactaría significativamente en el rendimiento del resolver.

¿Puede explicar qué está ocurriendo?

(Pista: observar los flags será de ayuda).

Consulte por el registro A de www.practica2.redes.unlp.edu.ar.

¿Obtuvo alguna respuesta?

La salida del comando dig que proporcionaste indica que se realizó una consulta DNS para el registro A de www.practica2.redes.unlp.edu.ar, y la respuesta contiene varios elementos clave que nos informan sobre el resultado de la consulta:

status: NXDOMAIN: Indica que el nombre de dominio consultado no existe en el servidor DNS autoritativo para el dominio redes.unlp.edu.ar. NXDOMAIN significa "Non-Existent Domain" (Dominio Inexistente).
ANSWER: 0: Significa que no se encontraron registros A para www.practica2.redes.unlp.edu.ar, es decir, no hay una respuesta con una dirección IP asociada a ese nombre de dominio.
AUTHORITY: 1: Muestra que hay una sección de autoridad con un registro, que en este caso es el SOA (Start of Authority) del dominio redes.unlp.edu.ar. Esto significa que, aunque no hay una respuesta directa para la consulta (ya que el dominio no existe), el servidor que respondió tiene autoridad sobre el dominio y por eso proporciona la información SOA.

Investigue sobre los codigos de respuesta de DNS.

NXDOMAIN: Se utiliza para indicar que el nombre de dominio especificado no existe. Es una respuesta definitiva que informa al cliente que el dominio que está buscando no se puede encontrar en el sistema de nombres de dominio.
NOERROR: Se utiliza para indicar que la consulta se completó con éxito, pero no necesariamente significa que se encontró una respuesta. En el caso de una consulta que devuelve registros válidos, la sección de respuestas tendrá una o más entradas y el estado será NOERROR.

¿Para qué son utilizados los mensajes NXDOMAIN y NOERROR?

NXDOMAIN: Específicamente útil para informar a los resolvers DNS y a los usuarios que el nombre de dominio que están tratando de alcanzar no existe y que deberían verificar si lo han escrito correctamente.
NOERROR: Indica que la consulta fue procesada correctamente y que la infraestructura de DNS está funcionando como se espera. Un estado NOERROR puede acompañarse de respuestas (si el dominio existe y tiene registros) o no (si la consulta fue por un tipo de registro no existente para ese dominio).

En tu caso específico, NXDOMAIN indica que www.practica2.redes.unlp.edu.ar no es un nombre de dominio existente bajo redes.unlp.edu.ar, y no se encontraron registros A asociados a él. El servidor proporcionó su registro SOA como parte de la respuesta autoritativa para mostrar que la respuesta viene del servidor autorizado para el dominio redes.unlp.edu.ar, pero que el subdominio consultado no existe en su configuración de DNS.

Mas sobre los codigos de respuestas DNS

Los códigos de respuesta DNS, también conocidos como RCODEs, son parte de la sección de encabezado en los mensajes DNS y proporcionan un estado sobre el éxito o fracaso de la consulta DNS. Aquí están los RCODEs más comunes:

NOERROR (0): La consulta se completó con éxito y no hubo errores.
FORMERR (1): Error de formato; el servidor DNS fue incapaz de interpretar la solicitud.
SERVFAIL (2): Fallo del servidor; el servidor DNS fue incapaz de procesar la consulta debido a un problema con el mismo.
NXDOMAIN (3): Dominio inexistente; el nombre de dominio consultado no existe.
NOTIMP (4), también conocido como NOTIMPL (No implementado): El servidor DNS no implementa el tipo de consulta solicitada.
REFUSED (5): La operación fue rechazada por el servidor DNS por razones de política.
YXDOMAIN (6): Nombre de dominio que no debería existir, existe.
YXRRSET (7): Conjunto de registros que no debería existir, existe.
NXRRSET (8): Conjunto de registros que debería existir, no existe.
NOTAUTH (9), también conocido como NOTAUTH (No autorizado): El servidor no está autorizado para la zona especificada.
NOTZONE (10): Nombre que no está dentro de la zona.

Los códigos de 11 a 15 son reservados para uso futuro. Además, hay extensiones para RCODEs como:

BADVERS (16): La primera implementación del código de respuesta extendido (EDNS) introdujo este código para señalar problemas con la versión de EDNS.

Los códigos de respuesta extendidos se pueden encontrar en la sección OPT PSEUDOSECTION de un mensaje DNS cuando EDNS está en uso. Los códigos de respuesta proporcionan información crítica para el diagnóstico de problemas en las consultas DNS y son una herramienta importante para los administradores de sistemas y redes al solucionar problemas de resolución de nombres.

Ejercicio 12

Investigue los comando nslookup y host. ¿Para qué sirven?

nslookup y host son herramientas de línea de comandos utilizadas para consultar el sistema de nombres de dominio (DNS) y obtener información sobre registros DNS de dominios específicos. Ambas pueden ser usadas para realizar una variedad de consultas DNS.

Intente con ambos comandos obtener:

Dirección IP de www.redes.unlp.edu.ar.

nslookup www.redes.unlp.edu.ar

host www.redes.unlp.edu.ar

Servidores de correo del dominio redes.unlp.edu.ar.

nslookup -query=MX redes.unlp.edu.ar

Con el flag -query=MX, nslookup buscará los registros MX que indican los servidores de correo para el dominio.

host -t MX redes.unlp.edu.ar

El flag -t MX especifica que queremos buscar los registros MX.

Servidores de DNS del dominio redes.unlp.edu.ar // (registros NS)?

nslookup -query=NS redes.unlp.edu.ar

Esta consulta devuelve los registros NS, que son los servidores de nombres autoritativos para el dominio.

host -t NS redes.unlp.edu.ar

Al igual que con nslookup, el flag -t NS le dice a host que busque los registros NS.

Ejercicio 13

¿Qué función cumple en Linux/Unix el archivo /etc/hosts o en Windows el archivo \WINDOWS\system32\drivers\etc\hosts?

En los sistemas operativos Linux/Unix, el archivo /etc/hosts y en Windows, el archivo \WINDOWS\system32\drivers\etc\hosts, tienen una función muy importante: proporcionar una tabla de nombres de host a direcciones IP localmente estática.

Cuando intentas acceder a un recurso de red utilizando un nombre de dominio, como www.ejemplo.com, el sistema operativo normalmente consulta primero el archivo hosts antes de hacer una consulta al sistema de nombres de dominio (DNS) en la red. Si una entrada correspondiente al nombre de dominio que se está buscando se encuentra en el archivo hosts, el sistema operativo utiliza la dirección IP especificada allí y no realiza una consulta DNS externa.

Estas son algunas de las funciones clave del archivo hosts:

Resolución de Nombres: Permite que el sistema operativo resuelva nombres de host a direcciones IP sin consultar un servidor DNS. Esto es útil para la red local o cuando se requiere un control específico sobre la resolución de nombres.
Pruebas y Desarrollo: Es comúnmente utilizado por desarrolladores para redirigir nombres de dominio a direcciones IP locales o de prueba durante el desarrollo de software y pruebas de aplicaciones web.
Bloqueo de Sitios Web: Al asignar nombres de dominio conocidos a direcciones no válidas o locales (como 127.0.0.1), los usuarios pueden bloquear efectivamente el acceso a sitios web indeseados.
Rendimiento y Caché: Al almacenar las direcciones IP localmente, el archivo hosts puede reducir los tiempos de respuesta al eliminar la necesidad de realizar consultas DNS para nombres de host comúnmente accedidos o críticos.
Redundancia y Seguridad: En caso de que el DNS no esté disponible o haya sido comprometido, el archivo hosts puede proporcionar una capa adicional de redundancia para resolver nombres de host críticos a sus direcciones IP.

El archivo hosts tiene una estructura simple, donde cada entrada consta de una dirección IP seguida de uno o más nombres de host. Las modificaciones en este archivo deben realizarse con cuidado, ya que los errores pueden provocar problemas de conectividad o bloqueos inadvertidos.

Ejercicio 14

Abra el programa Wireshark para comenzar a capturar el tráfico de red en la interfaz con IP 172.28.0.1.

Una vez abierto realice una consulta DNS con el comando dig para averiguar el registro MX de redes.unlp.edu.ar y luego, otra para averiguar los registros NS correspondientes al dominio redes.unlp.edu.ar.

Analice la información proporcionada por dig y compárelo con la captura.

dig mx redes.unlp.edu.ar +noall +answer

dig ns redes.unlp.edu.ar +noall +answer

Ejercicio 15

Dada la siguiente situación: “Una PC en una red determinada, con acceso a Internet, utiliza los servicios de DNS de un servidor de la red”. Analice

Parte a

¿Qué tipo de consultas (iterativas o recursivas) realiza la PC a su servidor de DNS?

Cuando una PC realiza consultas a su servidor DNS local (configurado habitualmente por DHCP o manualmente en la configuración de red), generalmente realiza consultas recursivas. Esto significa que la PC le pide al servidor DNS que le dé una respuesta definitiva. Si el servidor DNS local no tiene la respuesta almacenada en su caché, asume la responsabilidad de realizar las consultas adicionales necesarias para resolver el nombre completo, sin requerir más acción por parte de la PC.

Parte b

¿Qué tipo de consultas (iterativas o recursivas) realiza el servidor de DNS para resolver requerimientos de usuario como el anterior?

¿A quién le realiza estas consultas?

El servidor DNS configurado para resolver los nombres de dominio por parte de la PC realizará consultas iterativas cuando hable con otros servidores DNS en Internet. En una consulta iterativa, el servidor DNS local pregunta a otro servidor DNS (comenzando generalmente por los servidores raíz, seguidos por los servidores de los TLD y finalmente los servidores autoritativos para el dominio en cuestión) y si ese servidor no conoce la respuesta, devolverá la dirección de otro servidor DNS más cercano al nombre de dominio que se está buscando.

El servidor DNS local continuará esta serie de consultas iterativas hasta que encuentre un servidor que pueda responder con una autoridad (es decir, un servidor de nombres que alberga los registros DNS para el dominio solicitado) o hasta que determine que el dominio no existe (NXDOMAIN). Al final del proceso iterativo, el servidor DNS local tendrá la respuesta completa, que luego enviará de vuelta a la PC en respuesta a su consulta recursiva original.

Ejercicio 16

Practica 3 Ejercicio 16

Relacione DNS con HTTP

DNS (Sistema de Nombres de Dominio) y HTTP (Protocolo de Transferencia de Hipertexto) trabajan juntos para facilitar la navegación por Internet, pero cumplen funciones diferentes en el proceso:

DNS se encarga de traducir los nombres de dominio (como "www.example.com") en direcciones IP (como "93.184.216.34"). Esto es necesario porque aunque los humanos encuentran conveniente usar nombres de dominio fáciles de recordar para acceder a sitios web, las redes informáticas utilizan direcciones IP para localizar y comunicarse entre sí.
HTTP es un protocolo de la capa de aplicación utilizado para la transmisión de documentos hipermedia, como HTML. Es el fundamento de cualquier intercambio de datos en la Web y un protocolo cliente-servidor, lo que significa que las solicitudes son iniciadas por el receptor, usualmente el navegador web, permitiendo la recuperación de recursos web de servidores.

¿Se puede navegar si no hay servicio de DNS?

Sí, es posible navegar por Internet sin un servicio de DNS, pero con limitaciones significativas:

Uso Directo de Direcciones IP: Puedes acceder a sitios web directamente usando sus direcciones IP en lugar de sus nombres de dominio en la barra de direcciones del navegador. Por ejemplo, ingresar http://93.184.216.34 en lugar de http://www.example.com. Sin embargo, esto no siempre funciona para sitios web hospedados en servidores de alojamiento compartido donde múltiples dominios comparten la misma dirección IP y dependen del encabezado del host en la solicitud HTTP para servir el sitio correcto.
Archivo Hosts: Puedes utilizar el archivo hosts de tu sistema operativo para mapear manualmente nombres de dominio a direcciones IP. Al añadir entradas para los sitios web que deseas visitar, puedes navegar a ellos usando nombres de dominio sin necesidad de consultar un servidor DNS. Este método es práctico para un número pequeño de sitios web, pero no es escalable para la navegación general por Internet.

Aunque técnicamente es posible navegar sin DNS, la conveniencia, la escalabilidad y la flexibilidad que proporciona DNS lo hacen esencial para la experiencia moderna de Internet, facilitando el acceso a innumerables recursos en línea sin necesidad de recordar direcciones IP específicas.

Ejercicio 17

Observar el siguiente gráfico y contestar:

Si la PC-A, que usa comoservidor de DNSa "DNSServer", desea obtener la IP de www.unlp.edu.ar, cuáles serían, y en qué orden, los pasos que se ejecutarán para obtener la respuesta.

¿Dónde es recursiva la consulta? ¿Y dónde iterativa?

La imagen muestra una red con varios servidores DNS y un cliente (PC-A) que desea resolver la dirección IP de www.unlp.edu.ar. Aquí está el proceso paso a paso que seguirá la consulta DNS:

PC-A solicita la dirección IP para www.unlp.edu.ar:
- La consulta comienza cuando PC-A solicita a su servidor DNS local (192.168.10.2) la resolución del nombre www.unlp.edu.ar.
Consulta Recursiva al Servidor DNS Local:
- PC-A realiza una consulta recursiva al servidor DNS local. Esto significa que PC-A espera una respuesta definitiva y no participa en el proceso de resolución.
- Si el servidor DNS local tiene la respuesta en su caché y está aún dentro del tiempo de vida (TTL), la devolverá directamente a PC-A. Si no, continuará con el proceso.
Servidor DNS Local Realiza Consultas Iterativas:
- El servidor DNS local no tiene la información en caché, por lo que realiza consultas iterativas a otros servidores DNS para resolver la dirección.
- Primero consulta a un servidor raíz DNS (por ejemplo, A.Root-Server 205.10.100.10), que no resuelve la dirección sino que le indica dónde encontrar más información, en este caso, el servidor del TLD .ar.
Consulta al Servidor del TLD .ar:
- A continuación, el servidor DNS local consulta al servidor DNS del TLD .ar (a.dns.ar 200.108.145.50), que tampoco resolverá directamente la consulta, sino que dirigirá al servidor DNS local hacia el servidor de nombres autoritativo para el dominio edu.ar.
Consulta al Servidor del Dominio edu.ar:
- Luego, el servidor DNS local consulta al servidor de nombres para edu.ar (ns1.riu.edu.ar 170.210.0.18) que proporciona información sobre el servidor de nombres para unlp.edu.ar.
Consulta al Servidor de Nombres de unlp.edu.ar:
- Por último, el servidor DNS local hace una consulta al servidor de nombres para unlp.edu.ar (en la imagen no se muestra explícitamente este servidor DNS, pero asumimos que es donde el servidor DNS local obtendrá la información final) que finalmente le dará la dirección IP para www.unlp.edu.ar.
Respuesta a PC-A:
- El servidor DNS local regresa la respuesta a PC-A con la dirección IP de www.unlp.edu.ar, completando la solicitud inicial. Esta respuesta es el final de la consulta recursiva inicial realizada por PC-A.

En este proceso, la consulta recursiva se realiza entre el cliente (PC-A) y su servidor DNS local. Las consultas iterativas son realizadas por el servidor DNS local cuando habla con otros servidores DNS en la jerarquía hasta obtener la respuesta final. Cada servidor consultado proporciona una pieza del rompecabezas que permite al servidor DNS local llegar al servidor de nombres que tiene la autoridad directa sobre el dominio que se está consultando.

Ejercicio 18

¿A quién debería consultar para que la respuesta sobre www.google.com sea autoritativa?

¿Qué sucede si al servidor elegido en el paso anterior se lo consulta por www.info.unlp.edu.ar?

¿Y si la consulta es al servidor 8.8.8.8?

Consulta para obtener el servidor DNS autoritativo de www.google.com:
```
dig NS google.com +short
```
Este comando te dará una lista de los servidores DNS autoritativos para google.com.
Consulta para obtener una respuesta autoritativa de www.google.com: Selecciona uno de los servidores obtenidos en el paso anterior y realiza la consulta de registro A directamente a ese servidor:
```
dig @ns-autoritativo.google.com A www.google.com +noall +answer
```
Reemplaza ns-autoritativo.google.com con el servidor real obtenido en el primer paso.
Consulta al servidor DNS autoritativo de google.com para www.info.unlp.edu.ar: Si realizas esta consulta, lo más probable es que recibas un error o una respuesta no autoritativa, ya que ese servidor no tiene información sobre el dominio unlp.edu.ar:
```
dig @ns-autoritativo.google.com A www.info.unlp.edu.ar +noall +answer
```
Consulta al servidor público 8.8.8.8: Para realizar una consulta recursiva para cualquier dominio utilizando el servidor DNS público 8.8.8.8, usarías:
```
dig @8.8.8.8 A www.google.com +noall +answer
```
y para www.info.unlp.edu.ar:
```
dig @8.8.8.8 A www.info.unlp.edu.ar +noall +answer
```
Estos comandos solicitan al servidor público de Google que realice la resolución de DNS y te proporcione los resultados.

Con estos comandos puedes obtener información tanto de dominios específicos como de cualquier otro nombre de dominio a través de un servidor DNS público. Los resultados no serán autoritativos si el servidor que realizas la consulta no es el servidor DNS autoritativo para ese dominio. Sin embargo, servidores como 8.8.8.8 son resolvers recursivos confiables que obtendrán la información de los servidores autoritativos en tu nombre.

Ejercicio 19

Vamos a desglosar tus preguntas y responderlas en detalle con base en el contexto que proporcionas sobre las consultas DNS autoritativas y consultas a servidores específicos para dominios diferentes.

Pregunta 1: Consulta Autoritativa para www.google.com

Para obtener una respuesta autoritativa sobre www.google.com, deberías consultar a uno de los servidores de nombres autoritativos de google.com. Puedes encontrar estos servidores utilizando el comando:

dig NS google.com +short

Esto te proporcionará una lista de los servidores de nombres autoritativos para el dominio google.com. Luego, para obtener una respuesta específicamente autoritativa para www.google.com, deberías seleccionar uno de estos servidores y hacer una consulta directamente a él:

dig @ns-autoritativo.google.com A www.google.com +noall +answer

Reemplaza ns-autoritativo.google.com con uno de los nombres de servidor que obteniste del comando anterior.

Pregunta 2: Consulta al Servidor Autoritativo de Google para www.info.unlp.edu.ar

Si consultas al servidor DNS autoritativo para google.com acerca de www.info.unlp.edu.ar, es muy probable que recibas una respuesta de tipo "REFUSED" o simplemente no obtengas una respuesta autoritativa. Esto es porque los servidores de nombres de Google son autoritativos solo para los dominios bajo google.com y no tienen información sobre dominios externos como unlp.edu.ar.

Pregunta 3: Consulta al Servidor 8.8.8.8

Cuando consultas al servidor DNS público 8.8.8.8 (propiedad de Google y utilizado para la resolución DNS pública), este actuará como un resolver recursivo:

Para www.google.com:
```
dig @8.8.8.8 A www.google.com +noall +answer
```
Esta consulta le pide a 8.8.8.8 que resuelva la dirección de www.google.com. Como 8.8.8.8 es un servidor recursivo y no un servidor autoritativo para google.com, buscará la información contactando a los servidores autoritativos en tu nombre y luego te devolverá la respuesta.
Para www.info.unlp.edu.ar:
```
dig @8.8.8.8 A www.info.unlp.edu.ar +noall +answer
```
De manera similar, si consultas a 8.8.8.8 para www.info.unlp.edu.ar, el servidor realizará la recursión para buscar la información desde los servidores de nombres autoritativos para unlp.edu.ar y te proporcionará los resultados.

Resumen

En resumen, para obtener respuestas autoritativas, debes consultar a los servidores de nombres que están directamente asignados a gestionar el dominio específico. Los servidores DNS públicos como 8.8.8.8 pueden resolver cualquier dominio pero proporcionan respuestas no autoritativas que, sin embargo, son válidas y obtenidas de servidores autoritativos mediante el proceso de resolución recursiva.

Ejercicio Parcial

En base a la siguiente salida de dig, conteste las consignas. Justifique en todos los casos.

1 ;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 4, ADDITIONAL: 4
2 
3 ;; QUESTION SECTION:
4 ;ejemplo.com. IN __
5  
6 ;; ANSWER SECTION: 
7 ejemplo.com. 1634 IN __ 10 srv01.ejemplo.com.
8 ejemplo.com. 1634 IN __ 5 srv00.ejemplo.com.
9
10 ;; AUTHORITY SECTION:
11 ejemplo.com. 92354 IN __ ss00.ejemplo.com.
12 ejemplo.com. 92354 IN __ ss02.ejemplo.com.
13 ejemplo.com. 92354 IN __ ss01.ejemplo.com.
14 ejemplo.com. 92354 IN __ ss03.ejemplo.com.
15
16 ;; ADDITIONAL SECTION:
17 srv01.ejemplo.com. 272 IN __ 64.233.186.26
18 srv01.ejemplo.com. 240 IN __ 2800:3f0:4003:c00::1a
19 srv00.ejemplo.com. 272 IN __ 74.125.133.26
20 srv00.ejemplo.com. 240 IN __ 2a00:1450:400c:c07::1b

Para analizar la salida del comando dig y responder a tus preguntas, necesitamos primero completar los espacios en blanco (__) con los registros correctos, y luego interpretar la información.

a. Completar los registros correctos

Basándonos en el contexto típico de la salida de dig, los espacios en blanco probablemente corresponden a tipos de registros DNS. Aquí está la salida completada de acuerdo a lo que normalmente esperaríamos:

QUESTION SECTION: Aquí deberíamos tener el tipo de registro que se estaba consultando, como A para direcciones IPv4, AAAA para IPv6, MX para mail servers, etc. Dado que no especificas, asumiremos que se trata de registros MX (Mail Exchange) basados en la respuesta.
```
;ejemplo.com. IN MX
```

ANSWER SECTION: Se consultaron registros, probablemente MX dado que hay una prioridad (10 y 5).

ejemplo.com. 1634 IN MX 10 srv01.ejemplo.com.
ejemplo.com. 1634 IN MX 5 srv00.ejemplo.com.

AUTHORITY SECTION: Aquí, probablemente se consultaron registros NS (Name Server), indicando qué servidores son autoritativos para el dominio.

ejemplo.com. 92354 IN NS ss00.ejemplo.com.
ejemplo.com. 92354 IN NS ss02.ejemplo.com.
ejemplo.com. 92354 IN NS ss01.ejemplo.com.
ejemplo.com. 92354 IN NS ss03.ejemplo.com.

ADDITIONAL SECTION: Se proporcionan las direcciones IP para los servidores especificados en las secciones anteriores, tanto direcciones IPv4 (A) como IPv6 (AAAA).

srv01.ejemplo.com. 272 IN A 64.233.186.26
srv01.ejemplo.com. 240 IN AAAA 2800:3f0:4003:c00::1a
srv00.ejemplo.com. 272 IN A 74.125.133.26
srv00.ejemplo.com. 240 IN AAAA 2a00:1450:400c:c07::1b

b. ¿Es una respuesta autoritativa?

No, la respuesta no es autoritativa. Los flags no incluyen aa (Authoritative Answer).

¿A qué servidor le preguntaría para obtener una respuesta autoritativa?
Para obtener una respuesta autoritativa, deberías consultar directamente a uno de los servidores de nombres listados en la AUTHORITY SECTION. Por ejemplo, podrías hacer un dig @ss00.ejemplo.com MX ejemplo.com +noall +answer.

c. ¿La consulta fue recursiva? ¿Y la respuesta?

Consulta recursiva: Sí, la consulta fue recursiva, lo que se indica por la presencia del flag rd (Recursion Desired). Esto significa que el cliente solicitó al servidor que realice una búsqueda completa hasta obtener la información requerida.

La respuesta: La presencia del flag ra (Recursion Available) en la respuesta indica que el servidor DNS es capaz de realizar recursión. Sin embargo, la respuesta recibida no es autoritativa.

d. ¿Qué representan los valores 10 y 5 en las líneas (1) y (2)?

Los números 10 y 5 representan las prioridades de los servidores de correo en los registros MX. En el contexto de registros MX, una prioridad más baja indica un servidor de correo más preferido. Por lo tanto:

5 srv00.ejemplo.com. indica que srv00.ejemplo.com es el servidor de correo preferido.
10 srv01.ejemplo.com. indica que srv01.ejemplo.com es menos preferido y sería usado si el primero no está disponible.

Estas prioridades ayudan a dirigir el tráfico de correo electrónico de manera eficiente, asegurando que se utilice primero el servidor más deseable o más confiable.

Probando mas comandos

Queria tener un resumen a medida que voy haciendo la practica, separando bien la teoria de la practica

Conceptos antes de la practica

Investigue y describa cómo funciona el DNS.

¿Cuál es su objetivo?

¿Qué es un root server?

Un servidor raíz (root server) en el contexto del DNS es uno de los servidores DNS que contiene una lista completa de los nombres de dominio y sus direcciones IP asociadas para los dominios de nivel superior (TLDs). Es la primera parada en la resolución de nombres de dominio en Internet, dirigida a encontrar la dirección IP de un TLD específico. Los root servers son una parte crítica de la infraestructura de Internet, asegurando que la resolución de nombres funcione de manera eficiente y efectiva.

¿Qué es un generic top-level domain (gtld)?

Un dominio de nivel superior genérico (generic top-level domain o gTLD) es una categoría de dominios de nivel superior en el DNS que no está asociada a un país específico. Originalmente, los gTLDs incluían dominios como .com, .org, .net, entre otros, destinados a entidades comerciales, organizaciones y redes. Desde 2012, el número de gTLDs se ha expandido significativamente para incluir una amplia variedad de nombres como .academy, .bike, .beer, entre otros, permitiendo una mayor personalización y especificación para las direcciones de sitios web .

¿Qué diferencia una consulta DNS recursiva de una iterativa?

La diferencia principal entre una consulta DNS recursiva y una iterativa radica en el método de resolución y el grado de trabajo realizado por los servidores de nombres involucrados:

Consulta DNS recursiva: En una consulta recursiva, el cliente (generalmente el resolver DNS del sistema operativo del usuario) solicita una resolución completa del nombre a un servidor DNS. Si este servidor no tiene la respuesta en su caché, se hace cargo de la tarea completa de resolver la dirección, realizando tantas consultas adicionales como sean necesarias a otros servidores DNS en la jerarquía para obtener la respuesta definitiva. Una vez que tiene la respuesta completa, se la devuelve al cliente original. Este método es más cómodo para el cliente, ya que solo tiene que hacer una solicitud y esperar la respuesta sin realizar más acciones.

Consulta DNS iterativa: En una consulta iterativa, el cliente solicita una dirección a un servidor DNS, pero si este servidor no tiene la respuesta exacta, en lugar de resolver la consulta por completo, devuelve la mejor referencia que tiene a otro servidor DNS más cercano a la información solicitada. Luego, el cliente es responsable de consultar a este nuevo servidor DNS. Este proceso se repite iterativamente: el cliente va de servidor en servidor hasta que encuentra uno que pueda responder la pregunta directamente (con una respuesta autoritativa) o hasta que se agotan los servidores a consultar. En este caso, el trabajo de resolver el nombre se distribuye entre el cliente y varios servidores DNS.

La consulta recursiva es generalmente utilizada por los clientes finales ya que simplifica el proceso de resolución, mientras que la iterativa es utilizada entre servidores DNS para distribuir la carga y controlar el flujo de información.

¿Qué es una respuesta del tipo autoritativa?

Una respuesta autoritativa en DNS es aquella que proviene de un servidor de nombres que tiene la autoridad directa sobre el nombre de dominio consultado. Esto significa que el servidor de nombres puede proporcionar una respuesta definitiva a una consulta de nombre de dominio sin tener que referirse a otro servidor de nombres. Las respuestas autoritativas se utilizan para confirmar la existencia de un registro de dominio y su correspondiente información, como la dirección IP asociada. En el proceso de resolución de nombres de DNS, una respuesta autoritativa se considera la fuente definitiva y fiable para la información solicitada sobre un dominio .

Cuando un dominio cuenta con más de un servidor, uno de ellos es el primario (o maestro) y todos los demás son los secundarios (o esclavos).

¿Cuál es la razón de que sea así?

Sincronización y Consistencia de Datos: El servidor DNS primario mantiene la versión autoritativa de los registros de zona del dominio. Cualquier cambio en la configuración del DNS, como añadir o modificar registros A, MX, CNAME, etc., se realiza primero en el servidor primario. Los servidores secundarios luego sincronizan estos cambios desde el primario, asegurando que todos los servidores proporcionen respuestas consistentes a las consultas DNS.
Redundancia y Disponibilidad: Al tener múltiples servidores DNS secundarios, se garantiza que si el servidor primario falla o se vuelve inaccesible, los servidores secundarios pueden continuar respondiendo las consultas DNS, manteniendo la disponibilidad del servicio o sitio web asociado al dominio. Esto es crucial para la alta disponibilidad y la resistencia a fallos.
Distribución de Carga: Los servidores secundarios también ayudan a distribuir la carga de las solicitudes DNS, especialmente para sitios web de alto tráfico. Al distribuir las consultas entre varios servidores, se reduce la carga en el servidor primario y se mejora el tiempo de respuesta para los usuarios finales.
Seguridad: En algunos casos, mantener los servidores secundarios puede aumentar la seguridad. Por ejemplo, se puede configurar el servidor primario en una red segura, no accesible directamente desde Internet, y solo permitir que los servidores secundarios, ubicados en diferentes redes, sincronicen los datos y respondan a las solicitudes externas.
Eficiencia en la Actualización de Datos: Al realizar cambios solo en el servidor primario, se simplifica la administración de los registros DNS. Los servidores secundarios automáticamente obtienen y replican estos cambios a través de un proceso llamado transferencia de zona, lo que facilita la gestión de los registros DNS para los administradores.

Registros DNS

Similar al registro A, pero se utiliza para asociar un nombre de dominio con una dirección IPv6.

Especifica los servidores DNS autorizados para un dominio. Estos servidores DNS son los que contienen los registros DNS de ese dominio y pueden responder consultas relativas a él.

Practica

dig www.redes.unlp.edu.ar A
dig www.redes.unlp.edu.ar MX (Falta)
dig www.redes.unlp.edu.ar PTR
dig www.redes.unlp.edu.ar SRV
dig redes.unlp.edu.ar NS
dig redes.unlp.edu.ar CNAME
dig redes.unlp.edu.ar SOA
dig redes.unlp.edu.ar TXT
Ejemplos Varios
Ver los registros configurados para una URL

Registro A

dig www.redes.unlp.edu.ar A

redes@debian:~$ dig www.redes.unlp.edu.ar A

; <<>> DiG 9.16.27-Debian <<>> www.redes.unlp.edu.ar A
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 57307
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 6df89cfa69fa329b0100000066135ae75d8578ee82028b7d (good)
;; QUESTION SECTION:
;www.redes.unlp.edu.ar.		IN	A

;; ANSWER SECTION:
www.redes.unlp.edu.ar.	300	IN	A	172.28.0.50

;; Query time: 0 msec
;; SERVER: 172.28.0.29#53(172.28.0.29)
;; WHEN: Sun Apr 07 23:48:07 -03 2024
;; MSG SIZE  rcvd: 94

Desglose de la Respuesta

; <<>> DiG 9.16.27-Debian <<>> www.redes.unlp.edu.ar A
# Esta línea es el encabezado de la salida del comando `dig`, indicando la versión de `dig`
# usada (9.16.27) en un sistema Debian, seguido del dominio consultado 
# (`www.redes.unlp.edu.ar`) y el tipo de registro DNS solicitado (`A`).

;; global options: +cmd
# Indica las opciones globales aplicadas a la consulta. Aquí, `+cmd`
# muestra el comando exacto que se ejecutó.

;; Got answer:
# Confirma que se recibió una respuesta a la consulta DNS realizada.

;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 57307
# Sección de encabezado de la respuesta:
# - `opcode: QUERY` indica que la operación realizada fue una consulta DNS.
# - `status: NOERROR` muestra que la consulta se completó sin errores.
# - `id: 57307` es un identificador único para esta consulta, útil 
#               para emparejar solicitudes y respuestas en consultas múltiples.

;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
# Resumen de banderas y estadísticas de la consulta:
# - `qr` (query response) indica que esto es una respuesta a una consulta.
# - `aa` (authoritative answer) señala que la respuesta es autoritativa.
# - `rd` (recursion desired) muestra que se solicitó recursión.
# - `ra` (recursion available) indica que el servidor puede realizar consultas recursivas.
# - `QUERY: 1` muestra que se realizó una pregunta.
# - `ANSWER: 1` indica que se proporcionó una respuesta.
# - `AUTHORITY: 0` y `ADDITIONAL: 1` muestran el número de registros
#                                    de autoridad y adicionales proporcionados.

;; OPT PSEUDOSECTION:
# Sección para opciones extendidas (EDNS).
; EDNS: version: 0, flags:; udp: 1232
# Muestra la versión de EDNS utilizada y el tamaño máximo de paquete UDP soportado (1232 bytes).
; COOKIE: 6df89cfa69fa329b0100000066135ae75d8578ee82028b7d (good)
# Un mecanismo de seguridad que proporciona un 'cookie' para autenticar la respuesta.

;; QUESTION SECTION:
;www.redes.unlp.edu.ar.		IN	A
# La sección de pregunta de la consulta, pidiendo el registro A (dirección IPv4) para
# `www.redes.unlp.edu.ar`.

;; ANSWER SECTION:
www.redes.unlp.edu.ar.	300	IN	A	172.28.0.50
# La sección de respuesta proporciona la dirección IPv4 (`172.28.0.50`) asociada con el nombre 
# de dominio consultado, con un TTL de 300 segundos.

;; Query time: 0 msec
# El tiempo que tomó ejecutar la consulta, en este caso, 0 milisegundos, indicando una respuesta inmediata.

;; SERVER: 172.28.0.29#53(172.28.0.29)
# La dirección IP y puerto del servidor DNS que proporcionó la respuesta.

;; WHEN: Sun Apr 07 23:48:07 -03 2024
# La fecha y hora exactas de cuando se realizó la consulta.

;; MSG SIZE  rcvd: 94
# El tamaño del mensaje de respuesta recibido, en este caso, 94 bytes.

Registro

Registro NS

dig redes.unlp.edu.ar NS

redes@debian:~$ dig www.redes.unlp.edu.ar NS

; <<>> DiG 9.16.27-Debian <<>> www.redes.unlp.edu.ar NS
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 10661
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: d4e9ac68ddcc83a00100000066135b1dd8e4fc49567742d0 (good)
;; QUESTION SECTION:
;www.redes.unlp.edu.ar.		IN	NS

;; AUTHORITY SECTION:
redes.unlp.edu.ar.	86400	IN	SOA	ns-sv-b.redes.unlp.edu.ar. root.redes.unlp.edu.ar. 2020031700 604800 86400 2419200 86400

;; Query time: 0 msec
;; SERVER: 172.28.0.29#53(172.28.0.29)
;; WHEN: Sun Apr 07 23:49:01 -03 2024
;; MSG SIZE  rcvd: 127

Desglose de la Respuesta

; <<>> DiG 9.16.27-Debian <<>> www.redes.unlp.edu.ar NS
# Esta línea indica la ejecución del comando `dig` en un sistema Debian, consultando los registros NS 
# (Name Server o Servidores de Nombres) para el dominio www.redes.unlp.edu.ar.

;; global options: +cmd
# Muestra las opciones globales utilizadas por `dig`. 
# Aquí, `+cmd` significa que se incluye la línea de comando inicial en la salida para referencia.

;; Got answer:
# Indica que se ha recibido una respuesta del servidor DNS consultado.

;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 10661
# Sección del encabezado de la respuesta DNS:
# - `opcode: QUERY` especifica que la operación fue una consulta.
# - `status: NOERROR` indica que la consulta se completó sin errores.
# - `id: 10661` es el identificador de la transacción, útil para emparejar solicitudes con respuestas.

;; flags: qr aa rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 1
# Detalles de los indicadores y conteos de la consulta:
# - `qr` (query response) señala que esto es una respuesta.
# - `aa` (authoritative answer) indica que la respuesta es autoritativa.
# - `rd` (recursion desired) muestra que se solicitó recursión.
# - `ra` (recursion available) indica que el servidor puede hacer consultas recursivas.
# - `QUERY: 1` muestra que hubo una pregunta realizada.
# - `ANSWER: 0` indica que no hubo respuestas directas al tipo de registro solicitado (NS en este caso).
# - `AUTHORITY: 1` muestra que hay un registro de autoridad, en este caso un registro SOA.
# - `ADDITIONAL: 1` indica un registro adicional, probablemente relacionado con EDNS.

;; OPT PSEUDOSECTION:
# Sección de opciones extendidas del DNS (EDNS).
; EDNS: version: 0, flags:; udp: 1232
# Detalles de EDNS, incluyendo la versión y el tamaño máximo de UDP (1232 bytes).
; COOKIE: d4e9ac68ddcc83a00100000066135b1dd8e4fc49567742d0 (good)
# Un mecanismo de seguridad EDNS que proporciona un 'cookie' para autenticar solicitudes y respuestas.

;; QUESTION SECTION:
;www.redes.unlp.edu.ar.		IN	NS
# La sección de pregunta muestra la consulta realizada, solicitando los 
# registros NS para `www.redes.unlp.edu.ar`.

;; AUTHORITY SECTION:
redes.unlp.edu.ar.	86400	IN	SOA	ns-sv-b.redes.unlp.edu.ar. root.redes.unlp.edu.ar. 2020031700 604800 86400 2419200 86400
# Sección de autoridad que proporciona el registro SOA (Start of Authority) 
# para el dominio `redes.unlp.edu.ar`, 
# ya que no se encontraron registros NS específicos para `www.redes.unlp.edu.ar`. 
# El registro SOA incluye información crítica como el servidor de nombres principal, 
# el contacto de correo electrónico, y varios temporizadores para la zona.

;; Query time: 0 msec
# El tiempo que tomó realizar la consulta, 0 milisegundos, indicando una respuesta rápida.

;; SERVER: 172.28.0.29#53(172.28.0.29)
# La dirección IP y el puerto (#53) del servidor DNS que respondió a la consulta.

;; WHEN: Sun Apr 07 23:49:01 -03 2024
# La fecha y hora exacta en que se realizó la consulta.

;; MSG SIZE  rcvd: 127
# El tamaño del mensaje de respuesta recibido, en este caso, 127 bytes.

Consulta

Respuesta

Registro SOA

redes@debian:~$ dig redes.unlp.edu.ar SOA

redes@debian:~$ dig redes.unlp.edu.ar SOA

; <<>> DiG 9.16.27-Debian <<>> redes.unlp.edu.ar SOA
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 56877
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 7bd1c774cf6a7d920100000066135a6d5d9d14b02aa8c4b7 (good)
;; QUESTION SECTION:
;redes.unlp.edu.ar.		IN	SOA

;; ANSWER SECTION:
redes.unlp.edu.ar.	86400	IN	SOA	ns-sv-b.redes.unlp.edu.ar. root.redes.unlp.edu.ar. 2020031700 604800 86400 2419200 86400

;; Query time: 0 msec
;; SERVER: 172.28.0.29#53(172.28.0.29)
;; WHEN: Sun Apr 07 23:46:05 -03 2024
;; MSG SIZE  rcvd: 123

Desglose de la Respuesta

; <<>> DiG 9.16.27-Debian <<>> redes.unlp.edu.ar SOA
# Esta línea indica que se ejecutó el comando `dig` en una distribución Debian para consultar el registro SOA (Start of Authority) para el dominio redes.unlp.edu.ar. 

;; global options: +cmd
# Muestra las opciones globales aplicadas a la consulta. `+cmd` indica que el comando ejecutado se muestra en la salida para referencia.

;; Got answer:
# Confirma que se ha recibido una respuesta a la consulta DNS.

;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 56877
# Encabezado de la respuesta DNS:
# - `opcode: QUERY` indica que se realizó una consulta DNS.
# - `status: NOERROR` significa que la consulta se completó sin errores.
# - `id: 56877` es un identificador único para esta transacción, útil para correlacionar solicitudes y respuestas.

;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
# Detalles de la consulta:
# - `qr` (query response) señala que esto es una respuesta.
# - `aa` (authoritative answer) indica que la respuesta es autoritativa.
# - `rd` (recursion desired) muestra que se solicitó recursión.
# - `ra` (recursion available) indica que el servidor puede realizar consultas recursivas.
# - `QUERY: 1` muestra que hubo una pregunta realizada.
# - `ANSWER: 1` indica que se proporcionó una respuesta.
# - `AUTHORITY: 0` muestra que no hay registros de autoridad adicionales.
# - `ADDITIONAL: 1` indica un registro adicional, relacionado con EDNS.

;; OPT PSEUDOSECTION:
# Sección de opciones extendidas del DNS (EDNS).
; EDNS: version: 0, flags:; udp: 1232
# Muestra la versión de EDNS utilizada y el tamaño máximo de paquete UDP (1232 bytes).
; COOKIE: 7bd1c774cf6a7d920100000066135a6d5d9d14b02aa8c4b7 (good)
# Un mecanismo de seguridad EDNS que proporciona un 'cookie' para autenticar la consulta y la respuesta.

;; QUESTION SECTION:
;redes.unlp.edu.ar.		IN	SOA
# La sección de pregunta muestra que la consulta fue para el registro SOA del dominio redes.unlp.edu.ar.

;; ANSWER SECTION:
redes.unlp.edu.ar.	86400	IN	SOA	ns-sv-b.redes.unlp.edu.ar. root.redes.unlp.edu.ar. 2020031700 604800 86400 2419200 86400
# La sección de respuesta contiene el registro SOA para el dominio:
# - `ns-sv-b.redes.unlp.edu.ar.` es el servidor de nombres que tiene autoridad sobre el dominio.
# - `root.redes.unlp.edu.ar.` es el contacto administrativo para el dominio.
# - `2020031700` es el número de serie del registro SOA, importante para la gestión de cambios.
# - `604800` es el intervalo de refresco en segundos (cada 7 días).
# - `86400` es el tiempo de reintento en segundos (1 día), en caso de fallo al refrescar.
# - `2419200` es el tiempo de expiración en segundos (28 días), después del cual los datos se consideran obsoletos si no se logra la actualización.
# - `86400` es el valor mínimo de TTL (Time To Live) en segundos, que indica cuánto tiempo un registro puede ser cacheado por los servidores DNS.

;; Query time: 0 msec
# El tiempo que tomó realizar la consulta, 0 milisegundos, indicando una respuesta inmediata.

;; SERVER: 172.28.0.29#53(172.28.0.29)
# La dirección IP y el puerto del servidor DNS que respondió a la consulta.

;; WHEN: Sun Apr 07 23:46:05 -03 2024
# La fecha y hora exactas de cuando se realizó la consulta.

;; MSG SIZE  rcvd: 123
# El tamaño del mensaje de respuesta recibido, en este caso, 123 bytes.

Registro TXT

dig redes.unlp.edu.ar TXT

redes@debian:~$ dig www.redes.unlp.edu.ar TXT

; <<>> DiG 9.16.27-Debian <<>> www.redes.unlp.edu.ar TXT
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 60088
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 924f899d4f35a97f0100000066135f724ecbd98262016eb9 (good)
;; QUESTION SECTION:
;www.redes.unlp.edu.ar.		IN	TXT

;; AUTHORITY SECTION:
redes.unlp.edu.ar.	86400	IN	SOA	ns-sv-b.redes.unlp.edu.ar. root.redes.unlp.edu.ar. 2020031700 604800 86400 2419200 86400

;; Query time: 0 msec
;; SERVER: 172.28.0.29#53(172.28.0.29)
;; WHEN: Mon Apr 08 00:07:30 -03 2024
;; MSG SIZE  rcvd: 127

Desglose de la Respuesta

; <<>> DiG 9.16.27-Debian <<>> www.redes.unlp.edu.ar TXT
# Esta línea indica la ejecución del comando `dig` en un sistema Debian 
# para consultar registros TXT para el dominio www.redes.unlp.edu.ar.

;; global options: +cmd
# Indica las opciones globales aplicadas a la consulta, con `+cmd` mostrando el comando ejecutado.

;; Got answer:
# Confirma que se ha recibido una respuesta a la consulta DNS.

;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 60088
# La sección del encabezado de la respuesta DNS:
# - `opcode: QUERY` especifica que la operación fue una consulta.
# - `status: NOERROR` significa que la consulta se completó sin errores.
# - `id: 60088` es el identificador único para esta transacción, 
#               útil para correlacionar solicitudes y respuestas.

;; flags: qr aa rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 1
# Resumen de la consulta y la respuesta:
# - `qr` (query response) señala que esto es una respuesta.
# - `aa` (authoritative answer) indica que la respuesta es autoritativa.
# - `rd` (recursion desired) muestra que se solicitó recursión.
# - `ra` (recursion available) indica que el servidor puede realizar consultas recursivas.
# - `QUERY: 1` indica que se hizo una pregunta.
# - `ANSWER: 0` indica que no se encontraron registros TXT para el dominio consultado.
# - `AUTHORITY: 1` muestra que hay un registro de autoridad, un registro SOA en este caso.
# - `ADDITIONAL: 1` indica la presencia de una sección adicional, probablemente relacionada con EDNS.

;; OPT PSEUDOSECTION:
# Sección de opciones extendidas del DNS (EDNS).
; EDNS: version: 0, flags:; udp: 1232
# Muestra la versión de EDNS utilizada y el tamaño máximo de paquete UDP (1232 bytes).
; COOKIE: 924f899d4f35a97f0100000066135f724ecbd98262016eb9 (good)
# Un mecanismo de seguridad EDNS que proporciona un 'cookie' para autenticar la consulta y la respuesta.

;; QUESTION SECTION:
;www.redes.unlp.edu.ar.		IN	TXT
# La sección de pregunta muestra la consulta realizada, solicitando los registros 
# TXT para www.redes.unlp.edu.ar.

;; AUTHORITY SECTION:
redes.unlp.edu.ar.	86400	IN	SOA	ns-sv-b.redes.unlp.edu.ar. root.redes.unlp.edu.ar. 
  	                            2020031700 604800 86400 2419200 86400
# La sección de autoridad contiene un registro SOA para el dominio redes.unlp.edu.ar. 
# Este registro proporciona información administrativa sobre el dominio:
# - `ns-sv-b.redes.unlp.edu.ar.` es el servidor de nombres principal.
# - `root.redes.unlp.edu.ar.` es el contacto administrativo.
# - `2020031700` es el número de serie de la zona, importante para controlar las
#                versiones y las actualizaciones.
# - `604800` es el intervalo de refresco en segundos (cada 7 días).
# - `86400` es el tiempo de reintento en segundos (1 día), en caso de fallo al refrescar.
# - `2419200` es el tiempo de expiración en segundos (28 días), después del cual los 
#             datos se consideran obsoletos si no se logra la actualización.
# - `86400` es el valor mínimo de TTL (Time To Live) en segundos, que indica 
#           cuánto tiempo un registro puede ser cacheado por los servidores DNS.

;; Query time: 0 msec
# El tiempo que tomó realizar la consulta, 0 milisegundos, indicando una respuesta rápida.

;; SERVER: 172.28.0.29#53(172.28.0.29)
# La dirección IP y el puerto del servidor DNS que respondió a la consulta.

;; WHEN: Mon Apr 08 00:07:30 -03 2024
# La fecha y hora exactas de cuando se realizó la consulta.

;; MSG SIZE  rcvd: 127
# El tamaño del mensaje de respuesta recibido, en este caso, 127 bytes.

Ejemplos de Varios Comandos

redes@debian:~$ dig redes.unlp.edu.ar AAAA +noall +answer
redes@debian:~$ dig redes.unlp.edu.ar MX +noall +answer
redes.unlp.edu.ar.	86400	IN	MX	5 mail.redes.unlp.edu.ar.
redes.unlp.edu.ar.	86400	IN	MX	10 mail2.redes.unlp.edu.ar.
redes@debian:~$ dig redes.unlp.edu.ar A +noall +answer
redes@debian:~$ dig redes.unlp.edu.ar NS +noall +answer
redes.unlp.edu.ar.	86400	IN	NS	ns-sv-a.redes.unlp.edu.ar.
redes.unlp.edu.ar.	86400	IN	NS	ns-sv-b.redes.unlp.edu.ar.
redes@debian:~$ dig www.redes.unlp.edu.ar CNAME +noall +answer
redes@debian:~$ dig redes.unlp.edu.ar SOA +noall +answer
redes.unlp.edu.ar.	86400	IN	SOA	ns-sv-b.redes.unlp.edu.ar. root.redes.unlp.edu.ar. 2020031700 604800 86400 2419200 86400
redes@debian:~$ dig redes.unlp.edu.ar TXT +noall +answer
redes@debian:~$

Mira, lo que esta pasando aca chiquiFabo, es que la url no tiene configurado ciertos registros, no es que estes loco :D

Ver registros para una url

dig redes.unlp.edu.ar any

;; QUESTION SECTION:
;redes.unlp.edu.ar.		IN	ANY

;; ANSWER SECTION:
redes.unlp.edu.ar.	86400	IN	SOA	ns-sv-b.redes.unlp.edu.ar. root.redes.unlp.edu.ar. 2020031700 604800 86400 2419200 86400
redes.unlp.edu.ar.	86400	IN	NS	ns-sv-a.redes.unlp.edu.ar.
redes.unlp.edu.ar.	86400	IN	NS	ns-sv-b.redes.unlp.edu.ar.
redes.unlp.edu.ar.	86400	IN	MX	10 mail2.redes.unlp.edu.ar.
redes.unlp.edu.ar.	86400	IN	MX	5 mail.redes.unlp.edu.ar.

;; ADDITIONAL SECTION:
ns-sv-a.redes.unlp.edu.ar. 604800 IN	A	172.28.0.30
ns-sv-b.redes.unlp.edu.ar. 604800 IN	A	172.28.0.29
mail.redes.unlp.edu.ar.	86400	IN	A	172.28.0.90
mail2.redes.unlp.edu.ar. 86400	IN	A	172.28.0.91

;; Query time: 0 msec
;; SERVER: 172.28.0.29#53(172.28.0.29)
;; WHEN: Tue Apr 09 16:03:51 -03 2024
;; MSG SIZE  rcvd: 266

Resultado desglozado

;; QUESTION SECTION:
;redes.unlp.edu.ar.		IN	ANY
# Esta sección muestra la consulta realizada. Se pidió información "IN ANY", lo que significa que se solicitó cualquier tipo de registro DNS disponible para el dominio 'redes.unlp.edu.ar'.

;; ANSWER SECTION:
redes.unlp.edu.ar.	86400	IN	SOA	ns-sv-b.redes.unlp.edu.ar. root.redes.unlp.edu.ar. 2020031700 604800 86400 2419200 86400
# Un registro SOA (Start of Authority), que proporciona información esencial sobre el dominio, incluyendo el servidor de nombres principal (ns-sv-b.redes.unlp.edu.ar), el contacto administrativo (root.redes.unlp.edu.ar), el número de serie de la zona, y varios temporizadores relacionados con la actualización y la caducidad de los registros.

redes.unlp.edu.ar.	86400	IN	NS	ns-sv-a.redes.unlp.edu.ar.
# Un registro NS (Name Server), que indica que 'ns-sv-a.redes.unlp.edu.ar' es un servidor de nombres autoritativo para el dominio 'redes.unlp.edu.ar'.

redes.unlp.edu.ar.	86400	IN	NS	ns-sv-b.redes.unlp.edu.ar.
# Otro registro NS, señalando a 'ns-sv-b.redes.unlp.edu.ar' como otro servidor de nombres autoritativo para el dominio.

redes.unlp.edu.ar.	86400	IN	MX	10 mail2.redes.unlp.edu.ar.
# Un registro MX (Mail Exchange), que especifica 'mail2.redes.unlp.edu.ar' como servidor de correo para el dominio, con una prioridad de 10.

redes.unlp.edu.ar.	86400	IN	MX	5 mail.redes.unlp.edu.ar.
# Otro registro MX, que indica 'mail.redes.unlp.edu.ar' como servidor de correo para el dominio, con una prioridad de 5 (mayor prioridad que el anterior).

;; ADDITIONAL SECTION:
ns-sv-a.redes.unlp.edu.ar. 604800 IN	A	172.28.0.30
# La sección adicional proporciona direcciones IP para los servidores mencionados. Aquí, 'ns-sv-a.redes.unlp.edu.ar' se asocia con la dirección IP 172.28.0.30.

ns-sv-b.redes.unlp.edu.ar. 604800 IN	A	172.28.0.29
# Proporciona la dirección IP para 'ns-sv-b.redes.unlp.edu.ar', que es 172.28.0.29.

mail.redes.unlp.edu.ar.	86400	IN	A	172.28.0.90
# Da la dirección IP del servidor de correo 'mail.redes.unlp.edu.ar', que es 172.28.0.90.

mail2.redes.unlp.edu.ar. 86400	IN	A	172.28.0.91
# Proporciona la dirección IP para otro servidor de correo, 'mail2.redes.unlp.edu.ar', que es 172.28.0.91.

;; Query time: 0 msec
# El tiempo que tomó realizar la consulta, en este caso, fue instantáneo (0 milisegundos).

;; SERVER: 172.28.0.29#53(172.28.0.29)
# Indica el servidor DNS que respondió a la consulta, con su dirección IP y el puerto utilizado (53, el puerto estándar para DNS).

;; WHEN: Tue Apr 09 16:03:51 -03 2024
# Muestra la fecha y hora exactas en que se realizó la consulta.

;; MSG SIZE  rcvd: 266
# El tamaño total del mensaje de respuesta recibido, en bytes (266 en este caso).

Este resultado detalla los registros DNS recuperados para redes.unlp.edu.ar al solicitar cualquier tipo de registro (ANY). Proporciona una visión general de la configuración DNS del dominio, incluyendo servidores de nombres, servidores de correo, y la autoridad de inicio del dominio, junto con las direcciones IP asociadas a cada uno de estos servicios. La sección adicional ayuda a resolver nombres a direcciones IP sin necesidad de consultas adicionales.

Practica 4 Redes | Correo Electronico

Tue, 07 May 2024 00:00:00 GMT

Ejercicio 1 Protocolos de Envio
Ejercicio 2 Protocolos de Recepción
Ejercicio 3 Usando la VM
Ejercicio 4 Protocolo POP
Ejercicio 5 Protocolo IMAP
Ejercicio 6 IMAP VS POP
Ejercicio 7 Mandar más de un correo por la misma conexión TCP
Ejercicio 8 MSA escuche en un puerto TCP diferente
Ejercicio 9 MTA escuche en un puerto TCP diferente
Ejercicio 10 Integrador HTTP, DNS y MAIL
Ejercicio 11 Usando Swaks
Ejercicio 12 Observe el gráfico a continuación
Consultas

Ejercicio 1

El envío de correos electrónicos implica una serie de protocolos que gestionan tanto la comunicación entre el cliente de correo y su servidor, como la transferencia de emails entre servidores de correo. Aquí te explicaré ambos aspectos:

¿Qué protocolos se utilizan para el envío de mails entre el cliente y su servidor de correo?

SMTP (Simple Mail Transfer Protocol):
- Uso: SMTP es el protocolo estándar utilizado para enviar correos desde un cliente hacia un servidor de correo o entre servidores de correo. Sin embargo, para la conexión cliente-servidor, SMTP se usa típicamente sólo para enviar mensajes.
- Puertos: SMTP opera comúnmente a través del puerto 25 para conexiones no seguras y 587 para conexiones seguras que inician con un proceso de cifrado STARTTLS.
IMAP (Internet Message Access Protocol):
- Uso: IMAP se utiliza para recibir y gestionar correos electrónicos almacenados en el servidor de correo. Permite a los usuarios acceder a sus mensajes de correo electrónico desde múltiples dispositivos y gestionar sus correos directamente en el servidor.
- Puertos: IMAP utiliza comúnmente el puerto 143 para conexiones no seguras, y el puerto 993 para conexiones seguras (IMAP sobre SSL/TLS).
POP3 (Post Office Protocol version 3):
- Uso: POP3 es otro protocolo utilizado para recibir correos desde el servidor. A diferencia de IMAP, POP3 generalmente descarga los correos del servidor al dispositivo del usuario y luego los elimina del servidor, lo que lo hace más adecuado para situaciones donde solo se accede al correo desde un único dispositivo.
- Puertos: POP3 opera a través del puerto 110 para conexiones no seguras y 995 para conexiones seguras (POP3 sobre SSL/TLS).

¿Y entre servidores de correo?

SMTP (Simple Mail Transfer Protocol):
- Uso: SMTP no solo se utiliza entre clientes y servidores, sino que es el protocolo estándar para el envío de correos entre servidores. Cuando un correo electrónico se envía a través de la red, pasa de un servidor SMTP a otro hasta que alcanza su destino.
- Puertos: En las comunicaciones entre servidores, el puerto 25 es el más utilizado para SMTP. Aunque la conexión inicial puede ser no segura, los servidores modernos utilizan extensiones como STARTTLS para cifrar la comunicación SMTP después del establecimiento inicial de la conexión.

Seguridad Adicional:

TLS (Transport Layer Security):
- Uso: TLS se usa para cifrar las conexiones entre clientes y servidores de correo, así como entre servidores de correo para asegurar que la información sensible no pueda ser interceptada o alterada durante el tránsito.
- Implementación: TLS puede ser implementado en cualquier etapa de la comunicación de correo para cifrar los datos transmitidos y verificar la autenticidad de los servidores y clientes.

Resumen:

Entre cliente y servidor, se utilizan SMTP para enviar, IMAP o POP3 para recibir correos, con los puertos mencionados adaptándose a conexiones seguras o no seguras según las necesidades y configuraciones del servidor.
Entre servidores de correo, SMTP es el protocolo dominante para el traspaso de mensajes, con la adición de seguridad a través de TLS para proteger la comunicación.

Estos protocolos son esenciales para asegurar que la comunicación por correo electrónico sea eficiente, confiable y segura, adaptándose a las diversas necesidades y contextos en los que se utilizan.

Ejercicio 2

¿Qué protocolos se utilizan para la recepción de mails?

Para la recepción de correos electrónicos, los protocolos más comúnmente utilizados son el Post Office Protocol version 3 (POP3) y el Internet Message Access Protocol (IMAP). Ambos tienen características distintivas que los hacen adecuados para diferentes escenarios de uso. A continuación, te detallo cada uno de estos protocolos, sus características y diferencias:

Enumere y explique características diferencias entre las alternativas posibles.

1. POP3 (Post Office Protocol version 3)

Características:

Simplicidad: POP3 es un protocolo simple que permite descargar los correos electrónicos del servidor al cliente de correo local. Una vez que los correos son descargados, generalmente se eliminan del servidor, aunque la configuración puede ajustarse para dejar una copia en el servidor por un tiempo limitado.
Conexión y Descarga: Con POP3, el cliente de correo se conecta al servidor, descarga todos los nuevos mensajes, los almacena localmente y luego se desconecta. Esto hace que POP3 sea ideal para usuarios que prefieren acceder a su correo desde un único dispositivo y necesitan tener acceso offline a sus mensajes.
Puertos de Seguridad: Utiliza el puerto 110 para conexiones no cifradas y el puerto 995 para conexiones cifradas (POP3S, que es POP3 sobre SSL/TLS).

Ventajas:

Manejo simple y directo de los correos.
Buena elección para usuarios que solo acceden a su correo desde un único dispositivo.
Acceso offline completo a los mensajes descargados.

Desventajas:

No es adecuado para el acceso desde múltiples dispositivos.
Menos características para manejar correos directamente en el servidor.
Una vez descargados y eliminados del servidor, los correos no están disponibles en otros dispositivos.

2. IMAP (Internet Message Access Protocol)

Características:

Flexibilidad: IMAP permite a los usuarios ver y manipular los mensajes de correo electrónico directamente en el servidor sin descargarlos en su dispositivo local. Esto significa que puedes organizar, eliminar o marcar tus correos y los cambios se reflejarán en todos tus dispositivos.
Conexión Constante: Con IMAP, el cliente de correo mantiene una conexión constante con el servidor. Esto es útil para ver correos en tiempo real y gestionar tu bandeja de entrada de manera efectiva desde varios dispositivos.
Puertos de Seguridad: Opera a través del puerto 143 para conexiones no cifradas y el puerto 993 para conexiones cifradas (IMAPS, que es IMAP sobre SSL/TLS).

Ventajas:

Acceso y gestión de correo en múltiples dispositivos.
Los cambios realizados en un dispositivo se sincronizan con todos los demás.
No es necesario descargar grandes cantidades de datos para ver los correos.

Desventajas:

Requiere más ancho de banda y tiempo de conexión porque los correos se mantienen en el servidor.
Más complejo de implementar y administrar en comparación con POP3.

Comparación entre POP3 e IMAP

| Característica | POP3 | IMAP | |-----------------|--------------------------------|-------------------------------------| | Almacenamiento | Localmente en el dispositivo | En el servidor | | Acceso | Único dispositivo | Múltiples dispositivos | | Gestión | Simple y limitada | Compleja y flexible | | Uso de Red | Bajo después de la descarga | Alto, constante | | Sincronización | No aplica | Total entre dispositivos |

Conclusión

La elección entre POP3 e IMAP depende de tus necesidades específicas. Si necesitas acceder a tus correos desde múltiples dispositivos y quieres que los cambios se sincronicen entre todos ellos, IMAP es la mejor opción. Si solo accedes desde un dispositivo y prefieres una solución más simple y con acceso offline, POP3 podría ser adecuado. Ambos protocolos pueden usarse con medidas de seguridad como SSL/TLS para proteger la transmisión de datos.

Ejercicio 3

Utilizando la VM y teniendo en cuenta los siguientes datos, abra el cliente de correo (thunderbird) y configure dos cuentas de correo. Una de las cuentas utilizará POP para solicitar al servidor los mails recibidos para la misma mientras que la otra utilizará IMAP.

Al crear cada una de las cuentas, seleccionar Manual config y luego de configurar las mismas según lo indicado, ignorar advertencias por uso de conexión sin cifrado.

Datos para POP

Cuenta de correo: alumnopop@redes.unlp.edu.ar
Nombre de usuario: alumnopop
Contraseña: alumnopoppass
Puerto: 110

Datos para IMAP

Cuenta de correo: alumnoimap@redes.unlp.edu.ar
Nombre de usuario: alumnoimap
Contraseña: alumnoimappass
Puerto: 143

Datos comunes para ambas cuentas

Servidor de correo entrante (POP/IMAP):
- Nombre: mail.redes.unlp.edu.ar
- SSL: None
- Autenticación: Normal password
Servidor de correo saliente (SMTP):
- Nombre: mail.redes.unlp.edu.ar
- Puerto: 25
- SSL: None
- Autenticación: Normal password

Mini Tutorial Thunderbird (Espero que se entienda)

Ingresamos los datos solicitados

Y para agregar la otra cuenta damos click derecho en la zona negra para poder habilitar el menu

Una vez habilitado el menu le damos en la siguiente opción y agregamos el otro email con los datos correspondientes

Una vez que tenemos los dos mails, vamos a la configuración de cada uno, haciendo click derecho y en settings. Nos aseguramos de tener los siguientes datos.

Los datos para el otro mail

Y por ultimo tenemos que chequear lo siguiente

Parte a

Verificar el correcto funcionamiento enviando un email desde el cliente de una cuenta a la otra y luego desde la otra responder el mail hacia la primera.

Parte b

Análisis del protocolo SMTP

Utilizando Wireshark, capture el tráfico de red contra el servidor de correo mientras desde la cuenta alumnopop@redes.unlp.edu.ar envía un correo a alumnoimap@redes.unlp.edu.ar

ii. Utilice el filtro SMTP para observar los paquetes del protocolo SMTP en la captura generada y analice el intercambio de dicho protocolo entre el cliente y el servidor para observar los distintos comandos utilizados y su correspondiente respuesta. Ayuda: filtre por protocolo SMTP y sobre alguna de las líneas del intercambio haga click derecho y seleccione Follow TCP Stream...

4	5.005634483	172.28.0.90	172.28.0.1	SMTP	126	S: 220 mail.redes.unlp.edu.ar ESMTP Postfix (Lihuen-4.01/GNU)
8	5.009561864	172.28.0.1	172.28.0.90	SMTP	85	C: EHLO [172.28.0.1]
10	5.009691688	172.28.0.90	172.28.0.1	SMTP	225	S: 250-mail.redes.unlp.edu.ar | PIPELINING | SIZE 10240000 | VRFY | ETRN | STARTTLS | ENHANCEDSTATUSCODES | 8BITMIME | DSN | CHUNKING
12	5.012393833	172.28.0.1	172.28.0.90	SMTP	130	C: MAIL FROM:<alumnopop@redes.unlp.edu.ar> BODY=8BITMIME SIZE=444
14	5.012506165	172.28.0.90	172.28.0.1	SMTP	80	S: 250 2.1.0 Ok
16	5.013084972	172.28.0.1	172.28.0.90	SMTP	106	C: RCPT TO:<alumnoimap@redes.unlp.edu.ar>
18	5.013742698	172.28.0.90	172.28.0.1	SMTP	80	S: 250 2.1.5 Ok
20	5.014499789	172.28.0.1	172.28.0.90	SMTP	72	C: DATA
22	5.014592474	172.28.0.90	172.28.0.1	SMTP	103	S: 354 End data with <CR><LF>.<CR><LF>
24	5.015352422	172.28.0.1	172.28.0.90	SMTP	510	C: DATA fragment, 444 bytes
25	5.015675668	172.28.0.1	172.28.0.90	SMTP/IMF	69	from: alumnopop <alumnopop@redes.unlp.edu.ar>, subject: dddd,  (text/plain)
27	5.016902599	172.28.0.90	172.28.0.1	SMTP	102	S: 250 2.0.0 Ok: queued as 7839D60108
29	5.019272721	172.28.0.1	172.28.0.90	SMTP	72	C: QUIT
30	5.019837877	172.28.0.90	172.28.0.1	SMTP	81	S: 221 2.0.0 Bye

La secuencia que proporcionaste es un registro detallado de una sesión SMTP entre un cliente (dirección IP 172.28.0.1) y un servidor de correo electrónico (dirección IP 172.28.0.90). SMTP es el protocolo utilizado para enviar correos electrónicos a través de la red. A continuación te explico detalladamente cada paso de la comunicación:

Paso 4:

Tiempo: 5.005634483 segundos desde el inicio de la captura.
Fuente y Destino: Del servidor de correo (172.28.0.90) al cliente (172.28.0.1).
Protocolo y Longitud: SMTP con 126 bytes de longitud.
Información: El servidor SMTP responde con un saludo 220, indicando que está listo para comenzar la comunicación. ESMTP Postfix señala que está utilizando Postfix como su servidor de correo y que es capaz de manejar ESMTP (Extended SMTP).

Paso 8:

Tiempo: 5.009561864 segundos.
Fuente y Destino: Del cliente al servidor.
Información: El cliente envía el comando EHLO seguido de su dirección IP entre corchetes. EHLO se utiliza para identificar al cliente ante el servidor e iniciar la conversación SMTP.

Paso 10:

Tiempo: 5.009691688 segundos.
Información: El servidor SMTP responde con sus capacidades, incluyendo soporte para PIPELINING, límites de tamaño de mensaje (SIZE), y varios otros comandos ESMTP.

Paso 12

Tiempo: 5.012393833 segundos.
Información: El cliente indica la dirección de correo electrónico del remitente usando el comando MAIL FROM: y especifica que el cuerpo del correo permite contenido de 8 bits (BODY=8BITMIME) y que tiene un tamaño de 444 bytes.

Paso 14:

Tiempo: 5.012506165 segundos.
Información: El servidor confirma que el comando MAIL FROM es aceptable con una respuesta 250 2.1.0 Ok.

Paso 16:

Tiempo: 5.013084972 segundos.
Información: El cliente envía el comando RCPT TO: para especificar la dirección de correo electrónico del destinatario.

Paso 18:

Tiempo: 5.013742698 segundos.
Información: El servidor responde con 250 2.1.5 Ok, aceptando la dirección del destinatario.

Paso 20:

Tiempo: 5.014499789 segundos.
Información: El cliente solicita iniciar la transferencia del cuerpo del mensaje con el comando DATA.

Paso 22:

Tiempo: 5.014592474 segundos.
Información: El servidor invita al cliente a comenzar la transmisión del cuerpo del mensaje, terminando con <CR><LF>.<CR><LF> (retorno de carro y salto de línea, seguidos de un punto y otro retorno de carro y salto de línea).

Paso 24:

Tiempo: 5.015352422 segundos.
Información: El cliente comienza a enviar un fragmento del cuerpo del mensaje con una longitud de 444 bytes.

Paso 25:

Tiempo: 5.015675668 segundos.
Información: Se observa parte del contenido del mensaje, incluyendo el remitente y el asunto. El tipo MIME (text/plain) indica que es texto plano.

Paso 27:

Tiempo: 5.016902599 segundos.
Información: El servidor acepta el mensaje y responde con 250 2.0.0 Ok: queued as 7839D60108, indicando que el mensaje ha sido puesto en cola para su entrega y asignándole un identificador de cola.

Paso 29:

Tiempo: 5.019272721 segundos.
Información: El cliente finaliza la sesión con el comando QUIT.

Paso 30:

Tiempo: 5.019837877 segundos.
Información: El servidor confirma el cierre de la sesión con 221 2.0.0 Bye.

En resumen, esta secuencia muestra una transacción SMTP exitosa en la que un cliente envía un correo electrónico a un servidor, el servidor acepta y pone en cola el mensaje para su entrega, y finalmente, se cierra la sesión de comunicación de manera limpia.

Parte c

Usando el cliente de correo, thunderbird del usuario alumnopop@redes.unlp.edu.ar envíe un correo electrónico alumnoimap@redes.unlp.edu.ar el cual debe tener: un asunto, datos en el body y una imagen adjunta.

iVerifique los fuentes del correo recibido para entender como se utiliza el header “Content-Type: multipart/mixed“ para poder realizar el envío de distintos archivos adjuntos.

Return-Path: <alumnopop@redes.unlp.edu.ar>
X-Original-To: alumnoimap@redes.unlp.edu.ar
Delivered-To: alumnoimap@redes.unlp.edu.ar
Received: from [172.28.0.1] (unknown [172.28.0.1])
	by mail.redes.unlp.edu.ar (Postfix) with ESMTP id 17D0960192
	for <alumnoimap@redes.unlp.edu.ar>; Sun, 14 Apr 2024 23:36:32 +0000 (UTC)
Content-Type: multipart/alternative;
 boundary="------------Fju9GPlZ4P3UCqeMMOEz0o7L"
Message-ID: <2e205777-f17e-ee1a-f34a-847b156e847e@redes.unlp.edu.ar>
Date: Sun, 14 Apr 2024 20:36:26 -0300
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101
 Thunderbird/91.12.0
Content-Language: en-US
To: alumnoimap@redes.unlp.edu.ar
From: alumnopop <alumnopop@redes.unlp.edu.ar>
Subject: Ejercicio 3c

This is a multi-part message in MIME format.
--------------Fju9GPlZ4P3UCqeMMOEz0o7L
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit

Pruebas de textovegetauwu

--------------Fju9GPlZ4P3UCqeMMOEz0o7L
Content-Type: multipart/related;
 boundary="------------BTmIsRQtJHYCkUO0b2F4ssOE"

--------------BTmIsRQtJHYCkUO0b2F4ssOE
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: 7bit

<html>
  <head>

    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  </head>
  <body>
    <p>Pruebas de texto<img moz-do-not-send="false"
        src="cid:part1.vR1R0n7i.cHRUhuyT@redes.unlp.edu.ar"
        alt="vegetauwu" width="162" height="312"><br>
    </p>
  </body>
</html>
--------------BTmIsRQtJHYCkUO0b2F4ssOE
Content-Type: image/jpeg; name="vegeta.jpeg"
Content-Disposition: inline; filename="vegeta.jpeg"
Content-Id: <part1.vR1R0n7i.cHRUhuyT@redes.unlp.edu.ar>
Content-Transfer-Encoding: base64

/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAkGBxMSEhMRExIWFhUXFhUbFxgSFRcaFxcWFhcX

El mensaje que has proporcionado es un correo electrónico formateado usando MIME (Multipurpose Internet Mail Extensions), que permite incluir contenido multimedia en los correos electrónicos, como texto, HTML y archivos adjuntos (como imágenes).

Aquí hay un desglose detallado de las partes relevantes del encabezado del correo y la estructura del mensaje que utiliza Content-Type: multipart/alternative y Content-Type: multipart/related:

Encabezados MIME Generales

Content-Type: multipart/alternative;: Indica que hay varias versiones del cuerpo del mensaje (como texto plano y HTML), y que los clientes de correo pueden elegir cuál mostrar. El atributo boundary define el delimitador que separa las distintas partes del mensaje.

Partes del Mensaje

Parte de Texto Plano:
- Content-Type: text/plain; charset=UTF-8; format=flowed: Define que esta parte del mensaje es en texto plano con codificación UTF-8 y que el texto fluye (es decir, no tiene un ancho fijo de línea).
- Content-Transfer-Encoding: 7bit: Indica que el cuerpo del mensaje está codificado en 7 bits y no requiere codificación para caracteres especiales.
Parte HTML:
- Content-Type: multipart/related;: Utilizado para mensajes HTML que incluyen recursos vinculados como imágenes; estas se incrustan en el mensaje relacionando las partes mediante el uso de identificadores únicos (Content-Id).
- Dentro de esta sección hay dos partes:
  - HTML del Mensaje: La parte que es HTML, que incluye el contenido visual del mensaje y puede contener enlaces a recursos incrustados (como imágenes).
  - La Imagen Incrustada:
    - Content-Type: image/jpeg; name="vegeta.jpeg": Esta parte es una imagen JPEG adjunta al mensaje.
    - Content-Disposition: inline; filename="vegeta.jpeg": La disposición inline indica que la imagen se muestra dentro del flujo del mensaje HTML, y filename es el nombre del archivo adjunto.
    - Content-Id: Este es un identificador único para la parte del mensaje, que permite al HTML referirse a esta imagen usando cid: (Content ID).
    - Content-Transfer-Encoding: base64: La imagen está codificada en base64, que es un método común para codificar datos binarios en mensajes de correo electrónico.

Extracción de la Imagen Adjunta

Para extraer la imagen adjunta del cuerpo del mensaje, deberías copiar todo el texto que sigue a Content-Transfer-Encoding: base64 hasta el siguiente delimitador boundary. Luego, utiliza una herramienta de decodificación de base64 para convertir este texto en un archivo de imagen. La mayoría de los clientes de correo hacen esto automáticamente y te permiten descargar o guardar la imagen con solo hacer clic en ella.

ii. Extraiga la imagen adjunta del mismo modo que lo hace el cliente de correo a partir de los fuentes del mensaje.

Salida del Wireshark

2206	207.405826400	172.28.0.90	172.28.0.1	SMTP	81	S: 221 2.0.0 Bye
2204	207.395353495	172.28.0.90	172.28.0.1	SMTP	102	S: 250 2.0.0 Ok: queued as 17D0960192
2197	207.389918493	172.28.0.90	172.28.0.1	SMTP	103	S: 354 End data with <CR><LF>.<CR><LF>
2193	207.388964035	172.28.0.90	172.28.0.1	SMTP	80	S: 250 2.1.5 Ok
2189	207.380921813	172.28.0.90	172.28.0.1	SMTP	80	S: 250 2.1.0 Ok
2185	207.373677972	172.28.0.90	172.28.0.1	SMTP	225	S: 250-mail.redes.unlp.edu.ar | PIPELINING | SIZE 10240000 | VRFY | ETRN | STARTTLS | ENHANCEDSTATUSCODES | 8BITMIME | DSN | CHUNKING
2181	207.372299550	172.28.0.90	172.28.0.1	SMTP	126	S: 220 mail.redes.unlp.edu.ar ESMTP Postfix (Lihuen-4.01/GNU)
2205	207.405560036	172.28.0.1	172.28.0.90	SMTP	72	C: QUIT
2202	207.392380030	172.28.0.1	172.28.0.90	SMTP/IMF	69	from: alumnopop <alumnopop@redes.unlp.edu.ar>, subject: Ejercicio 3c,  (text/plain) (text/html) (image/jpeg)
2200	207.391704524	172.28.0.1	172.28.0.90	SMTP	4183	C: DATA fragment, 4117 bytes
2198	207.391660752	172.28.0.1	172.28.0.90	SMTP	7306	C: DATA fragment, 7240 bytes
2195	207.389793068	172.28.0.1	172.28.0.90	SMTP	72	C: DATA
2191	207.384549094	172.28.0.1	172.28.0.90	SMTP	106	C: RCPT TO:<alumnoimap@redes.unlp.edu.ar>
2187	207.377276018	172.28.0.1	172.28.0.90	SMTP	132	C: MAIL FROM:<alumnopop@redes.unlp.edu.ar> BODY=8BITMIME SIZE=11357
2183	207.373566919	172.28.0.1	172.28.0.90	SMTP	85	C: EHLO [172.28.0.1]

Una vez que seleccionamos nuetra imagen codigicada, buscamos la seccion de base64

Y terminamos de copiar aca

Una vez que copiamos eso, ejecutamos el siguiente comando

echo 'base64_data' | base64 -d > output_image.jpeg

Si queres dejarlo en el escritorio, hacete un ls y despues un cd Desktop y lo ejecutas desde ahi

ACORDATE DE PEGAR LO QUE SACAMOS DE LOS PAQUETES :D

Ejercicio 4

Análisis del protocolo POP

Parte a

Utilizando Wireshark, capture el tráfico de red contra el servidor de correo mientras desde la cuenta alumnoimap@redes.unlp.edu.ar le envía una correo a alumnopop@redes.unlp.edu.ar y mientras alumnopop@redes.unlp.edu.ar recepciona dicho correo.

Parte b

Utilice el filtro POP para observar los paquetes del protocolo POP en la captura generada y analice el intercambio de dicho protocolo entre el cliente y el servidor para observar los distintos comandos utilizados y su correspondiente respuesta.

Salida

24	15.815362054	172.28.0.90	172.28.0.1	POP	86	S: +OK Dovecot ready.
26	15.815692388	172.28.0.1	172.28.0.90	POP	72	C: CAPA
28	15.815751368	172.28.0.90	172.28.0.1	POP	155	S: +OK
30	15.815864015	172.28.0.1	172.28.0.90	POP	78	C: AUTH PLAIN
32	15.816150185	172.28.0.90	172.28.0.1	POP/IMF	70	+   
34	15.816293615	172.28.0.1	172.28.0.90	POP	124	C: AGFsdW1ub3BvcEByZWRlcy51bmxwLmVkdS5hcgBhbHVtbm9wb3BwYXNz
36	15.820537730	172.28.0.90	172.28.0.1	POP	82	S: +OK Logged in.
38	15.821232208	172.28.0.1	172.28.0.90	POP	72	C: STAT
40	15.821305252	172.28.0.90	172.28.0.1	POP	79	S: +OK 4 77565
42	15.822101933	172.28.0.1	172.28.0.90	POP	72	C: LIST
44	15.822222780	172.28.0.90	172.28.0.1	POP	117	S: +OK 4 messages:
46	15.822359564	172.28.0.1	172.28.0.90	POP	72	C: UIDL
48	15.822493963	172.28.0.90	172.28.0.1	POP	154	S: +OK
50	15.823820392	172.28.0.1	172.28.0.90	POP	72	C: QUIT
52	15.824108415	172.28.0.90	172.28.0.1	POP	84	S: +OK Logging out.
285	74.349487529	172.28.0.90	172.28.0.1	POP	86	S: +OK Dovecot ready.
287	74.350007804	172.28.0.1	172.28.0.90	POP	72	C: CAPA
289	74.350128832	172.28.0.90	172.28.0.1	POP	155	S: +OK
291	74.350386703	172.28.0.1	172.28.0.90	POP	78	C: AUTH PLAIN
293	74.350693542	172.28.0.90	172.28.0.1	POP/IMF	70	+   
295	74.350834556	172.28.0.1	172.28.0.90	POP	124	C: AGFsdW1ub3BvcEByZWRlcy51bmxwLmVkdS5hcgBhbHVtbm9wb3BwYXNz
297	74.354636341	172.28.0.90	172.28.0.1	POP	82	S: +OK Logged in.
299	74.355850493	172.28.0.1	172.28.0.90	POP	72	C: STAT
301	74.358377472	172.28.0.90	172.28.0.1	POP	79	S: +OK 5 91538
302	74.359257624	172.28.0.1	172.28.0.90	POP	72	C: LIST
304	74.359439633	172.28.0.90	172.28.0.1	POP	126	S: +OK 5 messages:
305	74.359647918	172.28.0.1	172.28.0.90	POP	72	C: UIDL
307	74.359889160	172.28.0.90	172.28.0.1	POP	174	S: +OK
308	74.360192871	172.28.0.1	172.28.0.90	POP	74	C: RETR 5
310	74.360561095	172.28.0.90	172.28.0.1	POP	2962	S: +OK 13973 octets
312	74.360688337	172.28.0.90	172.28.0.1	POP	4410	S: DATA fragment, 4344 bytes
314	74.360753542	172.28.0.90	172.28.0.1	POP	4410	S: DATA fragment, 4344 bytes
316	74.360817283	172.28.0.90	172.28.0.1	POP	1514	S: DATA fragment, 1448 bytes
317	74.360846553	172.28.0.90	172.28.0.1	POP	1028	S: DATA fragment, 962 bytes
319	74.368747868	172.28.0.1	172.28.0.90	POP	72	C: QUIT
321	74.370858388	172.28.0.90	172.28.0.1	POP	84	S: +OK Logging out.

El texto que has proporcionado parece ser un registro de una sesión de captura de tráfico utilizando el protocolo POP (Post Office Protocol), que se usa para recuperar correos electrónicos de un servidor de correo electrónico. A continuación, explicaré cada línea en detalle:

S: +OK Dovecot ready.: El servidor (S) responde con "OK", lo que significa que está listo para comenzar la comunicación. Dovecot es el nombre del servidor de correo.
C: CAPA: El cliente (C) envía el comando "CAPA" para solicitar las capacidades del servidor, como soporte para comandos adicionales o características de seguridad.
S: +OK: El servidor responde positivamente, indicando que está listo para listar sus capacidades.
C: AUTH PLAIN: El cliente solicita autenticarse con el método "PLAIN", que envía el nombre de usuario y la contraseña en texto claro.
S: +: El servidor indica que está listo para recibir los datos de autenticación.
C: AGFsd...: El cliente envía los datos de autenticación codificados en Base64. La cadena de texto después de "C:" es el nombre de usuario y la contraseña en Base64.
S: +OK Logged in.: El servidor responde que la autenticación fue exitosa y que el usuario ha iniciado sesión.
C: STAT: El cliente envía el comando "STAT" para solicitar información sobre la cantidad de mensajes y el tamaño total del buzón.
S: +OK 4 77565: El servidor responde que hay 4 mensajes con un tamaño total de 77565 bytes en el buzón.
C: LIST: El cliente solicita una lista de los mensajes y sus tamaños.
S: +OK 4 messages:: El servidor responde con la cantidad de mensajes.
C: UIDL: El cliente solicita una lista de los mensajes y sus identificadores únicos.
S: +OK: El servidor responde positivamente.
C: QUIT: El cliente envía el comando "QUIT" para cerrar la conexión.
S: +OK Logging out.: El servidor confirma que está cerrando la conexión.

Las líneas 302 a 316 muestran la recuperación de un mensaje específico (en este caso, el mensaje número 5) con el comando "RETR", seguido de la respuesta del servidor que incluye el mensaje real (datos del mensaje) fragmentado en varias partes, indicando que está transmitiendo el mensaje que tiene un tamaño de 13973 bytes.

El tráfico posterior de POP muestra que el cliente sigue interactuando con el servidor para recuperar y gestionar los mensajes en el buzón. Finalmente, el cliente envía de nuevo el comando "QUIT" para cerrar la sesión (C: QUIT), y el servidor responde que la sesión está cerrando (S: +OK Logging out.).

Ejercicio 5

Análisis del protocolo IMAP

Parte a

Utilizando Wireshark, capture el tráfico de red contra el servidor de correo mientras desde la cuenta alumnopop@redes.unlp.edu.ar le envía una correo a alumnoimap@redes.unlp.edu.ar y mientras alumnoimap@redes.unlp.edu.ar recepciona dicho correo.

Parte b

Utilice el filtro IMAP para observar los paquetes del protocolo IMAP en la captura generada y analice el intercambio de dicho protocolo entre el cliente y el servidor para observar los distintos comandos utilizados y su correspondiente respuesta.

3	0.000226978	172.28.0.90	172.28.0.1	IMAP	121	Response: 68 OK Idle completed (68.782 + 68.782 + 68.781 secs).
5	0.000740257	172.28.0.1	172.28.0.90	IMAP	75	Request: 69 noop
7	0.000952501	172.28.0.90	172.28.0.1	IMAP	110	Response: 69 OK NOOP completed (0.001 + 0.000 secs).
9	0.001157266	172.28.0.1	172.28.0.90	IMAP	92	Request: 70 UID fetch 8:* (FLAGS)
11	0.001387314	172.28.0.90	172.28.0.1	IMAP	154	Response: 70 OK Fetch completed (0.001 + 0.000 secs).
13	0.002704380	172.28.0.1	172.28.0.90	IMAP	75	Request: 71 IDLE
15	0.002941722	172.28.0.90	172.28.0.1	IMAP	76	Response: + idling
60	15.722543546	172.28.0.90	172.28.0.1	IMAP	90	Response: * 6 EXISTS
62	15.723339767	172.28.0.1	172.28.0.90	IMAP	72	Request: DONE
64	15.723507614	172.28.0.90	172.28.0.1	IMAP	121	Response: 71 OK Idle completed (15.721 + 15.718 + 15.720 secs).
66	15.723901320	172.28.0.1	172.28.0.90	IMAP	75	Request: 72 noop
68	15.724435617	172.28.0.90	172.28.0.1	IMAP	110	Response: 72 OK NOOP completed (0.001 + 0.000 secs).
70	15.724680116	172.28.0.1	172.28.0.90	IMAP	92	Request: 73 UID fetch 8:* (FLAGS)
72	15.725029146	172.28.0.90	172.28.0.1	IMAP	146	Response: 73 OK Fetch completed (0.001 + 0.000 secs).
74	15.725698775	172.28.0.1	172.28.0.90	IMAP	248	Request: 74 UID fetch 8 (UID RFC822.SIZE FLAGS BODY.PEEK[HEADER.FIELDS (From To Cc Bcc Subject Date Message-ID Priority X-Priority References Newsgroups In-Reply-To Content-Type Reply-To)])
76	15.727543896	172.28.0.90	172.28.0.1	IMAP/IMF	585	from: alumnopop <alumnopop@redes.unlp.edu.ar>, subject: hola cabron,  (text/plain)
78	15.759640063	172.28.0.1	172.28.0.90	IMAP	112	Request: 75 UID fetch 8 (UID RFC822.SIZE BODY.PEEK[])
80	15.760120544	172.28.0.90	172.28.0.1	IMAP/IMF	935	from: alumnopop <alumnopop@redes.unlp.edu.ar>, subject: hola cabron,  (text/plain)
82	15.777713054	172.28.0.1	172.28.0.90	IMAP	178	Request: 76 UID fetch 8 (UID BODY.PEEK[HEADER.FIELDS (Content-Type Content-Transfer-Encoding)] BODY.PEEK[TEXT]<0.2048>)
84	15.778617088	172.28.0.90	172.28.0.1	IMAP/IMF	322	(text/plain)
86	15.789742688	172.28.0.1	172.28.0.90	IMAP	75	Request: 77 IDLE
88	15.790254483	172.28.0.90	172.28.0.1	IMAP	76	Response: + idling
124	50.826116147	172.28.0.90	172.28.0.1	IMAP	83	Response: * OK Still here
126	50.827134065	172.28.0.1	172.28.0.90	IMAP	72	Request: DONE
128	50.827301220	172.28.0.90	172.28.0.1	IMAP	121	Response: 77 OK Idle completed (35.038 + 35.037 + 35.037 secs).
130	50.827765081	172.28.0.1	172.28.0.90	IMAP	75	Request: 78 noop
132	50.828498371	172.28.0.90	172.28.0.1	IMAP	110	Response: 78 OK NOOP completed (0.001 + 0.000 secs).
134	50.828829187	172.28.0.1	172.28.0.90	IMAP	92	Request: 79 UID fetch 9:* (FLAGS)
136	50.829174468	172.28.0.90	172.28.0.1	IMAP	146	Response: 79 OK Fetch completed (0.001 + 0.000 secs).
138	50.832179591	172.28.0.1	172.28.0.90	IMAP	75	Request: 80 IDLE
140	50.832654708	172.28.0.90	172.28.0.1	IMAP	76	Response: + idling

Esta salida de Wireshark muestra una serie de comunicaciones entre un cliente y un servidor utilizando el protocolo IMAP (Internet Message Access Protocol), que es utilizado para acceder y manejar correos electrónicos de forma remota en un servidor. Veamos lo que está ocurriendo en cada línea:

IDLE y NOOP:
- El comando IDLE es utilizado por el cliente para notificar al servidor que va a estar inactivo y espera notificaciones de nuevos mensajes o cambios en el buzón.
- NOOP es un comando que se utiliza para mantener la conexión abierta sin realizar ninguna acción.
UID FETCH:
- El cliente utiliza el comando UID fetch 8:* (FLAGS) para solicitar información sobre los mensajes desde el número 8 hasta el último del buzón, específicamente, sus marcadores (FLAGS).
FETCH Response:
- El servidor responde a los comandos FETCH, indicando que la acción solicitada se ha completado con éxito.
FETCH de Encabezados y Cuerpo del Mensaje:
- El cliente realiza un FETCH detallado para el mensaje número 8, solicitando diferentes campos de los encabezados (HEADER.FIELDS) y un vistazo al cuerpo del mensaje (BODY.PEEK[]).
Texto del Mensaje y Continuación del IDLE:
- El servidor responde con el contenido del mensaje número 8, mostrando el texto en formato MIME (Multipurpose Internet Mail Extensions) con los campos From, To, Subject, etc.
- Después, el cliente vuelve a enviar un comando IDLE para mantenerse en espera de nuevos mensajes o cambios.
Still Here:
- El servidor envía una confirmación de que todavía está ahí, lo cual es una forma de mantener la conexión activa durante el comando IDLE.
DONE:
- Cuando el cliente está listo para finalizar el estado de IDLE, envía el comando DONE.
FETCH de Mensajes Nuevos:
- Finalmente, el cliente solicita con UID fetch 9:* (FLAGS) información sobre los mensajes nuevos que podrían haber llegado desde la última verificación.

En resumen, la captura muestra el intercambio de comandos y respuestas estándar en una sesión IMAP, donde el cliente verifica la existencia de nuevos mensajes, solicita detalles de mensajes específicos, y espera activamente por nuevas llegadas con el comando IDLE.

Ejercicio 6

IMAP vs POP

Parte A

Marque como leídos todos los correos que tenga en el buzón de entrada de alumnopop y de alumnoimap. Luego, cree una carpeta llamada POP en la cuenta de alumnopop y una llamada IMAP en la cuenta de alumnoimap.

Asegurese que tiene mails en el inbox y en la carpeta recientemente creada en cada una de las cuentas.

Parte B

Cierre la sesión iniciada e ingrese nuevamente identificandose como usuario root y password packer, ejecute el cliente de correos.

De esta forma, iniciará el cliente de correo con el perfil del superusuario (diferente del usuario con el que ya configuró las cuentas antes mencionadas).

Luego configure las cuentas POP e IMAP de los usuarios alumnopop y alumnoimap como se describió anteriormente pero desde el cliente de correos ejecutado con el usuario root.

Luego responda:

¿Qué correos ve en el buzón de entrada de ambas cuentas?

¿Están marcados como leídos o como no leídos?

¿Por qué?

¿Qué pasó con las carpetas POP e IMAP que creó en el paso anterior?

No pude hacer andar la parte b :,(

Ejercicio 7

¿En algún caso es posible enviar más de un correo durante una misma conexión tcp?

Considere:

Destinatarios múltiples del mismo dominio entre MUA-MSA y entre MTA-MTA
Destinatarios múltiples de diferentes dominios entre MUA-MSA y entre MTA-MTA

Sí, es posible enviar más de un correo durante una misma conexión TCP en varios escenarios del proceso de envío de correo electrónico. Estos escenarios incluyen tanto la comunicación entre el Agente de Usuario de Correo (MUA) y el Agente de Envío de Correo (MSA), como entre Agentes de Transferencia de Correo (MTA).

Destinatarios múltiples del mismo dominio entre MUA-MSA: Cuando un usuario envía un correo electrónico a través de su cliente de correo (MUA) a su servidor (MSA), puede especificar varios destinatarios en los campos "Para", "CC" o "CCO". El MUA enviará una sola transacción SMTP al MSA que incluye todos estos destinatarios si pertenecen al mismo dominio.
Destinatarios múltiples de diferentes dominios entre MUA-MSA: Incluso cuando los destinatarios son de diferentes dominios, el MUA puede enviar todos los destinatarios en una sola transacción SMTP al MSA. Es responsabilidad del MSA clasificar y reenviar estos correos a los MTA correspondientes para los diferentes dominios.
Destinatarios múltiples del mismo dominio entre MTA-MTA: Cuando un MTA está enviando correos a otro MTA y todos los destinatarios pertenecen al mismo dominio, puede enviar todos esos correos en una única conexión TCP utilizando una única transacción SMTP. El protocolo SMTP permite enviar múltiples comandos "RCPT TO" durante la misma sesión para indicar múltiples destinatarios.
Destinatarios múltiples de diferentes dominios entre MTA-MTA: Si bien es técnicamente posible enviar correos a destinatarios de diferentes dominios en una sola conexión TCP, generalmente no se hace de esta manera debido a las políticas de enrutamiento y los posibles problemas de entrega. En la práctica, el MTA establecerá conexiones separadas para cada dominio de destino para manejar la entrega de correos electrónicos, a menos que tenga una configuración específica que permita el relaying o haya un acuerdo entre los dominios (como ocurre en federaciones o servicios internos de una empresa).

En todos los casos, el protocolo SMTP que se utiliza para enviar correos electrónicos entre MUAs, MSAs y MTAs admite transacciones con múltiples destinatarios en una sola sesión de conexión TCP, lo que puede mejorar la eficiencia al reducir el número de conexiones necesarias para enviar varios correos electrónicos. Sin embargo, la capacidad de hacerlo también puede estar limitada por políticas específicas de los servidores de correo o por medidas antispam.

Ejercicio 8

Indique sí es posible que el MSA escuche en un puerto TCP diferente a los convencionales y qué implicancias tendría.

Sí, es posible que un Mail Submission Agent (MSA), o cualquier servidor, escuche en un puerto TCP que no sea uno de los convencionales. Los puertos estándar para la sumisión de correo SMTP son el 25 para el intercambio entre servidores de correo (MTA a MTA), el 587 para la sumisión de correo desde un cliente de correo (MUA) a un MSA, y en algunos casos el 465 para conexiones seguras SMTP sobre SSL (aunque este último es informal y no está oficializado por la IETF).

Cambiar el puerto en el que un MSA escucha puede tener varias implicancias:

Configuración del cliente: Los clientes de correo electrónico que necesiten enviar correo a través de este MSA tendrán que configurarse para usar el nuevo puerto. Esto significa que el puerto no estándar debe ser comunicado a todos los usuarios y correctamente configurado en sus clientes de correo electrónico.
Compatibilidad y usabilidad: Muchos clientes de correo tienen preconfigurados los puertos estándar y los usuarios pueden no saber cómo cambiar esta configuración. Esto podría resultar en problemas de usabilidad y soporte técnico.
Seguridad: Algunos administradores de red pueden optar por cambiar el puerto de escucha de un servicio para evitar ataques automatizados que se dirigen a los puertos estándar. Sin embargo, este tipo de "seguridad por oscuridad" no es una medida de seguridad sólida y no debe ser la única protección.
Firewalls y filtros de red: Los firewalls y sistemas de seguridad de red pueden necesitar ser reconfigurados para permitir tráfico a través del nuevo puerto. Además, si los usuarios están detrás de firewalls corporativos que solo permiten tráfico a través de puertos conocidos, podrían experimentar problemas para conectarse al MSA.
Interoperabilidad: En el caso de comunicaciones entre servidores (MTA a MTA), cambiar el puerto podría llevar a que los correos no puedan ser entregados, ya que los servidores remotos esperarán que el MTA esté escuchando en el puerto estándar (25). Esto no aplica para MSA ya que la sumisión de correo normalmente es MUA a MSA.

En resumen, aunque es técnicamente posible cambiar el puerto, hacerlo se desvía de las convenciones y puede crear complicaciones adicionales tanto para los usuarios como para la administración de la red. Si se hace, es crucial que se gestione adecuadamente y que se informe y apoye a los usuarios en el proceso de cambio.

Ejercicio 9

Indique sí es posible que el MTA escuche en un puerto TCP diferente a los convencionales y qué implicancias tendría.

Sí, es posible que un Mail Transfer Agent (MTA) escuche en un puerto TCP que no sea uno de los convencionales, aunque esto no es habitual y puede tener varias implicaciones prácticas y técnicas.

Los puertos estándar para el MTA son el puerto 25 para la transmisión de mensajes entre servidores de correo (intercambio MTA a MTA) y, en algunos casos, el 587 para la recepción de mensajes de un cliente de correo o un MSA, aunque este último se usa principalmente para la sumisión de correo desde un MUA al MTA y no para la transferencia entre servidores.

Implicancias de un MTA en un Puerto No Convencional:

Configuración de Otros Servidores:
- Otros servidores que intenten enviar correo a este MTA necesitarán saber que deben conectarse a un puerto no estándar. Esto generalmente requiere configuración manual y acuerdos entre administradores de los sistemas implicados, lo cual puede complicar las relaciones y las configuraciones predeterminadas.
Firewalls y Routers:
- Los firewalls y routers que filtran el tráfico de red a menudo están configurados para permitir el tráfico SMTP a través del puerto 25. Cambiar a un puerto diferente podría requerir una reconfiguración significativa de estas políticas de seguridad, lo que podría ser problemático si la red es grande o si está gestionada por múltiples entidades.
Compatibilidad y Interoperabilidad:
- Utilizar un puerto no estándar puede afectar la interoperabilidad con otros sistemas de correo que esperan que el MTA esté disponible en el puerto 25. Esto podría resultar en errores de entrega o en la incapacidad de comunicarse con ciertos dominios que no reconocen la configuración personalizada.
Administración y Soporte:
- Los problemas de conectividad y entrega pueden ser más difíciles de diagnosticar si el MTA está operando en un puerto no estándar. Los administradores de sistemas y soporte técnico deben estar conscientes de esta configuración y preparados para manejar problemas que no seguirán los flujos de resolución de problemas estándar.
Seguridad:
- Cambiar el puerto de escucha de un servicio es a veces visto como una medida de seguridad para evitar ataques dirigidos a los puertos comunes. Sin embargo, esta forma de "seguridad por oscuridad" generalmente no ofrece una protección real contra adversarios determinados y no debe ser la única defensa contra amenazas de seguridad.

Conclusión:

Aunque técnicamente es posible configurar un MTA para que escuche en un puerto diferente al 25, hacerlo puede conducir a problemas de interoperabilidad, administración y seguridad. La mayoría de las organizaciones y administradores optan por adherirse a los estándares establecidos para garantizar la compatibilidad y minimizar problemas operativos. Si se considera necesario un cambio de este tipo, se deben tomar medidas cuidadosas para asegurarse de que todos los socios y sistemas implicados estén adecuadamente configurados y sean conscientes de esta desviación del estándar.

Ejercicio 10

Ejercicio integrador HTTP, DNS y MAIL

Suponga que registró bajo su propiedad el dominio redes2022.com.ar y dispone de 4 servidores:

Un servidor DNS instalado configurado como primario de la zona redes2022.com.ar. (hostname: ns1 / ip: 203.0.113.65).
Un servidor DNS instalado configurado como secundario de la zona redes2022.com.ar. (hostname: ns2 / ip: 203.0.113.66).
Un servidor de correo electrónico (hostname: mail / ip: 203.0.113.111). Permitirá a los usuarios envíar y recibir correos a cualquier dominio de Internet.
Un servidor WEB para el acceso a un webmail (hostname: correo / ip: 203.0.113.8). Permitirá a los usuarios gestionar vía web sus correos electrónicos a través de la URL https://webmail.redes2022.com.ar

Parte a

¿Qué información debería informar al momento del registro para hacer visible a Internet el dominio registrado?

Parte b

¿Qué registros sería necesario configurar en el servidor de nombres?

Indique toda la información necesaria del archivo de zona.

Puede utilizar la siguiente tabla de referencia (evalúe la necesidad de usar cada caso los siguientes campos):

Nombre del registro
Tipo de registro
Prioridad
TTLValor del registro.

Parte c

¿Es necesario que el servidor de DNS acepte consultas recursivas? Justifique.

Parte d

¿Qué servicios/protocolos de capa de aplicación configuraría en cada servidor?

Parte e

Para cada servidor, ¿qué puertos considera necesarios dejar abiertos a Internet?.

A modo de referencia, para cada puerto indique: servidor, protocolo de transporte y número de puerto.

Parte f

¿Cómo cree que se conectaría el webmail del servidor web con el servidor de correo?

¿Qué protocolos usaría y para qué?

Parte g

¿Cómo se podría hacer para que cualquier MTA reconozca como válidos los mails provienentes del dominio redes2022.com.ar solamente a los que llegan de la dirección 203.0.113.111?

¿Afectaría esto a los mails enviados desde el Webmail? Justifique.

Parte h

¿Qué característica propia de SMTP, IMAP y POP hace que al adjuntar una imagen o un ejecutable sea necesario aplicar un encoding (ej. base64)?

Parte i

¿Se podría enviar un mail a un usuario de modo que el receptor vea que el remitente es un usuario distinto?

En caso afirmativo, ¿Cómo?

¿Es una indicación de una estafa? Justifique

Parte j

¿Sepodría enviar un mail a un usuario de modo queel receptor vea que el destinatario es un usuario distinto?

En caso afirmativo, ¿Cómo?

¿Por qué no le llegaría al destinatario que el receptor vé?

¿Es esto una indicación de una estafa? Justifique

Parte k

¿Qué protocolo usará nuestro MUA para enviar un correo con remitente redes@info.unlp.edu.ar?

¿Con quién se conectará?

¿Qué información será necesaria y cómo la obtendría?

Parte l

Dado que solo disponemos de un servidor de correo

¿qué sucederá con los mails que intenten ingresar durante un reinicio del servidor?

Parte m

Suponga que contratamos un servidor de correo electrónico en la nube para integrarlo con nuestra arquitectura de servicios.

¿Cómo configuraría el DNS para que ambos servidores de correo se comporten de manera de dar un servicio de correo tolerante a fallos?

Ejercicio 11

Ejercicio 12

Consultas

Practica 5 Redes | Capa de Transporte

Tue, 07 May 2024 00:00:00 GMT

Practica 5

Capa de Transporte - Parte 1

Ejercicio 1 ¿Cuál es la función de la capa de transporte?
Ejercicio 2 Describa la estructura del segmento TCP y UDP.
Ejercicio 3 ¿Cuál es el objetivo del uso de puertos en el modelo TCP/IP?
Ejercicio 4 Compare TCP y UDP en cuanto a
Ejercicio 5 La PDU de la capa de transporte es el segmento
Ejercicio 6 Describa el saludo de tres vías de TCP.
Ejercicio 7 Investigue qué es el ISN
Ejercicio 8 Investigue qué es el MSS
Ejercicio 9 Utilice el comando ss
Ejercicio 10 Qué sucede si llega un segmento TCP con el flag SYN
Ejercicio 11 Qué sucede si llega un datagrama UDP
Ejercicio 12 Investigue los distintos tipos de estado que puede tener una conexión TCP
Ejercicio 13 Use CORE para armar una topología como la siguiente
Ejercicio 14 Dada la siguiente salida del comando ss
Ejercicio 15 Dadas las salidas de los siguientes comando se jecutados en el cliente y el servidor

Ejercicio 1

¿Cuál es la función de la capa de transporte?

La función de la capa de transporte es fundamental en el modelo de redes TCP/IP, ya que proporciona servicios de comunicación de extremo a extremo para aplicaciones sobre una red. Aquí hay algunas funciones clave que desempeña esta capa:

Segmentación de datos: Divide los datos de aplicación en segmentos más pequeños que son más manejables para enviar a través de una red.
Control de flujo: Regula la cantidad de datos que un remitente transmite para asegurarse de que el receptor pueda manejarlo, evitando que los buffers de recepción se desborden.
Transferencia de datos confiable: Asegura que los datos se transmitan de manera confiable a través de la red, utilizando acuses de recibo, retransmisiones y sumas de verificación para gestionar la pérdida de paquetes o datos corruptos.
Control de congestión: Evita que la red se sature controlando la tasa a la que se envían los datos, basándose en el estado percibido de la red y en la respuesta de los dispositivos dentro de la red.
Multiplexación y demultiplexación: Permite que múltiples aplicaciones utilicen simultáneamente la red, asignando a cada flujo de datos un puerto específico.

Estas funciones se implementan a través de dos protocolos principales: TCP (Protocolo de Control de Transmisión) y UDP (Protocolo de Datagrama de Usuario), cada uno ofreciendo diferentes niveles de servicio en función de las necesidades de la aplicación. TCP proporciona un servicio de transmisión confiable y controlado, mientras que UDP ofrece un servicio más rápido pero menos confiable.

Ejercicio 2

Describa la estructura del segmento TCP y UDP.

Estructura del Segmento TCP

Campos del Segmento TCP:

Puertos (MUX/DEMUX): Utilizados para multiplexar y demultiplexar los servicios de aplicación sobre el protocolo TCP, asignando el tráfico al proceso de aplicación correcto en los sistemas.
Longitud del encabezado (HDR LEN): Variable, puede tener un máximo de 60 bytes (unidad=4 bytes).
Checksum: Se calcula para verificar la integridad de los datos del segmento. Es obligatorio y ayuda a detectar errores en los datos transmitidos.
Flags: Incluyen señales importantes como SYN (sincronización), FIN (finalización) y RST (reset).
Número de secuencia y acuse de recibo (Num. Sec (#Seq), Num. Ack (#Ack)): Para el control de la transferencia de datos, indicando el orden y la confirmación de los datos recibidos.
Ventana (Win): Utilizada para el control de flujo, especificando la cantidad de bytes que están disponibles para ser recibidos en el buffer del receptor.
Opciones de control de congestión: Se agregan banderas adicionales relacionadas con la gestión de la congestión en la red.

Estructura del Datagrama UDP

Campos del Datagrama UDP:

Puertos (MUX/DEMUX): Similar a TCP, se utilizan para direccionar los datagramas a la aplicación correcta mediante la multiplexación y demultiplexación.
Longitud: Incluye la longitud total del encabezado de UDP y los datos (payload).
Checksum: Es opcional en IPv4 (UDP4) y se calcula sumando el encabezado de UDP, el pseudoencabezado y los datos. Proporciona una verificación de errores básica, aunque no es tan robusta como en TCP.
Pseudoencabezado: Incluye direcciones IP de origen y destino, un campo reservado a cero, el protocolo UDP y la longitud del UDP, ayudando a asegurar que el datagrama llegue al destino correcto y minimizando el mal enrutamiento.

Estas estructuras indican cómo TCP y UDP manejan la transmisión de datos, con TCP ofreciendo más características para la fiabilidad y el control, mientras que UDP proporciona un servicio más simple y rápido, ideal para aplicaciones que pueden manejar pérdidas ocasionales de paquetes, como streaming de video o juegos en línea.

Ejercicio 3

¿Cuál es el objetivo del uso de puertos en el modelo TCP/IP?

El objetivo del uso de puertos en el modelo TCP/IP es facilitar la multiplexación y la demultiplexación de múltiples conexiones a través de una única interfaz de red. Los puertos permiten que diferentes procesos o servicios de aplicación en una misma computadora identifiquen a qué sesión de comunicación pertenecen los paquetes de datos que llegan a través de la red. Esto se logra asignando un número de puerto único a cada servicio y sesión, lo que permite que el sistema operativo redirija correctamente los datos entrantes a la aplicación o proceso adecuado.

Funciones principales de los puertos en el modelo TCP/IP:

Identificación de Aplicación: Los puertos sirven como puntos finales en la capa de transporte. Cada aplicación o servicio en un dispositivo que necesita recibir datos de la red es asignada a un puerto específico, ya sea de manera estándar (puertos bien conocidos) o de manera dinámica.
Multiplexación: Permite a un servidor manejar múltiples conexiones entrantes para el mismo servicio, distinguiendo entre ellas a través de los números de puerto combinados con las direcciones IP de origen.
Demultiplexación: Facilita que el sistema operativo del dispositivo receptor distribuya correctamente los datos entrantes al programa o proceso correcto, basado en el número de puerto al que están dirigidos los datos.
Soporte para múltiples Aplicaciones: Los puertos permiten que múltiples aplicaciones se ejecuten simultáneamente en un dispositivo, con cada una usando su propio puerto para evitar conflictos y asegurar la correcta entrega de los datos.
Control de Acceso y Seguridad: Algunos puertos son reservados o bien conocidos y son utilizados por servicios específicos (como HTTP en el puerto 80 o HTTPS en el puerto 443), lo que permite implementar políticas de seguridad y firewalls más efectivos basados en números de puerto conocidos.

Los puertos son fundamentales para la eficiencia y organización del tráfico de red en sistemas que utilizan el modelo TCP/IP, facilitando la coexistencia de múltiples conexiones y aplicaciones dentro de un mismo dispositivo de red.

Ejercicio 4

Compare TCP y UDP en cuanto a:

TCP y UDP son dos protocolos fundamentales en la capa de transporte del modelo TCP/IP, cada uno con características y usos específicos. A continuación, se presenta una comparación detallada entre ambos protocolos en los aspectos solicitados:

a) Confiabilidad

TCP: Es un protocolo orientado a la conexión y ofrece garantías de entrega. Utiliza confirmaciones, retransmisiones y un mecanismo de control de errores para asegurar que los datos lleguen de manera correcta y en orden al destinatario. Si los datos se pierden o se dañan durante la transmisión, TCP se encarga de solicitar la retransmisión de estos.
UDP: Es un protocolo no orientado a la conexión y no garantiza la entrega de los paquetes. No utiliza confirmaciones ni retransmisiones, lo que significa que si los paquetes se pierden, no se recuperan automáticamente.

b) Multiplexación

TCP y UDP: Ambos protocolos soportan la multiplexación usando puertos. Cada segmento de TCP o datagrama de UDP contiene un puerto de origen y un puerto de destino, lo que permite que múltiples aplicaciones en los hosts envíen y reciban datos simultáneamente sin interferencia entre ellas.

c) Orientado a la conexión

TCP: Es un protocolo orientado a la conexión, lo que significa que antes de que cualquier dato pueda ser enviado, se debe establecer una conexión entre el cliente y el servidor mediante un proceso conocido como "three-way handshake".
UDP: No es orientado a la conexión, por lo que no requiere de una conexión inicial antes de enviar datos. Esto permite que la comunicación sea más rápida, pero menos fiable.

d) Controles de congestión

TCP: Implementa varios mecanismos de control de congestión para gestionar la cantidad de datos que se envían a través de la red, evitando así la saturación de la red y garantizando un rendimiento óptimo. Esto incluye algoritmos como "slow start", "congestion avoidance", "fast retransmit" y "fast recovery".
UDP: No tiene controles de congestión. Los datos se envían tan rápido como los permite la aplicación, sin tener en cuenta el estado de la red, lo que puede llevar a una mayor tasa de pérdida de paquetes si la red está congestionada.

e) Utilización de puertos

TCP y UDP: Ambos protocolos utilizan puertos para identificar las aplicaciones específicas dentro de los hosts que están enviando o recibiendo datos. Los puertos proporcionan una forma de dirigir los segmentos de datos (en TCP) o datagramas (en UDP) a la aplicación correcta en un proceso conocido como demultiplexación.

En resumen, TCP es más adecuado para aplicaciones que requieren entrega garantizada y confiabilidad, como transferencias de archivos, navegación web y correo electrónico. UDP es preferible para aplicaciones que requieren baja latencia y pueden tolerar cierta pérdida de datos, como juegos en línea, streaming de video o VoIP.

Ejercicio 5

La PDU de la capa de transporte es el segmento. Sin embargo, en algunos contextos suele utilizarse el término datagrama. Indique cuando.

En el contexto de la capa de transporte del modelo OSI o TCP/IP, el término "segmento" se utiliza específicamente para referirse a la unidad de datos manejada por el protocolo TCP (Transmission Control Protocol), mientras que el término "datagrama" se utiliza cuando se habla del protocolo UDP (User Datagram Protocol).

Aquí están las circunstancias en las que cada término es apropiado:

Segmento

Utilizado en TCP: El segmento es la unidad de transferencia en TCP. Un segmento de TCP encapsula los datos de la capa de aplicación y añade su propia cabecera TCP, que incluye información vital como números de secuencia y acuse de recibo, puertos de origen y destino, flags de control, ventana de recepción, y otros campos que son esenciales para la entrega confiable y controlada de datos.

Datagrama

Utilizado en UDP: Un datagrama UDP es la unidad de transferencia para el protocolo UDP. Los datagramas UDP también encapsulan datos de la capa de aplicación pero con una cabecera mucho más simple comparada con TCP. Esta cabecera incluye solo los puertos de origen y destino, la longitud total del datagrama y una suma de verificación. UDP es conocido por ser un protocolo sin conexión y no orientado a la confiabilidad, lo que permite un transporte más rápido pero menos seguro de los datos.

En resumen, "segmento" se usa cuando se discuten las operaciones de TCP debido a su naturaleza orientada a la conexión y sus mecanismos integrados para la confiabilidad. "Datagrama", por otro lado, se usa en el contexto de UDP, donde la velocidad y la eficiencia son prioritarias sobre la garantía de entrega y el orden de los paquetes.

Ejercicio 6

Describa el saludo de tres vías de TCP. ¿Se utiliza algo similar en UDP?

El saludo de tres vías (three-way handshake) es un procedimiento fundamental en TCP (Transmission Control Protocol) utilizado para establecer una conexión entre un cliente y un servidor antes de que comiencen a enviarse datos. Este mecanismo asegura que ambos extremos estén preparados para la transmisión de datos y manejen correctamente las secuencias de números de secuencia, que son cruciales para la entrega ordenada y confiable de los paquetes.

Saludo de Tres Vías en TCP

El proceso incluye tres pasos:

SYN: El cliente inicia la conexión enviando un segmento TCP con la bandera SYN (synchronize) activada, que incluye un número de secuencia inicial (ISN, por sus siglas en inglés).
SYN-ACK: El servidor responde al cliente con un segmento que tiene las banderas SYN y ACK (acknowledgment) activadas. Este segmento contiene el propio número de secuencia inicial del servidor y un número de acuse de recibo, que es el número de secuencia inicial del cliente incrementado en uno.
ACK: Finalmente, el cliente envía un segmento con la bandera ACK activada, reconociendo la recepción del segmento SYN del servidor. El número de acuse de recibo enviado por el cliente es el número de secuencia inicial del servidor incrementado en uno.

Esta secuencia establece una conexión fiable, donde ambos extremos confirman que han recibido los números de secuencia iniciales del otro y están listos para la comunicación.

UDP y su Mecanismo de "Saludo"

A diferencia de TCP, UDP (User Datagram Protocol) es un protocolo sin conexión, lo que significa que no establece una conexión antes de enviar datos. UDP envía datagramas sin esperar acuse de recibo y sin garantizar que los paquetes lleguen en orden o incluso que lleguen. Por lo tanto, no utiliza un mecanismo de saludo de tres vías ni ningún otro procedimiento similar para establecer una conexión.

En resumen, UDP es preferido en aplicaciones donde la velocidad y la eficiencia son más críticas que la confiabilidad, como en la transmisión de video o juegos en tiempo real, mientras que TCP es utilizado cuando se requiere garantizar la entrega de los datos, como en transferencias de archivo y comunicaciones de correo electrónico.

Ejercicio 7

Investigue qué es el ISN (Initial Sequence Number). Relaciónelo con el saludo de tres vías

El ISN (Initial Sequence Number) es un componente crítico en el protocolo TCP (Transmission Control Protocol) que se utiliza para iniciar una conexión de manera segura y ordenada. El ISN es un número de 32 bits seleccionado aleatoriamente por cada host al comenzar las conexiones TCP. Este número es esencial para la administración y el control de flujo del protocolo, permitiendo a los dispositivos participantes mantener un registro correcto y ordenado de los segmentos transmitidos y recibidos.

Relación del ISN con el Saludo de Tres Vías

El ISN juega un papel clave en el proceso de establecimiento de conexión en TCP, conocido como el saludo de tres vías, que funciona de la siguiente manera:

SYN: Cuando un cliente desea iniciar una conexión TCP con un servidor, envía un segmento con la bandera SYN activada. Este segmento incluye un ISN, que es el número de secuencia inicial para los segmentos que enviará el cliente. Este número no solo ayuda a iniciar el conteo de secuencia de los paquetes enviados por el cliente sino que también ayuda a prevenir algunos tipos de ataques y problemas relacionados con las conexiones antiguas que aún persisten en la red (problema conocido como "old duplicate segments").
SYN-ACK: El servidor responde al cliente con otro segmento, también marcado con las banderas SYN y ACK. Este segmento lleva su propio ISN, que se utiliza para la secuencia de segmentos enviados desde el servidor al cliente, además de incluir el número de acuse de recibo, que es el ISN del cliente incrementado en uno. Este paso confirma al cliente que el servidor está listo para recibir datos comenzando desde el número de secuencia que el cliente ha proporcionado.
ACK: Finalmente, el cliente envía un segmento ACK al servidor, confirmando la recepción del ISN del servidor. El número de acuse de recibo en este segmento será el ISN del servidor incrementado en uno. Este paso completa el establecimiento de la conexión, y ambos extremos están listos para comenzar la transmisión de datos.

La elección de un ISN aleatorio es crucial para la seguridad de la conexión TCP. Una selección predecible del ISN puede hacer que la conexión sea vulnerable a ataques de "hijacking" o inyección de paquetes, donde un atacante podría predecir los números de secuencia de los paquetes y enviar paquetes maliciosos dentro de la sesión TCP legítima.

En resumen, el ISN es fundamental para el establecimiento de una conexión TCP segura y confiable, asegurando que la secuencia de mensajes sea gestionada de manera correcta desde el inicio de la conexión.

Ejercicio 8

Investigue qué es el MSS. ¿Cuándo y cómo se negocia?

El MSS (Maximum Segment Size) es un parámetro utilizado en el protocolo TCP (Transmission Control Protocol) que especifica el tamaño máximo de datos, en bytes, que un dispositivo está dispuesto a recibir en un único segmento TCP. Este tamaño no incluye la cabecera TCP ni la cabecera IP, únicamente los datos del segmento.

¿Cuándo y cómo se negocia el MSS?

Negociación durante el establecimiento de la conexión:
- El MSS se negocia al inicio de una conexión TCP durante el proceso de establecimiento de la conexión, específicamente durante el saludo de tres vías.
- Cada host comunica su MSS utilizando la opción MSS en el segmento TCP que tiene la bandera SYN activada. Esto significa que tanto el cliente como el servidor envían su MSS preferido cuando envían sus respectivos paquetes SYN y SYN-ACK.
Propósito de la negociación:
- La negociación del MSS es crucial para optimizar el uso del ancho de banda y reducir la fragmentación en la red. Al acordar un tamaño máximo de segmento, los dispositivos pueden ajustar la cantidad de datos enviados en cada paquete para maximizar la eficiencia y evitar la fragmentación de paquetes a lo largo del camino de la red.
- El valor del MSS típicamente se establece en función del MTU (Maximum Transmission Unit) de la red menos el tamaño de las cabeceras TCP (20 bytes, sin opciones) y IP (20 bytes para IPv4 sin opciones). Por ejemplo, si el MTU es de 1500 bytes (común en redes Ethernet), el MSS sería 1460 bytes (1500 - 40).
Cómo se establece el MSS:
- Cada lado de una conexión TCP puede especificar un valor de MSS diferente. Por ejemplo, un host podría enviar un MSS de 1460 bytes mientras que el otro podría enviar un MSS de 1400 bytes.
- El tamaño efectivo del segmento que se utilizará es el menor de los dos valores MSS negociados. Esto garantiza que ambos hosts puedan manejar los segmentos que reciben sin necesidad de fragmentación y dentro de los límites de su capacidad de procesamiento y configuración de red.

En resumen, el MSS es un parámetro negociado al inicio de una conexión TCP que ayuda a definir el tamaño óptimo de los segmentos de datos, lo cual es clave para la eficiencia de la transmisión y la minimización de problemas como la fragmentación en la red.

Ejercicio 9

Utilice el comando ss (reemplazo de netstat) para obtener la siguiente información de su PC:

Para obtener la información requerida utilizando el comando ss en Linux, que es una herramienta moderna y rápida para monitorizar las conexiones de sockets, aquí están los comandos específicos para cada situación:

Comandos con `ss`

a) Para listar las comunicaciones TCP establecidas:

ss -t state established

Recv-Q    Send-Q       Local Address:Port       Peer Address:Port    Process

El comando ss -t state established es utilizado para ver las conexiones TCP que están actualmente establecidas en tu sistema. Aquí te explico en detalle cada parte del comando y lo que muestra en su salida:

Detalles del Comando:

ss: Es el comando que se usa para obtener estadísticas de los sockets.
-t: Filtra para mostrar solo los sockets TCP.
state established: Muestra solo las conexiones que están en el estado "ESTABLISHED", lo que significa que hay una sesión TCP activa y operativa entre dos dispositivos.

Salida del Comando:

La salida típica de este comando incluye varias columnas que proporcionan información detallada sobre cada conexión:

Recv-Q: Muestra la cantidad de bytes que están en la cola de recepción y que aún no han sido recogidos por el proceso que maneja esta conexión. Si hay datos esperando ser leídos por la aplicación, este valor será mayor que cero.
Send-Q: Muestra la cantidad de bytes en la cola de envío que todavía no han sido transmitidos a la red. Un número mayor que cero aquí indica que hay datos esperando ser enviados.
Local Address:Port: Muestra la dirección IP local y el puerto asociado con la conexión. Esta es la dirección en tu máquina.
Peer Address:Port: Muestra la dirección IP y el puerto del otro extremo de la conexión. Esta es la dirección del dispositivo remoto con el que se ha establecido la conexión TCP.
Process: Esta columna muestra información sobre el proceso que está utilizando la conexión. Esto incluye el ID del proceso (PID) y el nombre del programa que utiliza el socket. Esta información es muy útil para determinar qué aplicación específica está manejando la conexión. Sin embargo, es posible que necesites usar opciones adicionales (-p con privilegios de superusuario) para ver detalles del proceso si no aparecen por defecto.

Este comando es especialmente útil para los administradores de sistemas y desarrolladores que necesitan diagnosticar problemas de red, monitorear el rendimiento de las aplicaciones de red o simplemente obtener un resumen de todas las conexiones TCP activas en un sistema.

b) Para listar las comunicaciones UDP establecidas:

ss -u state established

Recv-Q   Send-Q        Local Address:Port       Peer Address:Port     Process   
0        0          10.0.2.15%enp0s3:bootpc         10.0.2.2:bootps

El comando ss -u state established es un poco inusual cuando se aplica a protocolos sin conexión como UDP, porque UDP, a diferencia de TCP, no tiene un estado "establecido" como tal. Sin embargo, el comando intentará mostrar las conexiones UDP que se pueden describir como activas o abiertas, aunque UDP en sí mismo no establece una conexión persistente entre dos puntos.

Explicación del Comando:

ss: Es el comando para obtener estadísticas de los sockets, sustituyendo al antiguo netstat.
-u: Filtra para mostrar solo los sockets UDP.
state established: Intenta listar conexiones UDP que están "activas". Aunque en UDP no aplicaría realmente el término "establecido", en algunos contextos, como las conexiones DHCP (bootp en el ejemplo), se puede considerar que hay un intercambio activo de paquetes.

Salida del Comando:

Recv-Q: Muestra la cantidad de bytes que están esperando ser recogidos por el proceso en la cola de recepción. Para UDP, esto generalmente indica si hay datos recibidos que aún no han sido procesados por la aplicación.
Send-Q: Muestra la cantidad de bytes que están esperando ser enviados. En UDP, debido a que no hay confirmación de la recepción de los paquetes, esto normalmente debería ser cero a menos que el buffer de salida esté momentáneamente lleno.
Local Address:Port: Esta columna muestra la dirección IP local y el puerto utilizado por tu máquina para esta comunicación UDP. En el ejemplo dado, 10.0.2.15%enp0s3:bootpc indica que la dirección IP local es 10.0.2.15 (con el interfaz de red enp0s3) y el puerto local es bootpc (67, usado típicamente para solicitudes DHCP).
Peer Address:Port: Muestra la dirección IP y el puerto del otro extremo con el que se está comunicando el socket UDP. En tu ejemplo, 10.0.2.2:bootps representa el servidor DHCP desde el cual el cliente (en este caso, la máquina local) espera recibir una respuesta.
Process: Detalles del proceso que usa este socket UDP, si están disponibles y si se ejecuta ss con los privilegios adecuados. En el ejemplo que has proporcionado, esta columna no muestra ningún proceso, lo que puede ser típico para las transmisiones de bajo nivel como DHCP donde el proceso puede ser parte del sistema operativo en lugar de un proceso de usuario visible.

En resumen, aunque el uso de state established con UDP puede no ser conceptualmente correcto debido a la naturaleza sin conexión de UDP, este comando puede ser útil para identificar los puertos UDP activos y la dirección de sus comunicaciones en situaciones específicas como transacciones DHCP o DNS.

c) Obtener sólo los servicios TCP que están esperando comunicaciones:

ss -tln

State   Recv-Q  Send-Q        Local Address:Port    Peer Address:Port  Process  
LISTEN  0       128                 0.0.0.0:22           0.0.0.0:*              
LISTEN  0       128               127.0.0.1:631          0.0.0.0:*              
LISTEN  0       5                 127.0.0.1:4038         0.0.0.0:*              
LISTEN  0       128                    [::]:22              [::]:*              
LISTEN  0       128                   [::1]:631             [::]:*              
LISTEN  0       4096                  [::1]:50051           [::]:*              
LISTEN  0       4096     [::ffff:127.0.0.1]:50051              *:*

El comando ss -tln es utilizado para listar todos los sockets TCP en estado LISTEN, lo cual indica que estos sockets están configurados para aceptar conexiones entrantes. Esta es una herramienta crucial para los administradores de sistemas y de redes para verificar qué servicios están activos y escuchando en qué puertos. Aquí está un desglose detallado de lo que muestra cada columna en la salida de este comando:

Explicación de las Opciones del Comando:

ss: Es el comando para obtener estadísticas de sockets.
-t: Filtra para mostrar solo sockets TCP.
-l: Muestra solo los sockets que están en estado de escucha (listen).
-n: Muestra los números de puerto y las direcciones IP en formato numérico, evitando la resolución de nombres, lo que puede hacer que la ejecución del comando sea más rápida y clara en su salida.

Desglose de las Columnas:

State: Muestra el estado actual del socket. Aquí, todos están en LISTEN, lo que significa que están esperando activamente conexiones entrantes.
Recv-Q y Send-Q: Estas columnas muestran el tamaño de la cola de recepción y envío respectivamente. Para los sockets en estado LISTEN, Recv-Q siempre será 0 porque no están recibiendo datos en ese momento. Send-Q también es normalmente 0 en este estado, indicando que no hay datos pendientes de envío.
Local Address:Port: Indica la dirección IP local y el puerto en los cuales el servicio está escuchando. Si ves 0.0.0.0 o [::], significa que el servicio está escuchando en todas las interfaces de red para IPv4 o IPv6 respectivamente. Si ves una dirección específica, como 127.0.0.1 o [::1], el servicio está escuchando solo en la interfaz de loopback, que es accesible solo desde la misma máquina.
Peer Address:Port: En el estado LISTEN, esta columna siempre muestra * o 0.0.0.0:*, lo que indica que el socket está listo para aceptar conexiones de cualquier dirección IP.
Process: Esta columna normalmente no aparece a menos que se especifique con opciones adicionales (-p). Muestra el identificador del proceso que está utilizando cada socket.

Ejemplos de la Salida:

0.0.0.0:22 y [::]:22 indican que el servicio SSH está escuchando en todas las interfaces IPv4 e IPv6 en el puerto 22.
127.0.0.1:631 y [::1]:631 muestran que el servicio de impresión (CUPS) está escuchando en la interfaz de loopback, tanto en IPv4 como en IPv6, solo accesible localmente.
127.0.0.1:4038 muestra otro servicio que está escuchando solo en la interfaz de loopback de IPv4.
[::1]:50051 muestra un servicio que está escuchando en el puerto 50051 solo en IPv6 en la interfaz de loopback.

Estos detalles son esenciales para la gestión de la seguridad y la configuración del servidor, ya que permiten a los administradores saber qué puertos están abiertos y listos para recibir conexiones, lo cual es vital para asegurar y optimizar el servidor.

El flag -l lista los sockets que están en estado de escucha, y -n evita la resolución de nombres, mostrando las direcciones IP y números de puerto en formato numérico.

d) Obtener sólo los servicios UDP que están esperando comunicaciones:

ss -uln

State   Recv-Q   Send-Q     Local Address:Port      Peer Address:Port  Process  
UNCONN  0        0                0.0.0.0:5353           0.0.0.0:*              
UNCONN  0        0                0.0.0.0:59816          0.0.0.0:*              
UNCONN  0        0                0.0.0.0:631            0.0.0.0:*              
UNCONN  0        0              127.0.0.1:4038           0.0.0.0:*              
UNCONN  0        0                   [::]:5353              [::]:*              
UNCONN  0        0                   [::]:40448             [::]:*

El comando ss -uln se utiliza para mostrar información sobre los sockets UDP que están en estado de espera (es decir, no están conectados pero están listos para recibir datos). Este comando es esencial para la administración de redes y la seguridad, ya que permite a los administradores verificar qué servicios UDP están activos y escuchando en la máquina local. A continuación, se detalla el significado de las opciones del comando y de cada columna en la salida:

Explicación de las Opciones del Comando:

ss: Es el comando para obtener estadísticas de sockets.
-u: Filtra para mostrar solo sockets UDP.
-l: Muestra solo los sockets que están en estado de escucha (listen).
-n: Muestra los números de puerto y las direcciones IP en formato numérico, lo que evita la resolución de nombres y agiliza la visualización.

Desglose de las Columnas:

State: Muestra el estado del socket. UNCONN (unconnected) indica que el socket no está conectado pero está listo para recibir paquetes UDP.
Recv-Q y Send-Q: Representan la cantidad de datos en la cola de recepción y envío, respectivamente. Para los sockets UDP en estado UNCONN, estas colas suelen estar en 0 porque los sockets simplemente están esperando para recibir datos.
Local Address:Port: Indica la dirección IP local y el puerto en los cuales el servicio está escuchando. Si la dirección es 0.0.0.0 o [::], el servicio está escuchando en todas las interfaces de red, tanto para IPv4 como IPv6. Direcciones específicas como 127.0.0.1 indican que el servicio solo acepta tráfico local (loopback).
Peer Address:Port: Dado que estos sockets están en estado UNCONN, esta columna siempre mostrará 0.0.0.0:* o [::]:*, lo que significa que están preparados para recibir datos desde cualquier dirección IP.

Ejemplos de la Salida:

0.0.0.0:5353 y [::]:5353: Muestra que el servicio mDNS está escuchando en todos los interfaces disponibles en el puerto 5353, tanto para IPv4 como para IPv6. Este servicio se utiliza comúnmente para la resolución de nombres en redes locales.
0.0.0.0:59816 y [::]:40448: Estos son puertos UDP dinámicos o efímeros que están escuchando en todas las interfaces. Estos puertos pueden ser utilizados por aplicaciones que esperan recibir datos específicos.
0.0.0.0:631 y 127.0.0.1:4038: Indica que estos servicios están escuchando para tráfico UDP, en el caso de 631 en todas las interfaces y para 4038 solo en la interfaz de loopback.

Estos detalles permiten a los administradores monitorizar y gestionar los servicios que utilizan el protocolo UDP, asegurándose de que solo los servicios deseados están accesibles y que no hay puertos abiertos innecesarios que podrían ser explotados por agentes maliciosos.

e) Repetir los anteriores para visualizar el proceso del sistema asociado a la conexión: Para TCP:

ss -tlnp

State   Recv-Q  Send-Q        Local Address:Port    Peer Address:Port  Process  
LISTEN  0       128                 0.0.0.0:22           0.0.0.0:*              
LISTEN  0       128               127.0.0.1:631          0.0.0.0:*              
LISTEN  0       5                 127.0.0.1:4038         0.0.0.0:*              
LISTEN  0       128                    [::]:22              [::]:*              
LISTEN  0       128                   [::1]:631             [::]:*              
LISTEN  0       4096                  [::1]:50051           [::]:*              
LISTEN  0       4096     [::ffff:127.0.0.1]:50051              *:*

El comando ss -tlnp es una herramienta poderosa para administradores de sistemas y de redes. Se utiliza para mostrar información detallada sobre las conexiones TCP en estado de escucha (LISTEN), incluyendo qué procesos están asociados con cada socket. Esto es fundamental para la gestión y la seguridad de la red, ya que permite identificar qué aplicaciones están utilizando los puertos de red. Aquí desglosaré las opciones del comando y explicaré cada columna en la salida:

Explicación de las Opciones del Comando:

ss: Comando para obtener estadísticas de los sockets.
-t: Filtra para mostrar solo conexiones TCP.
-l: Muestra solo los sockets que están en estado de escucha.
-n: Muestra números de puerto y direcciones IP en formato numérico, sin resolver nombres para acelerar la respuesta.
-p: Muestra el proceso que está asociado con cada socket.

Desglose de las Columnas:

State: Indica el estado del socket. LISTEN significa que el socket está esperando conexiones entrantes.
Recv-Q y Send-Q: Representan la cantidad de datos en las colas de recepción y envío, respectivamente. Para sockets en estado LISTEN, estos valores generalmente son cero porque no hay datos siendo enviados o recibidos aún.
Local Address:Port: Dirección y puerto locales en los que el servicio está escuchando. Por ejemplo, 0.0.0.0:22 indica que el servicio está escuchando en todas las interfaces de red disponibles en el puerto 22 (usualmente SSH). Si la dirección es específica, como 127.0.0.1:631, el servicio solo acepta conexiones locales.
Peer Address:Port: Muestra las direcciones a las que el socket puede aceptar conexiones. En el caso de sockets en estado LISTEN, típicamente se muestra como 0.0.0.0:* o [::]:*, indicando que pueden aceptar conexiones desde cualquier dirección IP.
Process: Esta columna muestra información sobre el proceso que utiliza el socket. Por ejemplo, puede incluir el nombre del proceso y el ID del proceso (PID). Esta información es crucial para identificar qué aplicación está utilizando cada puerto y es especialmente útil para resolver problemas o auditar la seguridad de los servicios de red.

Ejemplos de la Salida:

0.0.0.0:22 y [::]:22: Estos sockets están escuchando en todas las interfaces IPv4 e IPv6 respectivamente para conexiones SSH. El hecho de que estén escuchando en 0.0.0.0 y [::] significa que aceptan conexiones desde cualquier IP.
127.0.0.1:631 y [::1]:631: Estos están escuchando solo para conexiones locales (loopback) para el servicio de impresión (puerto 631, comúnmente usado por CUPS).
[::1]:50051 y [::ffff:127.0.0.1]:50051: Estos podrían ser servicios desarrollados internamente o específicos de aplicaciones que escuchan en IPv6 y mapeados IPv4-a-IPv6, respectivamente, solo accesibles localmente.

Esta información te permite entender qué servicios están corriendo en tu servidor, en qué puertos están escuchando, y a través de qué interfaces están disponibles, así como identificar qué aplicación o proceso es responsable de cada uno de estos servicios. Esto es vital para la gestión adecuada de los recursos de red y la seguridad informática.

Para UDP:

ss -ulnp

State   Recv-Q   Send-Q     Local Address:Port      Peer Address:Port  Process  
UNCONN  0        0                0.0.0.0:5353           0.0.0.0:*              
UNCONN  0        0                0.0.0.0:59816          0.0.0.0:*              
UNCONN  0        0                0.0.0.0:631            0.0.0.0:*              
UNCONN  0        0              127.0.0.1:4038           0.0.0.0:*              
UNCONN  0        0                   [::]:5353              [::]:*              
UNCONN  0        0                   [::]:40448             [::]:*

Detalles

El comando ss -ulnp es una herramienta útil para mostrar detalles sobre los sockets UDP que están actualmente abiertos y en estado de escucha en un sistema. Aquí te explico cada parte de este comando y la información que muestra:

Explicación de las Opciones del Comando:

ss: Es el comando para obtener estadísticas de los sockets.
-u: Filtra para mostrar solo conexiones UDP.
-l: Muestra solo los sockets que están en estado de escucha, es decir, esperando recibir paquetes de datos.
-n: Muestra números de puerto y direcciones IP en formato numérico, lo cual evita la demora de resolver los nombres.
-p: Muestra el proceso asociado con cada socket, incluyendo el ID del proceso y el nombre del programa que lo ha abierto.

Desglose de las Columnas:

State: Muestra el estado del socket. UNCONN (unconnected) indica que el socket está abierto pero no conectado, lo cual es típico para UDP, que es un protocolo sin conexión.
Recv-Q y Send-Q: Representan la cantidad de datos en las colas de recepción y envío, respectivamente. En UDP, estos valores suelen ser cero porque UDP es un protocolo sin conexión y no garantiza la entrega de paquetes.
Local Address:Port: Muestra la dirección IP local y el puerto en los que el servicio está escuchando. Por ejemplo, 0.0.0.0:5353 indica que el servicio está escuchando en todas las interfaces de red para el puerto 5353, que es comúnmente utilizado por servicios como mDNS.
Peer Address:Port: Para sockets UDP en estado de escucha, esta columna generalmente muestra 0.0.0.0:* o [::]:*, indicando que el socket puede recibir datagramas de cualquier dirección IP.
Process: Esta columna brinda detalles sobre el proceso que usa el socket, incluyendo el nombre del programa y el PID. Esto es especialmente útil para identificar qué aplicación está utilizando cada puerto UDP.

Ejemplos de la Salida:

0.0.0.0:5353 y [::]:5353: Estos sockets están escuchando en todas las interfaces IPv4 e IPv6, respectivamente, para el Multicast DNS (mDNS), que permite la resolución de nombres en redes locales sin necesidad de un servidor DNS centralizado.
0.0.0.0:59816 y [::]:40448: Estos puertos están abiertos para recibir datagramas UDP en cualquier interfaz. Los números de puerto altos son típicamente seleccionados aleatoriamente por aplicaciones que necesitan recibir respuestas a consultas o comandos enviados a otros servicios.
127.0.0.1:4038 y 0.0.0.0:631: Estos sockets están escuchando para tráfico local (127.0.0.1:4038) o en todas las interfaces (0.0.0.0:631), el puerto 631 generalmente está asociado con el sistema de impresión de red (CUPS).

Esta información es crucial para la administración de la red, ayudando a identificar qué servicios están usando los puertos UDP, y es fundamental para tareas como la resolución de problemas de red, auditorías de seguridad, y la configuración del firewall.

El flag -p muestra el proceso asociado a cada socket.

Comandos con `netstat`

El comando netstat, aunque en desuso en las distribuciones modernas de Linux que favorecen ss, todavía está disponible en muchos sistemas y puede ser utilizado para las mismas tareas:

a) Para listar las comunicaciones TCP establecidas:

netstat -tn

Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State

El comando netstat -tn es una herramienta de diagnóstico que se utiliza para mostrar las conexiones de red TCP establecidas en un sistema. Aquí te detallo cada parte del comando y la información que proporciona:

Explicación de las Opciones del Comando:

netstat: Es el comando para obtener estadísticas de la red y del estado de los sockets.
-t: Filtra para mostrar solo conexiones TCP.
-n: Muestra números de puerto y direcciones IP en formato numérico, evitando la demora que implica resolver los nombres a direcciones.

Desglose de las Columnas:

Proto: Indica el protocolo de la conexión. En este caso, por el uso de la opción -t, solo se mostrarán las conexiones que utilizan el protocolo TCP.
Recv-Q: Representa la cantidad de datos que han sido recibidos por el sistema local pero aún no han sido leídos por la aplicación. En otras palabras, muestra la cantidad de datos en la cola de recepción que aún no han sido procesados por la aplicación local.
Send-Q: Indica la cantidad de datos que la aplicación local ha enviado pero que aún no han sido confirmados por el receptor. Es decir, muestra los datos que están en la cola de envío esperando ser reconocidos por el otro extremo de la conexión.
Local Address: Muestra la dirección IP local y el puerto asociado a la conexión. Esta dirección es la del equipo en el que se ejecuta netstat.
Foreign Address: Muestra la dirección IP y el puerto del sistema remoto con el que está establecida la conexión. Esta es la dirección del otro dispositivo involucrado en la comunicación.
State: Muestra el estado actual de la conexión. Los estados comunes incluyen:
- ESTABLISHED: La conexión ha sido establecida y está activa.
- SYN_SENT o SYN_RECEIVED: Etapas del inicio de la conexión TCP.
- FIN_WAIT1 o FIN_WAIT2: Etapas de la terminación de la conexión TCP.
- TIME_WAIT: Indica que el lado local ha cerrado la conexión, pero se espera por si llegan aún paquetes retrasados del otro lado.

Ejemplo de Uso y Salida:

Cuando ejecutas netstat -tn, puedes ver algo como esto:

Proto Recv-Q Send-Q Local Address           Foreign Address         State      
tcp        0      0 192.168.1.100:45678     93.184.216.34:80        ESTABLISHED
tcp        0      0 192.168.1.100:22        203.0.113.25:53792      ESTABLISHED

Esta salida indica que hay dos conexiones TCP activas:

Una conexión desde el puerto local 45678 a la dirección IP 93.184.216.34 en el puerto 80 (HTTP), que está en estado ESTABLISHED.
Una conexión SSH desde el puerto local 22 a la dirección IP 203.0.113.25 en el puerto 53792, también en estado ESTABLISHED.

Este comando es útil para monitorear qué aplicaciones están comunicándose activamente a través de la red, identificar posibles conexiones no deseadas y ayudar en la resolución de problemas de red y aplicaciones.

b) Para listar las comunicaciones UDP establecidas:

netstat -un

Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State      
udp        0      0 10.0.2.15:68            10.0.2.2:67             ESTABLISHED

El comando netstat -un se utiliza para mostrar conexiones de red, específicamente aquellas que utilizan el protocolo UDP. Detallaré cada opción y la información proporcionada en este comando:

Explicación de las Opciones del Comando:

netstat: Es una herramienta de diagnóstico que ofrece información sobre conexiones de red, tablas de enrutamiento, estadísticas de interfaces, masquerade connections, y estadísticas multicast.
-u: Filtra para mostrar sólo conexiones UDP.
-n: Muestra direcciones y números de puerto en formato numérico, evitando la resolución de nombres, lo que acelera la presentación de los datos.

Desglose de las Columnas:

Proto: Indica el protocolo de la conexión, en este caso, udp para UDP.
Recv-Q: Representa la cantidad de datos recibidos por el sistema local que aún no han sido procesados por la aplicación. En UDP, este campo suele ser 0 ya que UDP no tiene control de flujo ni garantiza la entrega de paquetes.
Send-Q: Indica la cantidad de datos enviados por la aplicación local que aún no han sido enviados por el sistema operativo. Similar a Recv-Q, en UDP, este campo generalmente también es 0.
Local Address: Muestra la dirección IP local y el puerto usado por la conexión. Representa el punto final en el dispositivo local.
Foreign Address: Muestra la dirección IP y el puerto del sistema remoto con el que se establece la conexión. En UDP, dado que es un protocolo sin conexión, es menos común ver direcciones extranjeras asociadas excepto durante la transmisión de datos.
State: En UDP, el estado generalmente no se muestra porque UDP es un protocolo sin conexión, lo que significa que no mantiene un estado de conexión establecida como TCP. Sin embargo, si se muestra, puede ser ESTABLISHED indicando que la comunicación está activa en ambos sentidos (esto es raro y puede ser específico de la implementación).

Ejemplo de Uso y Salida:

Cuando ejecutas netstat -un, puedes ver algo así:

Proto Recv-Q Send-Q Local Address           Foreign Address         State      
udp        0      0 10.0.2.15:68            10.0.2.2:67             ESTABLISHED

Esta salida indica que hay una comunicación UDP entre el puerto 68 del dispositivo local y el puerto 67 de un dispositivo remoto. Este tipo de conexión es típicamente usado por el protocolo DHCP (Dynamic Host Configuration Protocol), donde un cliente (en el puerto 68) recibe información de configuración de red de un servidor DHCP (en el puerto 67).

Importancia:

Este comando es útil para diagnosticar la actividad de las aplicaciones que utilizan UDP, como los juegos en línea, aplicaciones de streaming y protocolos de red como DHCP y DNS. Permite a los administradores de red verificar qué aplicaciones están usando UDP y con qué otros sistemas están comunicando.

Obtener sólo los servicios TCP que están esperando comunicaciones:

netstat -tln

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State      
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN     
tcp        0      0 127.0.0.1:631           0.0.0.0:*               LISTEN     
tcp        0      0 127.0.0.1:4038          0.0.0.0:*               LISTEN     
tcp6       0      0 :::22                   :::*                    LISTEN     
tcp6       0      0 ::1:631                 :::*                    LISTEN     
tcp6       0      0 ::1:50051               :::*                    LISTEN     
tcp6       0      0 127.0.0.1:50051         :::*                    LISTEN

d) Obtener sólo los servicios UDP que están esperando comunicaciones:

netstat -uln

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State      
udp        0      0 0.0.0.0:5353            0.0.0.0:*                          
udp        0      0 0.0.0.0:59816           0.0.0.0:*                          
udp        0      0 0.0.0.0:631             0.0.0.0:*                          
udp        0      0 127.0.0.1:4038          0.0.0.0:*                          
udp6       0      0 :::5353                 :::*                               
udp6       0      0 :::40448                :::*

e) Repetir los anteriores para visualizar el proceso del sistema asociado a la conexión: Para TCP y UDP con procesos:

netstat -tlnp

(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
udp        0      0 0.0.0.0:5353            0.0.0.0:*                           -                   
udp        0      0 0.0.0.0:59816           0.0.0.0:*                           -                   
udp        0      0 0.0.0.0:631             0.0.0.0:*                           -                   
udp        0      0 127.0.0.1:4038          0.0.0.0:*                           -                   
udp6       0      0 :::5353                 :::*                                -                   
udp6       0      0 :::40448                :::*

netstat -ulnp

(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      -                   
tcp        0      0 127.0.0.1:631           0.0.0.0:*               LISTEN      -                   
tcp        0      0 127.0.0.1:4038          0.0.0.0:*               LISTEN      -                   
tcp6       0      0 :::22                   :::*                    LISTEN      -                   
tcp6       0      0 ::1:631                 :::*                    LISTEN      -                   
tcp6       0      0 ::1:50051               :::*                    LISTEN      -                   
tcp6       0      0 127.0.0.1:50051         :::*                    LISTEN      -

Estos comandos proporcionan información detallada sobre el estado de las conexiones de red en tu sistema, mostrando tanto las conexiones activas como las que están en escucha para posibles nuevas conexiones.

Ejercicio 10 CONSULTAR ESTE EJERCICIO

¿Qué sucede si llega un segmento TCP con el flag SYN activo a un host que no tiene ningún proceso esperando en el puerto destino de dicho segmento (es decir, que dicho puerto no está en estado LISTEN)?

Cuando un segmento TCP con el flag SYN activo llega a un puerto que no está en estado LISTEN en el host de destino (es decir, no hay ningún proceso escuchando en ese puerto), el sistema operativo generalmente responde con un paquete TCP que tiene el flag RST (Reset) activado. Esto indica al emisor que el puerto de destino no está disponible o que no hay un servicio esperando aceptar conexiones.

Utilice **hping3** para enviar paquetes TCP al puerto destino 22 de la máquina virtual con el flag SYN activado.

hping3 -p 22 -S localhost

redes@debian:~$ sudo hping3 -p 22 -S localhost
HPING localhost (lo 127.0.0.1): S set, 40 headers + 0 data bytes
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=0 win=65495 rtt=8.0 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=1 win=65495 rtt=7.7 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=2 win=65495 rtt=6.2 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=3 win=65495 rtt=0.3 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=4 win=65495 rtt=4.1 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=5 win=65495 rtt=3.6 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=6 win=65495 rtt=7.3 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=7 win=65495 rtt=3.2 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=8 win=65495 rtt=10.7 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=9 win=65495 rtt=8.8 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=10 win=65495 rtt=2.6 ms
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=22 flags=SA seq=11 win=65495 rtt=1.5 ms
^C
--- localhost hping statistic ---
12 packets transmitted, 12 packets received, 0% packet loss
round-trip min/avg/max = 0.3/5.3/10.7 ms

Cuando ejecutas el comando hping3 con los parámetros que proporcionaste, estás realizando una serie de pruebas para enviar paquetes TCP con el flag SYN activado (indicado por -S) al puerto 22 del host local (localhost o 127.0.0.1). Veamos en detalle qué significa cada parte de la salida y qué está ocurriendo:

Descripción del Comando y Salida

Comando: sudo hping3 -p 22 -S localhost
- -p 22: Esto especifica que el puerto destino de los paquetes es el 22, que es típicamente utilizado por el servicio SSH.
- -S: Indica que el flag SYN (synchronize) de TCP está activado. Este flag se utiliza para iniciar una conexión TCP, es la primera parte del "three-way handshake" que TCP usa para establecer una conexión.
- localhost: Es el nombre del host que se resuelve a la dirección IP 127.0.0.1, que es la dirección de loopback. Esto significa que estás enviando paquetes a tu propio equipo.

Salida de `hping3`

Cada línea de la salida muestra un paquete que ha sido enviado y la respuesta recibida:

len=44: Longitud del paquete, incluyendo cabeceras IP y TCP, que suman 40 bytes más algunos bytes de opciones de TCP, totalizando 44 bytes.
ip=127.0.0.1: La dirección IP de destino (y de origen, ya que es loopback).
ttl=64: Time to live, establecido por defecto en sistemas Linux. Indica el número máximo de saltos (routers) que un paquete puede hacer antes de ser descartado.
DF: Don't Fragment flag está activado, lo que significa que el paquete no debería ser fragmentado durante la transmisión.
id=0: Identificador del paquete, utilizado para la reensamblación de fragmentos.
sport=22: Puerto de origen, que es el puerto 22, aunque en realidad representa el puerto destino en este contexto.
flags=SA: Indica los flags TCP establecidos en la respuesta. 'S' es SYN, y 'A' es ACK. Esto significa que el host de destino ha recibido tu SYN y está respondiendo con SYN y ACK, que es el segundo paso en el establecimiento de una conexión TCP.
seq=0 y así sucesivamente: Número de secuencia del paquete.
win=65495: Tamaño de la ventana TCP, que indica cuántos bytes están dispuestos a recibir antes de recibir un acuse de recibo.
rtt=8.0 ms y variaciones: Round-trip time, el tiempo que toma para que el paquete vaya y vuelva desde el origen al destino.

Estadísticas de `hping3`

12 packets transmitted, 12 packets received, 0% packet loss: Total de paquetes enviados y recibidos, mostrando que no hubo pérdida de paquetes, lo cual es esperado en una interfaz de loopback, donde los paquetes no necesitan viajar a través de redes externas.
round-trip min/avg/max = 0.3/5.3/10.7 ms: Estadísticas del tiempo de ida y vuelta mínimo, promedio y máximo.

Interpretación

El hecho de que recibas respuestas con los flags SYN y ACK indica que hay un proceso (en este caso, probablemente el servidor SSH) escuchando en el puerto 22 de tu máquina local. La conexión de loopback es utilizada para probar servicios en tu propio equipo sin afectar la red externa, proporcionando una manera eficaz de asegurarse de que el servicio está operativo y responde como se espera.

Utilice **hping3** para enviar paquetes TCP al puerto destino 40 de la máquina virtual con el flag SYN activado.

redes@debian:~$ sudo hping3 -p 40 -S localhost
HPING localhost (lo 127.0.0.1): S set, 40 headers + 0 data bytes
len=40 ip=127.0.0.1 ttl=64 DF id=0 sport=40 flags=RA seq=0 win=0 rtt=8.0 ms
len=40 ip=127.0.0.1 ttl=64 DF id=0 sport=40 flags=RA seq=1 win=0 rtt=3.6 ms
len=40 ip=127.0.0.1 ttl=64 DF id=0 sport=40 flags=RA seq=2 win=0 rtt=7.2 ms
len=40 ip=127.0.0.1 ttl=64 DF id=0 sport=40 flags=RA seq=3 win=0 rtt=12.3 ms
len=40 ip=127.0.0.1 ttl=64 DF id=0 sport=40 flags=RA seq=4 win=0 rtt=2.6 ms
len=40 ip=127.0.0.1 ttl=64 DF id=0 sport=40 flags=RA seq=5 win=0 rtt=0.2 ms
len=40 ip=127.0.0.1 ttl=64 DF id=0 sport=40 flags=RA seq=6 win=0 rtt=3.6 ms
^C
--- localhost hping statistic ---
7 packets transmitted, 7 packets received, 0% packet loss
round-trip min/avg/max = 0.2/5.4/12.3 ms

La salida del comando hping3 que ejecutaste al enviar paquetes TCP con el flag SYN al puerto 40 en tu propia máquina (localhost o 127.0.0.1) muestra un comportamiento interesante, y algo diferente de lo que observaste cuando el puerto destino era el 22. Aquí está lo que cada parte de la salida significa y por qué es diferente:

Descripción del Comando y Salida

Comando: sudo hping3 -p 40 -S localhost
- -p 40: Especifica que el puerto destino de los paquetes es el 40, un puerto que no es comúnmente utilizado para servicios estándar.
- -S: Indica que el flag SYN está activado, que se usa para solicitar el inicio de una conexión TCP.

Salida de `hping3`

Cada línea refleja la respuesta a cada paquete SYN enviado:

len=40: Longitud del paquete, solo incluye las cabeceras IP y TCP sin datos adicionales.
ip=127.0.0.1: Dirección IP de destino, que es la dirección de loopback.
ttl=64: Time to live, configurado por defecto en sistemas Linux.
DF: Don't Fragment flag está activado.
id=0: Identificador del paquete.
sport=40: Puerto de origen en la respuesta, que refleja el puerto destino que especificaste.
flags=RA: Los flags TCP establecidos en la respuesta. 'R' es RST (Reset) y 'A' es ACK. Esto indica que el host de destino (tu propia máquina) ha recibido tu solicitud SYN pero no tiene ningún proceso escuchando en el puerto 40, por lo que responde con un Reset para indicar que la conexión no puede ser establecida.
seq=0 y así sucesivamente: Número de secuencia del paquete.
win=0: Tamaño de la ventana TCP es 0, lo que refuerza el hecho de que la conexión no se puede establecer porque no hay un proceso que acepte la conexión.
rtt=8.0 ms y variaciones: Tiempo de ida y vuelta del paquete.

Estadísticas de `hping3`

7 packets transmitted, 7 packets received, 0% packet loss: Todos los paquetes enviados fueron respondidos, lo que indica que los paquetes alcanzaron el destino y fueron procesados.
round-trip min/avg/max = 0.2/5.4/12.3 ms: Tiempos de respuesta mínimos, promedios y máximos.

Interpretación

La diferencia clave aquí es que los paquetes fueron respondidos con el flag RST activado, indicando que el puerto 40 no está en estado de escucha y no hay ningún servicio disponible para aceptar la conexión en ese puerto. Este es un comportamiento normal cuando se intenta conectar a un puerto que no tiene un servicio asociado: el sistema operativo automáticamente responde con un paquete TCP con el flag RST para cerrar la conexión.

El uso de RST es una manera eficiente de informar al emisor que no hay un receptor válido en el puerto especificado, permitiendo al emisor cerrar el intento de conexión inmediatamente en lugar de esperar tiempos de espera por respuestas que nunca llegarán.

¿Qué diferencias nota en las respuestas obtenidas en los dos casos anteriores? ¿Puede explicar a qué se debe?

(Ayuda: utilice el comando ss visto anteriormente)

redes@debian:~$ ss -tuln
Netid   State    Recv-Q   Send-Q          Local Address:Port      Peer Address:Port  Process  
udp     UNCONN   0        0                     0.0.0.0:631            0.0.0.0:*              
udp     UNCONN   0        0                     0.0.0.0:47816          0.0.0.0:*              
udp     UNCONN   0        0                   127.0.0.1:4038           0.0.0.0:*              
udp     UNCONN   0        0                     0.0.0.0:5353           0.0.0.0:*              
udp     UNCONN   0        0                        [::]:44538             [::]:*              
udp     UNCONN   0        0                        [::]:5353              [::]:*              
tcp     LISTEN   0        128                   0.0.0.0:22             0.0.0.0:*              
tcp     LISTEN   0        128                 127.0.0.1:631            0.0.0.0:*              
tcp     LISTEN   0        5                   127.0.0.1:4038           0.0.0.0:*              
tcp     LISTEN   0        128                      [::]:22                [::]:*              
tcp     LISTEN   0        128                     [::1]:631               [::]:*              
tcp     LISTEN   0        4096                    [::1]:50051             [::]:*              
tcp     LISTEN   0        4096       [::ffff:127.0.0.1]:50051                *:*

Para analizar las diferencias en las respuestas obtenidas al enviar paquetes SYN a los puertos 22 y 40 usando hping3 y entender a qué se deben, primero recapitulemos los resultados:

Puerto 22 (SSH)
- Recibiste respuestas con flags SA (SYN-ACK), indicando que el puerto está en estado LISTEN y que un proceso (el servidor SSH) está activo y listo para aceptar conexiones.
Puerto 40
- Las respuestas tenían los flags RA (RST-ACK), indicando que no hay ningún proceso escuchando en ese puerto, y el sistema operativo responde automáticamente con un paquete de reset para cerrar el intento de conexión.

Uso del Comando `ss` para Confirmar

Para entender mejor por qué ocurren estas diferencias, podemos usar el comando ss que proporciona estadísticas de los sockets. Ejecutar ss -tuln mostrará los puertos que están actualmente en escucha (LISTEN) en tu sistema:

ss -tuln

-t muestra sockets TCP.
-u muestra sockets UDP (no necesarios en este caso, pero útiles para una visión completa).
-l lista solo los sockets que están en estado LISTEN.
-n muestra números de puerto en lugar de nombres de servicio.

Este comando te permitirá ver claramente qué puertos están activos y escuchando. Por ejemplo, verás el puerto 22 listado bajo TCP si SSH está activo, y no verás el puerto 40 si ningún servicio está vinculado a él.

Explicación de las Diferencias

Las diferencias en las respuestas se deben a cómo el sistema operativo maneja los puertos sin servicios asignados comparado con los que sí tienen servicios escuchando:

Puerto con Servicio (22): Cuando un puerto está en estado LISTEN y recibe un paquete SYN, el protocolo TCP del sistema operativo responde con un paquete SYN-ACK, invitando al remitente a continuar con el establecimiento de la conexión (el three-way handshake de TCP).
Puerto sin Servicio (40): Cuando un paquete SYN llega a un puerto que no está en estado LISTEN, el sistema operativo envía un paquete RST-ACK para rechazar inmediatamente el intento de conexión, indicando que no hay ningún servicio que pueda manejar esa solicitud en el puerto especificado.

Esta gestión ayuda a optimizar los recursos del sistema y proporciona retroalimentación inmediata a los clientes que intentan establecer conexiones, lo cual es crucial para aplicaciones y servicios que dependen de la disponibilidad de puertos específicos para funcionar correctamente.

Ejercicio 11

¿Qué sucede si llega un datagrama UDP a un host que no tiene a ningún proceso esperando en el puerto destino de dicho datagrama (es decir, que dicho puerto no está en estado LISTEN)?

Cuando un datagrama UDP llega a un puerto en un host donde no hay ningún proceso esperando (es decir, ningún proceso vinculado a ese puerto específico), el comportamiento típico del sistema es enviar un mensaje de error de tipo ICMP (Internet Control Message Protocol) de vuelta al emisor. Este mensaje de error generalmente es del tipo "Destination Unreachable", específicamente con un código que indica "Port Unreachable". Esto informa al emisor que no hay ninguna aplicación que pueda manejar el datagrama en el puerto destino.

Parte a

Utilice hping3 para enviar datagramas UDP al puerto destino 5353 de la máquina virtual.

redes@debian:~$ sudo hping3 -2 -p 5353 -S localhost
HPING localhost (lo 127.0.0.1): udp mode set, 28 headers + 0 data bytes

^C
--- localhost hping statistic ---
2 packets transmitted, 0 packets received, 100% packet loss
round-trip min/avg/max = 0.0/0.0/0.0 ms
redes@debian:~$

Parte b

Utilice hping3 para enviar datagramas UDP al puerto destino 40 de la máquina virtual.

redes@debian:~$ sudo hping3 -2 -p 40 -S localhost
HPING localhost (lo 127.0.0.1): udp mode set, 28 headers + 0 data bytes
ICMP Port Unreachable from ip=127.0.0.1 name=localhost 
status=0 port=2212 seq=0
ICMP Port Unreachable from ip=127.0.0.1 name=localhost 
status=0 port=2213 seq=1
ICMP Port Unreachable from ip=127.0.0.1 name=localhost 
status=0 port=2214 seq=2
ICMP Port Unreachable from ip=127.0.0.1 name=localhost 
status=0 port=2215 seq=3
ICMP Port Unreachable from ip=127.0.0.1 name=localhost 
status=0 port=2216 seq=4
^C
--- localhost hping statistic ---
5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max = 4.3/6.8/10.8 ms

En este caso, utilizaste hping3 para enviar paquetes UDP al puerto 40 de tu host local (localhost) y también has incluido el flag -S que, como mencionamos anteriormente, es inapropiado para UDP. Sin embargo, esta vez has recibido respuestas, así que vamos a examinar qué sucedió.

Comando y Configuración

sudo hping3 -2 -p 40 -S localhost

-2: Configura hping3 para usar el modo UDP.
-p 40: Especifica el puerto destino como el 40, que generalmente no es utilizado por servicios comunes.
-S: A pesar de ser un flag de TCP, en este contexto parece no afectar la formación del paquete UDP en hping3, aunque su presencia es innecesaria y puede ser confusa.

Salida de `hping3`

ICMP Port Unreachable from ip=127.0.0.1 name=localhost: Este es un mensaje de error del tipo ICMP, específicamente un "Destination Unreachable" con el código "Port Unreachable". Este mensaje es generado por el sistema operativo cuando un paquete UDP llega a un puerto en el cual no hay ningún proceso escuchando.
status=0 port=2212 seq=0 y las líneas similares indican el número de puerto desde el cual hping3 está enviando los paquetes y la secuencia de los mismos. Los puertos mencionados (2212, 2213, etc.) son los puertos de origen seleccionados por hping3 para enviar los paquetes, y no tienen que ver con el puerto destino (40).

Interpretación de la Respuesta

El hecho de que recibas "ICMP Port Unreachable" confirma varias cosas:

No hay ningún proceso escuchando en el puerto 40: Esto es esperado ya que el puerto 40 raramente es usado por servicios estándar.
Tu sistema está correctamente configurado para responder a paquetes UDP no solicitados con mensajes ICMP apropiados: Esto es útil para diagnósticos de red y asegura que los sistemas emisores puedan saber cuando sus paquetes están siendo dirigidos a puertos inactivos.

Conclusión

Este experimento muestra cómo hping3 puede ser utilizado para diagnosticar el estado de los puertos en tu sistema usando UDP y cómo el sistema responde con mensajes de error ICMP cuando no encuentra un servicio escuchando en el puerto especificado. En futuras pruebas, para evitar confusiones, es mejor omitir el flag -S cuando estés enviando paquetes UDP con hping3.

Parte c

¿Qué diferencias nota en las respuestas obtenidas en los dos casos anteriores? ¿Puede explicar a qué se debe? (Ayuda: utilice el comando ss visto anteriormente).

Para analizar las diferencias entre las respuestas obtenidas en los dos casos anteriores (usando hping3 para enviar paquetes a los puertos 22 y 40) y determinar a qué se deben estas diferencias, es útil utilizar el comando ss que mencionaste. Este comando nos proporcionará información sobre los puertos que están actualmente en estado LISTEN en la máquina, es decir, aquellos puertos que tienen un servicio asociado escuchando conexiones entrantes.

Recordatorio de los Comandos y Respuestas:

Puerto 22 (Conexión SSH)
- Los paquetes TCP enviados al puerto 22 recibieron una respuesta con los flags SA (SYN-ACK), indicando que hay un servicio (SSH) listo y dispuesto a establecer una conexión TCP.
Puerto 40 (Sin Servicio Conocido)
- Los paquetes UDP enviados al puerto 40 resultaron en respuestas ICMP de tipo "Port Unreachable", indicando que no hay un servicio escuchando en ese puerto.

Usando el Comando `ss`

Ahora vamos a usar el comando ss para confirmar estos detalles:

ss -tuln

redes@debian:~$ ss -tuln
Netid State  Recv-Q Send-Q      Local Address:Port    Peer Address:Port Process 
udp   UNCONN 0      0                 0.0.0.0:5353         0.0.0.0:*            
udp   UNCONN 0      0                 0.0.0.0:50522        0.0.0.0:*            
udp   UNCONN 0      0                 0.0.0.0:631          0.0.0.0:*            
udp   UNCONN 0      0               127.0.0.1:4038         0.0.0.0:*            
udp   UNCONN 0      0                    [::]:35837           [::]:*            
udp   UNCONN 0      0                    [::]:5353            [::]:*            
tcp   LISTEN 0      128             127.0.0.1:631          0.0.0.0:*            
tcp   LISTEN 0      5               127.0.0.1:4038         0.0.0.0:*            
tcp   LISTEN 0      128               0.0.0.0:22           0.0.0.0:*            
tcp   LISTEN 0      128                 [::1]:631             [::]:*            
tcp   LISTEN 0      4096                [::1]:50051           [::]:*            
tcp   LISTEN 0      4096   [::ffff:127.0.0.1]:50051              *:*            
tcp   LISTEN 0      128                  [::]:22              [::]:*

Este comando te dará una lista de todos los puertos en estado LISTEN en tu sistema:

-t muestra los sockets TCP.
-u muestra los sockets UDP.
-l filtra para mostrar solo aquellos en estado LISTEN.
-n muestra números de puerto, en lugar de intentar resolver los nombres de servicio.

Interpretación Esperada

Si ejecutas ss -tuln, esperarías ver el puerto 22 listado bajo TCP, indicando que SSH está activo y escuchando.
No esperarías ver el puerto 40 listado bajo TCP o UDP, lo que confirma por qué el sistema respondió con mensajes ICMP de "Port Unreachable" cuando intentaste enviar paquetes UDP a ese puerto.

¿Por Qué las Diferencias en las Respuestas?

Puerto 22: Al estar en estado LISTEN y tener un servicio activo (SSH), el sistema operativo responde a paquetes SYN con un SYN-ACK, facilitando la fase inicial de un three-way handshake de TCP, el proceso estándar para establecer una conexión TCP.
Puerto 40: Al no tener un servicio escuchando en ese puerto, no hay ningún proceso que pueda responder a paquetes UDP dirigidos a él, resultando en que el sistema operativo genere automáticamente respuestas ICMP de "Port Unreachable". Esto es un mecanismo estándar para informar al emisor que el puerto destino no está disponible para recibir o procesar paquetes.

Estos resultados reflejan la configuración de los servicios en tu sistema y cómo el sistema operativo maneja los paquetes dirigidos a puertos inactivos o activos. Las respuestas ICMP "Port Unreachable" son una forma importante de proporcionar feedback a los emisores sobre la falta de disponibilidad de un puerto o servicio, permitiendo que los procesos de red se ajusten en consecuencia.

Ejercicio 12

Investigue los distintos tipos de estado que puede tener una conexión TCP.

Ver https://users.cs.northwestern.edu/~agupta/cs340/project2/TCPIP_State_Transition_Diagram.pdf

En TCP (Protocolo de Control de Transmisión), cada conexión pasa por varios estados durante su ciclo de vida. TCP es un protocolo de comunicación orientado a la conexión, lo que significa que establece una conexión explícita antes de la transferencia de datos y la cierra una vez completada la transferencia. Aquí están los principales estados de una conexión TCP:

1. CLOSED

Es el estado inicial y final de cada conexión. Indica que no hay conexión activa o pendiente.

2. LISTEN

El servidor está esperando conexiones entrantes. En este estado, el servidor está listo para aceptar solicitudes de conexión de clientes.

3. SYN-SENT

El cliente envía un segmento SYN para iniciar una conexión activa y pasa al estado SYN-SENT, esperando una respuesta del servidor.

4. SYN-RECEIVED

El servidor recibe el segmento SYN del cliente y responde con un segmento SYN-ACK. El servidor entonces pasa al estado SYN-RECEIVED mientras espera la confirmación del cliente.

5. ESTABLISHED

Ambos sistemas (cliente y servidor) han recibido los segmentos SYN y ACK. En este estado, la conexión está abierta y los datos pueden ser enviados bidireccionalmente.

6. FIN-WAIT-1

El estado FIN-WAIT-1 indica que la aplicación ha solicitado el cierre de la conexión, y el sistema espera que el segmento FIN sea acusado o que el servidor envíe su propio segmento FIN.

7. FIN-WAIT-2

En este estado, el sistema ha recibido un acuse de recibo del segmento FIN del otro extremo y espera un segmento FIN del otro extremo.

8. CLOSE-WAIT

El sistema ha recibido un segmento FIN del otro extremo y espera que la aplicación local responda con un segmento FIN.

9. CLOSING

Ambos lados han solicitado el cierre de la conexión y esperan acusar recibo del cierre del otro extremo.

10. LAST-ACK

El sistema ha enviado un segmento FIN y espera el último acuse de recibo (ACK) del otro extremo.

11. TIME-WAIT

El sistema espera durante un tiempo suficiente para asegurarse de que el extremo remoto ha recibido el acuse de recibo final de su segmento FIN. Este estado también permite que los paquetes viejos en la red se disipen.

12. CLOSED

Después de que todos los segmentos FIN y ACK se han intercambiado adecuadamente, la conexión se cierra completamente.

Estos estados garantizan que TCP sea un protocolo confiable y orientado a la conexión, proporcionando gestión de errores, control de flujo, y garantías de entrega de datos en orden.

Ejercicio 13

Dada la siguiente salida del comando ss, responda:

Dada la salida del comando ss que mostraste, podemos responder a las preguntas basándonos en la información de los estados de conexión TCP y los puertos listados:

a) ¿Cuántas conexiones hay establecidas? El estado "ESTAB" indica que una conexión está establecida. De la salida, podemos contar:

Cinco conexiones establecidas (ESTAB) hacia el puerto 443.
Una conexión establecida hacia el puerto 22 desde 127.0.0.1 a 127.0.0.1:41220.

Total: 6 conexiones establecidas

b) ¿Cuántos puertos hay abiertos a la espera de posibles nuevas conexiones? Los puertos en estado "LISTEN" están abiertos esperando nuevas conexiones. En la salida, los siguientes puertos están escuchando:

Puerto 22 (SSH)
Puerto 80 (HTTP)
Puerto 53 (DNS)
Puerto 25 (SMTP)

Total: 4 puertos escuchando

c) El cliente y el servidor de las comunicaciones HTTPS (puerto 443), ¿residen en la misma máquina? Las conexiones a HTTPS mostradas utilizan direcciones IP como 163.10.5.222 en el lado local y direcciones como 64.233.163.120, 200.115.89.30, y 64.233.190.99 en el lado remoto, indicando que el cliente y el servidor no residen en la misma máquina.

d) El cliente y el servidor de la comunicación SSH (puerto 22), ¿residen en la misma máquina? Hay una conexión SSH desde 127.0.0.1:41220 a 127.0.0.1:22, lo que indica que tanto el cliente como el servidor residen en la misma máquina (comunicación de loopback).

e) Liste los nombres de todos los procesos asociados con cada comunicación. Indique para cada uno si se trata de un proceso cliente o uno servidor.

SSH (puerto 22): sshd (servidor)
HTTP (puerto 80): apache2 (servidor)
HTTPS (puerto 443): x-www-browser (cliente)
DNS (puerto 53): named (servidor)
SMTP (puerto 25): postfix (servidor)
SSH (puerto 22, loopback): sshd (servidor) y cliente desde el mismo proceso sshd (cliente)

f) ¿Cuáles conexiones tuvieron el cierre iniciado por el host local y cuál es por el remoto? El estado "CLOSE-WAIT" indica que el cierre fue iniciado por el host remoto, y el host local está esperando cerrar la conexión. Hay una conexión en estado "CLOSE-WAIT" hacia 200.115.89.30:443, indicando que el cierre fue iniciado por el remoto.

g) ¿Cuántas conexiones están aún pendientes por establecerse? El estado "SYN-SENT" indica que la conexión está en proceso de ser establecida, con el host local habiendo enviado un SYN y esperando un SYN-ACK en respuesta. Hay una conexión en estado "SYN-SENT" hacia 43.232.2.2:9500.

Estos análisis proporcionan una visión detallada de los estados y actividades de la red en la máquina en cuestión, basándonos en los estados de las conexiones TCP y los puertos en uso.

Ejercicio 14

Dadas las salidas de los siguientes comandos ejecutados en el cliente y el servidor, responder:

La información mostrada en las salidas de los comandos ss de ambos el servidor y el cliente revela detalles sobre el estado de la conexión TCP en el puerto 110, que comúnmente se usa para el servicio de correo electrónico POP3. Aquí está el análisis detallado de las preguntas planteadas:

a) ¿Qué segmentos llegaron y cuáles se están perdiendo en la red?

Servidor:

Estado LISTEN en el puerto 110: El servidor está escuchando en el puerto 110, esperando conexiones entrantes.
Estado SYN-RECV desde 157.0.0.1:110 hacia 157.0.0.11:52843: Esto indica que el servidor ha recibido un segmento SYN del cliente y ha respondido con un segmento SYN-ACK, que está esperando ser confirmado (ACK) por el cliente.

Cliente:

Estado SYN-SENT desde 157.0.0.11:52843 hacia 157.0.0.1:110: Esto muestra que el cliente ha enviado un segmento SYN al servidor y está esperando una respuesta SYN-ACK del servidor.

Análisis de los segmentos perdidos:

Dado que el servidor muestra SYN-RECV, ha enviado el SYN-ACK al cliente, pero el cliente aún está en SYN-SENT. Esto sugiere que el segmento SYN-ACK enviado por el servidor puede haberse perdido en la red, ya que el cliente no parece haberlo recibido.

b) ¿A qué protocolo de capa de aplicación y de transporte se está intentando conectar el cliente?

Capa de Aplicación: El puerto 110 es típicamente usado por el protocolo POP3 (Post Office Protocol versión 3), que es un protocolo de capa de aplicación utilizado para recuperar correo electrónico desde un servidor de correo.
Capa de Transporte: Dado que estamos observando conexiones TCP (ss -natu), el cliente está utilizando el protocolo TCP (Protocolo de Control de Transmisión) para establecer una conexión segura y confiable con el servidor.

c) ¿Qué flags tendría seteado el segmento perdido?

El segmento que probablemente se perdió es el SYN-ACK, que es la respuesta del servidor después de recibir un SYN del cliente. Este segmento SYN-ACK es crucial para el segundo paso en el proceso de handshake de tres vías de TCP.
Flags del segmento perdido:
- SYN (Synchronize): Indica que es una sincronización durante el establecimiento de la conexión.
- ACK (Acknowledgment): Confirma la recepción del segmento SYN inicial del cliente.

Este análisis indica que hay problemas de conectividad que podrían estar relacionados con la configuración de red, pérdida de paquetes, o problemas con firewalls o dispositivos intermediarios que están bloqueando o descartando paquetes específicos. Sería recomendable revisar la configuración de red y posiblemente realizar pruebas adicionales como traceroute o tcpdump para diagnosticar más a fondo el problema de conectividad.

Ejercicio 15 CONSULTAR ESTE SI HAY TIEMPO :(

Use CORE para armar una topología como la siguiente, sobre la cual deberá realizar:

Viendo tu captura de pantalla del emulador de red CORE, parece que ya has colocado dos nodos (computadoras) en tu topología. Ahora, para avanzar con el ejercicio y configurar la comunicación entre ellos, te guiaré paso a paso.

Paso 1: Conectar los Nodos

Conectar los Nodos: Utiliza la herramienta de enlace (normalmente representada por un icono de cable) para conectar los dos nodos. Haz clic en un nodo, luego en el otro para establecer un enlace directo entre ellos.

Paso 2: Configurar las Interfaces de Red de los Nodos

Asignar Direcciones IP: Haz doble clic en cada nodo para abrir su configuración. Necesitarás asignar direcciones IP estáticas a cada interfaz de red conectada. Asegúrate de que estén en la misma subred para que puedan comunicarse. Por ejemplo, puedes usar 192.168.1.1/24 para el primer nodo y 192.168.1.2/24 para el segundo.

Paso 3: Iniciar la Emulación

Iniciar la Emulación: Una vez que los nodos están configurados y conectados, inicia la emulación. Esto generalmente se hace con un botón en la barra de herramientas que puede parecer un botón de "play".

Paso 4: Abrir Terminales en los Nodos

Abrir Terminales: Haz clic derecho en cada nodo y selecciona "Open Terminal" o algo similar. Esto abrirá un terminal para cada nodo, donde podrás ejecutar comandos.

Parte a: Monitorear las Conexiones

Ejecutar el Comando para Monitorear: En cada terminal de los nodos, ejecuta el siguiente comando para monitorear el estado de las conexiones en tiempo real:
```
watch -n 1 'ss -nat'
```
- watch -n 1: Este comando actualizará la salida cada segundo.
- 'ss -nat': Muestra todas las conexiones TCP activas y los puertos que están escuchando.

Explicación del Comando

watch: Este comando se utiliza para ejecutar otro comando de forma periódica, mostrando su salida en pantalla completa. Es útil para ver la evolución de la salida de un comando a lo largo del tiempo.
ss -nat:
- ss es una utilidad para inspeccionar sockets en el sistema.
- -n evita convertir direcciones en nombres.
- -a muestra todos los sockets.
- -t filtra para mostrar solo sockets TCP.

Este comando proporcionará una vista en tiempo real de las conexiones y puertos, lo cual es ideal para tu ejercicio en CORE, ya que podrás ver cómo cambian los estados de las conexiones a medida que realizas configuraciones o pruebas de red.

Parte a

En ambos equipos inspeccionar el estado de las conexiones y mantener abiertas ambas ventanas con el comando corriendo para poder visualizar los cambios a medida que se realiza el ejercicio.

Ayuda: watch-n1 ’ss-nat’

Parte b

EnServidor, utilice la herramienta ncat para levantar un servicio que escuche en el puerto 8001/TCP.

Utilice la opcion-k para que el servicio sea persistente. Verifique el estado de las conexiones.

Parte c

Desde CLIENTE1 conectarse a dicho servicio utilizando también la herramienta ncat. Inspeccione el estado de las conexiones.

Parte d

Iniciar otra conexión desde CLIENTE1 de la misma manera que la anterior y verificar el estado de las conexiones. ¿De qué manera puede identificar cada conexión?

Parte e

En base a lo observado en el item anterior ,¿es posible iniciar más de una conexión desde el cliente al servidor en el mismo puerto destino? ¿Por qué ¿Cómo se garantiza que los datos de una conexión no se mezclarán con los de la otra?

Parte f

Analice en el tráfico de red, los flags de los segmentos TCP que ocurren cuando:

i. Cierra la última conexión establecida desde CLIENTE1. Evalúe los estados de las conexiones en ambos equipos.

ii. Corta el servicio de ncat en el servidor(Ctrl+C). Evalúe los estados de las conexiones en ambos equipos.

iii. Cierra la conexión en el cliente. Evalúe nuevamente los estados de las conexiones.

Practica 6 Redes | Capa de Transporte

Tue, 07 May 2024 00:00:00 GMT

Indice

Ejercicio 1
Ejercicio 2
Ejercicio 3
Ejercicio 4
Ejercicio 5
Ejercicio 6
Ejercicio 7
Ejercicio 8
Ejercicio 9
Ejercicio 10
Ejercicio 11
Ejercicio 12
Ejercicio 13

Ejercicio 1.

¿Cuál es el puerto por defecto que se utiliza en los siguientes servicios?

Web / SSH / DNS / Web Seguro / POP3 / IMAP / SMTP

Investigue en qué lugar en Linux y en Windows está descrita la asociación utilizada por defecto para cada servicio.

Los puertos por defecto para los servicios comunes son establecidos por convenciones ampliamente aceptadas y utilizadas por los sistemas operativos y aplicaciones de red para facilitar la comunicación estándar a través de Internet. A continuación, te proporciono los puertos por defecto para cada uno de los servicios que mencionaste:

Puertos por Defecto

Web (HTTP): 80
- Utilizado para tráfico web no cifrado.
SSH (Secure Shell): 22
- Utilizado para la administración segura de sistemas remotos.
DNS (Domain Name System): 53
- Utilizado para resolver nombres de dominio en direcciones IP.
Web Seguro (HTTPS): 443
- Utilizado para tráfico web cifrado.
POP3 (Post Office Protocol versión 3): 110
- Utilizado para descargar correos electrónicos desde un servidor de correo a un cliente. El puerto 995 se utiliza para POP3 sobre SSL/TLS.
IMAP (Internet Message Access Protocol): 143
- Utilizado para acceder y gestionar correos electrónicos directamente desde el servidor de correo. El puerto 993 se utiliza para IMAP sobre SSL/TLS.
SMTP (Simple Mail Transfer Protocol): 25
- Utilizado para el envío de correos electrónicos. Para SMTP seguro, que incluye cifrado, el puerto 465 (SMTPS) o 587 (SMTP con STARTTLS) son comúnmente usados.

Ubicación de la Asociación de Puertos en Sistemas Operativos

Linux

En los sistemas operativos basados en Linux, la asociación de puertos con servicios está comúnmente definida en el archivo /etc/services. Este archivo lista los nombres de servicios, sus puertos correspondientes y el tipo de protocolo (TCP/UDP). Puedes visualizar este archivo usando un editor de texto o mediante comandos como cat o less:

cat /etc/services

Este archivo es utilizado por varias aplicaciones y procesos del sistema para determinar los números de puerto para nombres de servicios conocidos.

Windows

En Windows, la asociación de puertos no se define en un archivo de configuración plano como en Linux. Sin embargo, Windows usa la base de datos de Servicios de Red, similar al archivo /etc/services de Linux, pero está incorporada en el sistema y no es tan directamente accesible por los usuarios. Los desarrolladores pueden acceder a esta información programáticamente usando la API de Windows.

Para administrar y ver configuraciones de puerto, las herramientas como PowerShell y diversas interfaces de administración de red GUI pueden ser utilizadas. Por ejemplo, puedes usar netstat en la línea de comandos para ver las conexiones activas y los puertos que están escuchando:

netstat -aon

Esta información te proporcionará una visión clara de los servicios y sus puertos en uso activo.

Estos son los detalles básicos sobre los puertos y dónde encontrar su configuración en los sistemas operativos más comunes. Si necesitas más información detallada sobre cómo cambiar o gestionar estos puertos o configuraciones adicionales, estaré encantado de ayudar.

Ejercicio 2

¿Qué es Multicast?

Multicast es un método de comunicación de red que permite la entrega eficiente de información a múltiples destinos simultáneamente utilizando una única transmisión. Este enfoque es especialmente útil en aplicaciones donde los mismos datos necesitan ser enviados a varios receptores, como en la transmisión de video y audio en vivo, actualizaciones de software a gran escala, y la difusión de información financiera.

En el modelo de multicast, los datos se envían solo una vez desde la fuente, independientemente del número de destinatarios. Los routers dentro de la red son responsables de replicar los paquetes a medida que se necesitan para alcanzar todos los destinos suscritos, lo que reduce significativamente el ancho de banda necesario en comparación con el envío de una copia individual a cada receptor.

¿Sobre cuál de los protocolos de capa de transporte funciona el Multicast?

Multicast generalmente funciona sobre UDP (User Datagram Protocol) en la capa de transporte:

UDP es un protocolo sin conexión y no garantiza la entrega, el orden de llegada de los paquetes, ni la integridad de los datos. Sin embargo, su simplicidad y eficiencia lo hacen ideal para multicast, donde la velocidad y la eficiencia de la transmisión son más críticas que la fiabilidad de la entrega de cada paquete individual.
UDP permite que un servidor envíe un solo paquete a un grupo de direcciones IP de destino, lo que es fundamental para la implementación de servicios multicast. Las aplicaciones que utilizan multicast manejan la control de la fiabilidad y el orden en niveles superiores si es necesario.

¿Se podría adaptar para que funcione sobre el otro protocolo de capa de transporte?

El otro protocolo de capa de transporte principal es TCP (Transmission Control Protocol), que es orientado a conexión, confiable y garantiza que todos los paquetes lleguen en orden y sin errores. Aunque teóricamente es posible implementar algún tipo de "multicast" sobre TCP, hay varias razones por las que esto no es práctico ni recomendable:

Orientado a Conexión: TCP requiere una conexión establecida entre un único emisor y un único receptor, lo que significa que debería establecerse una conexión individual con cada receptor en un escenario de multicast. Esto eliminaría los beneficios de eficiencia de ancho de banda que proporciona el multicast.
Sobrecarga: La gestión de conexiones múltiples simultáneamente para cada receptor aumentaría considerablemente la sobrecarga en el servidor, haciendo que el proceso sea ineficiente en términos de recursos computacionales y de red.
Control de Congestión y Flujo: TCP implementa control de flujo y control de congestión, ajustando la tasa de envío según la capacidad del receptor y las condiciones de la red. En un entorno multicast, estos mecanismos serían difíciles de administrar de manera efectiva debido a la variabilidad en las capacidades de recepción y las condiciones de red entre un grupo potencialmente grande y diverso de receptores.

Conclusión

Multicast está diseñado para ser utilizado con UDP debido a su naturaleza sin conexión y eficiente. Adaptarlo para funcionar sobre TCP presentaría desafíos significativos que contrarrestarían las ventajas inherentes del multicast. En cambio, para escenarios donde se requiere fiabilidad en la entrega multicast, las aplicaciones a menudo implementan sus propios mecanismos de control en niveles superiores o utilizan otros protocolos diseñados específicamente para la entrega confiable de multicast, como Reliable Multicast Protocol (RMP).

Ejercicio 3

Investigue cómo funciona el protocolo de aplicación FTP teniendo en cuenta las diferencias en su funcionamiento cuando se utiliza el modo activo de cuando se utiliza el modo pasivo

¿En qué se diferencian estos tipos de comunicaciones del resto de los protocolos de aplicación vistos?

El Protocolo de Transferencia de Archivos (FTP) es un protocolo de la capa de aplicación utilizado para transferir archivos entre sistemas a través de una red TCP/IP. FTP es uno de los protocolos de Internet más antiguos y aún se utiliza ampliamente hoy en día debido a su eficacia en la transferencia de archivos grandes. Uno de los aspectos más interesantes y únicos de FTP es su uso de dos canales de comunicación separados: un canal de control y un canal de datos.

Modos de FTP: Activo vs. Pasivo

FTP puede operar en dos modos distintos: activo y pasivo. Estos modos afectan cómo se establece la conexión de datos entre el cliente y el servidor.

Modo Activo En el modo activo, el cliente inicia la conexión al servidor para enviar comandos a través del puerto 21 (canal de control). Para transferir datos, el servidor intentará establecer una conexión de retorno al cliente. Aquí están los pasos específicos:

El cliente se conecta desde un puerto aleatorio a la puerto 21 del servidor y envía el comando PORT especificando en qué puerto del cliente el servidor debe conectarse para transferir datos.
El servidor entonces inicia una conexión desde su puerto 20 (puerto de datos) al puerto especificado por el cliente para transferir datos.

Modo Pasivo En el modo pasivo, que fue desarrollado para trabajar con firewalls y NAT (Network Address Translation), la conexión se inicia de manera diferente:

El cliente se conecta desde un puerto aleatorio al puerto 21 del servidor y envía el comando PASV, solicitando al servidor que entre en modo pasivo.
El servidor abre un puerto aleatorio y envía este número de puerto al cliente. Luego, el cliente inicia la conexión de datos al puerto especificado por el servidor desde otro puerto aleatorio.

Diferencias con Otros Protocolos de Aplicación

Comparando FTP con otros protocolos de aplicación, aquí hay algunas diferencias clave:

Dos Canales Separados (Control y Datos): A diferencia de HTTP, SMTP y otros protocolos de aplicación que generalmente utilizan una sola conexión (TCP) para todo el tráfico, FTP utiliza dos conexiones separadas, lo que permite que los comandos y la transferencia de datos se manejen de forma independiente. Esto significa que la sesión de control puede permanecer abierta para enviar comandos adicionales sin interrumpir la transferencia de datos en curso.
Estado de la Conexión: FTP es un protocolo basado en estado, lo que significa que mantiene una sesión de control durante toda la interacción entre el cliente y el servidor. Esto es diferente de protocolos sin estado como HTTP, donde cada solicitud es independiente.
Complejidad y Flexibilidad: FTP ofrece una gama más amplia de comandos que permiten no solo la transferencia de archivos sino también operaciones detalladas en el sistema de archivos del servidor (como cambiar directorios, listar archivos y cambiar permisos), lo que lo hace más complejo pero también más flexible.
Configuración del Firewall/NAT: El uso de dos canales separados y especialmente el modo activo de FTP pueden complicar la configuración de firewalls y NAT, lo que no suele ser un problema con protocolos más modernos como HTTP/S.

En resumen, el FTP es un protocolo poderoso y flexible con algunas peculiaridades, especialmente en cómo maneja las conexiones, que requieren consideraciones especiales cuando se trabaja con firewalls y en entornos con NAT.

Ejercicio 4

Suponiendo Selective Repeat; tamaño de ventana 4 y sabiendo que E indica que el mensaje llegó con errores. Indique en el siguiente gráfico, la numeración de los ACK que el host B envía al Host A

El gráfico que proporcionaste muestra una secuencia de eventos entre dos hosts, Host A y Host B, en un escenario de comunicación de red utilizando el protocolo Selective Repeat ARQ (Automatic Repeat reQuest). Este protocolo es utilizado para el control de errores en redes de datos y permite la retransmisión selectiva de paquetes que han sido detectados como erróneos o que no han sido confirmados dentro de un tiempo de espera.

Descripción de la Secuencia:

En el gráfico, observamos lo siguiente:

Host A envía múltiples paquetes a Host B.
Las líneas negras indican que los paquetes fueron enviados.
Las líneas rojas indican que se enviaron acuses de recibo (ACK) de vuelta a Host A.
La línea magenta marcada con una 'E' muestra que el paquete llegó con errores.

Análisis de la Numeración de los ACK:

Con Selective Repeat y un tamaño de ventana de 4:

Paquetes Enviados desde Host A a Host B: La numeración de paquetes enviados se observa en el lado izquierdo del gráfico. Las flechas negras que se mueven hacia arriba representan los paquetes que llegan correctamente y la flecha magenta representa el paquete con errores.
ACKs Enviados desde Host B a Host A: Las flechas rojas indican los ACKs enviados por Host B a Host A. Estos ACKs confirmarán la recepción de los paquetes que llegaron correctamente.

Interpretación Basada en el Gráfico:

ACK 1: Confirmación del paquete 1 (el primer ACK rojo que sube).
ACK 2: Confirmación del paquete 2 (segundo ACK rojo que sube).
No hay ACK para el paquete 3: Ya que el paquete 3 llega con errores (indicado por la línea magenta con 'E'), no se envía un ACK para este paquete en este momento.
ACK 4: Confirmación del paquete 4 (tercer ACK rojo que sube).
ACK 5: Confirmación del paquete 5 (cuarto ACK rojo que sube).

Notas Adicionales:

ACK de paquete 3: Eventualmente, Host A deberá retransmitir el paquete 3 debido a que no recibió un ACK por este, y suponiendo que Host A detecta la falta de este ACK (posiblemente a través de un timeout o por la recepción de ACKs de paquetes con números de secuencia superiores sin haber recibido el ACK para el paquete 3).

Conclusión: En Selective Repeat, cada paquete es reconocido independientemente, y el receptor solo envía ACKs para los paquetes que ha recibido correctamente. Los paquetes que llegan con errores (como el paquete 3 en tu diagrama) deben ser retransmitidos y no se les envía ACK hasta que sean recibidos correctamente en una nueva transmisión.

Ejercicio 5

¿Qué restricción existe sobre el tamaño de ventanas en el protocolo Selective Repeat?

En el protocolo Selective Repeat ARQ, una de las principales restricciones es sobre el tamaño de la ventana de transmisión y recepción. Esta restricción es crucial para evitar ambigüedades en la numeración de los paquetes y para garantizar que el protocolo funcione correctamente y de manera eficiente. El tamaño de la ventana determina cuántos paquetes pueden ser enviados sin recibir un acuse de recibo (ACK) y aún así mantener el orden y el control correctos sobre los paquetes que necesitan ser retransmitidos.

Restricción sobre el Tamaño de Ventanas en Selective Repeat

El tamaño de la ventana en el protocolo Selective Repeat no debe ser mayor que la mitad del espacio de numeración de secuencia disponible. Esto es debido a las siguientes razones:

Desambiguación de Números de Secuencia:
- En el protocolo Selective Repeat, cada paquete tiene un número de secuencia, y estos números se utilizan para identificar y confirmar la recepción de paquetes individuales.
- Para evitar cualquier confusión entre un paquete nuevo y la retransmisión de un paquete viejo que no ha sido aún acusado, es crucial que los números de secuencia de los paquetes en tránsito no se superpongan. Si el tamaño de la ventana fuera mayor que la mitad del espacio de numeración de secuencia, podría haber ambigüedad en la identificación de los paquetes, particularmente cuando algunos paquetes se pierden y requieren retransmisión.
Maximización de la Utilización del Canal sin Confusión:
- Con un tamaño de ventana que es la mitad del espacio de numeración de secuencia, se maximiza la cantidad de datos en tránsito en el canal sin riesgo de confundir un paquete nuevo con uno antiguo. Esto permite una utilización eficiente del canal, manteniendo al mismo tiempo la integridad y la fiabilidad de los datos.

Ejemplo

Si el espacio de numeración de secuencia es de 0 a 15 (16 posibles números de secuencia), el tamaño de la ventana en Selective Repeat no debe exceder 8. Esto asegura que en cualquier momento, los paquetes en tránsito o pendientes de acuse de recibo no superarán la mitad del espacio de numeración, eliminando cualquier posibilidad de confusión entre los números de secuencia de los paquetes viejos y nuevos.

Conclusión

Esta restricción sobre el tamaño de la ventana en Selective Repeat es fundamental para el correcto funcionamiento del protocolo, especialmente en entornos donde la pérdida de paquetes o los altos tiempos de latencia pueden causar que los paquetes lleguen fuera de orden o necesiten ser retransmitidos frecuentemente. Al limitar el tamaño de la ventana a la mitad del espacio de numeración de secuencia, Selective Repeat equilibra eficientemente entre el alto rendimiento y la confiabilidad en la transmisión de datos.

Ejercicio 6

De acuerdo a la captura TCP de la siguiente figura, indique los valores de los campos borroneados.

La captura de pantalla que has compartido muestra un segmento TCP capturado, probablemente con Wireshark u otra herramienta de análisis de protocolos. Basándome en la información visible y los estándares comunes de los paquetes TCP, puedo ayudarte a deducir o explicar los valores típicos de los campos que están borrosos en la imagen:

Número de Secuencia:
- Valor visible: 1047417501
- Descripción: Este número identifica la posición de los primeros datos del paquete en el flujo de datos del emisor. El número de secuencia de un segmento es el del primer byte de datos en el segmento.
Número de Reconocimiento:
- Valor visible: 3933822138
- Descripción: Este número indica el próximo número de secuencia que el receptor está esperando. Esto confirma la recepción de todos los bytes anteriores.
Longitud del Encabezado:
- Valor visible: 40 bytes
- Descripción: Este campo, también conocido como "Data Offset", indica la longitud del encabezado TCP en múltiplos de 4 bytes. Un valor de 40 bytes indica que hay opciones adicionales de TCP presentes, ya que el mínimo tamaño de encabezado TCP es de 20 bytes.
Flags:
- Valores visibles: SYN, ACK
- Descripción: El flag SYN es utilizado para iniciar una conexión y sincronizar números de secuencia. El flag ACK indica que el campo de número de reconocimiento es válido.
Tamaño de la Ventana:
- Valor visible: 5792
- Descripción: Este campo especifica el tamaño de la ventana de recepción (en bytes) que el emisor está dispuesto a recibir, lo que controla el flujo de datos para evitar el desbordamiento del buffer del receptor.
Checksum:
- Valor visible: 0x9803
- Descripción: Este valor es calculado por el emisor y verificado por el receptor para asegurar la integridad del encabezado y de los datos de un segmento TCP.
Opciones de TCP:
- Posibles valores: Podría incluir varias opciones como MSS (Maximum Segment Size), SACK Permitted (Selective Acknowledgment Permitted), Timestamps, y otros. Estas opciones están diseñadas para mejorar el rendimiento de TCP en diversos entornos de red.

Dada la información que se muestra en la captura y la descripción estándar de los campos en los paquetes TCP, estos valores son típicos o esperados. Para análisis más detallado o específico, se recomendaría tener acceso directo a la herramienta de captura o tener una visión completa del paquete sin campos borrosos.

Ejercicio 7 Este esta re mal xd

Dada la sesión TCP de la figura, completar los valores marcados con un signo de interrogación.

1. Establecimiento de la conexión y primera transmisión de datos

1.360 s: SYN (Seq = 0)
- Host A envía un SYN para iniciar la conexión con Secuencia 0.
1.360 s: SYN, ACK (Seq = 0, Ack = 1)
- Host B responde con SYN, ACK. Este paquete confirma la recepción del SYN inicial (Ack = 1) y también envía su propio número de secuencia inicial como 0.
1.360 s: ACK (Seq = 1, Ack = 1)
- Host A envía un ACK. El número de secuencia 1 confirma la recepción del SYN de Host B, y el número de reconocimiento 1 indica que Host A está listo para recibir datos comenzando con el primer byte de Host B.

2. Transmisión de datos

3.581 s: PSH, ACK, Len = 9 (Seq = 1, Ack = 1)
- Host A envía datos (9 bytes) con PSH y ACK. El número de secuencia 1 indica que estos son los primeros datos enviados, y el número de reconocimiento 1 todavía está confirmando el SYN inicial de Host B.
8.796 s: ACK (Seq = 1, Ack = 10)
- Host B envía un ACK. El número de secuencia 1 indica que Host B no ha enviado datos propios, y el número de reconocimiento 10 confirma la recepción de los 9 bytes de datos, esperando el byte de secuencia 10 a continuación.
14.382 s: PSH, ACK, Len = 5 (Seq = 10, Ack = 1)
- Host A envía otros 5 bytes de datos. El número de secuencia 10 es continuación del último byte de datos confirmado, y el número de reconocimiento 1 todavía confirma solo el SYN de Host B.
14.382 s: ACK (Seq = 1, Ack = 15)
- Host B envía un ACK. El número de secuencia 1 sigue sin cambiar porque Host B no ha enviado datos propios, y el número de reconocimiento 15 confirma los 5 bytes adicionales enviados por Host A.

3. Cierre de la conexión

15.190 s: FIN, ACK (Seq = 15, Ack = 1)
- Host A envía un FIN para comenzar a cerrar la conexión, indicando que no enviará más datos. El número de secuencia 15 sigue desde el último byte enviado, y el número de reconocimiento 1 sigue igual.
15.190 s: FIN, ACK (Seq = 1, Ack = 16)
- Host B también inicia el cierre con un FIN. El número de secuencia 1 indica que no ha habido datos enviados por B, y el número de reconocimiento 16 confirma la recepción del FIN de A.
15.190 s: ACK (Seq = 16, Ack = 2)
- Host A envía un ACK final. El número de secuencia 16 sigue desde el FIN de A, y el número de reconocimiento 2 confirma el FIN de B.

Este análisis debe proporcionar una comprensión clara y detallada de los números de secuencia y de reconocimiento en toda la secuencia de comunicación TCP mostrada en tu imagen.

Ejercicio 8

¿Qué es el RTT?

El RTT (Round-Trip Time) es el tiempo que tarda un paquete de datos en viajar desde un origen a un destino y volver al origen. Este tiempo incluye la propagación de los datos a través del medio físico, los retrasos en los dispositivos de red como routers y switches, y el tiempo de procesamiento en el destino para generar una respuesta. En redes de computadoras y comunicaciones, el RTT es fundamental para entender y optimizar el rendimiento de la red.

¿Cómo se calcula el RTT?

En el contexto de TCP, el RTT se calcula comúnmente como el tiempo entre el envío de un paquete y la recepción de un acuse de recibo (ACK) para ese paquete. Sin embargo, como los paquetes pueden tomar diferentes rutas y experimentar diferentes retrasos, el cálculo del RTT a menudo implica un promedio de varios valores de RTT medidos a lo largo del tiempo para obtener un valor más estable. En la práctica, los algoritmos como el Algoritmo de Karn y Jacobson/Karels algorithm se utilizan para ajustar y suavizar los cálculos del RTT.

`Investigue la opción TCP timestamp y los campos TSval y TSecr.`

Implementación Técnica TCP usa el valor del RTT para ajustar el RTO (Retransmission Timeout), que es el tiempo que espera TCP antes de retransmitir un paquete que no ha sido acusado, presumiendo que se ha perdido en la red.

Opción TCP Timestamp

La opción TCP Timestamp, definida en el RFC 7323, es utilizada para mejorar el cálculo del RTT y proveer una mejor estimación del RTO. Además, permite a TCP funcionar de manera eficiente sobre conexiones de larga distancia y de alta velocidad (conocidas como redes LFN, Long Fat Networks). Esta opción añade dos campos al encabezado de los segmentos TCP:

TSval (Timestamp Value): Es un valor de marca de tiempo que el emisor pone en el paquete cuando lo envía.
TSecr (Timestamp Echo Reply): Es un campo en el que el emisor copia el último valor TSval recibido del receptor.

Funcionamiento de los Campos TSval y TSecr

TSval: Incrementa cada vez que el reloj del sistema del emisor avanza. Este campo se utiliza para ayudar al receptor a calcular el RTT, proporcionando un sello de tiempo preciso de cuándo fue enviado originalmente el paquete.
TSecr: Es utilizado por el receptor para devolver el valor de TSval que recibió en el último paquete enviado por el emisor. Este valor reflejado permite al emisor medir el RTT midiendo el tiempo entre cuando el segmento original fue enviado y cuando se recibe el segmento con el TSecr correspondiente.

Beneficios de la Opción TCP Timestamp

Mejora la precisión del RTT: Al usar marcas de tiempo explícitas, se puede calcular de manera más precisa el RTT, especialmente en redes donde los paquetes pueden ser reordenados.
Evita la ambigüedad en la secuencia: Ayuda en situaciones donde los números de secuencia pueden volver a envolverse (wrap around).
Protección contra ataques PAWS (Protection Against Wrapped Sequence numbers): Previene errores en la conexión causados por la reutilización de números de secuencia viejos.

En resumen, el RTT es un componente vital para la administración de rendimiento en TCP, y la opción TCP Timestamp es una herramienta avanzada que ayuda a optimizar esta métrica, facilitando la operación de TCP en una variedad de entornos de red.

Ejercicio 9 Esto es un re quilombo

Para la captura tcp-captura.pcap, responder las siguientes preguntas.

a. ¿Cuántos intentos de conexiones TCP hay?

Deberías contar el número de banderas SYN que no tienen un SYN-ACK correspondiente o que tienen múltiples retransmisiones del SYN para identificar intentos de conexión.

b. ¿Cuáles son la fuente y el destino (IP:port) para c/u?

Para cada intento de conexión, mira en los campos de fuente y destino del segmento TCP en los paquetes SYN.

c. ¿Cuántas conexiones TCP exitosas hay en la captura? ¿Cómo diferencia las exitosas de las que no lo son? ¿Cuáles flags encuentra en cada una?

Las conexiones exitosas se identifican por un handshake de tres vías completado, observable por la presencia de las banderas SYN, SYN-ACK, y ACK. Las conexiones no exitosas podrían tener solo SYN o SYN seguido por RST sin progresar a un handshake completo.

d. Dada la primera conexión exitosa responder:

¿Quién inicia la conexión? Generalmente es el host que envía el primer SYN.
¿Quién es el servidor y quién el cliente? El servidor es el dispositivo que responde con SYN-ACK, y el cliente es el que envía el SYN inicial.
¿En qué segmentos se observa el handshake de tres vías? Busca el primer SYN, la respuesta SYN-ACK, y el ACK final.
¿Cuáles son los números de secuencia iniciales (ISNs)? Estos se encuentran en los campos de número de secuencia de los paquetes SYN y SYN-ACK.
¿Qué MSS se negoció? Esto se encuentra en el campo de opciones de los paquetes SYN, etiquetado como tamaño máximo de segmento.
¿Qué host envía la mayor cantidad de datos? Suma las longitudes de la carga útil de los segmentos TCP enviados por cada host después del handshake para determinar esto.

e. Identificar primer segmento de datos (origen, destino, tiempo, número de fila y número de secuencia TCP).

Origen, destino, tiempo, número de fila y número de secuencia TCP: Busca el primer paquete después del handshake con una carga útil mayor que cero.
¿Cuántos datos lleva? Este es el tamaño de la carga útil, sin contar el encabezado TCP.
¿Cuándo y cómo se confirma? Se confirma por un segmento ACK, que reconocerá el número de secuencia igual al número de secuencia original más la longitud de los datos.
¿Qué cantidad de bytes confirma la confirmación? Sería el incremento en el campo de reconocimiento sobre el ACK anterior.

f. ¿Quién inicia el cierre de la conexión? ¿Qué flags se utilizan? ¿En cuáles segmentos se ve (tiempo, número de fila y número de secuencia TCP)?

¿Quién inicia el cierre? Busca quién envía la primera bandera FIN.
¿Qué banderas se utilizan? Típicamente, FIN y ACK se usan.
¿En qué segmentos se ve el cierre? Estos son los segmentos con FIN y el ACK final.

Para llevar a cabo este análisis, abrirías el archivo pcap en Wireshark, seguirías el flujo TCP y revisarías los detalles de los paquetes como se describió. Podrías filtrar tu vista en Wireshark con expresiones como tcp.flags.syn == 1 para paquetes SYN, o tcp.flags.fin == 1 para paquetes FIN, para aislar los paquetes relevantes para tu análisis.

Para más detalles sobre cómo usar Wireshark para tal análisis, considera explorar recursos y tutoriales específicamente sobre cómo usar Wireshark, ya que te proporcionarán instrucciones paso a paso sobre cómo navegar e interpretar los datos.

Ejercicio 10

Responda las siguientes preguntas respecto del mecanismo de control de flujo.

El control de flujo es un mecanismo fundamental en la gestión de comunicaciones en redes de computadoras, especialmente en protocolos de la capa de transporte como TCP (Protocolo de Control de Transmisión). Aquí se explica cómo funciona este mecanismo, quién lo activa, el problema que resuelve, y bajo qué condiciones opera.

a. ¿Quién lo activa? ¿De qué forma lo hace?

El control de flujo es activado tanto por el emisor como por el receptor en una comunicación de datos:

Emisor: Regula la cantidad de datos que envía al receptor antes de recibir un acuse de recibo (ACK), asegurándose de no saturar el buffer del receptor.
Receptor: Proporciona retroalimentación al emisor sobre cuántos datos puede recibir sin riesgo de perder información. Esto lo hace a través del campo "ventana" en los encabezados de los paquetes TCP, que indica la cantidad de bytes que está dispuesto a recibir.

Por ejemplo, en TCP, cada segmento que un receptor recibe y procesa exitosamente es respondido con un ACK, donde se especifica la cantidad de espacio libre en el buffer del receptor, informando al emisor cuántos datos más puede enviar antes de que el receptor se sature.

b. ¿Qué problema resuelve?

El control de flujo resuelve varios problemas clave en la transmisión de datos en redes:

Prevención de la saturación del receptor: Evita que el emisor envíe más datos de los que el receptor puede procesar a la vez. Sin control de flujo, el buffer del receptor podría desbordarse, llevando a la pérdida de paquetes y a una reducción en la eficiencia de la red debido a la necesidad de retransmisiones.
Optimización del uso del ancho de banda: Asegura que la transmisión de datos se haga a una velocidad que ambos, emisor y receptor, puedan manejar eficientemente, adaptándose a las fluctuaciones en la disponibilidad del ancho de banda y en las capacidades de procesamiento del receptor.

c. ¿Cuánto tiempo dura activo y qué situación lo desactiva?

El control de flujo está activo durante toda la sesión de la conexión TCP y se ajusta dinámicamente según las condiciones de la red y el estado de los buffers de recepción:

Duración: Permanece activo mientras la conexión TCP está establecida. Cada paquete transmitido puede ajustar el estado del control de flujo según las necesidades actuales del receptor.
Desactivación: El mecanismo de control de flujo se desactiva automáticamente al cerrar la conexión TCP. Además, si el buffer del receptor se vacía (es decir, todos los datos han sido procesados y el espacio en el buffer es suficiente), el tamaño de la ventana comunicada al emisor puede incrementarse, permitiendo la transmisión de más datos.

Este sistema adaptativo de control de flujo es crucial para mantener la estabilidad y eficiencia en las comunicaciones sobre redes que operan bajo el protocolo TCP, adaptándose continuamente a las condiciones cambiantes de la red y a la capacidad de procesamiento de los dispositivos conectados.

Ejercicio 11

Responda las siguientes preguntas respecto del mecanismo de control de congestión.

El control de congestión en redes de computadoras, particularmente en el Protocolo de Control de Transmisión (TCP), es un mecanismo fundamental diseñado para evitar la sobrecarga de la red, lo que puede llevar a una degradación del rendimiento general y pérdida de paquetes. A continuación, se exploran los aspectos fundamentales de este mecanismo.

a. ¿Quién activa el mecanismo de control de congestión? ¿Cuáles son los posibles disparadores?

Activación: El mecanismo de control de congestión es activado por el emisor basándose en la percepción de eventos de la red que sugieren congestión.

Disparadores Posibles:

Pérdida de Paquetes: Identificada por la ausencia de un acuse de recibo (ACK) para un paquete enviado dentro del tiempo esperado, lo que puede llevar al emisor a retransmitir el paquete y ajustar su tasa de envío.
Aumento en el Tiempo de Ida y Vuelta (RTT): Un incremento significativo en el RTT puede indicar que los paquetes están experimentando colas más largas en los routers, lo que es un síntoma de congestión.
Indicaciones Explícitas de Pérdida de Paquetes (ECN): Algunas redes modernas utilizan señalizaciones explícitas como el ECN (Explicit Congestion Notification), que permite a los routers informar al emisor de la presencia de congestión antes de que se pierdan los paquetes.

b. ¿Qué problema resuelve?

El control de congestión busca abordar varios problemas críticos en las redes:

Prevención de la Caída del Rendimiento de la Red: Cuando demasiados paquetes son enviados simultáneamente, los routers pueden empezar a perder paquetes porque sus buffers se llenan, lo que lleva a retransmisiones que, a su vez, agravan la congestión.
Maximización del Uso del Ancho de Banda: Ajustando la tasa de envío de datos, el control de congestión ayuda a utilizar el ancho de banda disponible de manera más eficiente, asegurando un flujo de datos constante sin sobrecargar la red.
Equidad: El control de congestión también busca asegurar que todos los usuarios de la red tengan un acceso justo al ancho de banda, evitando que cualquier emisor monopolice la capacidad de la red.

c. Diferencie slow start de congestion-avoidance.

Slow Start:

Función: Slow Start es una fase de inicio en la gestión de control de congestión de TCP donde el emisor comienza con una tasa baja de envío de datos y aumenta exponencialmente esta tasa cada RTT hasta que ocurre una pérdida de paquetes o hasta alcanzar un umbral conocido como ssthresh.
Objetivo: Rápidamente encontrar un nivel seguro de utilización de ancho de banda.

Congestion Avoidance:

Función: Una vez que se alcanza el umbral ssthresh, ya sea por la detección de pérdida de paquetes o al finalizar Slow Start, TCP entra en la fase de Congestion Avoidance. En esta fase, el incremento en la ventana de congestión es más conservador, típicamente aumentando linealmente, lo que significa que la ventana de congestión aumenta en 1 MSS (tamaño máximo de segmento) por cada RTT completo.
Objetivo: Mantener el envío de datos en un nivel cercano al punto de congestión de la red sin provocar una pérdida de paquetes, buscando un equilibrio entre eficiencia y estabilidad en el flujo de datos.

En resumen, Slow Start es utilizado para rampar rápidamente la tasa de envío desde cero, mientras que Congestion Avoidance toma el control una vez que se ha encontrado una base de utilización y busca afinar el rendimiento sin saturar la red. Estos mecanismos son críticos para mantener la robustez y eficiencia de las comunicaciones en redes complejas y altamente utilizadas.

Ejercicio 12

Para la captura udp-captura.pcap, responder las siguientes preguntas.

a. ¿Cuántas comunicaciones (srcIP,srcPort,dstIP,dstPort) UDP hay en la captura?

En Wireshark, filtras los paquetes por protocolo UDP y luego utilizas las estadísticas de "Conversaciones" para ver cuántas comunicaciones únicas hay, clasificadas por dirección IP de origen y destino, así como los puertos.

b. ¿Cómo se podrían identificar las exitosas de las que no lo son?

Para UDP, que es un protocolo sin conexión, no hay una confirmación explícita del receptor como los ACK en TCP. Por lo tanto, determinar si una comunicación fue "exitosa" puede depender de si el protocolo o aplicación de capa superior tiene algún método para confirmar la recepción de los datos. Podrías buscar respuestas correspondientes a las solicitudes en la misma sesión para determinar si una comunicación fue exitosa.

c. ¿UDP puede utilizar el modelo cliente/servidor?

Sí, UDP puede ser usado en un modelo cliente/servidor. Por ejemplo, un servidor DNS utiliza UDP y opera en un modelo cliente/servidor donde el cliente envía una solicitud de resolución de DNS al servidor, y el servidor responde con la información solicitada.

d. ¿Qué servicios o aplicaciones suelen utilizar este protocolo? ¿Qué requerimientos tienen?

Aplicaciones que requieren baja latencia y pueden tolerar alguna pérdida de paquetes a menudo utilizan UDP. Ejemplos incluyen:

DNS (Domain Name System)
Streaming de video y audio
Juegos en línea
VoIP (Voice over IP)

Estos servicios requieren transferencias rápidas y, en caso de pérdida de paquetes, a menudo es mejor continuar sin retransmisión para evitar la latencia.

e. ¿Qué hace el protocolo UDP en relación al control de errores?

UDP realiza un mínimo control de errores. Proporciona checksums para verificar la integridad de los datos del encabezado y la carga útil. Si un paquete tiene un checksum incorrecto, generalmente es descartado por el receptor, pero no hay retransmisión automática de paquetes erróneos.

f. Con respecto a los puertos vistos en las capturas, ¿observa algo particular que lo doferencie de TCP?

En UDP, los puertos se utilizan para identificar las aplicaciones de destino de manera similar a TCP. Sin embargo, no hay una negociación de conexión, y los paquetes simplemente se envían a esos puertos esperando que la aplicación esté escuchando.

g. Dada la primera comunicación en la cual se ven datos en ambos sentidos (identificar el primer datagrama):

i. ¿Cuál es la dirección IP que envía el primer datagrama?,¿desde cuál puerto?
ii. ¿Cuántos datos se envían en un sentido y en el otro?

Para estas preguntas, necesitarías revisar los detalles específicos de los paquetes en Wireshark, observando los campos de dirección IP y puerto en el encabezado UDP de los paquetes, así como la longitud de la carga útil de UDP que indica la cantidad de datos enviados.

Para realizar un análisis práctico, abrirías el archivo pcap con Wireshark, aplicarías un filtro por UDP y examinarías las columnas y detalles de los paquetes para responder a estas preguntas específicas.

Ejercicio 13

Dada la salida que se muestra en la imagen, responda los ítems debajo

Suponga que ejecuta los siguientes comandos desde un host con la IP 10.100.25.90. Responda qué devuelve la ejecución de los siguientes comandos y, en caso que corresponda, especifique los flags.

a. `hping3 -p 3306 –udp 10.100.25.135`

Qué devuelve: Dado que el puerto 3306 (usualmente utilizado por MySQL) está en estado LISTEN en la captura, y el comando está enviando paquetes UDP, lo más probable es que no haya respuesta directa del host de destino, ya que MySQL escucha en TCP, no en UDP.
Flags: No aplica, ya que UDP no usa flags como TCP.

b. `hping3 -S -p 25 10.100.25.135`

Qué devuelve: No se espera que devuelva una respuesta, porque no hay ningún servicio listado como escuchando en el puerto 25 (SMTP) en TCP en la dirección IP dada. Es probable que el host envíe un paquete TCP RST en respuesta.
Flags: S (SYN) para iniciar la conexión TCP, pero probablemente recibirás un RST como respuesta.

c. `hping3 -S -p 22 10.100.25.135`

Qué devuelve: Este comando intenta establecer una conexión TCP al puerto 22, que está en estado LISTEN y asociado a sshd en la captura. Deberías recibir un SYN-ACK en respuesta, indicando que el puerto está abierto y escuchando.
Flags: S (SYN) enviado y SA (SYN-ACK) recibido en caso de que el puerto esté abierto.

d. `hping3 -S -p 110 10.100.25.135`

Qué devuelve: Similar al comando para el puerto 25, no hay evidencia en la captura de que el puerto 110 (POP3) esté abierto o en escucha en la IP especificada. Es probable que recibas un RST como respuesta.
Flags: S (SYN) enviado, probablemente un RST recibido.

¿Cuántas conexiones distintas hay establecidas? Justifique

Para determinar cuántas conexiones distintas están establecidas, observamos las filas con estado ESTAB en la salida:

Hay conexiones establecidas entre 127.0.0.1:3306 y 127.0.0.1:34338 (MySQL local).
Entre 10.100.25.135:222 y 200.100.120.210:61576 (SSH).
Otra conexión local de SSH entre 127.0.0.1:34330 y 127.0.0.1:3306.

Justificación: Las conexiones en estado ESTAB indican que la conexión TCP ha completado el handshake y está activa, permitiendo el tráfico bidireccional de datos. Estas conexiones se han establecido y confirmado mediante el intercambio de paquetes SYN, SYN-ACK y ACK, mostrando que ambos extremos están comunicando activamente.

Esto resume el estado de las conexiones basadas en los estados de los puertos y la IP mostrados en la captura, así como la previsión de resultados al ejecutar los comandos hping3 especificados.

Practica 7 Redes | Capa de Red

Tue, 07 May 2024 00:00:00 GMT

Indice

Ejercicio 1
Ejercicio 2
Ejercicio 3
Ejercicio 4
Ejercicio 5
Ejercicio 6
Ejercicio 7
Ejercicio 8
Ejercicio 9
Ejercicio 10
Ejercicio 11
Ejercicio 12
Ejercicio 13
Ejercicio 14
Ejercicio 15
Ejercicio 16
Ejercicio 17
Ejercicio 18
Ejercicio 19
Ejercicio 20
Ejercicio 21

Introducción

Ejercicio 1

¿Qué servicios presta la capa de red?

La capa de red, también conocida como capa 3 del Modelo OSI, es fundamental para el funcionamiento de las redes de datos, especialmente en entornos de red extensos e interconectados como el Internet. Los principales servicios que ofrece la capa de red incluyen:

Encaminamiento (Routing): La capa de red es responsable de determinar y gestionar la ruta que los paquetes de datos deben seguir desde el origen hasta el destino a través de la red. Utiliza protocolos de encaminamiento como RIP, OSPF e BGP para descubrir rutas eficientes.
Direccionamiento Lógico: A diferencia del direccionamiento físico (MAC) de la capa de enlace de datos, la capa de red implementa un sistema de direccionamiento lógico que permite una jerarquía y una estructura más organizada. IP (Protocolo de Internet) es el ejemplo más conocido de un protocolo de direccionamiento lógico.
Segmentación y Reensamblaje: La capa de red puede segmentar un bloque de datos más grande en paquetes más pequeños para el transporte y luego reensamblar estos paquetes en el destino. Esto es crucial para manejar los diferentes tamaños máximos de transmisión (MTU) que pueden tener diferentes segmentos de red.
Control de Congestión y Calidad de Servicio (QoS): Aunque el control de congestión es más visible en la capa de transporte, la capa de red puede participar en la gestión de la congestión y en la implementación de políticas de QoS para garantizar el rendimiento de la red según los requerimientos de los diferentes tipos de tráfico.
Aislamiento de Fallos y Diagnóstico de Red: Herramientas y protocolos a nivel de red, como ICMP (Internet Control Message Protocol), ayudan en la identificación y el diagnóstico de problemas en la red, facilitando la detección y reparación de fallos.

¿Cuál es la PDU en esta capa?

La unidad de datos de protocolo (PDU) de la capa de red es el paquete. En el contexto de IP, un paquete incluye la cabecera IP que contiene información esencial como las direcciones IP de origen y destino, la versión del protocolo, la longitud del paquete, y otros flags y campos que facilitan el encaminamiento y la entrega eficiente del paquete a través de la red.

¿Qué dispositivo es considerado sólo de la capa de red?

El router es el dispositivo típicamente asociado con la capa de red. Su función principal es interconectar redes diferentes, determinando la mejor ruta para enviar los paquetes entre ellas basándose en la información de la capa de red. Los routers leen las direcciones incluidas en los paquetes de la capa de red para tomar decisiones de encaminamiento y dirigir el tráfico adecuadamente hacia su destino final.

Estos componentes y funciones de la capa de red aseguran que los datos se transmitan de manera efectiva y eficiente a través de redes complejas y a gran escala, como el Internet.

Ejercicio 2

¿Por qué se lo considera un protocolo de mejor esfuerzo?

El término "protocolo de mejor esfuerzo" ("best effort protocol") se refiere comúnmente al Protocolo de Internet (IP), que es ampliamente utilizado en redes informáticas para la entrega de paquetes de datos. Este término describe la naturaleza del servicio que IP proporciona en términos de entrega de paquetes en una red.

Razones por las que IP es considerado un protocolo de mejor esfuerzo:

No garantiza la entrega: IP no asegura que los paquetes lleguen a su destino. Los paquetes pueden perderse debido a congestionamientos, errores en los enrutadores, o rutas ineficientes. IP no implementa mecanismos para recuperar paquetes perdidos; esta responsabilidad recae en los protocolos de capas superiores, como TCP.
No garantiza orden: Los paquetes IP pueden llegar a su destino en un orden diferente al que fueron enviados. No hay mecanismos dentro de IP para reordenar los paquetes a medida que llegan; nuevamente, esto es manejado por protocolos en la capa de transporte, como TCP, que reensambla los paquetes en el orden correcto.
No garantiza integridad: Aunque IP incluye un campo de suma de verificación en su cabecera que ayuda a detectar errores en los datos del encabezado, no protege la integridad del contenido del paquete en sí. Protocolos como TCP o UDP tienen sus propios mecanismos de suma de verificación que cubren todo el paquete.
No previene la duplicación: En algunas circunstancias, los paquetes IP pueden duplicarse, y más de una copia del mismo paquete puede llegar al destino. IP no tiene mecanismos para gestionar la eliminación de duplicados.
No controla la congestión: IP no tiene mecanismos integrados para evitar o gestionar la congestión en la red. En su lugar, depende de la respuesta de los protocolos de las capas superiores y de la gestión activa de la red para controlar la congestión.

Implicaciones de ser un protocolo de mejor esfuerzo

Al ser un protocolo de "mejor esfuerzo", IP permite una implementación y operación relativamente sencillas y eficientes de la red. Esto contribuye a la escalabilidad y la flexibilidad de Internet. Sin embargo, también significa que la calidad del servicio (QoS) no puede garantizarse sin la ayuda de tecnologías adicionales que operen junto con IP, como MPLS para redes gestionadas o técnicas de control de congestión y corrección de errores en los extremos de la comunicación.

Este enfoque de "mejor esfuerzo" permite que el núcleo de la red se mantenga simple y que la complejidad se maneje en los extremos, siguiendo el principio de diseño end-to-end, que es una característica fundamental de la arquitectura de Internet.

Ejercicio 3

¿Cuántas redes clase A, B y C hay? ¿Cuántos hosts como máximo pueden tener cada una?

Las direcciones IP originalmente se dividían en clases para organizar el rango de direcciones según el tamaño y las necesidades de las redes. Las clases A, B y C son las más comunes dentro de este esquema de clasificación. Aquí detallamos cuántas redes existen en cada clase y cuántos hosts pueden contener como máximo:

Redes Clase A

Rango de Direcciones: 1.0.0.0 a 126.0.0.0 (se excluyen ciertos rangos como 127.0.0.0, que está reservado para loopback).
Cantidad de Redes Posibles: 126 redes. El primer octeto define la red, y va de 1 a 126.
Hosts por Red: Cada red de Clase A puede tener hasta 16,777,214 hosts (2^24 - 2, donde se restan dos direcciones por la dirección de red y la de broadcast).

Redes Clase B

Rango de Direcciones: 128.0.0.0 a 191.255.0.0.
Cantidad de Redes Posibles: 16,384 redes. El primer y segundo octeto definen la red, comenzando en 128.0 y terminando en 191.255.
Hosts por Red: Cada red de Clase B puede tener hasta 65,534 hosts (2^16 - 2, también restando la dirección de red y la de broadcast).

Redes Clase C

Rango de Direcciones: 192.0.0.0 a 223.255.255.0.
Cantidad de Redes Posibles: 2,097,152 redes. Los primeros tres octetos definen la red, desde 192.0.0 hasta 223.255.255.
Hosts por Red: Cada red de Clase C puede tener hasta 254 hosts (2^8 - 2, igualmente restando la dirección de red y la de broadcast).

Contexto y Transición a CIDR

Es importante señalar que este método de clasificación basado en clases ha sido en gran parte reemplazado por el enfoque sin clases conocido como CIDR (Classless Inter-Domain Routing) a principios de los años 90. CIDR permite un uso más eficiente y flexible del espacio de direcciones IP mediante la asignación basada en "prefijos" que describen la máscara de subred, en lugar de estar restringido por las clases fijas. Esto ayuda a mejorar la eficiencia de la asignación de direcciones IP, especialmente frente a la escasez de direcciones IP bajo IPv4 y la necesidad de alojar múltiples redes de diferentes tamaños.

Ejercicio 4

¿Qué son las subredes?

Las subredes, o subredes de red, son divisiones lógicas de una red de mayor tamaño. Este proceso de subdivisión permite una organización más eficiente y segura del espacio de direcciones IP dentro de una red más grande. Crear subredes implica segmentar una red en múltiples redes más pequeñas, cada una con su propio rango único de direcciones IP.

La subdivisión de una red en subredes puede hacerse por varias razones, tales como:

Mejora del Rendimiento: Reducir el tamaño de una red puede disminuir el tráfico local en cada segmento, reduciendo así la contención y la sobrecarga de la red, y potencialmente aumentando el rendimiento general.
Administración Simplificada: Las subredes permiten a los administradores de red gestionar y mantener segmentos de red de manera más efectiva. Esto es especialmente útil en redes grandes donde manejar una sola red extensa podría ser complejo y poco práctico.
Seguridad Mejorada: Las subredes pueden proporcionar capas adicionales de seguridad. Limitar la comunicación entre subredes puede prevenir la propagación de actividades maliciosas dentro de la red.
Optimización del Uso de Direcciones IP: Al segmentar una red, se pueden asignar direcciones IP de manera más eficiente, reduciendo el desperdicio de direcciones en redes con pocos hosts.

¿Por qué es importante siempre especificar la máscara de subred asociada?

La máscara de subred es fundamental porque define cómo se divide el espacio de direcciones de una red entre la dirección de red y los hosts. Específicamente, la máscara de subred determina qué parte de la dirección IP se utiliza para identificar la subred y qué parte se utiliza para identificar los dispositivos individuales (hosts) dentro de esa subred.

Determinación de la Subred: La máscara de subred es esencial para determinar a qué subred pertenece una dirección IP específica. Esto es crucial para el enrutamiento de paquetes dentro y entre redes, ya que los enrutadores utilizan la máscara de subred para dirigir el tráfico a la subred correcta.
Comunicación y Enrutamiento: Los dispositivos dentro de una red utilizan la máscara de subred para determinar si otros dispositivos están en la misma subred o en una externa. Esto afecta cómo se envían los paquetes de datos: directamente entre dispositivos en la misma subred o a través de un enrutador para alcanzar dispositivos en subredes diferentes.
Evitar Conflictos de Direcciones: Una máscara de subred incorrecta puede llevar a conflictos de direcciones y problemas de enrutamiento, donde los dispositivos podrían no ser capaces de comunicarse correctamente dentro de la red.
Planificación de la Red: En la fase de diseño de una red, la máscara de subred ayuda a planificar cuántos hosts pueden ser soportados en cada subred y cómo se deben distribuir las direcciones IP para maximizar la eficiencia.

En resumen, las subredes y las máscaras de subred son componentes esenciales del diseño y operación de redes modernas. Permiten una gestión más eficiente del espacio de direcciones IP, mejoran la seguridad y el rendimiento de la red, y son clave para el enrutamiento correcto y efectivo del tráfico de datos.

Ejercicio 5

El campo "Protocol" en la cabecera IP desempeña una función crucial al definir el protocolo de la capa de transporte que se utilizará para los datos encapsulados en el paquete IP. Este campo es esencial para asegurar que el paquete de datos se maneje correctamente en su llegada al destino, orientando al sistema sobre cómo interpretar los datos contenidos en el segmento de datos del paquete.

¿Cuál es la finalidad del campo Protocol en la cabecera IP?

Identificación del Protocolo de la Capa de Transporte: El campo "Protocol" en la cabecera IP especifica el protocolo de la siguiente capa (capa de transporte) que se ha usado para segmentar los datos y que debe ser utilizado para reensamblar y procesar estos datos en el destino. Este campo es un número que identifica de manera única cada protocolo de la capa de transporte. Por ejemplo, el número 6 representa TCP (Transmission Control Protocol), mientras que el número 17 representa UDP (User Datagram Protocol).

¿A qué campos de la capa de transporte se asemeja en su funcionalidad?

En términos de funcionalidad, el campo "Protocol" en la cabecera IP es similar a los campos como:

Puertos de Origen y Destino en TCP/UDP: Aunque el campo "Protocol" no realiza la misma función que los puertos, que se utilizan para dirigir el tráfico a la aplicación correcta dentro de un host, ambos tipos de campos sirven como mecanismos de direccionamiento a niveles diferentes. Los puertos dirigen el tráfico al programa adecuado dentro del host, mientras que el campo "Protocol" indica cómo debe interpretarse el conjunto de datos a nivel de sistema.
Campo 'Next Header' en IPv6: En IPv6, el campo "Next Header" realiza una función similar al campo "Protocol" en IPv4, indicando el tipo del siguiente encabezado en el paquete. Esto puede ser un encabezado de extensión o un encabezado de capa superior.

El campo "Protocol" es, por lo tanto, vital para la interoperabilidad entre diferentes capas de red y es fundamental para el enrutamiento y procesamiento adecuados de los datos en redes de computadoras. Su rol asegura que los datos sean entregados y procesados por el protocolo correcto en el destino, facilitando así una comunicación efectiva entre dispositivos en una red.

Divisiónde subredes

Ejercicio 6

Para cada una de las siguientes direcciones IP determine

172.16.58.223/26
163.10.5.49/27
128.10.1.0/23
10.1.0.0/24
8.40.11.179/12

A) ¿De qué clase de red es la dirección dada (Clase A, B o C)?

Paso 1: Observar el Primer Octeto Para cada dirección IP, observa el primer número antes del primer punto. Por ejemplo, para la dirección 172.16.58.223, el primer octeto es 172.

Paso 2: Comparar con los Rangos de Clases Las clases de direcciones IP se definen por rangos específicos en el primer octeto:

Clase A: 1-126 (127 está reservado para loopback)
Clase B: 128-191
Clase C: 192-223
Clase D (multicast): 224-239 (no solicitado, pero para referencia)
Clase E (uso experimental): 240-255 (no solicitado, pero para referencia)

Paso 3: Determinar la Clase de cada Dirección

Aplicando el rango del primer octeto:

172.16.58.223
- Primer octeto: 172
- Clase B: Ya que 172 está entre 128 y 191.
163.10.5.49
- Primer octeto: 163
- Clase B: Ya que 163 también está entre 128 y 191.
128.10.1.0
- Primer octeto: 128
- Clase B: Es el límite inferior de la Clase B.
10.1.0.0
- Primer octeto: 10
- Clase A: Ya que 10 está entre 1 y 126.
8.40.11.179
- Primer octeto: 8
- Clase A: Ya que 8 está dentro del rango de la Clase A.

b) ¿Cuál es la dirección de subred?

172.16.58.223/26

Convertir la máscara de subred de notación CIDR a formato decimal

Para determinar la dirección de subred de una dirección IP dada con su máscara de subred (en notación CIDR), se realiza un procedimiento lógico llamado "AND" entre la dirección IP y la máscara de subred.

Paso 1.1 Determinar la cantidad de bits para la red

Tomemos por ejemplo /26. Esto significa que los primeros 26 bits de la dirección IP son para la red.

Paso 1.2 Convierte esos Bits a Binario

En binario, los primeros 26 bits se establecerán en '1' y el resto en '0'. Así, para /26:

11111111.11111111.11111111.11000000

Esto se lee como los primeros 26 bits son 1s y los últimos 6 bits son 0s.

Paso 1.3 Convierte el Binario a Decimal

Cada segmento de 8 bits (octeto) se convierte a su equivalente decimal:

11111111 en binario es 255 en decimal.
11000000 en binario es 192 en decimal.

Así, la máscara de subred /26 en formato decimal es 255.255.255.192.

Aplicar la operación AND lógica entre la dirección IP y la máscara de subred

La operación AND compara cada bit de la dirección IP con el bit correspondiente en la máscara de subred. Si ambos bits son 1, el resultado es 1; de lo contrario, es 0.

Ejemplo para calcular la dirección de subred: Tomemos la dirección 172.16.58.223/26:

Dirección IP en binario, podes usar esta web para pasar de decimal a binario: Decimal a Binario

10101100.00010000.00111010.11011111

Máscara de subred /26 en binario:

11111111.11111111.11111111.11000000

Aplicamos la operación and

10101100.00010000.00111010.11011111
AND
11111111.11111111.11111111.11000000
=
10101100.00010000.00111010.11000000 = 172.16.58.192

Dirección de subred = 172.16.58.192

Aplicamos lo mismo para todas las demas direcciones

a. 172.16.58.223/26

Dirección de Subred: 172.16.58.192

b. 163.10.5.49/27

Dirección de Subred: 163.10.5.32
- Máscara de subred /27 en binario: 11111111.11111111.11111111.11100000
- Dirección IP y máscara AND resultan en 163.10.5.32

c. 128.10.1.0/23

Dirección de Subred: 128.10.0.0
- Máscara de subred /23 en binario: 11111111.11111111.11111110.00000000
- Dirección IP y máscara AND resultan en 128.10.0.0

d. 10.1.0.0/24

Dirección de Subred: 10.1.0.0
- Máscara de subred /24 en binario: 11111111.11111111.11111111.00000000
- Dirección IP y máscara AND resultan en 10.1.0.0

e. 8.40.11.179/12

Dirección de Subred: 8.32.0.0
- Máscara de subred /12 en binario: 11111111.11110000.00000000.00000000
- Dirección IP y máscara AND resultan en 8.32.0.0

Este proceso te permite identificar la red a la que pertenece una dirección IP y es fundamental para el diseño de redes y el enrutamiento de paquetes en Internet y otras redes de comunicaciones.

c) ¿Cuál es la cantidad máxima de hosts que pueden estar en esa subred?

Para determinar la cantidad máxima de hosts que pueden estar en cada subred dada, primero necesitamos entender cómo se calcula a partir de la máscara de subred asociada con cada dirección. La máscara de subred define cuántos bits de la dirección IP están reservados para identificar la subred y cuántos bits están disponibles para identificar hosts dentro de esa subred.

Paso 1: Determinar la Cantidad de Bits para Hosts

La cantidad de bits disponibles para los hosts en cada subred es igual a 32 menos el número de bits de la máscara de subred (el número después del /). Por ejemplo, si tienes una máscara de /26, entonces 32 - 26 = 6 bits están disponibles para los hosts.

Paso 2: Calcular la Cantidad Máxima de Hosts

La fórmula para calcular la cantidad máxima de hosts en una subred es (2^{n} - 2), donde (n) es el número de bits disponibles para hosts. Se restan dos para excluir la dirección de la red misma y la dirección de broadcast.

Aplicación del Cálculo para Cada Subred

172.16.58.223/26

Bits para hosts: (32 - 26 = 6)
Cantidad máxima de hosts: (2^6 - 2 = 64 - 2 = 62)

163.10.5.49/27

Bits para hosts: (32 - 27 = 5)
Cantidad máxima de hosts: (2^5 - 2 = 32 - 2 = 30)

128.10.1.0/23

Bits para hosts: (32 - 23 = 9)
Cantidad máxima de hosts: (2^9 - 2 = 512 - 2 = 510)

10.1.0.0/24

Bits para hosts: (32 - 24 = 8)
Cantidad máxima de hosts: (2^8 - 2 = 256 - 2 = 254)

8.40.11.179/12

Bits para hosts: (32 - 12 = 20)
Cantidad máxima de hosts: (2^{20} - 2 = 1,048,576 - 2 = 1,048,574)

Cada subred tiene una capacidad máxima de hosts determinada por el número de bits disponibles para los hosts, que se calcula a partir de la máscara de subred en notación CIDR. Este cálculo es fundamental para el diseño de la red, asegurando que haya suficientes direcciones disponibles para todos los dispositivos previstos en cada segmento de la red sin desperdiciar espacio de direcciones IP.

d) ¿Cuál es la dirección de broadcast de esa subred?

Para calcular la dirección de broadcast de una subred, se sigue un proceso sistemático que implica determinar la máscara de subred en formato binario, aplicar operaciones lógicas sobre la dirección IP, y finalmente determinar la dirección de broadcast que es utilizada para enviar paquetes a todos los hosts dentro de esa subred específica.

Paso 1: Convertir la Máscara de Subred a Formato Binario

Primero, necesitamos convertir la notación CIDR de la máscara de subred a su forma binaria completa. Este es un ejemplo general de cómo hacerlo:

/26 se convierte en 255.255.255.192, que en binario es 11111111.11111111.11111111.11000000.
/27, /23, /24, /12 se convierten de forma similar, rellenando con 1s hasta el bit especificado por el CIDR, y el resto son 0s.

Paso 2: Determinar la Dirección de Red

La dirección de red se obtiene haciendo un AND lógico entre la dirección IP y la máscara de subred. El resultado muestra qué parte de la dirección IP representa la red.

Paso 3: Calcular la Dirección de Broadcast

Para obtener la dirección de broadcast, se realiza una operación OR entre la dirección de red y el inverso de la máscara de subred (donde todos los bits de host son '1'):

Invierte la máscara de subred (los bits que eran '0' se convierten en '1', y viceversa).
Realiza una operación OR entre la dirección de red (resultado del Paso 2) y esta máscara invertida. Esto pondrá '1' en todos los bits de host, generando la dirección de broadcast.

a. 172.16.58.223/26

Dirección de Red: 172.16.58.192 (calculado anteriormente).
Invertir la Máscara de Subred /26: 00000000.00000000.00000000.00111111
Dirección de Broadcast: 172.16.58.255 (OR entre 172.16.58.192 y 00000000.00000000.00000000.00111111).

b. 163.10.5.49/27

Dirección de Red: 163.10.5.32 (calculado anteriormente).
Invertir la Máscara de Subred /27: 00000000.00000000.00000000.00011111
Dirección de Broadcast: 163.10.5.63.

c. 128.10.1.0/23

Dirección de Red: 128.10.0.0 (calculado anteriormente).
Invertir la Máscara de Subred /23: 00000000.00000000.00000001.11111111
Dirección de Broadcast: 128.10.1.255.

d. 10.1.0.0/24

Dirección de Red: 10.1.0.0.
Invertir la Máscara de Subred /24: 00000000.00000000.00000000.11111111
Dirección de Broadcast: 10.1.0.255.

e. 8.40.11.179/12

Dirección de Red: 8.32.0.0 (calculado anteriormente).
Invertir la Máscara de Subred /12: 00001111.11110000.11111111.11111111
Dirección de Broadcast: 8.47.255.255.

Este método asegura que la dirección de broadcast calculada pueda ser utilizada para enviar mensajes a todos los dispositivos en la subred especificada, lo cual es crucial para ciertas operaciones de red, como la distribución de información a todos los nodos de una vez.

e. ¿Cuál es el rango de direcciones IP válidas dentro de la subred?

Para calcular el rango de direcciones IP válidas dentro de cada subred especificada, primero debemos determinar las direcciones de red y de broadcast que ya calculamos en preguntas anteriores. Usando estas direcciones, podemos establecer el rango de direcciones IP que pueden ser asignadas a dispositivos dentro de la subred.

Paso 1: Identificar la Dirección de Red y de Broadcast

Como ya hemos calculado anteriormente, la dirección de red es el primer número IP en la subred y la dirección de broadcast es el último. La dirección de red se usa para identificar la subred y no se asigna a ningún dispositivo, mientras que la dirección de broadcast se usa para comunicación a todos los dispositivos de la subred y tampoco se asigna a dispositivos individuales.

Paso 2: Calcular el Rango de Direcciones IP Válidas

El rango de direcciones IP válidas para los dispositivos es todas las direcciones entre la dirección de red y la de broadcast, excluyendo estas dos direcciones.

a. 172.16.58.223/26

Dirección de Red: 172.16.58.192
Dirección de Broadcast: 172.16.58.255
Rango de Direcciones Válidas: 172.16.58.193 a 172.16.58.254

b. 163.10.5.49/27

Dirección de Red: 163.10.5.32
Dirección de Broadcast: 163.10.5.63
Rango de Direcciones Válidas: 163.10.5.33 a 163.10.5.62

c. 128.10.1.0/23

Dirección de Red: 128.10.0.0
Dirección de Broadcast: 128.10.1.255
Rango de Direcciones Válidas: 128.10.0.1 a 128.10.1.254

d. 10.1.0.0/24

Dirección de Red: 10.1.0.0
Dirección de Broadcast: 10.1.0.255
Rango de Direcciones Válidas: 10.1.0.1 a 10.1.0.254

e. 8.40.11.179/12

Dirección de Red: 8.32.0.0
Dirección de Broadcast: 8.47.255.255
Rango de Direcciones Válidas: 8.32.0.1 a 8.47.255.254

Importancia de Conocer el Rango de Direcciones Válidas

Este rango es crítico para los administradores de redes para planificar adecuadamente la asignación de direcciones IP dentro de la red, evitar conflictos de direcciones, y asegurar que todos los dispositivos tengan conectividad adecuada. Además, ayuda a aplicar políticas de seguridad y configurar servicios de red como DHCP de manera efectiva.

Ejercicio 7

Su organización cuenta con la dirección de red 128.50.10.0. Indique:

a. ¿Es una dirección de red o de host? PREGUNTAR ACA

"128.50.10.0" podría ser técnicamente una dirección de host bajo ciertas máscaras de subred específicas, generalmente se considera una dirección de red bajo el supuesto común de una máscara /24. Sin embargo, es crucial contar con la información correcta sobre la configuración de la red para hacer esta determinación con precisión.

b. Clase a la que pertenece y máscara de clase.

Para determinar a qué clase pertenece la dirección IP 128.50.10.0 y cuál es su máscara de clase estándar, seguimos estos pasos:

Paso 1: Observar el Primer Octeto

La clasificación de la clase de una dirección IP se basa en el primer octeto (el primer conjunto de números antes del primer punto). En este caso, el primer octeto es 128.

Paso 2: Determinar la Clase Basada en el Primer Octeto

Las direcciones IP se clasifican en cinco clases principales (A, B, C, D, E) según los primeros bits del primer octeto:

Clase A: Las direcciones comienzan con un bit inicial de 0. Esto significa que las direcciones Clase A van desde 0.0.0.0 hasta 127.255.255.255 (aunque la dirección 127.x.x.x se reserva para loopback, y la dirección 0.x.x.x no se utiliza).
Clase B: Las direcciones comienzan con bits iniciales de 10. El rango de direcciones Clase B va desde 128.0.0.0 hasta 191.255.255.255.
Clase C: Las direcciones comienzan con bits iniciales de 110. El rango de direcciones Clase C va desde 192.0.0.0 hasta 223.255.255.255.
Clase D (Multicast): Comienza con bits iniciales de 1110, cubriendo direcciones desde 224.0.0.0 hasta 239.255.255.255.
Clase E (Experimental): Comienza con bits iniciales de 1111, extendiéndose desde 240.0.0.0 hasta 255.255.255.255.

Paso 3: Aplicar la Información al Caso Presentado

Dado que el primer octeto es 128, la dirección IP 128.50.10.0 cae dentro del rango de la Clase B.

Paso 4: Máscara de Clase Estándar para la Clase B

Para las direcciones de Clase B, la máscara de subred estándar es 255.255.0.0. Esto significa que los dos primeros octetos (255.255) identifican la red, mientras que los dos últimos octetos (0.0) son utilizados para los hosts dentro de esa red.

Resumen

La dirección IP 128.50.10.0 es una dirección de Clase B y su máscara de subred de clase estándar es 255.255.0.0. Esto es fundamental para entender cómo se dividen las redes y cómo se asignan direcciones dentro de esas redes, especialmente para la planificación y la gestión de redes a gran escala.

| Clase | Rango de Direcciones IP | Máscara de Subred por Defecto | Uso Típico | |-----------|-----------------------------|----------------------------------|-------------------------------| | A | 1.0.0.0 a 126.255.255.255 | 255.0.0.0 (/8) | Redes muy grandes | | B | 128.0.0.0 a 191.255.255.255 | 255.255.0.0 (/16) | Redes medianas | | C | 192.0.0.0 a 223.255.255.255 | 255.255.255.0 (/24) | Redes pequeñas | | D | 224.0.0.0 a 239.255.255.255 | No aplicable | Multicasting | | E | 240.0.0.0 a 255.255.255.255 | No aplicable | Uso experimental y futuro |

c. Cantidad de hosts posibles.

Para determinar la cantidad de hosts posibles para la dirección de red 128.50.10.0, necesitamos conocer la máscara de subred asociada con esta dirección. Sin embargo, si consideramos que no se especifica una máscara en la consulta y que estamos tratando con una dirección que parece ser de Clase B (basada en su primer octeto, que está entre 128 y 191), podemos asumir la máscara de subred estándar de Clase B, que es 255.255.0.0 o /16.

Paso a Paso para Calcular la Cantidad de Hosts Posibles

Paso 1: Identificar la Máscara de Subred

Para una dirección de red de Clase B sin especificaciones adicionales, la máscara de subred es típicamente /16. Esto significa que los primeros 16 bits de la dirección IP se utilizan para identificar la red, y los últimos 16 bits son para los hosts dentro de esa red.

Paso 2: Calcular los Bits de Host

Con una máscara de subred de /16, hay 16 bits disponibles para los hosts. La cantidad de combinaciones posibles que se pueden hacer con 16 bits se calcula como 2^16.

Paso 3: Ajustar por Direcciones Reservadas

De las combinaciones posibles, dos direcciones están reservadas y no se pueden asignar a hosts individuales:

La dirección de red (donde todos los bits de host son 0, es decir, 128.50.10.0 en este caso).
La dirección de broadcast (donde todos los bits de host son 1, es decir, 128.50.255.255 para una máscara /16).

Paso 4: Calcular el Número Total de Hosts Posibles

Restamos dos del total calculado en el paso 2 para excluir estas direcciones reservadas:

[ \text{Total de hosts posibles} = 2^{16} - 2 = 65536 - 2 = 65534 ]

Conclusión Para la dirección de red 128.50.10.0 con una máscara de subred de /16, la cantidad máxima de hosts que se pueden configurar en esta red es 65,534. Este cálculo asume que estamos utilizando la configuración de subred estándar para una dirección de Clase B y que no hay segmentaciones adicionales (subredes más pequeñas) dentro de esta dirección.

d. Se necesitan crear, al menos, 513 subredes. Indique:

i. Máscara necesaria.

Para crear al menos 513 subredes a partir de una dirección de red 128.50.10.0, necesitas determinar cuántos bits adicionales de subred se requieren para lograr ese número de subredes. Aquí está el paso a paso para calcular la máscara de subred necesaria:

Paso 1: Comprender la Necesidad

Necesitas al menos 513 subredes, lo que significa que debes calcular cuántos bits son necesarios para representar al menos esa cantidad de subredes únicas.

Paso 2: Calcular los Bits Necesarios para las Subredes

Para encontrar el número de bits necesarios, debes calcular el menor ( n ) tal que ( 2^n ) sea mayor o igual a 513.

( 2^8 = 256 ) no es suficiente.
( 2^9 = 512 ) sigue siendo insuficiente.
( 2^{10} = 1024 ) cumple con el requisito.

Por lo tanto, necesitas 10 bits adicionales para la subred.

Paso 3: Determinar la Máscara de Subred Original

Dado que 128.50.10.0 parece ser una dirección de Clase B (basado en el primer octeto, que cae dentro del rango de 128-191), la máscara de subred predeterminada para una red de Clase B es 255.255.0.0, lo que equivale a una máscara /16.

Paso 4: Calcular la Nueva Máscara de Subred

Si ya tienes una máscara /16 y necesitas 10 bits adicionales para subredes, sumas esos 10 bits a los 16 existentes:

Máscara original: /16
Bits adicionales: +10
Nueva máscara: /26

Paso 5: Convertir la Nueva Máscara a Formato Decimal

Una máscara /26 significa que los primeros 26 bits de la dirección IP son para la red y el resto para los hosts. Esto se divide como sigue:

Los primeros 26 bits: 11111111.11111111.11111111.11000000
En formato decimal: 255.255.255.192

Conclusión

La máscara de subred necesaria para crear al menos 513 subredes desde la dirección 128.50.10.0 es 255.255.255.192, o /26. Esto te permite tener suficientes bits para crear las subredes requeridas y proporcionar una cantidad adecuada de direcciones IP para hosts dentro de cada subred.

ii. Cantidad de redes asignables.

Para determinar la cantidad de redes asignables cuando se crean al menos 513 subredes a partir de la dirección de red 128.50.10.0 con una máscara de subred /26 (como se calculó anteriormente), debemos comprender cómo afecta esta configuración de subredes al espacio de direcciones disponibles.

Paso 1: Confirmar la Configuración de la Máscara de Subred

Dado que decidimos usar una máscara /26 para satisfacer la necesidad de al menos 513 subredes:

La máscara /26 implica que se utilizan 26 bits para la red, dejando 6 bits para los hosts dentro de cada subred.

Paso 2: Calcular el Número de Redes Asignables

Usando los 10 bits adicionales para la subred (pasando de una máscara /16 original de una dirección de Clase B a una /26), se calcula el número de subredes posibles:

(2^{10} = 1024)

Estos 10 bits adicionales permiten la creación de 1024 subredes diferentes bajo la misma red principal. Cada una de estas subredes puede ser considerada como una "red asignable".

Paso 3: Confirmar la Cantidad de Redes Asignables

Dado que cada uno de estos nuevos bits de subred puede ser configurado independientemente como 0 o 1, y con 10 bits, tenemos (2^{10}) combinaciones posibles, resultando en 1024 redes asignables bajo la configuración /26.

Conclusión

Al subdividir la red original 128.50.10.0/16 en subredes más pequeñas con una máscara /26, podemos asignar hasta 1024 redes diferentes. Esto significa que la organización puede tener 1024 subredes distintas, cada una con su propio rango de direcciones IP para hosts, satisfaciendo ampliamente la necesidad inicial de crear al menos 513 subredes.

Este proceso es crítico para la planificación de la red, asegurando que haya suficiente flexibilidad y capacidad para el crecimiento y la organización de la red conforme a las necesidades futuras.

iii. Cantidad de hosts por subred.

Para calcular la cantidad de hosts posibles por subred después de segmentar una dirección de red inicial 128.50.10.0 en 513 subredes o más con una máscara de subred /26, se sigue este proceso paso a paso:

Paso 1: Identificar la Máscara de Subred Utilizada

Para crear 513 subredes, se determinó previamente que la máscara de subred necesaria es /26. Esto significa que 26 bits de la dirección IP se destinan a la red y los restantes bits se utilizan para identificar hosts dentro de cada subred.

Paso 2: Calcular los Bits Disponibles para Hosts

Con una máscara de subred /26, tenemos un total de 32 bits en la dirección IP.
26 bits son para la red, lo que deja (32 - 26 = 6) bits para los hosts.

Paso 3: Calcular la Cantidad de Hosts por Subred

Los 6 bits disponibles para los hosts teóricamente permiten (2^6 = 64) combinaciones posibles. Sin embargo, dentro de cada subred, dos direcciones están reservadas y no pueden ser asignadas a hosts:

La dirección de red, donde todos los bits de host son 0.
La dirección de broadcast, donde todos los bits de host son 1.

Paso 4: Restar las Direcciones Reservadas

Para obtener el número de hosts utilizables en cada subred, debemos restar estas dos direcciones reservadas del total calculado:

(2^6 - 2 = 64 - 2 = 62)

Conclusión

Cada subred de la red 128.50.10.0 con una máscara /26 puede soportar 62 hosts utilizables. Este cálculo es crucial para la planificación de la asignación de direcciones IP dentro de la red, asegurando que cada subred tenga suficiente capacidad para acomodar los dispositivos necesarios sin exceder el límite disponible.

iv. Dirección de la subred 710.

Para calcular la dirección de la subred 710, dado que se han segmentado las subredes utilizando una máscara de /26 a partir de la dirección de red 128.50.10.0, seguimos los siguientes pasos:

Paso 1: Entender la Estructura de la Subred

Con una máscara /26, cada subred utiliza 26 bits de la dirección IP. Esto significa que cada subred tiene (2^{32-26} = 64) direcciones IP, incluyendo la dirección de red y la dirección de broadcast.

Paso 2: Calcular el Rango de Direcciones para Cada Subred

Cada subred de /26 cubre 64 direcciones IP. La dirección de la subred se determina sumando 64 direcciones al inicio de la subred anterior para obtener el inicio de la nueva subred.

Paso 3: Calcular la Dirección de la Subred 710

Para encontrar la dirección de la subred 710, primero determinamos cuál es la dirección de la subred 1 bajo esta configuración y luego procedemos a calcular la dirección de la subred 710 sumando adecuadamente.

Inicio de la subred 1: La primera subred comienza en 128.50.10.0.
Incremento por Subred: Cada subred abarca 64 direcciones, entonces la dirección de inicio de cada nueva subred se incrementa en 64.
Calculando el inicio de la subred 710:
- Subred 1 comienza en 128.50.10.0.
- Subred 710 comienza en 128.50.10.0 + 709 x 64 direcciones.

Paso 4: Convertir el Incremento a Direcciones IP

Cada incremento de 64 direcciones avanza 64 posiciones en el espacio de direcciones IP. Calculamos cuántas veces pasa de 255 para ajustar los octetos adecuadamente.

709 x 64 direcciones es igual a 45,376 direcciones IP.
Convierte 45,376 en notación de dirección IP:
- Dividimos 45,376 por 256 (número de direcciones por octeto) para calcular el avance en los octetos.
- 45376 dividido por 256 es aproximadamente 177, con un remanente que determinará el nuevo último octeto.

Paso 5: Determinar la Dirección Exacta

Octeto base: 10.0
Avance de 177 octetos desde el inicio de la red en el tercer octeto (10 + 177 = 187).
Calcular el remanente: 45376 - 177 x 256 = 64 (que corresponde al último octeto del nuevo bloque).

Dirección de la Subred 710: 128.50.187.64

Conclusión

La dirección de la subred 710 es 128.50.187.64 bajo la máscara /26, partiendo de la dirección base 128.50.10.0. Este proceso implica un cálculo cuidadoso para garantizar la precisión en la asignación de direcciones dentro de la red extendida.

v. Dirección de broadcast de la subred 710

Para calcular la dirección de broadcast de la subred 710 a partir de la dirección de red 128.50.10.0 con una máscara de /26, sigue estos pasos detallados:

Paso 1: Identificar la Dirección de la Subred

Primero, debemos confirmar la dirección de la subred 710. Como se calculó anteriormente, esta subred comienza en 128.50.187.64.

Paso 2: Entender la Máscara de Subred /26 Una máscara /26 significa que los primeros 26 bits son para la red, dejando los últimos 6 bits para los hosts. Esto implica que cada subred tiene (2^6 = 64) direcciones IP, desde la dirección de red hasta la dirección de broadcast.

Paso 3: Calcular la Dirección de Broadcast

Para encontrar la dirección de broadcast para una subred dada, tomamos la dirección de inicio de la subred y sumamos 63 (ya que el rango incluye la dirección de red y la de broadcast):

Dirección de inicio de la subred: 128.50.187.64
Dirección de broadcast: 128.50.187.64 + 63 = 128.50.187.127

Paso 4: Verificación

La dirección de broadcast es siempre la última dirección en el rango de la subred. Para una subred que comienza en 128.50.187.64 con una máscara /26, el cálculo es directo:

La dirección de broadcast, 128.50.187.127, es calculada sumando 63 a la dirección de inicio, porque el rango completo de la subred incluye 64 direcciones (de 128.50.187.64 a 128.50.187.127).

Conclusión

La dirección de broadcast de la subred 710 es 128.50.187.127. Esta dirección es utilizada para comunicaciones que deben ser recibidas por todos los dispositivos dentro de esta subred específica.

Ejercicio 8

Si usted estuviese a cargo de la administración del bloque IP 195.200.45.0/24

a. ¿Qué máscara utilizaría si necesita definir al menos 9 subredes?

Para administrar el bloque IP 195.200.45.0/24 y dividirlo en al menos 9 subredes, debes calcular la máscara de subred adecuada que te permita tener suficientes subredes y, al mismo tiempo, un número adecuado de hosts por subred. Aquí te explico el proceso paso a paso:

Paso 1: Entender la Máscara Original

La máscara original para tu bloque IP es /24, lo que significa que todos los bits hasta el octeto final están reservados para la red, dejando el último octeto (8 bits) para los hosts. En la práctica, esto te permite tener 256 direcciones en total.

Paso 2: Calcular la Cantidad de Bits Necesarios para las Subredes

Para dividir la red en al menos 9 subredes, necesitas determinar cuántos bits adicionales deberás "tomar prestados" del espacio de host para crear estas subredes.

Cálculo de Bits Necesarios: Necesitas encontrar el menor ( n ) tal que ( 2^n ) cubra el número de subredes deseado. Para 9 subredes, ( 2^3 = 8 ) no es suficiente, mientras que ( 2^4 = 16 ) es suficiente.

Paso 3: Determinar la Nueva Máscara de Subred

Si tomas prestados 4 bits adicionales del espacio de host, estarás cambiando la máscara de subred de /24 a /28:

Nueva Máscara de Subred: /28
Esto convierte la máscara de subred de 255.255.255.0 (para /24) a 255.255.255.240 (para /28).

Paso 4: Verificar la Cantidad de Subredes y Hosts por Subred

Con una máscara /28, cada subred tendrá ( 2^4 = 16 ) direcciones en total, pero solo 14 de ellas serán utilizables para hosts, ya que la primera dirección es la dirección de red y la última es la dirección de broadcast.

Subredes Posibles con /28: Tendrás 16 subredes posibles, que es suficiente para satisfacer la necesidad de al menos 9 subredes.
Hosts por Subred: Cada subred puede tener hasta 14 dispositivos conectados (excluyendo la dirección de red y broadcast).

Conclusión

Para definir al menos 9 subredes en un bloque 195.200.45.0/24, deberías utilizar una máscara de subred /28. Esto te proporciona 16 subredes posibles, cada una con capacidad para 14 hosts, lo cual es adecuado para una gestión eficiente de la red y maximiza el uso de tu espacio de direcciones IP.

b. Indique la dirección de subred de las primeras 9 subredes

Para calcular las direcciones de subred de las primeras 9 subredes en el bloque IP 195.200.45.0/24 utilizando una máscara de subred /28, como hemos decidido en la pregunta anterior, sigue estos pasos detallados:

Paso 1: Comprender la Estructura de la Subred

Con una máscara /28, cada subred utiliza 28 bits de la dirección IP. Esto significa que cada subred tiene (2^{32-28} = 16) direcciones IP, incluyendo la dirección de red y la dirección de broadcast.

Paso 2: Calcular el Rango de Direcciones para Cada Subred

Cada subred de /28 cubre 16 direcciones IP. La dirección de la subred es siempre el primer número en ese bloque, y la dirección de broadcast es el último número.

Paso 3: Listar las Direcciones de Subred para las Primeras 9 Subredes

Dirección Base para Subredes: 195.200.45.0
Incremento por Subred: 16 direcciones

Aquí están las direcciones de las primeras 9 subredes:

Subred 1: 195.200.45.0
- Rango: 195.200.45.0 - 195.200.45.15
- Dirección de subred: 195.200.45.0
Subred 2: 195.200.45.16
- Rango: 195.200.45.16 - 195.200.45.31
- Dirección de subred: 195.200.45.16
Subred 3: 195.200.45.32
- Rango: 195.200.45.32 - 195.200.45.47
- Dirección de subred: 195.200.45.32
Subred 4: 195.200.45.48
- Rango: 195.200.45.48 - 195.200.45.63
- Dirección de subred: 195.200.45.48
Subred 5: 195.200.45.64
- Rango: 195.200.45.64 - 195.200.45.79
- Dirección de subred: 195.200.45.64
Subred 6: 195.200.45.80
- Rango: 195.200.45.80 - 195.200.45.95
- Dirección de subred: 195.200.45.80
Subred 7: 195.200.45.96
- Rango: 195.200.45.96 - 195.200.45.111
- Dirección de subred: 195.200.45.96
Subred 8: 195.200.45.112
- Rango: 195.200.45.112 - 195.200.45.127
- Dirección de subred: 195.200.45.112
Subred 9: 195.200.45.128
- Rango: 195.200.45.128 - 195.200.45.143
- Dirección de subred: 195.200.45.128

Paso 4: Verificación Cada dirección de subred es el primer número en un bloque de 16 direcciones, y el proceso sigue secuencialmente con un aumento constante de 16. Esto asegura que cada subred está claramente definida y no se superpone con otras subredes.

Este cálculo detallado proporciona una base clara para configurar y administrar las subredes dentro de la red principal, garantizando que cada segmento esté correctamente asignado sin conflictos de dirección.

c. Seleccione una e indique dirección de broadcast y rango de direcciones asignables en esa subred

Para seleccionar una subred del bloque IP 195.200.45.0/24 con una máscara /28 y determinar la dirección de broadcast y el rango de direcciones asignables, podemos seguir el ejemplo de la subred 4, que se ha calculado anteriormente con dirección de subred 195.200.45.48.

Paso 1: Confirmar la Dirección de Subred

Basado en la subdivisión previa, sabemos que:

Dirección de Subred 4: 195.200.45.48

Paso 2: Calcular la Dirección de Broadcast

Con una máscara /28, cada subred tiene 16 direcciones IP. La dirección de broadcast es siempre la última dirección en este rango.

Inicio de la Subred: 195.200.45.48
Fin de la Subred: 195.200.45.48 + 15 = 195.200.45.63

La última dirección (195.200.45.63) será la dirección de broadcast para esta subred.

Dirección de Broadcast:

195.200.45.63

Paso 3: Determinar el Rango de Direcciones Asignables El rango de direcciones asignables es entre la dirección de subred y la dirección de broadcast, excluyendo estas dos direcciones:

Primera Dirección Asignable: 195.200.45.48 + 1 = 195.200.45.49
Última Dirección Asignable: 195.200.45.63 - 1 = 195.200.45.62

Rango de Direcciones Asignables:

Desde 195.200.45.49 hasta 195.200.45.62

Paso 4: Resumen del Rango y la Broadcast de la Subred Para la subred 195.200.45.48/28:

Dirección de Broadcast: 195.200.45.63
Rango de Direcciones Asignables: 195.200.45.49 a 195.200.45.62

Este rango de direcciones asignables incluye 14 direcciones IP utilizables para dispositivos dentro de la subred. Estas direcciones son adecuadas para asignar a servidores, estaciones de trabajo, impresoras, u otros dispositivos de red que requieran conectividad IP dentro de esta subred específica.

Ejercicio 9

Dado el siguiente gráfico:

Router B:

eth2: 191.26.145.20/24 (Conexión a Internet)
eth0: 172.26.22.1/30 (Conexión a Router A)
eth1: 172.17.10.14/28 (Conexión a Router C)

Router A:

eth1: 172.26.22.3/30 (Conexión a Router B)
eth0: 192.168.5.1/24 (Red local)

Router C:

eth1: 172.17.10.17/28 (Conexión a Router B)
eth0: 10.0.10.1/24 (Red local)

a. Verifique si es correcta la asignación de direcciones IP y, en caso de no serlo, modifique la misma para que lo sea.

Para verificar y explicar las direcciones y subredes en el gráfico proporcionado, vamos a analizar cada conexión y cada dirección de subred en detalle:

Conexión Router B (191.26.145.20) al Internet

Dirección de Router B: 191.26.145.20
Máscara de subred: /24
Rango de direcciones en esta subred: 191.26.145.0 - 191.26.145.255
Dirección de broadcast: 191.26.145.255
Comentarios: La dirección es válida y la subred parece configurada correctamente para conectar al Internet.

Conexión entre Router B y Router A

Dirección de Router B (eth0): 172.26.22.1
Dirección de Router A (eth1): 172.26.22.3
Máscara de subred: /30
Rango de direcciones en esta subred: 172.26.22.0 - 172.26.22.3
- Dirección de red: 172.26.22.0
- Dirección de broadcast: 172.26.22.3
Comentarios: La configuración es incorrecta en términos de la dirección de broadcast. En una subred /30, 172.26.22.3 es la dirección de broadcast, lo que significa que no debería asignarse a un dispositivo. El Router A debería tener la dirección 172.26.22.2.

Conexión entre Router B y Router C

Dirección de Router B (eth1): 172.17.10.14
Dirección de Router C (eth1): 172.17.10.17
Máscara de subred: /28
Rango de direcciones en esta subred: 172.17.10.0 - 172.17.10.15
- Dirección de red: 172.17.10.0
- Dirección de broadcast: 172.17.10.15
Comentarios: La configuración es incorrecta. La dirección de Router C, 172.17.10.17, está fuera del rango de direcciones de la subred. Debería estar dentro del rango 172.17.10.1 - 172.17.10.14.

Red Interna de Router A

Dirección de Router A (eth0): 192.168.5.1
Máscara de subred: /24
Rango de direcciones en esta subred: 192.168.5.0 - 192.168.5.255
- Dirección de red: 192.168.5.0
- Dirección de broadcast: 192.168.5.255
Comentarios: Esta dirección está bien configurada para una red local.

Red Interna de Router C

Dirección de Router C (eth0): 10.0.10.1
Máscara de subred: /24
Rango de direcciones en esta subred: 10.0.10.0 - 10.0.10.255
- Dirección de red: 10.0.10.0
- Dirección de broadcast: 10.0.10.255
Comentarios: Esta dirección está bien configurada para una red local.

Correcciones Necesarias

Router A: Cambiar la dirección de 172.26.22.3 a 172.26.22.2 para la conexión con Router B.
Router C: Ajustar la dirección dentro del rango de la subred 172.17.10.0/28, posiblemente a 172.17.10.2 o cualquier dirección entre 172.17.10.1 y 172.17.10.14.

Estas correcciones asegurarán que todas las direcciones y subredes estén configuradas adecuadamente y sin conflictos en la red.

b. ¿Cuántos bits se tomaron para hacer subredes en la red 10.0.10.0/24? ¿Cuántas subredes se podrían generar?

Como es una direccion IP de clase A, podemos decir que se tomaron 16 bits para hacer subredes. En total se pueden generar 2^16 = 65536 subredes.

c. Para cada una de las redes utilizadas indique si son públicas o privadas.

Para diferenciar entre redes públicas y privadas, es importante comprender cómo se distribuyen y gestionan las direcciones IP a nivel global y local. Las direcciones IP son asignadas por la Internet Assigned Numbers Authority (IANA) y se clasifican en dos categorías principales: públicas y privadas. Aquí te explico cómo identificar cada una de estas y cuál es su propósito:

Direcciones IP Públicas

Definición y Uso:
- Direcciones IP públicas son aquellas que son únicas en todo el Internet. No se repiten y son la forma en que un dispositivo puede ser identificado de manera única en Internet. Estas direcciones son asignadas por proveedores de servicios de internet y otras entidades registradas.
- Son necesarias para los dispositivos que necesitan comunicarse directamente con Internet, como los servidores web, los correos electrónicos y los routers de borde de las redes corporativas o residenciales.
Acceso:
- Cualquier dispositivo con una dirección IP pública es potencialmente accesible desde cualquier lugar del mundo a través de Internet, sujeto a las políticas de firewall y seguridad.
Ejemplos de Rangos No Privados:
- Cualquier dirección IP que no caiga dentro de los rangos específicos reservados para uso privado (ver más abajo) se considera pública.

Direcciones IP Privadas

Definición y Uso:
- Direcciones IP privadas son aquellas que se utilizan dentro de redes locales (LAN) y no son ruteables en Internet. Esto significa que estas direcciones no pueden ser usadas directamente para comunicarse con dispositivos fuera de la red local.
- Se usan para comunicaciones dentro de una red doméstica, empresarial, o entre dispositivos en redes internas sin exponer directamente esos dispositivos a Internet.
Acceso:
- Los dispositivos con direcciones IP privadas requieren traducción de direcciones de red (NAT) para conectarse a Internet a través de una dirección pública, usualmente realizada por un router.
Rangos Reservados:
- Las direcciones IP privadas están definidas específicamente en los siguientes rangos por IANA para evitar conflictos con direcciones asignadas globalmente:
  - 10.0.0.0 a 10.255.255.255 (10/8 prefix)
  - 172.16.0.0 a 172.31.255.255 (172.16/12 prefix)
  - 192.168.0.0 a 192.168.255.255 (192.168/16 prefix)
- Además, 169.254.0.0 a 169.254.255.255 se utilizan para configuración automática de direcciones locales (APIPA) en caso de que un dispositivo no pueda obtener una dirección de un servidor DHCP.

Cómo Identificar Si Una Dirección IP Es Pública o Privada

Para saber si una dirección IP es pública o privada, puedes simplemente verificar si cae dentro de los rangos mencionados para direcciones privadas. Si no está en esos rangos, es pública. Herramientas y comandos como ipconfig (en Windows) o ifconfig (en sistemas basados en Unix), así como la configuración de tu router, pueden decirte qué tipo de dirección IP está asignada a tus dispositivos.

Resumen

La distinción entre direcciones IP públicas y privadas es crucial para la administración de redes, la seguridad y el diseño de la infraestructura IT. Entender estas diferencias ayuda a implementar las prácticas adecuadas para el acceso a recursos internos y externos, y asegura la correcta funcionalidad de los sistemas de comunicaciones digitales.

Para determinar si las direcciones IP utilizadas en las redes del diagrama son públicas o privadas, analizaremos cada dirección basándonos en los rangos definidos por la IANA para redes privadas y públicas. A continuación, un desglose de cada red en el diagrama:

1. Dirección IP de Internet y Router B

191.26.145.1 y 191.26.145.20/24: Este rango de direcciones no está dentro de los bloques reservados para redes privadas, lo que indica que son direcciones IP públicas. Las direcciones públicas son asignadas por la IANA y utilizadas para el tráfico en Internet, siendo accesibles globalmente.

2. Conexión entre Router B y Router A

172.26.22.1 y 172.26.22.3/30: Aunque la dirección 172.x.x.x podría sugerir que es una dirección privada, solo el rango 172.16.0.0 hasta 172.31.255.255 está reservado para redes privadas. Por lo tanto, estas direcciones caen dentro del rango de redes privadas y no son accesibles directamente desde Internet.

3. Conexión entre Router B y Router C

172.17.10.14 y 172.17.10.17/28: Este rango está dentro de 172.16.0.0 hasta 172.31.255.255, que es específicamente reservado para redes privadas. Por ende, estas direcciones también son privadas y diseñadas para uso interno dentro de organizaciones, no siendo accesibles desde Internet.

4. Red Interna de Router A

192.168.5.1/24: El rango 192.168.0.0 - 192.168.255.255 está reservado exclusivamente para redes privadas. Las direcciones dentro de este rango no son ruteables en Internet, indicando que es una dirección privada usada comúnmente para redes domésticas o corporativas internas.

5. Red Interna de Router C

10.0.10.1/24: El rango 10.0.0.0 - 10.255.255.255 está destinado para redes privadas. Estas direcciones son utilizadas ampliamente en diversos entornos corporativos y domésticos para la configuración de redes internas y no son accesibles directamente desde Internet.

Conclusión

Las direcciones asignadas en las conexiones entre los routers y las redes internas son todas privadas, excepto las direcciones que conectan el Router B con Internet, que son públicas. Las direcciones privadas se utilizan para limitar el acceso directo desde y hacia Internet, proporcionando una capa adicional de seguridad y permitiendo una gestión más eficiente del espacio de direcciones IP dentro de una organización. Las direcciones públicas, por otro lado, son necesarias para que los dispositivos se comuniquen directamente con otros dispositivos en Internet.

CIDR

Ejercicio 10

CIDR (Classless Inter-Domain Routing) es un método para asignar direcciones IP y enrutar mensajes de red que fue introducido para mejorar la eficiencia del enrutamiento en Internet y para retrasar la agotación de direcciones IPv4. Esta técnica fue introducida en 1993 y marcó un cambio significativo en la forma en que las direcciones IP se asignan y se maneja el enrutamiento.

¿Qué es CIDR (Class Interdomain routing)?

CIDR reemplaza el antiguo sistema de clases de red (Clase A, B, C) donde las direcciones IP se dividían en bloques fijos basados en los primeros bits de la dirección. Con CIDR, los bloques de direcciones pueden tener cualquier longitud, lo que permite una asignación de direcciones mucho más flexible y un uso más eficiente del espacio de direcciones IP. CIDR se representa generalmente mediante la notación de prefijo, como por ejemplo 192.0.2.0/24, donde el /24 indica que los primeros 24 bits de la dirección forman parte del identificador de red.

¿Por qué resulta útil?

Uso eficiente del espacio de direcciones IP:
- CIDR permite una asignación de direcciones más precisa y ajustada a las necesidades reales de las organizaciones, reduciendo la cantidad de direcciones IP desperdiciadas bajo el antiguo sistema de clases.
Mejora del enrutamiento:
- Con CIDR, las tablas de enrutamiento pueden agregarse para reducir su tamaño. Esto se hace combinando múltiples entradas de red en una sola. Esto no solo simplifica la gestión de las rutas, sino que también mejora la eficiencia del enrutamiento en toda la Internet.
Retraso en la agotación de IPv4:
- Al permitir un uso más eficiente de las direcciones disponibles, CIDR ha sido crucial para extender la vida útil de IPv4, que ha estado bajo la presión de la agotación debido al crecimiento exponencial de dispositivos conectados a Internet.
Flexibilidad y escalabilidad en la asignación de direcciones:
- CIDR permite que las direcciones IP se asignen en varios tamaños que pueden adaptarse mejor a la cantidad de direcciones realmente necesarias. Esto es especialmente útil para organizaciones más pequeñas o para subredes dentro de una organización más grande.
Facilita el enrutamiento interdominio:
- CIDR simplifica el enrutamiento entre diferentes dominios y proveedores de Internet, lo que es crucial para la operatividad de la red global de Internet.

En resumen, CIDR es una herramienta esencial en la gestión de redes modernas, proporcionando una manera más flexible y eficiente de asignar direcciones IP y administrar el enrutamiento en una era donde los recursos de dirección IP son cada vez más valiosos. Su implementación ha permitido no solo una gestión más eficiente del espacio de direcciones IPv4, sino también una mejora en el rendimiento del enrutamiento en la infraestructura de red global.

Ejercicio 11

¿Cómo publicaría un router las siguientes redes si se aplica CIDR?

a. 198.10.1.0/24
b. 198.10.0.0/24
c. 198.10.3.0/24
d. 198.10.2.0/24

Para explicar detalladamente cómo se agrupan las redes utilizando CIDR y cómo se calculan las nuevas máscaras de subred, usaremos la representación binaria de las direcciones IP para visualizar mejor los cambios. Tomemos las direcciones que mencionaste:

Direcciones Involucradas

198.10.1.0/24
198.10.0.0/24
198.10.3.0/24
198.10.2.0/24

Paso 1: Convertir las Direcciones a Binario

Primero, convertimos las direcciones a su forma binaria (considerando solo el último octeto para simplicidad, ya que solo ese cambia aquí):

198.10.0.0/24: 00000000
198.10.1.0/24: 00000001
198.10.2.0/24: 00000010
198.10.3.0/24: 00000011

Paso 2: Identificar Agrupaciones Posibles Observamos los bits y encontramos posibles agrupaciones. Para CIDR, agrupamos direcciones que pueden ser cubiertas por una sola red ajustando la máscara de subred para incluir más direcciones.

Agrupación 1 (198.10.0.0 y 198.10.1.0):
- Binario: 00000000 y 00000001
- Los 7 primeros bits son comunes (0000000), y solo cambia el último bit.
- Nueva máscara: /23 (permitiendo que el último bit varíe entre los dos valores)
Agrupación 2 (198.10.2.0 y 198.10.3.0):
- Binario: 00000010 y 00000011
- Igualmente, los 7 primeros bits son comunes (0000001).
- Nueva máscara: /23

Paso 3: Calcular la Nueva Dirección de Red y la Dirección de Broadcast para las Agrupaciones

Con la nueva máscara /23:

Para 198.10.0.0/23:
- Dirección de Red: 198.10.0.0 (binario: 00000000)
- Dirección de Broadcast: 198.10.1.255 (binario: 00000001 11111111)
Para 198.10.2.0/23:
- Dirección de Red: 198.10.2.0 (binario: 00000010)
- Dirección de Broadcast: 198.10.3.255 (binario: 00000011 11111111)

Paso 4: Impacto en el Enrutamiento

Al utilizar una máscara /23 en lugar de /24 para estas redes, reduces el número de entradas en la tabla de enrutamiento global, mejorando así la eficiencia del enrutamiento en toda la red.
Esto es especialmente útil en entornos donde las direcciones IP son limitadas y el enrutamiento debe ser optimizado para conservar recursos.

Conclusión CIDR es una técnica poderosa que permite un uso más flexible y eficiente del espacio de direcciones IP. Al agrupar direcciones IP que están secuencialmente alineadas y ajustar las máscaras de subred correspondientes, las redes pueden ser diseñadas de manera más eficiente, reduciendo la complejidad del enrutamiento y mejorando el rendimiento general de la red.

Podes seguir reduciendo esto

Para considerar si usar una máscara /22 para las direcciones dadas (198.10.0.0/24, 198.10.1.0/24, 198.10.2.0/24, 198.10.3.0/24) sería adecuado, debemos entender qué implica y cuántas direcciones abarcaría.

Qué Implica una Máscara /22 Una máscara /22 implica que los primeros 22 bits de la dirección IP son fijos para definir la red, dejando 10 bits para los hosts dentro de esa red. Esto significa que la red puede tener (2^{10} = 1024) direcciones en total.

Cómo Se Distribuirían Estas Direcciones

Dirección de Red: Sería la más baja en el rango que comienza con los mismos 22 bits.
Dirección de Broadcast: Sería la más alta en este rango.

Dado que las redes 198.10.0.0/24 hasta 198.10.3.0/24 son secuenciales y cubren un bloque de 4 subredes /24, podemos calcular el rango cubierto por una máscara /22:

Dirección de Red con /22: 198.10.0.0
Dirección de Broadcast con /22: 198.10.3.255
- Esto cubriría de 198.10.0.0 hasta 198.10.3.255, encapsulando completamente las cuatro subredes /24 mencionadas.

Análisis de la Utilidad de una Máscara /22

Eficiencia de Enrutamiento: Al usar una máscara /22, reducirías la cantidad de entradas en las tablas de enrutamiento al consolidar cuatro entradas de /24 en una sola entrada de /22. Esto simplifica la gestión de la red y puede mejorar el rendimiento del enrutamiento.
Flexibilidad de Asignación: Con /22, tendrías más flexibilidad en la asignación de direcciones dentro de un rango más amplio, lo que podría ser útil si esperas una expansión o si hay una necesidad variable de direcciones IP dentro del grupo de subredes.

Consideraciones

Segmentación y Control: Al ampliar la máscara de subred, se podría perder granularidad en el control del tráfico y la administración de segmentos de red más pequeños. Esto es relevante en términos de seguridad y rendimiento de la red, especialmente si diferentes segmentos requieren diferentes políticas.
Planificación de la Capacidad: Es crucial asegurarse de que la capacidad de la red y las políticas de seguridad puedan manejar un rango más amplio de direcciones de manera efectiva sin comprometer la integridad de la red.

Conclusión

Usar una máscara /22 para estas redes es completamente viable y puede ofrecer beneficios significativos en términos de simplificación del enrutamiento y eficiencia administrativa. Sin embargo, es esencial considerar los requisitos específicos de la red y las posibles necesidades futuras antes de decidir expandir la máscara de subred. La decisión debe alinearse con los objetivos de la organización en términos de crecimiento, seguridad y gestión de la red.

Ejercicio 12

Listar las redes involucradas en los siguientes bloques CIDR:

200.56.168.0/21
195.24.0.0/13
195.24/13

Para entender cómo listar las redes involucradas dentro de los bloques CIDR dados, analizaremos cada caso utilizando la notación binaria para clarificar cómo se dividen las direcciones IP dentro de cada rango específico.

1. Bloque CIDR: 200.56.168.0/21

Paso 1: Entender la Máscara /21

Una máscara /21 significa que los primeros 21 bits de la dirección son fijos. Esto deja 11 bits para definir las direcciones de host dentro de la red.

Paso 2: Calcular el Rango de Direcciones

Los primeros 21 bits de 200.56.168.0 se quedan constantes.
La parte variable de la dirección, que son los últimos 11 bits, puede variar desde 00000000000 (0) hasta 11111111111 (2047).
Esto da un rango total desde 200.56.168.0 hasta 200.56.175.255.

Rango de Direcciones:

Dirección de Red: 200.56.168.0
Dirección de Broadcast: 200.56.175.255
Rango Útil de Hosts: De 200.56.168.1 a 200.56.175.254

2. Bloque CIDR: 195.24.0.0/13 y 195.24/13

"195.24/13" es probablemente un error de tipografía y debe ser interpretado como "195.24.0.0/13" para mantener la consistencia.

Explicación Detallada:

Paso 1: Entender la Máscara /13

Una máscara /13 indica que los primeros 13 bits son fijos. Esto deja 19 bits para las direcciones de host.

Paso 2: Calcular el Rango de Direcciones

Los primeros 13 bits de 195.24.0.0 son constantes, empezando desde 11000011 0001 (los primeros 13 bits de 195.24 en binario).
La parte variable de la dirección, que son los últimos 19 bits, puede variar desde 0000000000000000000 (0) hasta 1111111111111111111 (524287).
Esto da un rango total desde 195.16.0.0 hasta 195.31.255.255 (el rango debe ajustarse para incluir todas las posibles direcciones que cumplen con los primeros 13 bits fijos).

Rango de Direcciones:

Dirección de Red: 195.16.0.0 (comienzo del bloque que mantiene los 13 bits fijos)
Dirección de Broadcast: 195.31.255.255

Ejercicio 13

El bloque CIDR 128.0.0.0/2 o 128/2, ¿Equivale a listar todas las direcciones de red de clase B?

Para entender cómo se relaciona el bloque CIDR 128.0.0.0/2 con las direcciones de red de clase B y cómo se agruparían todas las redes de clase A bajo CIDR, es fundamental revisar cómo funcionan las máscaras de subred en CIDR y la clasificación original de las direcciones IP en clases A, B y C.

`Bloque CIDR 128.0.0.0/2`

Paso 1: Determinar los bits de red fijos

La máscara /2 significa que los dos primeros bits de la dirección IP son fijos. En el caso de 128.0.0.0/2, estos dos bits están configurados como 10.

Paso 2: Calcular el rango de direcciones IP

Con solo los dos primeros bits fijos, los siguientes bits pueden variar. Esto abarca desde 10000000.00000000.00000000.00000000 (128.0.0.0) hasta 10111111.11111111.11111111.11111111 (191.255.255.255).
Esto incluye todas las direcciones desde 128.0.0.0 hasta 191.255.255.255, que cubre todas las direcciones de clase B (128.0.0.0 a 191.255.255.255) y parte de las direcciones de clase A y clase C.

Paso 3: Relación con las direcciones de red de clase B

Este bloque CIDR incluye todas las direcciones de red de clase B, pero no se limita solo a ellas. También incluye la parte alta de las direcciones de clase A y la parte baja de las direcciones de clase C.

`¿Cuál sería el bloque CIDR que agrupa todas las redes de clase A?`

Paso 1: Identificar el rango de direcciones de clase A

Las direcciones de clase A originalmente abarcan de 0.0.0.0 a 127.255.255.255, con el primer bit establecido como 0.

Paso 2: Determinar la máscara de CIDR adecuada

Para cubrir todo el rango de direcciones de clase A con un bloque CIDR, necesitaríamos una máscara que deje el primer bit como variable y fije los demás según sea necesario para cubrir desde 0.0.0.0 hasta 127.255.255.255.
Esto significa utilizar una máscara /1 que fija solo el primer bit a 0. Esto permite que el segundo bit varíe, lo que adecuadamente abarca desde 00000000.00000000.00000000.00000000 (0.0.0.0) hasta 01111111.11111111.11111111.11111111 (127.255.255.255).

Conclusión El bloque CIDR 128.0.0.0/2 incluye todas las direcciones de red de clase B, pero no se limita a estas, ya que también abarca partes de las clases A y C. Para agrupar todas las redes de clase A, se usaría el bloque CIDR 0.0.0.0/1. Este enfoque de CIDR permite una utilización más flexible y eficiente del espacio de direcciones IP en comparación con el sistema de clases original.

VLSM

Ejercicio 14

¿Qué es y para qué se usa VLSM?

Variable Length Subnet Masking (VLSM) es una técnica que permite a los administradores de red subdividir una red IP en múltiples subredes de tamaño variable, optimizando así el uso del espacio de direcciones IP asignado a una organización. Esta técnica se utiliza para hacer un uso más eficiente del espacio de direcciones IP y para adaptar la segmentación de la red a las necesidades específicas de diferentes segmentos dentro de la red.

¿Para qué se usa VLSM?

Eficiencia en la Utilización del Espacio de Direcciones IP:
- VLSM permite dividir redes grandes en subredes más pequeñas sin desperdiciar direcciones IP. Esto es crucial en entornos donde el número de direcciones IP es limitado.
Flexibilidad en el Diseño de Redes:
- Al permitir subredes de diferentes tamaños, VLSM ofrece flexibilidad en el diseño de la red, lo que permite a los diseñadores de red ajustar el tamaño de la subred según las necesidades de número de hosts en diferentes segmentos de la red.
Optimización del Enrutamiento:
- VLSM puede mejorar la eficiencia del enrutamiento al reducir el número de rutas que un router debe manejar. Al permitir redes más precisas en el enrutamiento, puede minimizar la cantidad de información de enrutamiento que se necesita propagar a través de la red.
Soporte para Múltiples Protocolos de Enrutamiento:
- VLSM es compatible con protocolos de enrutamiento que soportan la propagación de máscaras de subred de longitud variable, como OSPF, EIGRP y BGP. Esto permite una implementación más eficaz y dinámica de los cambios de red.

Cómo Funciona VLSM

La implementación de VLSM comienza con la red de mayor tamaño asignada y luego divide progresivamente las direcciones disponibles para crear subredes más pequeñas para segmentos específicos de la red que requieren menos direcciones. Esta técnica requiere que los administradores de red y los dispositivos involucrados tengan una capacidad de manejo detallada del enrutamiento y la tabla de direcciones.

Ejemplo de Aplicación de VLSM

Supongamos que una empresa tiene una dirección de red 192.168.1.0/24 y necesita crear tres subredes; una que soporte 50 dispositivos, otra que soporte 30 dispositivos y una última que soporte 10 dispositivos. Con VLSM, se pueden crear subredes que usen solo el número necesario de bits, maximizando así el uso eficiente del espacio de dirección:

Subred 1: 192.168.1.0/26 - Soporta hasta 62 hosts (útil para 50 dispositivos)
Subred 2: 192.168.1.64/27 - Soporta hasta 30 hosts
Subred 3: 192.168.1.96/28 - Soporta hasta 14 hosts (útil para 10 dispositivos)

Esta forma de asignar direcciones permite un aprovechamiento eficiente y lógico del espacio de direcciones IP disponible.

En conclusión, VLSM es una herramienta poderosa en la gestión de redes que permite un uso más racionalizado y estratégico del espacio de direcciones IP, lo cual es esencial en la planificación de redes modernas.

Ejercicio 15

Describa, con sus palabras, el mecanismo para dividir subredes utilizando VLSM.

El mecanismo para dividir subredes utilizando VLSM (Variable Length Subnet Masking) es un proceso que permite una asignación más eficiente y flexible de direcciones IP dentro de una red, adecuando el tamaño de cada subred a las necesidades específicas de cada segmento de la red. Aquí describo paso a paso cómo funciona este mecanismo:

Paso 1: Evaluación de Necesidades

Antes de comenzar a dividir la red principal en subredes, es necesario evaluar cuántos hosts se necesitarán en cada subred. Esta evaluación debe incluir consideraciones sobre el crecimiento futuro y los requerimientos de espacio de dirección para evitar el rediseño de la red.

Paso 2: Asignación de la Máscara de Subred Más Grande

Se comienza con la subred más grande que requerirá el mayor número de direcciones IP. A esta subred se le asigna la máscara de subred más pequeña posible (lo que significa menos bits para la red y más bits para los hosts). Esto asegura que se cumplan las necesidades de host mientras se conserva el espacio de direcciones IP para otras subredes.

Paso 3: Subdivisión Progresiva

Después de asignar la máscara a la subred más grande, el siguiente paso es dividir el espacio restante para otras subredes. Cada subred posterior se puede asignar con una máscara que precise más bits para la red y menos para los hosts, dependiendo de la cantidad de hosts que se necesite en cada una. Esto se hace de manera progresiva hasta cubrir todas las necesidades específicas de la red.

Paso 4: Optimización del Enrutamiento

Con VLSM, cada subred puede tener una máscara de subred diferente, lo cual optimiza el enrutamiento. Los routers que soportan VLSM pueden enviar y recibir actualizaciones de enrutamiento que incluyen la longitud de las máscaras de subred, permitiendo una mayor eficiencia en la gestión del tráfico y la utilización de los recursos de red.

Paso 5: Documentación

Es crucial documentar cada asignación de subred y máscara para mantener una referencia clara de la estructura de la red. Esto facilita la gestión, el troubleshooting y la planificación futura de la red.

Ejemplo Práctico

Supongamos que tienes una dirección de red 192.168.100.0/24 y necesitas crear subredes para diferentes departamentos con diferentes cantidades de hosts:

Departamento A necesita 100 hosts.
Departamento B necesita 30 hosts.
Departamento C necesita 2 hosts.

Podrías asignar:

Departamento A: 192.168.100.0/25 (128 hosts, 126 útiles)
Departamento B: 192.168.100.128/26 (64 hosts, 62 útiles)
Departamento C: 192.168.100.192/30 (4 hosts, 2 útiles)

Cada subred tiene una máscara adaptada a sus necesidades específicas, maximizando el uso del rango de direcciones IP disponible.

En resumen, VLSM es una técnica esencial para redes modernas que buscan una utilización eficiente de las direcciones IP, permitiendo adaptar el tamaño de las subredes a las necesidades reales de la organización mientras se mejora el rendimiento de la red.

Ejercicio 16

Suponga que trabaja en una organización que tiene la red que se ve en el gráfico y debe armar el direccionamiento para la misma, minimizando el desperdicio de direcciones IP.

Dicha organización posee la red 205.10.192.0/19, que es la que usted deberá utilizar.

a. ¿Es posible asignar las subredes correspondientes a la topología utilizando subnetting sin VLSM? Indique la cantidad de hosts que se desperdicia en cada subred.

Para resolver este escenario utilizando subnetting tradicional sin VLSM (Variable Length Subnet Masking) y utilizando la red 205.10.192.0/19, necesitamos dividir esta red en subredes que puedan alojar al menos 128, 20, 1530 y 7 hosts, respectivamente, para cada una de las subredes RED A, RED B, RED C y RED D, minimizando el desperdicio de direcciones IP.

Paso 1: Determinar el Tamaño de las Subredes

Para cada subred, necesitamos calcular el número de bits necesarios para soportar la cantidad de hosts requerida:

RED A: 128 hosts ⇒ Se requieren 7 bits para los hosts (128-2 = 126 hosts útiles, 2^7=128 es el tamaño de la subred más cercano).
RED B: 20 hosts ⇒ Se requieren 5 bits para los hosts (30 hosts útiles, 2^5=32 es el tamaño de la subred más cercano).
RED C: 1530 hosts ⇒ Se requieren 11 bits para los hosts (2046 hosts útiles, 2^11=2048 es el tamaño de la subred más cercano).
RED D: 7 hosts ⇒ Se requieren 3 bits para los hosts (6 hosts útiles, 2^3=8 es el tamaño de la subred más cercano).

Paso 2: Asignar Máscaras de Subred Basadas en el Mayor Requerimiento

Para maximizar el uso de las direcciones IP sin VLSM, debemos asignar las máscaras de subred de manera que acomoden el número de hosts requerido en cada subred. Sin VLSM, la máscara seleccionada para cada subred es más restrictiva:

RED A: /25 (255.255.255.128) - Aloja 126 hosts útiles.
RED B: /27 (255.255.255.224) - Aloja 30 hosts útiles.
RED C: /21 (255.255.248.0) - Aloja 2046 hosts útiles.
RED D: /29 (255.255.255.248) - Aloja 6 hosts útiles.

Paso 3: Calcular el Desperdicio de Direcciones IP

Al asignar máscaras de subred sin utilizar VLSM, cada subred tiene un número fijo de direcciones, muchas de las cuales pueden no ser utilizadas:

RED A: Desperdicio de 2 direcciones (128 - 126).
RED B: Desperdicio de 12 direcciones (32 - 20).
RED C: Desperdicio de 516 direcciones (2048 - 1530).
RED D: Desperdicio de 1 dirección (8 - 7).

Paso 4: Direccionamiento de Subredes

Considerando que estamos trabajando con una red 205.10.192.0/19:

205.10.192.0/25 para RED A.
205.10.192.128/27 para RED B.
205.10.193.0/21 para RED C.
205.10.200.0/29 para RED D.

Conclusión

Sin VLSM, el desperdicio de direcciones IP puede ser considerable, especialmente en subredes que no se ajustan perfectamente a las potencias de dos. Con VLSM, podríamos asignar máscaras de subred más precisas para cada subred específica, reduciendo así el desperdicio y utilizando el espacio de direcciones de manera más eficiente. En este caso, el uso de VLSM sería altamente recomendable para maximizar la eficiencia del espacio de direcciones disponible.

b. Asigne direcciones a todas las redes de la topología. Tome siempre en cada paso la primera dirección de red posible.

Para asignar direcciones IP a las redes en la topología presentada, utilizando la red 205.10.192.0/19 y considerando la necesidad de subredes para 128, 20, 1530, y 7 hosts, respectivamente, y utilizando el método de Variable Length Subnet Mask (VLSM) para optimizar el uso del espacio de direcciones IP, seguiríamos estos pasos:

Paso 1: Listar las Subredes por Tamaño

Ordenamos las subredes por el número de hosts que cada una necesita, empezando por la más grande hasta la más pequeña, para minimizar el desperdicio de direcciones:

RED C: 1530 hosts
RED A: 128 hosts
RED B: 20 hosts
RED D: 7 hosts

Paso 2: Calcular Máscaras de Subred para Cada Red

Usamos la fórmula 2^n - 2 >= hosts necesarios para determinar el número mínimo de bits requeridos para los hosts en cada subred, donde (n) es el número de bits para los hosts.

RED C: Mínimo de 1530 hosts ⇒ (2^{11} = 2048) hosts (2046 útiles), máscara /21
RED A: Mínimo de 128 hosts ⇒ (2^7 = 128) hosts (126 útiles), máscara /25
RED B: Mínimo de 20 hosts ⇒ (2^5 = 32) hosts (30 útiles), máscara /27
RED D: Mínimo de 7 hosts ⇒ (2^3 = 8) hosts (6 útiles), máscara /29

Paso 3: Asignar Direcciones IP Utilizando VLSM

Comenzamos con la dirección de red más baja disponible y asignamos bloques de direcciones a cada subred, ajustando la máscara de subred para satisfacer la cantidad de hosts necesarios.

RED C (205.10.192.0/21):
- Rango: 205.10.192.0 - 205.10.199.255
- Dirección de red: 205.10.192.0
- Dirección de broadcast: 205.10.199.255
- Rango de hosts: 205.10.192.1 - 205.10.199.254
RED A (205.10.200.0/25):
- Rango: 205.10.200.0 - 205.10.200.127
- Dirección de red: 205.10.200.0
- Dirección de broadcast: 205.10.200.127
- Rango de hosts: 205.10.200.1 - 205.10.200.126
RED B (205.10.200.128/27):
- Rango: 205.10.200.128 - 205.10.200.159
- Dirección de red: 205.10.200.128
- Dirección de broadcast: 205.10.200.159
- Rango de hosts: 205.10.200.129 - 205.10.200.158
RED D (205.10.200.160/29):
- Rango: 205.10.200.160 - 205.10.200.167
- Dirección de red: 205.10.200.160
- Dirección de broadcast: 205.10.200.167
- Rango de hosts: 205.10.200.161 - 205.10.200.166

Paso 4: Revisión y Ajuste

Revisamos si hay espacio restante y ajustamos si es necesario, asegurándonos de que todas las subredes estén correctamente definidas sin solapamientos y optimizando el uso de la dirección IP disponible.

Conclusión

Este método de VLSM permite un uso eficiente del espacio de direcciones IP, asignando a cada subred la cantidad justa de direcciones que necesita, lo que reduce el desperdicio y mejora la administración de la red.

o asi se entiede mas facil

c. Para mantener el orden y el inventario de direcciones disponibles, haga un listado de todas las direcciones libres que le quedaron, agrupándolas utilizando CIDR

Para calcular y listar todas las direcciones libres que quedan después de asignar las subredes requeridas para RED A, RED B, RED C, y RED D en la red 205.10.192.0/19, procederemos de la siguiente manera:

Recordatorio de las Asignaciones de Subred:

RED C: 205.10.192.0/21 (direcciones desde 205.10.192.0 hasta 205.10.199.255)
RED A: 205.10.200.0/25 (direcciones desde 205.10.200.0 hasta 205.10.200.127)
RED B: 205.10.200.128/27 (direcciones desde 205.10.200.128 hasta 205.10.200.159)
RED D: 205.10.200.160/29 (direcciones desde 205.10.200.160 hasta 205.10.200.167)

Paso 1: Calcular el Rango Total de la Red Principal

La red principal es 205.10.192.0/19, que abarca desde 205.10.192.0 hasta 205.10.223.255.

Paso 2: Identificar los Rangos Utilizados

Los rangos utilizados ya están definidos como parte de las subredes anteriores. Sumarizamos:

205.10.192.0 a 205.10.199.255 para RED C.
205.10.200.0 a 205.10.200.167 para RED A, B, y D (combinando las subredes).

Paso 3: Identificar Direcciones Libres

Las direcciones libres estarán entre los rangos utilizados y el final de la red principal.

Desde 205.10.200.168 hasta 205.10.223.255. Este rango está disponible después de asignar las direcciones para las subredes específicas.

Paso 4: Agrupar las Direcciones Libres Utilizando CIDR

Para agrupar eficientemente las direcciones libres, buscamos el mayor bloque contiguo de direcciones que pueda ser representado utilizando una máscara de subred CIDR adecuada.

205.10.200.168/29: Esta subred puede alojar 6 hosts. Al ser una pequeña porción, se identifica primero para detalle.
205.10.200.176/28: Aloja 14 hosts.
205.10.200.192/26: Aloja 62 hosts.
205.10.201.0/24 hasta 205.10.223.255: Esto es un bloque grande y puede agruparse más eficientemente en una única subred que abarca múltiples direcciones /24. La máscara resultante sería 205.10.201.0/19 que abarca desde 205.10.201.0 hasta 205.10.223.255.

Conclusión

Al listar todas las direcciones libres, organizadas con CIDR, aseguramos que el espacio de dirección IP no utilizado esté claramente definido y pueda ser asignado eficientemente en el futuro para cualquier necesidad adicional o expansión de la red. Esta organización ayuda a mantener un control estricto del inventario de direcciones IP y facilita la gestión de la red.

d. Asigne direcciones IP a todas las interfaces de la topología que sea posible.

Para asignar direcciones IP a todas las interfaces en la topología presentada, necesitamos considerar cada conexión entre los dispositivos (routers y switches) y asegurarnos de que cada interface tenga una dirección IP única dentro de su subred correspondiente. Utilizaremos las subredes ya definidas en pasos anteriores para cada red (RED A, RED B, RED C, RED D) y agregaremos interfaces de red adicionales para las conexiones entre routers si es necesario.

Asignaciones de Subred Basadas en la Topología

Asumiendo que ya hemos establecido las subredes siguientes:

RED C: 205.10.192.0/21
RED A: 205.10.200.0/25
RED B: 205.10.200.128/27
RED D: 205.10.200.160/29

Asignación de Direcciones IP a Interfaces

1. Router Interconexiones:

Para las conexiones entre los routers, necesitaremos asignar bloques de direcciones pequeños, típicamente /30 para conexiones punto a punto, que permitan 2 direcciones útiles por conexión.

2. Interfaces de Router a Switches:

Cada router tendrá una interfaz en la subred correspondiente que conecta a cada RED.

Ejemplo de Asignación Detallada

Router 1:

Interfaz a RED A: 205.10.200.1/25
Interfaz a RED C: 205.10.192.1/21
Interfaz a otro router (supongamos Router 2): 205.10.223.252/30 (ejemplo de dirección en un nuevo bloque /30 que estaría libre)

Router 2:

Interfaz a RED B: 205.10.200.129/27
Interfaz a RED D: 205.10.200.161/29
Interfaz a otro router (Router 1): 205.10.223.253/30

3. Direcciones para Conexión a la Nube:

Suponiendo que uno de los routers tiene una conexión directa a un recurso externo (como un servicio en la nube o internet), esta interfaz deberá tener una dirección pública o una dirección interna si hay NAT de por medio. Supongamos que el Router 2 se conecta a la nube:
- Interfaz a la nube: 190.200.10.2/30 (usando una dirección pública ficticia o interna según el diseño de red)

Consideraciones Adicionales

Direcciones de Broadcast y de Red: Cada subred tiene una dirección específica de red y una de broadcast que no deben ser asignadas a host o interfaces.
Consistencia y Conectividad: Asegúrate de que las direcciones asignadas sean consistentes y no se superpongan entre subredes para evitar conflictos de direccionamiento.
Documentación: Documenta todas las direcciones IP asignadas y cualquier cambio en la topología de la red para futuras referencias y solución de problemas.

Este esquema de asignación asume que solo se utilizan direcciones internas y cualquier conexión a redes externas requeriría configuraciones adicionales de NAT o direcciones públicas según sea necesario.

Ejercicio 17

Utilizando la siguiente topología y el bloque asignado, arme el plan de direccionamiento IPv4 teniendo en cuenta las siguientes restricciones:

a. Utilizar el bloque IPv4 200.100.8.0/22.
b. La red A tiene 125 hosts y se espera un crecimiento máximo de 20 hosts.
c. La red X tiene 63 hosts.
d. La red B cuenta con 60 hosts
e. La red Y tiene 46 hosts y se espera un crecimiento máximo de 18 hosts.
f. En cada red, se debe desperdiciar la menor cantidad de direcciones IP posibles. En este sentido, las redes utilizadas para conectar los routers deberán utilizar segmentos de red /30 de modo de desperdiciar la menor cantidad posible de direcciones IP.

Para diseñar un plan de direccionamiento IPv4 eficiente para la topología dada con el bloque 200.100.8.0/22 y cumpliendo con las restricciones especificadas, necesitaremos utilizar técnicas de Variable Length Subnet Mask (VLSM). Esta técnica permite optimizar el uso del espacio de direcciones asignando tamaños de subred adecuados según la cantidad de hosts en cada red y las expectativas de crecimiento.

Paso 1: Determinación del Tamaño de Cada Subred

Dado el número de hosts y el crecimiento esperado en cada red, determinamos el tamaño de subred necesario:

Red A: 125 hosts + 20 de crecimiento = 145 hosts → Se necesita una máscara que permita al menos 145 hosts. La máscara /24 permite hasta 254 hosts.
Red X: 63 hosts → Se necesita una máscara que permita al menos 63 hosts. La máscara /26 permite hasta 62 hosts, así que se usa una /25 que permite hasta 126 hosts.
Red B: 60 hosts → Se necesita una máscara que permita al menos 60 hosts. La máscara /26 permite hasta 62 hosts.
Red Y: 46 hosts + 18 de crecimiento = 64 hosts → Se necesita una máscara que permita al menos 64 hosts. Una /26 permite hasta 62 hosts, así que se usa una /25 que permite hasta 126 hosts.
Conexiones entre Routers: Usar segmentos /30 que permiten 2 hosts útiles.

Paso 2: Asignación de Subredes

Comenzamos asignando las subredes desde la dirección más baja disponible:

Red A: 200.100.8.0/24
- Rango de hosts: 200.100.8.1 - 200.100.8.254
- Dirección de broadcast: 200.100.8.255
Red X: 200.100.9.0/25
- Rango de hosts: 200.100.9.1 - 200.100.9.126
- Dirección de broadcast: 200.100.9.127
Red B: 200.100.9.128/26
- Rango de hosts: 200.100.9.129 - 200.100.9.190
- Dirección de broadcast: 200.100.9.191
Red Y: 200.100.9.192/25
- Rango de hosts: 200.100.9.193 - 200.100.9.254
- Dirección de broadcast: 200.100.9.255
Conexiones entre Routers:
- Por ejemplo, entre r1 y r2: 200.100.10.0/30
- Otros enlaces se asignarán subredes /30 consecutivas dentro del rango disponible de 200.100.10.4/30, 200.100.10.8/30, etc., hasta 200.100.10.252/30.

Paso 3: Verificación y Ajustes

Después de asignar las direcciones, es crucial verificar que todas las subredes y conexiones:

No se solapen.
Cumplan con las expectativas de crecimiento.
Sean eficientes en el uso del espacio de direcciones disponible sin desperdiciar direcciones IP.

Paso 4: Documentación

Documentar cada asignación con detalles específicos de cada subred y conexión para futuras referencias y gestión de la red. Esta documentación es vital para el mantenimiento y la expansión futura de la red.

Este enfoque proporciona una asignación lógica y sistemática de direcciones que maximiza la utilización del bloque de direcciones IP dado, asegurando la escalabilidad y la eficiencia en la administración de la red.

Ejercicio 18

Asigne direcciones IP en los equipos de la topología según el plan anterior.

Este grafico es de agusrnf me daba fiaca hacer uno

ICMP y Configuraciones IP

Ejercicio 19

Describa qué es y para qué sirve el protocolo ICMP.

El protocolo ICMP (Internet Control Message Protocol) es un componente crucial de la suite de protocolos de Internet, utilizado primordialmente para diagnosticar problemas de red y facilitar mensajes operativos sobre el estado de la red. Este protocolo se define en el RFC 792 y es fundamental para el funcionamiento de redes IP. Aquí te describo qué es y para qué sirve ICMP en detalle:

¿Qué es ICMP?

ICMP es un protocolo de capa de red según el modelo OSI, que se utiliza junto con el protocolo IP (Internet Protocol). A diferencia de los protocolos de transporte como TCP y UDP, ICMP no se utiliza para enviar datos entre aplicaciones, sino que se encarga de la gestión y el control de la red proporcionando mensajes de error y operativos.

Funciones Principales de ICMP:

Diagnóstico de Red:
- ICMP permite diagnosticar problemas en la red enviando mensajes de error que indican, por ejemplo, que un servicio o host no está alcanzable o que un datagrama ha tenido que ser descartado debido a un TTL (Time to Live) que ha expirado. Esto es útil para herramientas como ping, que mide la accesibilidad entre dispositivos en una red.
Mensajes de Error:
- Destino Inalcanzable: Se envía cuando no se puede entregar un paquete IP debido a problemas como un puerto o host inexistente.
- Tiempo Excedido: Indica que el TTL de un paquete IP ha expirado, lo que usualmente significa que ha habido un bucle en el enrutamiento.
- Problemas de Parámetro: Alerta sobre errores en los campos de cabecera que impiden que un paquete sea procesado.
Redireccionamiento:
- Los mensajes de redireccionamiento informan a los hosts sobre rutas más eficientes para el envío de paquetes. Esto es parte de la gestión de la red para optimizar el enrutamiento y la eficiencia.
Solicitud y Respuesta de Eco (Ping):
- Esta es probablemente la función más conocida de ICMP, utilizada para verificar la conectividad general entre dos nodos en una red. Un mensaje de eco se envía a un dispositivo, que luego debe responder con un eco de respuesta, confirmando la conectividad.

Importancia de ICMP

Aunque es un protocolo simple, ICMP es vital para la administración de la red y la rápida solución de problemas. Ayuda a los administradores a monitorear y responder a eventos en tiempo real, asegurando que la infraestructura de red sea robusta y confiable. También es fundamental para la configuración de redes más eficientes y para informar a los sistemas sobre cómo y cuándo el tráfico debe ser reruteado para optimizar el rendimiento.

En resumen, ICMP es un componente esencial de la pila de protocolos de Internet, proporcionando retroalimentación sobre problemas y estado de la red, lo que es crucial para el mantenimiento y la operación eficiente de redes basadas en IP.

a. Analice cómo funciona el comando ping.

El comando ping es una herramienta utilizada para probar la accesibilidad de un host en una red IP y para medir el tiempo que toman los mensajes para ir y volver desde el host de origen al destino. Funciona utilizando el protocolo ICMP (Internet Control Message Protocol), específicamente mediante el envío de mensajes de eco y la espera por respuestas de eco.

Funcionamiento del Comando Ping

Envío de Solicitud de Eco:
- Cuando ejecutas el comando ping a una dirección IP, tu dispositivo envía un paquete ICMP de tipo "Echo Request" al dispositivo de destino.
- Este paquete contiene datos que el dispositivo receptor deberá devolver, permitiendo medir el tiempo de ida y vuelta.
Recepción de Respuesta de Eco:
- El dispositivo de destino, al recibir el paquete ICMP "Echo Request", deberá responder con un paquete ICMP de tipo "Echo Reply".
- Al recibir este paquete de respuesta, tu dispositivo puede calcular el tiempo que tardó el mensaje en ir y volver, comúnmente conocido como RTT (Round-Trip Time).

Tipos y Códigos ICMP Utilizados por Ping

i. Indique el tipo y código ICMP que usa el ping.

Tipo y Código ICMP que Usa el Ping (Solicitud de Eco)

Tipo: 8 (Echo Request)
Código: 0

Este tipo y código corresponden a la solicitud de eco que el comando ping envía para verificar la conectividad.

ii. Indique el tipo y código ICMP que usa la respuesta de un ping.

Tipo y Código ICMP que Usa la Respuesta de un Ping (Respuesta de Eco)

Tipo: 0 (Echo Reply)
Código: 0

Este tipo y código corresponden a la respuesta de eco que el host de destino envía en respuesta a la solicitud de eco.

Importancia del Ping

El comando ping es una herramienta esencial para la resolución de problemas de red, permitiendo a los usuarios y administradores de sistemas verificar la accesibilidad de hosts en una red. Su simplicidad y efectividad lo hacen indispensable en muchas tareas de diagnóstico y monitoreo de red. Además, debido a que proporciona una medida del tiempo de ida y vuelta, es útil para evaluar la calidad de la conexión y la latencia en la red.

b. Analice cómo funcionan comandos como traceroute/tracert de Linux/Windows y cómo manipulan el campo TTL de los paquetes IP.

Los comandos traceroute en Linux y tracert en Windows son herramientas utilizadas para diagnosticar la ruta que toman los paquetes para alcanzar un host de destino en una red. Estas herramientas proporcionan una visión detallada de cada salto (hop) que el paquete realiza en su camino hacia el destino, permitiendo a los usuarios identificar dónde pueden estar ocurriendo retrasos o bloqueos en la ruta.

Funcionamiento de Traceroute/Tracert

Manipulación del Campo TTL

Inicialización del TTL:
- Traceroute comienza enviando paquetes de datos con el campo TTL (Time To Live) del encabezado IP inicializado a 1. El TTL es un contador que reduce su valor en 1 cada vez que el paquete pasa por un router. Si el TTL llega a 0, el paquete se descarta para evitar que los paquetes de datos circulen indefinidamente en la red.
Incremento del TTL:
- En cada subsiguiente intento, traceroute incrementa el valor del TTL en 1. Este proceso se repite, incrementando el TTL hasta que el paquete alcanza el host de destino o hasta que se alcanza un número máximo de saltos (hops) predefinido.
Recepción de Respuestas ICMP:
- Cada vez que un paquete con un determinado TTL es descartado por un router debido a que el TTL alcanza 0, el router envía de vuelta al origen un paquete ICMP de tipo "Tiempo Excedido" (Time Exceeded), que contiene la dirección IP del router. Esto le permite a traceroute identificar y registrar cada router por el que el paquete pasa en su ruta hacia el destino.
Finalización:
- El proceso termina cuando el paquete con el TTL suficientemente alto para llegar al destino es recibido y el host de destino envía una respuesta, típicamente un paquete ICMP de tipo "Echo Reply", indicando que ha sido alcanzado.

Utilidad de Traceroute/Tracert

Diagnóstico de Red: Ayuda a diagnosticar puntos de fallo o cuellos de botella en la ruta de los datos.
Seguridad: Puede ayudar a identificar rutas inesperadas que podrían indicar configuraciones erróneas o ataques de redireccionamiento.
Rendimiento: Permite a los administradores de red medir la latencia a lo largo de diferentes tramos de la red.

El uso de traceroute o tracert es invaluable para los profesionales de TI y los administradores de red para mantener y resolver problemas en redes complejas, ofreciendo una mirada en tiempo real sobre cómo los paquetes de datos navegan a través de la infraestructura de Internet y redes internas.

c. Indique la cantidad de saltos realizados desde su computadora hasta el sitio www.nasa.gov. Analice:

Para determinar la cantidad de saltos desde tu computadora hasta el sitio www.nasa.gov y analizar los detalles relacionados, puedes usar el comando traceroute en Linux o tracert en Windows. A continuación, te explico cómo realizar este procedimiento y te proporciono información sobre las preguntas específicas que planteaste:

Realizando Traceroute/Tracert a www.nasa.gov

En Windows:
- Abre el Símbolo del sistema (cmd).
- Escribe el comando: tracert www.nasa.gov
- Presiona Enter.
En Linux:
- Abre una terminal.
- Escribe el comando: traceroute www.nasa.gov
- Presiona Enter.

i. Cómo Hacer para que no Muestre el Nombre del Dominio Asociado a la IP de Cada Salto

En Windows: Utiliza el comando tracert -d www.nasa.gov. La opción -d evita que tracert intente resolver las direcciones IP a nombres de dominio, acelerando el proceso y mostrando solo las direcciones IP.
En Linux: Utiliza el comando traceroute -n www.nasa.gov. La opción -n hace que traceroute no resuelva los nombres de los nodos, solo muestra las direcciones IP.

ii. La Razón de la Aparición de * en Parte o Toda la Respuesta de un Salto

Estrellas (*): Cuando ves * en los resultados de traceroute o tracert, esto indica que no se recibió respuesta de ese salto específico dentro del tiempo de espera predeterminado. Las posibles razones incluyen:
- Filtrado de paquetes: Algunos routers configuran reglas de firewall que bloquean los mensajes ICMP utilizados por traceroute. Cuando un router tiene estas reglas, no responderá a las solicitudes de eco.
- Pérdida de paquetes: La red puede estar congestionada, lo que resulta en la pérdida de paquetes ICMP antes de que alcancen su destino o regresen.
- Tiempo de espera: El tiempo de espera para la respuesta del paquete ha expirado antes de que se recibiera una respuesta.

Estos resultados te ayudan a entender mejor la ruta que toman tus datos en la red y te proporcionan una idea sobre posibles problemas de conectividad o configuraciones restrictivas en la ruta hacia el destino.

d. Verifique el recorrido hacia los servidores de nombre del dominio unlp.edu.ar. En base al recorrido realizado, ¿podría confirmar cuál de ellos toma un camino distinto?

Eh morido

Ejercicio 20

¿Para que se usa el bloque 127.0.0.0/8? ¿Qué PC responde a los siguientes comandos?

a. ping 127.0.0.1
b. ping 127.0.54.43

El bloque 127.0.0.0/8 se usa en redes de computadoras para designar direcciones IP que se refieren a la "máquina local" o "host local", a menudo llamadas direcciones de loopback. Estas direcciones son utilizadas principalmente para pruebas de red interna dentro de un solo sistema. El uso de estas direcciones permite que el software de red pruebe la conectividad y funcionalidad de la red sin la necesidad de salir al exterior a través de una red física.

¿Qué PC responde a los siguientes comandos?

a. ping 127.0.0.1

127.0.0.1 es la dirección de loopback más comúnmente usada. Cuando utilizas este comando, estás enviando un paquete ICMP Echo Request a tu propia máquina. Por lo tanto, la máquina que responde al ping 127.0.0.1 es el propio equipo desde el que se emite el comando. Se usa para verificar que el software de pila TCP/IP en el host está funcionando correctamente.

b. ping 127.0.54.43

Al igual que el caso anterior, cualquier dirección dentro del bloque 127.0.0.0/8 (que incluye 127.0.54.43) se dirige al loopback de la propia máquina. Por lo tanto, si emites ping 127.0.54.43, también estás enviando paquetes a tu propia computadora. La respuesta también proviene de tu propia máquina, verificando así la funcionalidad del loopback y la pila TCP/IP interna.

En resumen, cuando pings a cualquier dirección dentro del bloque 127.0.0.0/8, estás realizando una prueba de loopback interna, y la máquina que responde es siempre la máquina desde la que se emiten los comandos. Esto es útil para diagnósticos y pruebas de conectividad sin necesidad de utilizar la red externa.

Ejercicio 21

Investigue para qué sirven los comandos ifconfig y route. ¿Qué comandos podría utilizar en su reemplazo? Inicie una topología con CORE, cree una máquina y utilice en ella los comandos anteriores para practicar sus diferentes opciones, mínimamente:

Configurar y quitar una dirección IP en una interfaz.
Ver la tabla de ruteo de la máquina

Los comandos ifconfig y route son herramientas tradicionales en sistemas Unix y Linux utilizadas para la configuración de interfaces de red y la gestión de la tabla de ruteo, respectivamente. Aunque todavía están presentes en muchos sistemas, han sido reemplazados por herramientas más modernas y potentes que ofrecen mejor compatibilidad con las nuevas características de red.

Funciones de los Comandos

ifconfig: Se utiliza para configurar, manejar y mostrar la información de las interfaces de red. Permite activar o desactivar interfaces, asignar direcciones IP, configurar máscaras de red, y mucho más.
route: Se utiliza para ver y manipular la tabla de ruteo del sistema. Esto incluye agregar, eliminar o cambiar las rutas utilizadas por el sistema operativo para dirigir el tráfico de red.

Comandos de Reemplazo

ip: Este comando es parte del paquete iproute2 en sistemas Linux y puede realizar las funciones de ifconfig y route, además de muchas otras tareas relacionadas con la red. Está diseñado para ser un reemplazo directo, ofreciendo una sintaxis más coherente y un conjunto de características más amplio.
ip addr, ip link: Reemplazan a ifconfig para la configuración de interfaces.
ip route: Reemplaza a route para la gestión de la tabla de ruteo.

Practicando con CORE

Para utilizar estos comandos en un entorno práctico como CORE (Common Open Research Emulator), puedes seguir estos pasos básicos:

Iniciar una Topología con CORE:
- Abre CORE.
- Crea una nueva topología arrastrando algunos nodos (por ejemplo, PCs y switches).
- Conecta los nodos con enlaces.
Utilizar ifconfig y route en una Máquina:

Configurar y Quitar una Dirección IP en una Interfaz
- Configurar una dirección IP:
```
ifconfig eth0 192.168.1.10 netmask 255.255.255.0 up
```
- Quitar una dirección IP:
```
ifconfig eth0 down
ip addr flush dev eth0
```
Ver la Tabla de Ruteo de la Máquina
- Usando route:
```
route -n
```
- Usando ip route (recomendado):
```
ip route show
```

Estos comandos te permitirán ver cómo se configuran y manipulan las interfaces de red y las tablas de ruteo directamente desde la consola de cada máquina virtual en CORE. Practicar con estos comandos en un entorno simulado es una excelente manera de entender cómo funcionan y cómo se pueden utilizar para gestionar una red.

Practica 8 Redes | Ruteo

Tue, 07 May 2024 00:00:00 GMT

Indice

Ejercicio 1
Ejercicio 2
Ejercicio 3
Ejercicio 4
Ejercicio 5
Ejercicio 6
Ejercicio 7
Ejercicio 8
Ejercicio 9
Ejercicio 10
Ejercicio 11
Ejercicio 12
Ejercicio 13
Ejercicio 14
Ejercicio 15

Recomendación

Al final de la práctica se encuentra un ejercicio para ser realizado en la herramienta CORE.

Si bien el ejercicio no agrega conceptos nuevos a los vistos previamente, recomendamos su resolución para que puedan configurar, probar y analizar todo lo aprendido en una simulación de una red

Fragmentación

Ejercicio 1

Se tiene la siguiente red con los MTUs indicados en la misma. Si desde pc1 se envía un paquete IP a pc2 con un tamaño total de 1500 bytes (cabecera IP más payload) con el campo Identification = 20543, responder:

Indicar IPs origen y destino y campos correspondientes a la fragmentación cuando el paquete sale de pc1

Cuando envías un paquete IP desde pc1 a pc2 en una red con múltiples MTUs, como en tu caso, hay una serie de pasos y consideraciones importantes relacionados con la fragmentación debido a los diferentes MTUs configurados en la red. Aquí te explicaré detalladamente cómo abordar esta situación paso a paso, especialmente cuando el paquete inicial sale de pc1.

Paso 1: Preparar el Paquete IP en pc1

1. Configuración del paquete IP:

IP Origen: 10.0.0.20 (pc1)
IP Destino: 10.0.2.20 (pc2)
Tamaño total del paquete: 1500 bytes (esto incluye la cabecera IP y el payload).
Campo Identification: 20543 (esto se usa para identificar todos los fragmentos de un mismo paquete original).

Paso 2: Confrontar el MTU en el primer enlace

2. MTU del enlace pc1 a R1:

MTU: 1500 bytes
Aquí no hay problema ya que el MTU del enlace es igual al tamaño del paquete. No se requiere fragmentación en este punto.

Paso 3: Manejo de la Fragmentación en R1

3. Encuentro con el primer MTU reducido entre R1 y R2:

MTU del enlace R1 a R2: 600 bytes
Como el MTU es menor que el tamaño del paquete de 1500 bytes, R1 necesita fragmentar el paquete.

Paso 4: Fragmentación del Paquete

4. Cálculo de la fragmentación:

La cabecera IP tiene un tamaño típico de 20 bytes.
MTU de 600 bytes menos 20 bytes de cabecera deja 580 bytes para datos por fragmento.
El paquete original se divide en múltiples fragmentos donde cada uno, excepto posiblemente el último, lleva 580 bytes de datos.

5. Campos de Fragmentación:

Flags:
- Los fragmentos excepto el último tendrán el bit 'More Fragments' (MF) establecido en 1.
- El último fragmento tendrá el bit 'MF' establecido en 0.
Fragment Offset:
- Se calcula en unidades de 8 bytes. Cada fragmento sucesivo aumenta su offset en (580/8) unidades respecto al anterior.

6. Reconstrucción de fragmentos:

Unificación de los fragmentos: Ocurre en pc2, el host de destino final.
Si algún fragmento se pierde durante la transmisión, la reconstrucción completa del paquete original en pc2 no será posible, y típicamente, el paquete se descartará después de un tiempo.

Paso 5: Continuación de la Transmisión

7. Envío de fragmentos a través de R2:

Asumiendo que el MTU en el enlace R2 a pc2 es de 1500 bytes, todos los fragmentos pueden pasar sin requerir fragmentación adicional.

Consideraciones Adicionales

Este proceso de fragmentación puede introducir una sobrecarga significativa y aumentar la probabilidad de errores. Es recomendable, cuando sea posible, ajustar el tamaño del paquete en la fuente o configurar los MTUs en la red para que sean uniformes y evitar la fragmentación.

Estos pasos te proporcionan un marco para entender y manejar la fragmentación de paquetes en redes con MTUs variados, asegurando que estés preparado para configurar y diagnosticar problemas en entornos de red similares.

¿Qué sucede cuando el paquete debe ser reenviado por el router R1?

Cuando un paquete IP de 1500 bytes es enviado desde pc1 a pc2 en la red descrita, y debe ser reenviado por el router R1, se enfrenta a un desafío debido al MTU más pequeño en la interfaz entre R1 y R2. Vamos a explorar detalladamente y paso a paso lo que sucede en este escenario:

Paso 1: Recepción del Paquete por R1

Paquete recibido: R1 recibe el paquete de 1500 bytes de pc1.
MTU del enlace de R1 a pc1: 1500 bytes, por lo que el paquete es recibido sin necesidad de fragmentación.

Paso 2: Evaluación del MTU en la Interfaz R1-R2

MTU del enlace R1 a R2: 600 bytes.
Dado que el MTU de este enlace es menor que el tamaño del paquete recibido (1500 bytes), R1 debe fragmentar el paquete antes de reenviarlo a R2.

Paso 3: Fragmentación del Paquete

Cálculo de la fragmentación:
- La cabecera IP típicamente ocupa 20 bytes.
- El MTU de 600 bytes en el enlace permite 580 bytes de datos por fragmento después de considerar la cabecera.
Creación de fragmentos:
- Fragmento 1: 580 bytes de datos + 20 bytes de cabecera = 600 bytes total. Flags de fragmentación indican más fragmentos (MF = 1), y el offset es 0.
- Fragmentos subsiguientes: Se continúa fragmentando en bloques de 580 bytes de datos hasta cubrir el total del paquete original. Cada fragmento nuevo incrementa el offset en 580 bytes divididos entre 8 (porque el offset se mide en bloques de 8 bytes).

Paso 4: Reenvío de Fragmentos

Envío a R2: Cada fragmento es enviado individualmente a través del enlace entre R1 y R2. R1 maneja la retransmisión de cada fragmento asegurándose de que cumpla con el MTU de 600 bytes.

Paso 5: Recepción y Reensamblaje en pc2

Recepción por R2: R2 recibe los fragmentos uno por uno.
Envío a pc2: R2 reenvía los fragmentos hacia pc2. El MTU entre R2 y pc2 es de 1500 bytes, por lo que no se requiere fragmentación adicional.
Reensamblaje: pc2 reensambla los fragmentos para formar el paquete original. Este proceso ocurre completamente en pc2, el destinatario final.

Consideraciones Adicionales

Pérdida de fragmentos: Si algún fragmento se pierde durante el transporte, pc2 no podrá reconstruir el paquete original completamente. Esto puede requerir una retransmisión del paquete completo desde pc1 si se detecta la pérdida (dependiendo del protocolo de capa superior, como TCP).
Eficiencia: La fragmentación puede aumentar la latencia y reducir la eficiencia de la red, ya que implica un mayor procesamiento por parte de los routers y un mayor número de paquetes a transmitir.

Este análisis detalla cómo el router R1 gestiona un paquete que debe ser fragmentado debido a un MTU más pequeño en la red, ilustrando el impacto que las diferencias de MTU pueden tener en el tráfico de la red.

Indicar cómo quedarían los paquetes fragmentados para ser enviados por el enlace entre R1 y R2.

Cuando un paquete de 1500 bytes es enviado desde pc1 a pc2 y debe pasar por el enlace entre R1 y R2 que tiene un MTU de 600 bytes, se requerirá la fragmentación del paquete para asegurar que pueda ser transmitido correctamente. Vamos a detallar cómo se llevaría a cabo esta fragmentación, paso a paso:

Paso 1: Tamaño de los Fragmentos

MTU del enlace R1-R2: 600 bytes.
Cabecera IP: 20 bytes.
Datos útiles por fragmento: 600 - 20 = 580 bytes.

Paso 2: Cantidad de Fragmentos Necesarios

Tamaño total de datos: 1500 - 20 (cabecera original) = 1480 bytes.
Número de fragmentos requeridos: 1480 / 580 = 2.55, por lo que necesitamos 3 fragmentos (los dos primeros fragmentos serán de 580 bytes de datos y el último ajustará el resto).

Paso 3: Características de los Fragmentos

Primer Fragmento:
- Tamaño: 600 bytes (580 de datos + 20 de cabecera).
- Flags: More Fragments (MF) = 1 (indicando que hay más fragmentos).
- Offset: 0 (es el primer fragmento, así que el desplazamiento es 0).
- Identification: 20543 (todos los fragmentos comparten este ID para asociarse como parte del mismo paquete original).
Segundo Fragmento:
- Tamaño: 600 bytes (580 de datos + 20 de cabecera).
- Flags: MF = 1.
- Offset: 580 / 8 = 72.5, pero debe ser un número entero, por lo tanto, redondeamos a 72 (esto representa el desplazamiento en bloques de 8 bytes del primer byte de datos respecto al inicio del paquete original).
Tercer Fragmento:
- Tamaño: 320 bytes (300 de datos + 20 de cabecera, ajustando el total del paquete a 1500 bytes).
- Flags: MF = 0 (este es el último fragmento, no hay más después de este).
- Offset: (580 + 580) / 8 = 145 (este offset sigue al segundo fragmento y es calculado de la misma forma).

Paso 4: Envío y Reensamblaje

Envío: Cada fragmento es enviado individualmente a través del enlace entre R1 y R2.
Reensamblaje: Todos los fragmentos son reensamblados en pc2 para reconstruir el paquete original. Esto requiere que todos los fragmentos lleguen correctamente; si alguno se pierde, el paquete no puede ser reconstruido por completo.

Consideraciones Adicionales

Overhead de la fragmentación: La fragmentación incrementa el overhead ya que cada fragmento lleva su propia cabecera IP.
Riesgo de pérdida: Si se pierde un fragmento, el paquete completo no puede ser reensamblado, lo que potencialmente requiere una retransmisión del paquete original.
Eficiencia de la red: La fragmentación puede afectar la eficiencia de la red, consumiendo más recursos tanto en los routers como en los hosts finales.

Este proceso ilustra cómo los routers manejan la fragmentación necesaria cuando los paquetes IP deben pasar a través de enlaces con MTU restrictivo, garantizando que la comunicación entre dispositivos en diferentes segmentos de red se realice eficazmente incluso bajo restricciones de infraestructura.

¿Dónde se unen nuevamente los fragmentos? ¿Qué sucede si un fragmento no llega?

En la red que has descrito, los fragmentos de un paquete IP original enviado desde pc1 se reunirán y reensamblarán en el destino final, que en este caso es pc2. Este proceso de reensamblaje es crucial para que pc2 pueda procesar correctamente el paquete original como fue enviado. Aquí explicaré paso a paso cómo ocurre esto y qué sucede si un fragmento no llega.

Paso 1: Fragmentación del Paquete

Fragmentación en R1:
- Dado que el paquete original es de 1500 bytes y el MTU entre R1 y R2 es de solo 600 bytes, R1 fragmentará el paquete en varios fragmentos más pequeños, cada uno dentro del límite del MTU de 600 bytes.
Envío de Fragmentos:
- R1 enviará estos fragmentos uno por uno a través de la interfaz hacia R2.

Paso 2: Transmisión y Recepción de Fragmentos

Recepción por R2:
- R2 recibe los fragmentos uno tras otro. Estos fragmentos aún no son útiles como datos individuales, ya que necesitan ser reensamblados para formar el paquete original.

Paso 3: Reensamblaje de Fragmentos

Reensamblaje en pc2:
- Todos los fragmentos enviados por R1 y retransmitidos por R2 deben llegar a pc2 para que se puedan reunir.
- El reensamblaje se realiza en el buffer de recepción de pc2, donde los fragmentos se ordenan y combinan basándose en sus desplazamientos y el número de identificación, que es 20543 en este caso.

Paso 4: Proceso de Reensamblaje Completo

Construcción del Paquete Original:
- Una vez que todos los fragmentos han llegado y están en el orden correcto, pc2 los combina para reconstruir el paquete original de 1500 bytes.
- El proceso se completa cuando todos los fragmentos han sido reunidos y el paquete se procesa como si hubiera llegado intacto.

Problemas Potenciales: Pérdida de Fragmentos

Pérdida de un Fragmento:
- Si alguno de los fragmentos se pierde durante la transmisión y no llega a pc2, el paquete original no puede ser completamente reensamblado.
- En este caso, el paquete incompleto generalmente se descarta después de un tiempo de espera.
Impacto de la Pérdida de Fragmentos:
- La pérdida de fragmentos puede llevar a una retransmisión del paquete original por parte de la aplicación o la capa de transporte, especialmente si se utiliza TCP, que maneja la retransmisión de datos faltantes.

En resumen, el reensamblaje de los fragmentos se realiza en el host de destino (pc2), y es crucial que todos los fragmentos lleguen para que el paquete original pueda ser reconstruido correctamente. La pérdida de cualquier fragmento puede resultar en la necesidad de retransmitir el paquete entero, lo cual puede reducir la eficiencia de la red y aumentar la latencia.

Si un fragmento tiene que ser reenviado por un enlace con un MTU menor al tamaño del fragmento, ¿qué hará el router con ese fragmento?

Cuando un fragmento de un paquete IP necesita ser reenviado por un enlace con un MTU menor que el tamaño del fragmento, el router enfrenta un dilema de fragmentación adicional. Este es el proceso paso a paso de lo que ocurre:

Paso 1: Detección del MTU más pequeño

Evaluación del MTU: El router detecta que el MTU del siguiente enlace es menor que el tamaño del fragmento que debe enviar.

Paso 2: Fragmentación adicional

Fragmentación: Para manejar esta situación, el router debe fragmentar aún más el fragmento original en unidades más pequeñas que se ajusten al MTU del nuevo enlace. Este proceso se llama "fragmentación de fragmentos".

Paso 3: Ajuste de los Campos de los Fragmentos

Campos de Control: El router ajustará los campos necesarios en las cabeceras de los nuevos fragmentos más pequeños, como el campo de desplazamiento y los flags, para asegurar que al llegar al destino final, todos los fragmentos puedan ser reensamblados correctamente en el orden adecuado.
Flags de Fragmentación: El bit 'More Fragments' (MF) se establece en 1 en todos los fragmentos adicionales excepto en el último, donde se establece en 0.

Paso 4: Reenvío de los Nuevos Fragmentos

Transmisión: Cada uno de los nuevos fragmentos se envía individualmente a través del enlace con el MTU reducido.

Implicaciones de la Fragmentación Adicional

Ineficiencia: La fragmentación adicional introduce una sobrecarga significativa en la red y puede afectar el rendimiento general de la red debido a la cantidad incrementada de cabeceras y el procesamiento adicional necesario en cada hop y en el destino final.
Riesgo de Pérdida: Cada fragmento adicional incrementa el riesgo de pérdida de paquetes, ya que más fragmentos significan más oportunidades para que ocurran errores durante la transmisión.

Conclusiones

La necesidad de fragmentar aún más los fragmentos debido a un MTU reducido en un enlace subsiguiente es un escenario desafiante que los administradores de red prefieren evitar. Configurar todos los enlaces de la red para que tengan un MTU uniforme o utilizar técnicas como Path MTU Discovery (PMTUD) puede ayudar a mitigar estos problemas, permitiendo a los sistemas ajustar el tamaño de los paquetes para evitar la fragmentación siempre que sea posible.

Ruteo

Ejercicio 2

¿Qué es el ruteo?

El ruteo, también conocido como enrutamiento, es el proceso mediante el cual se determina la ruta que deben seguir los paquetes de datos desde su origen hasta su destino en una red de computadoras. Este proceso es esencial para garantizar que la información transmitida a través de redes amplias y complejas, como Internet, llegue de manera eficiente y precisa al punto adecuado.

¿Por qué es necesario?

Interconexión de Redes: Permite la comunicación entre diferentes redes, que pueden estar separadas geográficamente y conectadas a través de varios dispositivos intermediarios, como routers.
Selección de la Mejor Ruta: Los algoritmos de ruteo evalúan múltiples rutas posibles y seleccionan la más óptima para enviar los paquetes. Esto se basa en varios criterios, como el costo, la distancia, el ancho de banda disponible y la congestión de la red.
Eficiencia en la Transmisión: Optimiza el uso de los recursos de la red al evitar caminos saturados o más lentos, reduciendo así el tiempo total de tránsito y mejorando la calidad de servicio.
Escalabilidad de la Red: A medida que las redes crecen en tamaño y complejidad, el ruteo se vuelve crucial para manejar la creciente cantidad de tráfico y para asegurar que la red pueda escalar de manera eficiente sin degradar el rendimiento.
Recuperación ante Fallas: Los protocolos de ruteo pueden adaptarse dinámicamente a los cambios en la topología de la red, como fallas en los enlaces o routers. Esto asegura la robustez y la confiabilidad de la red, redirigiendo el tráfico según sea necesario para evitar los puntos de falla.

El ruteo es un componente crítico de la infraestructura de TI que soporta no solo Internet, sino también redes corporativas, redes de proveedores de servicios, y más. Es fundamental para la operación diaria de innumerables aplicaciones y servicios que dependen de la transmisión eficaz de datos a través de redes digitales.

Ejercicio 3

En las redes IP el ruteo puede configurarse en forma estática o en forma dinámica. Indique ventajas y desventajas de cada método

El ruteo estático es un método donde las rutas a través de una red se configuran manualmente en los routers por los administradores de red. Las rutas permanecen constantes hasta que se cambian manualmente, lo que hace que este método sea simple y predecible. No utiliza recursos de red adicionales para el intercambio de información de rutas, lo que lo hace más seguro y menos propenso a fallos automáticos, pero requiere una gestión cuidadosa y puede ser impracticable en redes grandes o en rápido cambio.

El ruteo dinámico utiliza protocolos de ruteo para permitir que los routers comuniquen entre sí la información sobre las rutas de manera automática. Los protocolos más comunes incluyen RIP, OSPF y BGP. Este método permite que la red se adapte automáticamente a los cambios, como fallas en los enlaces o cambios en la topología de la red, sin intervención manual. Aunque es más complejo de configurar inicialmente y utiliza más recursos del sistema, el ruteo dinámico escala eficazmente para redes grandes y cambiantes.

En las redes IP, la configuración del ruteo puede realizarse de manera estática o dinámica, cada uno con sus propias ventajas y desventajas. Aquí se detallan las características principales de cada método:

Ruteo Estático

Ventajas:

Simplicidad: La configuración estática es más simple y fácil de implementar en redes pequeñas donde las rutas no cambian frecuentemente.
Control: Ofrece un control total sobre las rutas que los paquetes deben seguir, permitiendo a los administradores de red definir explícitamente el camino más óptimo.
Seguridad: Al no utilizar intercambios de información de ruteo con otros routers, reduce la posibilidad de problemas de seguridad relacionados con protocolos de ruteo.

Desventajas:

Escalabilidad: No es adecuado para redes grandes y dinámicas donde los cambios son frecuentes, ya que cualquier cambio requiere una reconfiguración manual.
Falta de Flexibilidad: No puede responder automáticamente a cambios en la red, como fallas de enlaces o cambios en la topología.
Mantenimiento: Requiere una administración manual intensiva, lo que puede ser propenso a errores y consume tiempo.

Ruteo Dinámico

Ventajas:

Adaptabilidad: Capaz de ajustarse automáticamente a cambios en la red, como la adición de rutas nuevas o fallas en los enlaces.
Menor Carga Administrativa: Una vez configurados, los protocolos de ruteo dinámico mantienen las tablas de ruteo actualizadas sin intervención manual.
Escalabilidad: Ideal para redes grandes y en constante cambio debido a su capacidad para manejar complejidades y cambios sin intervención humana directa.

Desventajas:

Complejidad: Los protocolos de ruteo dinámico son más complejos de configurar y requieren un entendimiento profundo de cómo funcionan para optimizar su rendimiento.
Recursos: Utilizan más recursos del sistema, como CPU y memoria, debido al procesamiento de algoritmos de ruteo y al intercambio de información de ruteo.
Seguridad: Más susceptibles a ataques de seguridad, como falsificación de rutas o inundación de la red con rutas inútiles.

Conclusión

La elección entre ruteo estático y dinámico depende de las necesidades específicas de la red, la experiencia del administrador de la red, y los recursos disponibles. En redes pequeñas y estáticas, el ruteo estático puede ser más eficiente y fácil de manejar. En cambio, en redes grandes y complejas, el ruteo dinámico ofrece la flexibilidad y escalabilidad necesarias para mantener la red operando eficientemente ante cualquier cambio.

Ejercicio 4

Una máquina conectada a una red pero no a Internet, ¿tiene tabla de ruteo?

Sí, una máquina conectada a una red pero no a Internet todavía tiene una tabla de ruteo. Esta tabla es fundamental para el funcionamiento de la red, incluso si la red es local y no tiene acceso a Internet. Aquí te explico por qué:

Función de la Tabla de Ruteo

Enrutamiento de Tráfico Local:
- La tabla de ruteo en una máquina controla cómo se envían los paquetes de datos desde esa máquina a otras direcciones dentro de la misma red. Incluso en una red cerrada (sin acceso a Internet), los dispositivos necesitan saber cómo llegar a otros dispositivos dentro de la misma red.
Gestión de Subredes:
- Si la red local consta de múltiples subredes, la tabla de ruteo ayudará a dirigir el tráfico entre estas subredes de manera efectiva.
Interfaz de Loopback y Direcciones Locales:
- Las tablas de ruteo también gestionan el tráfico destinado a la interfaz de loopback de la propia máquina (usualmente 127.0.0.1, que es utilizada para pruebas y procesos internos del sistema).
Rutas Predeterminadas:
- Incluso sin acceso a Internet, una tabla de ruteo puede contener una ruta predeterminada (gateway) que se utilizaría para intentar enviar tráfico a direcciones fuera de la red local conocida.

Ejemplo de Tabla de Ruteo

En una máquina con Windows o Linux, la tabla de ruteo puede incluir entradas como:

Rutas a la subred local, que dirigen el tráfico a direcciones dentro de la misma subred.
Una ruta de loopback, que maneja el tráfico destinado a la propia máquina.
Opcionalmente, una ruta predeterminada que apuntaría a un router o gateway, aunque no lleve a Internet.

Cómo Verificar la Tabla de Ruteo

Puedes verificar la tabla de ruteo de una máquina usando comandos en el terminal:

En Windows: route print
En Linux: ip route show

Estos comandos mostrarán todas las rutas activas y cómo la máquina maneja el tráfico de red, independientemente de si tiene acceso a Internet o no. Esto demuestra que la tabla de ruteo es una parte integral de la configuración de red de cualquier dispositivo conectado a una red, ayudando a manejar el tráfico eficientemente dentro de los límites de esa red.

Ejercicio 5

Observando el siguiente gráfico y la tabla de ruteo del router D, responder:

a. ¿Está correcta esa tabla de ruteo?

En caso de no estarlo, indicar el o los errores encontrados.

Detalle de Entradas de la Tabla de Ruteo de Router-D

Red Destino: 153.10.20.128/27
- Iface: eth1
- Error: No hay error evidente; esta red está correctamente señalada como directamente conectada a través de eth1.
Red Destino: 10.0.0.4/30
- Iface: eth0
- Error: Esta ruta aparece sin un next-hop definido. Debería especificar a través de qué router o interfaz específica se debe encaminar el tráfico para llegar a esta red. Además, no parece haber una conexión directa en la topología proporcionada que justifique esta configuración.
Red Destino: 10.0.0.0/30
- Iface: eth5
- Error: Esta entrada indica que la red está directamente conectada a eth5, lo cual es incorrecto según la topología. No hay conexión directa que justifique esta configuración.
Red Destino: 10.0.0.12/30
- Next-Hop: 10.0.0.5/30
- Iface: eth0
- Error: El formato del next-hop está incorrectamente expresado con una máscara (/30) que no debería aparecer en un campo de next-hop. Además, según la topología, no parece haber una justificación para que esta ruta utilice eth0, y la conexión parece no existir.
Red Destino: 10.0.0.16/30
- Next-Hop: 10.0.0.10
- Iface: eth3
- Error: Aunque el next-hop y la interfaz parecen razonables, la topología no muestra claramente esta conexión. Se necesita verificar si este enlace realmente existe.
Red Destino: 10.0.0.8/30
- Next-Hop: 10.0.0.9
- Iface: eth5
- Error: Esta configuración parece correcta si asumimos que Router-D se conecta directamente a través de eth5 hacia Router-B, lo cual es coherente con la topología.
Red Destino: 205.10.0.128/25
- Next-Hop: 10.0.0.2
- Iface: eth5
- Error: Parece haber un error en la asignación del next-hop. Este no es visible en la topología proporcionada y debe ser revisado para asegurar que la ruta es factible.
Red Destino: 205.20.0.192/26
- Next-Hop: 10.0.0.1
- Iface: eth5
- Error: Similar al anterior, el next-hop listado no es claro según la topología, y la interfaz parece ser incorrectamente asignada o la conexión no está bien documentada en el diagrama.
Red Destino: 163.10.5.64/27
- Next-Hop: 10.0.0.10
- Iface: eth3
- Error: Aunque parece que el next-hop podría ser correcto, no hay evidencia clara en la topología de que esta conexión a través de eth3 sea la adecuada.

Recomendaciones:

Revisión de la Topología: Es fundamental revisar la documentación de la red y confirmar las conexiones físicas y lógicas entre los routers y las redes.
Corrección de Next-Hops y Interfaces: Asegurarse de que cada entrada de la tabla de ruteo tenga el next-hop y la interfaz correctos conforme a la topología real y las conexiones disponibles.
Validación de Conectividad: Comprobar mediante herramientas de diagnóstico como ping o traceroute que las rutas configuradas son efectivamente alcanzables y funcionales.

Estos pasos ayudarán a asegurar que la red funcione de manera óptima y que el tráfico sea encaminado eficientemente a través de las rutas disponibles.

Escribir la tabla correctamente (no es necesario agregar las redes que conectan contra los ISPs)

| Red Destino | Máscara | Next-Hop | Interfaz | |-------------------|---------|-------------|----------| | 153.10.20.128 | /27 | - | eth1 | | 10.0.0.4 | /30 | - | eth5 | | 10.0.0.0 | /30 | 10.0.0.5 | eth5 | | 10.0.0.12 | /30 | 10.0.0.5 | eth0 | | 10.0.0.16 | /30 | 10.0.0.10 | eth3 | | 205.10.128.0 | /25 | 10.0.0.2 | eth5 | | 205.20.192.0 | /26 | 10.0.0.1 | eth5 | | 205.20.128.0 | /26 | 10.0.0.5 | eth0 | | 163.10.5.64 | /27 | 10.0.0.10 | eth3 |

Para corregir la tabla de ruteo del Router-D, debemos asegurarnos de que cada entrada refleje correctamente las conexiones físicas y lógicas mostradas en la topología de la red proporcionada. Vamos a revisar y ajustar la tabla de ruteo basándonos en la información correcta, incluyendo la configuración adecuada de las interfaces y los next-hops.

Tabla de Ruteo Corregida para Router-D:

| Red Destino | Máscara | Next-Hop | Iface | |------------------|---------|-------------|--------| | 153.10.20.128/27 | /27 | - | eth1 | | 10.0.0.0/30 | /30 | 10.0.0.9 | eth5 | | 10.0.0.4/30 | /30 | 10.0.0.1 | eth5 | | 10.0.0.8/30 | /30 | 10.0.0.5 | eth3 | | 10.0.0.12/30 | /30 | 10.0.0.13 | eth3 | | 10.0.0.16/30 | /30 | 10.0.0.17 | eth0 | | 205.20.0.192/26 | /26 | 10.0.0.2 | eth5 | | 205.10.0.128/25 | /25 | 10.0.0.2 | eth5 | | 163.10.5.64/27 | /27 | 10.0.0.10 | eth3 |

Explicación de los Cambios:

153.10.20.128/27: No se necesita cambiar; está directamente conectado a eth1.
10.0.0.0/30 hasta 10.0.0.16/30: Se ajustaron los next-hops para reflejar las conexiones entre los routers según la topología:
- 10.0.0.0/30: Cambiado a 10.0.0.9 via eth5, ya que en la topología parece que este segmento se comunica a través de Router-C.
- 10.0.0.4/30: Ajustado a 10.0.0.1 via eth5, conectando a través de otro router intermedio que no se muestra detalladamente.
- 10.0.0.8/30: Ajustado a 10.0.0.5 via eth3, que es la interfaz de conexión entre Router-D y Router-C.
- 10.0.0.12/30: Ajustado a 10.0.0.13 via eth3.
- 10.0.0.16/30: Cambiado a 10.0.0.17 via eth0, indicando que es directamente conectado.
205.20.0.192/26 y 205.10.0.128/25: Ajustado para mostrar el next-hop correcto a 10.0.0.2 vía eth5, indicando la ruta hacia estas redes a través de un router específico que maneja esa dirección.
163.10.5.64/27: No se necesita cambio; se confirma que la ruta es 10.0.0.10 via eth3.

Esta tabla ajustada proporciona un mejor reflejo de la topología física y las conexiones entre dispositivos en la red, asegurando que el tráfico se enrute eficientemente entre las subredes y los routers mostrados en el diagrama.

TENGO QUE PREGUNTAR UN MONTON DE COSAS

b. Con la tabla de ruteo del punto anterior, Red D, ¿tiene salida a Internet? ¿Por qué?

¿Cómo lo solucionaría? Suponga que los demás routers están correctamente configurados, con salida a Internet y que Rtr-D debe salir a Internet por Rtr-C

Según la tabla de ruteo proporcionada y la topología, el router D (Rtr-D) no tiene una ruta directa configurada para acceder a Internet. Esto se debe a que en la tabla de ruteo no se observa ninguna entrada que dirija el tráfico hacia las direcciones IP de los ISP o una ruta predeterminada (default gateway) que permitiría al tráfico destinado a redes desconocidas ser dirigido hacia el ISP.

Solución:

Para permitir que el Rtr-D tenga acceso a Internet a través de Rtr-C, necesitarías añadir una ruta predeterminada (default route) en la configuración de Rtr-D. Esto dirige todo el tráfico destinado a redes no especificadas directamente en la tabla de ruteo hacia un next-hop específico, que en este caso sería Rtr-C.

Agregar una ruta predeterminada: Deberías configurar una ruta predeterminada en Rtr-D que apunte a la dirección IP de Rtr-C que está directamente conectada a Rtr-D o accesible a través de un next-hop que sea alcanzable. Basándonos en la topología y suponiendo que las conexiones están configuradas correctamente entre los routers, un ejemplo de comando para configurar esto en el router D podría ser (este ejemplo podría variar según el hardware y software del router):
```
ip route add default via [IP de Rtr-C conectada a Rtr-D]
```
Donde [IP de Rtr-C conectada a Rtr-D] debería ser reemplazado por la dirección IP de la interfaz de Rtr-C que Rtr-D puede alcanzar.
Confirmación: Después de agregar la ruta predeterminada, asegúrate de que el tráfico pueda pasar efectivamente a través de Rtr-C hacia el ISP. Esto puede implicar configurar o verificar las rutas en Rtr-C para asegurar que el tráfico proveniente de Rtr-D pueda llegar a Internet y viceversa.

Agregar esta ruta asegura que cualquier solicitud de Rtr-D hacia Internet que no coincida con las redes más específicas en la tabla de ruteo local sea enviada a Rtr-C, y desde allí hacia el ISP correspondiente.

c. Teniendo en cuenta lo aplicado en el punto anterior, si Rtr-C tuviese la siguiente entrada en su tabla de ruteo, ¿qué sucedería si desde una PC en Red D se quiere acceder un servidor con IP 163.10.5.15?

Red Destino Mask Next-Hop Iface
163.10.5.0 /24 10.0.0.9 eth1

Si desde una PC en Red D se intenta acceder a un servidor con IP 163.10.5.15 y Rtr-C tiene la siguiente entrada en su tabla de ruteo:

| Red Destino | Mask | Next-Hop | Iface | |--------------|-------|----------|-------| | 163.10.5.0 | /24 | 10.0.0.9 | eth1 |

Análisis de la situación:

Dirección de Destino: La IP 163.10.5.15 cae dentro del rango de la red 163.10.5.0/24, que está explícitamente mencionada en la tabla de ruteo de Rtr-C.
Configuración de la Ruta: La ruta indica que el tráfico destinado a la red 163.10.5.0/24 debería ser dirigido al next-hop 10.0.0.9 a través de la interfaz eth1.
Verificación del Next-Hop: El next-hop 10.0.0.9 necesita ser una dirección IP válida y alcanzable desde Rtr-C. Si esta dirección IP no es alcanzable (es decir, si no hay una ruta válida hacia 10.0.0.9 desde Rtr-C o si esta IP no existe en la configuración de red actual), el tráfico destinado al servidor 163.10.5.15 no podrá ser entregado correctamente.
Posibles Problemas:
- Inaccesibilidad del Next-Hop: Si el next-hop 10.0.0.9 no es accesible desde Rtr-C, cualquier intento de conexión desde Red D hacia la dirección 163.10.5.15 fallaría.
- Configuración de Red Incorrecta: Si hay un error en la topología o configuración de la red que impide el acceso al next-hop especificado, se producirá un fallo en el enrutamiento.

Posibles Soluciones:

Verificar y Corregir la Ruta en Rtr-C: Asegurarse de que la dirección IP de next-hop 10.0.0.9 es correcta y accesible. Si es incorrecta o inaccesible, ajustar la entrada de ruteo para reflejar una dirección de next-hop válida y alcanzable.
Diagnóstico de Red: Utilizar herramientas como ping o traceroute desde Rtr-C hacia 10.0.0.9 para verificar la conectividad y determinar si el next-hop está efectivamente en la ruta de transmisión del tráfico.

Si se resuelven estos problemas y se asegura que el next-hop es correcto y accesible, el tráfico desde una PC en Red D debería poder alcanzar el servidor en la dirección 163.10.5.15 sin problemas.

d. ¿Es posible aplicar sumarización en la tabla del router Rtr-D? ¿Por qué? ¿Qué debería suceder para poder aplicarla?

Sumarización de Rutas

La sumarización de rutas en redes es una técnica utilizada para reducir el número de rutas que un router necesita almacenar en su tabla de ruteo. Esto se logra mediante la combinación de varias redes más pequeñas en una única entrada de ruteo más grande y más general que abarca todas las redes individuales. La sumarización es útil porque:

Reduce el tamaño de la tabla de ruteo: Menos entradas en la tabla de ruteo implican menos uso de memoria y procesamiento.
Mejora la eficiencia del enrutamiento: Menos entradas simplifican el proceso de toma de decisiones de enrutamiento.
Disminuye la propagación de cambios de ruteo: Menos entradas reducen la cantidad de actualizaciones de rutas necesarias cuando ocurren cambios en la red.

Aplicación de la Sumarización en Rtr-D

Para determinar si es posible aplicar la sumarización en la tabla de ruteo del router Rtr-D, consideramos las redes que Rtr-D conoce y cómo están distribuidas. Observando las redes conectadas y las direcciones de los enlaces:

Redes Directamente Conectadas:
- 10.0.0.4/30
- 10.0.0.8/30
- 10.0.0.12/30
- 10.0.0.16/30
Redes a través de Next-Hops:
- 205.10.128.0/25
- 205.20.192.0/26
- 163.10.5.64/27

Pasos para Evaluar la Sumarización:

Examinar Direcciones IP: Verificar si las redes están en bloques contiguos que puedan ser representados por una única dirección de red con una máscara de subred más amplia. Por ejemplo, las redes 10.0.0.4/30, 10.0.0.8/30, 10.0.0.12/30 y 10.0.0.16/30 son contiguas y podrían sumarizarse en una red más grande si sus direcciones base se ajustan a una sola red con una máscara que cubra todos esos rangos.
Ajustar la Máscara de Subred: Determinar la nueva máscara de subred que pueda englobar todas las redes relevantes. En el caso de las redes 10.0.0.4/30 a 10.0.0.16/30, podrían sumarizarse bajo una máscara /29 si cubre desde 10.0.0.4 hasta 10.0.0.19.
Modificar las Tablas de Ruteo: Cambiar las entradas individuales por la entrada sumarizada en la tabla de ruteo del Rtr-D y asegurarse de que los next-hops sean coherentes y correctos para la nueva ruta sumarizada.

Consideraciones:

Consistencia: Todas las rutas que se sumarizarán deben tener el mismo next-hop. Si las rutas sumarizadas van a diferentes next-hops, no pueden ser sumarizadas eficientemente.
Alcance de la Sumarización: La sumarización debe hacerse de manera que no se superpongan con otras redes no relacionadas y debe reflejar correctamente la topología de la red.

Para aplicar la sumarización, se necesita que las redes a sumarizar tengan una secuencia y contigüidad lógica, y que no se interpongan configuraciones de otros routers que podrían requerir conocimiento de las redes individuales para procesos específicos de enrutamiento o políticas de seguridad. Si estas condiciones se cumplen, se puede aplicar la sumarización para simplificar la gestión de la red en Rtr-D.

e. La sumarización aplicada en el punto anterior, ¿se podría aplicar en Rtr-B? ¿Por qué?

La posibilidad de aplicar sumarización en Rtr-B, al igual que en cualquier otro router, depende de cómo estén organizadas las redes conectadas y cómo estén distribuidas las direcciones IP en la tabla de ruteo. Vamos a analizar los elementos específicos en Rtr-B para determinar si la sumarización es viable:

Consideraciones para Sumarización en Rtr-B

Redes Directamente Conectadas:
- Rtr-B conecta directamente con la Red B y Red E, además de enlaces punto a punto con otros routers.
Distribución de Direcciones IP:
- Red B: 205.20.0.192/26
- Red E: 205.20.0.128/26
- Enlaces punto a punto, como por ejemplo 10.0.0.12/30, 10.0.0.4/30, entre otros.

Análisis para Sumarización:

Contigüidad de Redes:
- Las direcciones de Red B y Red E son contiguas y parte del mismo bloque /24, pero las máscaras de subred y la distribución de las redes hacen que una sumarización directa no sea completamente eficiente, ya que no todas las direcciones de la subred más grande están utilizadas.
Requerimientos de Ruteo:
- Las redes de Rtr-B podrían necesitar acceso directo y explícito a ciertas direcciones IP específicas, lo cual podría complicar una sumarización que generalize demasiado las rutas.
Efecto en el Enrutamiento:
- Sumarizar en Rtr-B podría simplificar la tabla de ruteo local, pero es esencial asegurarse de que todos los caminos críticos y las políticas de acceso están adecuadamente representados en la nueva tabla de ruteo sumarizada. Además, la sumarización incorrecta podría ocultar rutas necesarias para otros routers y hosts en la red.

Conclusión:

La sumarización en Rtr-B es técnicamente posible, especialmente para las redes internas (Red B y Red E), pero debe manejarse con cuidado para asegurarse de que no se pierda acceso detallado necesario para el control de tráfico y las políticas de seguridad de la red. También es crucial considerar cómo esta sumarización afectaría el enrutamiento hacia y desde otros routers y redes externas.

En resumen, mientras que Rtr-D tiene un escenario más favorable para la sumarización debido a la concentración de redes internas similares y conexiones punto a punto, Rtr-B puede enfrentar más desafíos debido a la necesidad de mantener accesibilidad precisa a múltiples subredes menores y enlaces externos.

f. Escriba la tabla de ruteo de Rtr-B teniendo en cuenta lo siguiente:

Debe llegarse a todas las redes del gráfico
Debe salir a Internet por Rtr-A
Debe pasar por Rtr-D para llegar a Red D
Sumarizar si es posible

| Red Destino | Máscara | Next-Hop | Iface | |-----------------|---------|-------------|--------| | 0.0.0.0/0 | /0 | 10.0.0.1 | eth1 | # Default route hacia Internet via Rtr-A | 153.10.20.128/27| /27 | 10.0.0.5 | eth0 | # Red D via Rtr-D | 163.10.5.64/27 | /27 | 10.0.0.9 | eth0 | # Red C via Rtr-C | 205.10.0.128/25 | /25 | 10.0.0.1 | eth1 | # Red A via Rtr-A | 205.20.0.192/26 | /26 | - | eth0 | # Red B directamente conectada | 205.20.0.128/26 | /26 | 10.0.0.5 | eth0 | # Red E via Rtr-D

Explicación de la tabla de ruteo:

0.0.0.0/0: La ruta por defecto (default route) redirige todo el tráfico destinado a Internet a través de Rtr-A, que está configurado para ser el gateway de salida a Internet.
153.10.20.128/27: Las direcciones IP dentro de esta subred se alcanzan a través de Rtr-D. Esta ruta es específica para alcanzar la Red D y está encaminada a través de la interfaz que conecta con Rtr-D.
163.10.5.64/27: Similarmente, esta ruta permite el acceso a la Red C, encaminando el tráfico a través de Rtr-C, que es el router que conecta directamente con esa subred.
205.10.0.128/25: Esta es la ruta hacia la Red A, que se alcanza a través de Rtr-A, indicando que cualquier paquete destinado a esa red debe ser enviado a través de la interfaz que se conecta con Rtr-A.
205.20.0.192/26: Esta entrada indica que la Red B está directamente conectada al Rtr-B y por lo tanto no requiere un next-hop porque los dispositivos están en la misma red local.
205.20.0.128/26: La Red E también se alcanza a través de Rtr-D, utilizando la misma interfaz que se usa para alcanzar la Red D.

Esta configuración asegura que el tráfico fluya correctamente hacia todas las redes internas y hacia Internet, siguiendo las rutas más directas o especificadas según la topología dada.

g. Si Rtr-C pierde conectividad contra ISP-2, ¿es posible restablecer el acceso a Internet sin esperar a que vuelva la conectividad entre esos dispositivos?

Para restablecer el acceso a Internet en Rtr-C después de perder conectividad con ISP-2, se podría considerar una ruta alternativa a través de otro ISP o router disponible en la red, si existe alguno. En el caso de esta topología, aquí están los pasos para redirigir el tráfico a través de ISP-1 utilizando Rtr-A:

Configuración de Rtr-C: Rtr-C necesitaría una ruta de respaldo configurada que apunte hacia Rtr-A para acceder a Internet a través de ISP-1. Esto implicaría ajustar la tabla de ruteo de Rtr-C para incluir una nueva entrada de ruta por defecto (0.0.0.0/0) con Rtr-A como next-hop si aún no existe.
Configuración de Rtr-A: Asegurarse de que Rtr-A tiene capacidad para manejar el tráfico adicional y que sus tablas de ruteo están configuradas para permitir el tráfico de Rtr-C hacia ISP-1.
Configuración del protocolo de enrutamiento: Si se utilizan protocolos de enrutamiento dinámico (como OSPF, EIGRP, BGP), se deberían hacer los ajustes necesarios para propagar la nueva ruta a través de la red.
Validación y pruebas: Realizar pruebas para asegurar que el tráfico está siendo enrutado correctamente a través de Rtr-A hacia ISP-1 y que los servicios de Internet se restauran sin problemas.
Monitorización: Monitorear la red para cualquier problema de rendimiento o cuellos de botella que puedan surgir debido al cambio de ruta, especialmente si Rtr-A no estaba previamente dimensionado para manejar todo el tráfico de Internet de Rtr-C.

Implementar una solución de redundancia de este tipo mejora la resiliencia de la red y minimiza el tiempo de inactividad ante fallos en uno de los enlaces de salida a Internet.

Ejercicio 6

Evalúe para cada caso si el mensaje llegará a destino, saltos que tomará y tipo de respuesta recibida en el emisor

Router 1 route -n

| Destination | Gateway | Genmask | Iface | |-------------|----------|----------------|-------| | 10.0.0.0 | 0.0.0.0 | 255.255.255.0 | eth0 | | 10.0.3.0 | 0.0.0.0 | 255.255.255.0 | eth1 | | 10.0.4.0 | 0.0.0.0 | 255.255.255.0 | eth2 | | 10.0.0.0 | 10.0.3.1 | 255.255.0.0 | eth1 | | 0.0.0.0 | 10.0.0.2 | 0.0.0.0 | eth0 |

Router 2 route -n

| Destination | Gateway | Genmask | Iface | |-------------|----------|------------------|-------| | 10.0.0.0 | 0.0.0.0 | 255.255.255.0 | eth0 | | 10.0.1.0 | 0.0.0.0 | 255.255.255.0 | eth1 | | 10.0.5.0 | 0.0.0.0 | 255.255.255.0 | eth2 | | 0.0.0.0 | 10.0.0.1 | 0.0.0.0 | eth0 |

Router 3 route -n

| Destination | Gateway | Genmask | Iface | |-------------|-----------|----------------|-------| | 10.0.2.0 | 0.0.0.0 | 255.255.255.0 | eth0 | | 10.0.3.0 | 0.0.0.0 | 255.255.255.0 | eth1 | | 10.0.7.0 | 0.0.0.0 | 255.255.255.0 | eth2 | | 0.0.0.0 | 10.0.2.1 | 0.0.0.0 | eth0 |

Router 4 route -n

| Destination | Gateway | Genmask | Iface | |-------------|-----------|----------------|-------| | 10.0.1.0 | 0.0.0.0 | 255.255.255.0 | eth0 | | 10.0.2.0 | 0.0.0.0 | 255.255.255.0 | eth1 | | 10.0.6.0 | 0.0.0.0 | 255.255.255.0 | eth2 | | 0.0.0.0 | 10.0.1.1 | 255.0.0.0 | eth0 |

Evalúe para cada caso si el mensaje llegará a destino, saltos que tomará y tipo de respuesta recibida en el emisor.

Un mensaje ICMP enviado por PC-B a PC-C.
Un mensaje ICMP enviado por PC-C a PC-B.
Un mensaje ICMP enviado por PC-C a 8.8.8.8.
Un mensaje ICMP enviado por PC-B a 8.8.8.8.

Gracias por el gráfico más claro. Ahora, con esta información y las correcciones indicadas anteriormente, vamos a revisar y responder tus consultas sobre el tráfico entre PC-B y PC-C, y sus conexiones a Internet.

Un mensaje ICMP enviado por PC-B a PC-C:

Ruta del mensaje: PC-B -> Router2 -> Router4 -> PC-C.
Tipo de respuesta en el emisor: PC-B recibirá una respuesta de eco ICMP si la configuración de las redes permite la comunicación directa y no hay reglas de firewall que lo impidan.

Un mensaje ICMP enviado por PC-C a PC-B:

Ruta del mensaje: PC-C -> Router4 -> Router2 -> PC-B.
Tipo de respuesta en el emisor: PC-C recibirá una respuesta de eco ICMP de manera similar, asumiendo que no existen bloqueos en la ruta.

Un mensaje ICMP enviado por PC-C a 8.8.8.8:

Ruta del mensaje: PC-C -> Router4 -> Router2 -> Router1 -> Internet.
Tipo de respuesta en el emisor: Si la red está correctamente configurada para salida a Internet y las rutas están correctamente establecidas hacia ISP-1 o ISP-2, PC-C debería poder recibir una respuesta de eco ICMP de 8.8.8.8, suponiendo que no haya bloqueos en la ruta.

Un mensaje ICMP enviado por PC-B a 8.8.8.8:

Ruta del mensaje: PC-B -> Router2 -> Router1 -> Internet.
Tipo de respuesta en el emisor: De manera similar a PC-C, PC-B debería recibir una respuesta siempre que las rutas estén correctamente configuradas y no existan bloqueos.

Es crucial que las tablas de enrutamiento en cada router estén configuradas correctamente para asegurar que todos los tráficos fluyan adecuadamente y se enrutencen hacia los destinos correctos. La configuración de las tablas de enrutamiento que proporcioné anteriormente y cualquier ajuste necesario basado en la nueva información del gráfico deberían ayudar a garantizar la conectividad deseada.

DHCP y NAT

Ejercicio 7

Con la máquina virtual con acceso a Internet realice las siguientes observacionesrespecto de la autoconfiguración IP vía DHCP:

a. Inicie una captura de tráfico Wireshark utilizando el filtro bootp para visualizar únicamente tráfico de DHCP.

redes@debian:~$ sudo dhclient -r
redes@debian:~$ sudo dhclient -v
Internet Systems Consortium DHCP Client 4.4.1
Copyright 2004-2018 Internet Systems Consortium.
All rights reserved.
For info, please visit https://www.isc.org/software/dhcp/

Listening on LPF/veth4976b9c/36:ad:a6:94:34:78
Sending on   LPF/veth4976b9c/36:ad:a6:94:34:78
Listening on LPF/vethbcd283a/8a:11:86:ee:91:f4
Sending on   LPF/vethbcd283a/8a:11:86:ee:91:f4
Listening on LPF/veth399a010/56:5f:67:57:11:a0
Sending on   LPF/veth399a010/56:5f:67:57:11:a0
Listening on LPF/veth5d6224c/92:17:59:53:d1:6b
Sending on   LPF/veth5d6224c/92:17:59:53:d1:6b
Listening on LPF/docker0/02:42:a7:c8:88:ce
Sending on   LPF/docker0/02:42:a7:c8:88:ce
Listening on LPF/br-c8ee5a5c812e/02:42:e3:95:9b:6c
Sending on   LPF/br-c8ee5a5c812e/02:42:e3:95:9b:6c
Listening on LPF/enp0s3/08:00:27:4e:7c:74
Sending on   LPF/enp0s3/08:00:27:4e:7c:74
Sending on   Socket/fallback
DHCPDISCOVER on veth4976b9c to 255.255.255.255 port 67 interval 4
DHCPDISCOVER on vethbcd283a to 255.255.255.255 port 67 interval 6
DHCPDISCOVER on veth399a010 to 255.255.255.255 port 67 interval 8
DHCPDISCOVER on veth5d6224c to 255.255.255.255 port 67 interval 4
DHCPDISCOVER on docker0 to 255.255.255.255 port 67 interval 4
DHCPDISCOVER on br-c8ee5a5c812e to 255.255.255.255 port 67 interval 5
DHCPDISCOVER on enp0s3 to 255.255.255.255 port 67 interval 4
DHCPOFFER of 10.0.2.15 from 10.0.2.2
DHCPREQUEST for 10.0.2.15 on enp0s3 to 255.255.255.255 port 67
DHCPACK of 10.0.2.15 from 10.0.2.2
RTNETLINK answers: File exists
bound to 10.0.2.15 -- renewal in 40680 seconds.

b. En una terminal de root, ejecute el comando | ESTE NO ME FUNCIONA

$ sudo /sbin/dhclient eth0

y analice el intercambio de paquetes capturado

c. Analice la información registrada en el archivo /var/lib/dhcp/dhclient.leases, ¿cuál parece su función?

redes@debian:~$ cat /var/lib/dhcp/dhclient.leases
lease {
  interface "enp0s3";
  fixed-address 10.0.2.15;
  filename "Redes y Comunicaciones v22.2.pxe";
  option subnet-mask 255.255.255.0;
  option routers 10.0.2.2;
  option dhcp-lease-time 86400;
  option dhcp-message-type 5;
  option domain-name-servers 186.130.128.250,186.130.129.250;
  option dhcp-server-identifier 10.0.2.2;
  renew 1 2024/06/24 07:27:38;
  rebind 1 2024/06/24 17:09:38;
  expire 1 2024/06/24 20:09:38;
}

El archivo /var/lib/dhcp/dhclient.leases almacena los detalles de las concesiones (leases) de DHCP que ha recibido el cliente DHCP del sistema para sus interfaces de red. Cada concesión en este archivo representa un conjunto de parámetros de configuración de red asignados por un servidor DHCP. La función principal de este archivo es permitir que el cliente DHCP mantenga un registro de las concesiones activas y pasadas, y gestione la renovación, la nueva vinculación y la expiración de estas concesiones. Vamos a analizar la información mostrada en el archivo:

Estructura de una Concesión DHCP

Interface:
- Indica la interfaz de red ("enp0s3") para la cual se obtuvo la concesión DHCP.
Fixed-address:
- fixed-address 10.0.2.15 especifica la dirección IP que el servidor DHCP ha asignado a la interfaz.
Filename:
- El archivo "Redes y Comunicaciones v22.2.pxe" podría ser un archivo de configuración o un archivo de arranque que el servidor DHCP proporciona para procesos de arranque en red, como PXE (Preboot eXecution Environment).
Options:
- Subnet Mask: 255.255.255.0 define la máscara de subred para la red de la IP asignada.
- Routers: 10.0.2.2 es la dirección del router o gateway predeterminado para salir a otras redes.
- DHCP Lease Time: 86400 segundos (24 horas) es el tiempo de validez de la concesión antes de que deba renovarse.
- DHCP Message Type: 5 indica que este mensaje es una confirmación (ACK) de la concesión.
- Domain Name Servers: Lista los servidores DNS (186.130.128.250, 186.130.129.250) proporcionados para la resolución de nombres de dominio.
Timing:
- Renew: 1 2024/06/24 07:27:38 indica cuándo el cliente intentará renovar esta concesión (antes de que expire).
- Rebind: 1 2024/06/24 17:09:38 indica cuándo el cliente intentará contactar cualquier servidor DHCP para renovar la concesión si no ha conseguido renovarla con el servidor original.
- Expire: 1 2024/06/24 20:09:38 indica cuándo la concesión expirará y la dirección IP deberá ser liberada si no se ha renovado.

Función del Archivo

El archivo dhclient.leases sirve para:

Mantener la Configuración de Red: Asegura que el cliente puede mantener su configuración de red entre reinicios o cuando el servidor DHCP no está disponible temporalmente.
Renovación Automática: Facilita la automatización del proceso de renovación de la IP para mantener la conectividad de red sin intervención manual.
Registro de Actividad: Proporciona un registro histórico de las asignaciones de IP y configuraciones de red recibidas y utilizadas por el cliente.

Este archivo es crucial para la gestión dinámica de la configuración de red en entornos donde las direcciones IP y otros parámetros de red pueden cambiar con frecuencia.

d. Ejecute el siguiente comando para eliminar información temporal asignada por el servidor DHCP.

$ rm /var/lib/dhcp/dhclient.leases

El comando rm /var/lib/dhcp/dhclient.leases se utiliza para eliminar el archivo dhclient.leases, que contiene las asignaciones de arrendamiento DHCP actuales y pasadas obtenidas por el cliente DHCP en el sistema. Este archivo almacena detalles críticos como la dirección IP asignada, la máscara de subred, la puerta de enlace predeterminada, los servidores DNS, y los tiempos de renovación y expiración del arrendamiento.

Función del comando:

Eliminar información de arrendamiento: Al eliminar este archivo, se borra toda la información sobre los arrendamientos DHCP anteriores y actuales. Esto significa que el cliente DHCP no tiene registro de las asignaciones anteriores.
Reinicio de configuración DHCP: La eliminación de este archivo puede ser útil si se están experimentando problemas con la configuración de red actual que se sospecha son causados por un arrendamiento DHCP corrupto o inadecuado. Al borrar este archivo y reiniciar el servicio de red o reiniciar el cliente DHCP, se fuerza al cliente a solicitar un nuevo arrendamiento, posiblemente resolviendo problemas de configuración.
Renovación de configuración de red: Es especialmente útil en escenarios donde la dirección IP o la configuración del servidor DHCP han cambiado. Al eliminar el archivo y reiniciar el servicio DHCP, se garantiza que el cliente solicite y reciba la configuración más actualizada basada en el estado actual del servidor DHCP.

Consideraciones:

Riesgo de Conectividad: Eliminar este archivo mientras el sistema está en uso podría resultar en una pérdida temporal de conectividad de red hasta que el cliente DHCP adquiera un nuevo arrendamiento.
Necesidad de reinicio: Después de eliminar el archivo, es recomendable reiniciar el servicio de red o el cliente DHCP para que inmediatamente intente obtener un nuevo arrendamiento DHCP.
Permisos: Este comando debe ejecutarse con privilegios de superusuario (sudo), ya que los archivos en /var/lib/dhcp/ generalmente están protegidos y solo accesibles para el usuario root.

Este procedimiento es una forma común de diagnosticar y resolver problemas de red relacionados con configuraciones DHCP obsoletas o incorrectas.

e. En una terminal de root, vuelva a ejecutar el comando $ sudo /sbin/dhclient eth0 y analice el intercambio de paquetes capturado nuevamente ¿a que se debió la diferencia con lo observado en el punto “b”?

Cuando se ejecuta el comando sudo /sbin/dhclient eth0 después de haber eliminado el archivo de arrendamientos DHCP, el cliente DHCP comienza un nuevo proceso para obtener un arrendamiento de dirección IP desde el servidor DHCP. Dado que se ha eliminado el archivo de arrendamientos, el cliente actúa como si fuera la primera vez que solicita una dirección IP, sin ningún conocimiento de arrendamientos anteriores.

Análisis del intercambio de paquetes capturado:

DHCPDISCOVER: El cliente envía un mensaje DHCPDISCOVER en el que busca servidores DHCP disponibles en la red.
DHCPOFFER: Los servidores DHCP que reciben el DHCPDISCOVER responden con un DHCPOFFER, ofreciendo una dirección IP al cliente.
DHCPREQUEST: El cliente responde al servidor DHCP con un DHCPREQUEST, solicitando la dirección IP que se le ofreció.
DHCPACK: El servidor finaliza el proceso enviando un DHCPACK al cliente, confirmando que la dirección IP ha sido asignada al cliente.

La diferencia principal en este proceso, en comparación con el observado antes de eliminar el archivo dhclient.leases, es que todo el proceso de negociación DHCP se realiza desde cero, sin ningún contexto o estado anterior que pudiera influir en el proceso de asignación de IP.

f. Tanto en “b” como en “e”, ¿qué información es brindada al host que realiza la petición DHCP, además de la dirección IP que tiene que utilizar?

En ambas situaciones, es decir, en los intercambios iniciales y después de reiniciar el proceso DHCP, la información proporcionada al host incluye:

Dirección IP: La dirección IP que el host debe usar.
Máscara de subred: La máscara de red asociada a la dirección IP asignada.
Puerta de enlace predeterminada (routers): La dirección IP del router o gateway a través del cual el host puede alcanzar otras redes, incluida Internet.
Servidores DNS: Direcciones IP de los servidores de nombres de dominio (DNS) que el host debe usar para la resolución de nombres de dominio.
Tiempo de arrendamiento: La duración del arrendamiento de la dirección IP; después de este período, el cliente debe renovar el arrendamiento.
Otras opciones: Dependiendo de la configuración del servidor DHCP, pueden incluirse opciones adicionales como el servidor de tiempo (NTP), el servidor WINS, el nombre de dominio, entre otros.

Este conjunto de información permite al host configurarse adecuadamente para la comunicación en la red y asegurar la conectividad y la resolución de nombres necesarias para operar eficazmente dentro de la red y en Internet.

Ejercicio 8

¿Qué es NAT y para qué sirve? De un ejemplo de su uso y analice cómo funcionaría en ese entorno.

Ayuda: analizar el servicio de Internet hogareño en el cual varios dispositivos usan Internet simultáneamente

¿Qué es NAT?

NAT (Network Address Translation) es una técnica utilizada para remapear una dirección IP en una red interna a una dirección IP diferente en una red externa. El propósito principal de NAT es permitir que múltiples dispositivos en una red privada accedan a internet o a otra red utilizando una única dirección IP pública.

¿Para qué sirve NAT?

NAT sirve principalmente para dos propósitos:

Conservación de direcciones IP: Debido a la escasez de direcciones IPv4, NAT permite que múltiples dispositivos compartan una única dirección IP pública, lo que reduce la necesidad de direcciones IP únicas para cada dispositivo en la red.
Seguridad: Al ocultar las direcciones IP internas de una red y permitiendo solo conexiones iniciadas internamente, NAT proporciona una capa de seguridad que protege a los dispositivos dentro de una red privada de accesos directos desde internet.

Ejemplo de uso de NAT

Un ejemplo común del uso de NAT es en un servicio de Internet hogareño. Consideremos un hogar donde varios dispositivos, como smartphones, tablets, y computadoras, necesitan acceder a internet simultáneamente. La mayoría de los hogares solo tienen una dirección IP pública asignada por su proveedor de servicios de Internet (ISP).

Configuración

Router: Tiene una interfaz conectada a internet con una dirección IP pública (ej. 203.0.113.1) y otra interfaz que maneja la red local con una dirección privada (ej. 192.168.1.1).
Dispositivos:
- PC: 192.168.1.100
- Smartphone: 192.168.1.101
- Tablet: 192.168.1.102

Funcionamiento de NAT en este entorno

Inicio de una conexión:
- Supongamos que la PC desea acceder a un sitio web. Envía un paquete IP donde la dirección de origen es 192.168.1.100 y la dirección de destino es la del servidor web.
Traducción en el router:
- Cuando el paquete llega al router, NAT traduce la dirección IP origen interna (192.168.1.100) a la dirección IP pública del router (203.0.113.1). Además, el router cambia el número de puerto origen a un número único para mantener el seguimiento de la sesión (por ejemplo, de puerto 12345 a puerto 40001).
Envío a internet:
- El paquete modificado, con la dirección origen como 203.0.113.1:40001, es enviado a internet hacia el servidor web.
Respuesta del servidor web:
- El servidor web responde al paquete enviando la respuesta a la dirección IP pública del router (203.0.113.1) al puerto 40001.
Reversión de la traducción en el router:
- Cuando el router recibe la respuesta, consulta la tabla NAT para determinar a qué dirección IP y puerto internos debe dirigir la respuesta. Reconoce que el puerto 40001 corresponde al dispositivo con IP 192.168.1.100.
Envío al dispositivo interno:
- El router envía la respuesta al dispositivo original (PC) en la dirección 192.168.1.100, restableciendo los parámetros originales del paquete.

Este proceso permite que múltiples dispositivos utilicen simultáneamente la misma dirección IP pública sin conflictos, cada uno manteniendo sus propias sesiones únicas con servidores en internet, gracias a la traducción de direcciones y puertos realizada por NAT.

Ejercicio 9

¿Qué especifica la RFC 1918 y cómo se relaciona con NAT?

RFC 1918: Address Allocation for Private Internets

La RFC 1918, titulada "Address Allocation for Private Internets", es un documento de la Internet Engineering Task Force (IETF) que especifica rangos de direcciones IP que están designados para uso privado dentro de redes corporativas, hogares y organizaciones, sin que estas direcciones sean enrutable en la internet pública global. Esta especificación fue publicada en febrero de 1996 para abordar y aliviar la escasez de direcciones IPv4, permitiendo a múltiples entidades usar la misma dirección IP sin conflicto en redes separadas.

Rangos de Direcciones en RFC 1918

La RFC 1918 define los siguientes rangos de direcciones IP que pueden ser utilizados en redes privadas:

10.0.0.0 - 10.255.255.255 (10/8 prefix)
- Este rango permite casi 16.7 millones de direcciones IP y es comúnmente utilizado en redes de gran escala.
172.16.0.0 - 172.31.255.255 (172.16/12 prefix)
- Este rango ofrece 1,048,576 direcciones IP, adecuado para uso en redes de tamaño medio a grande.
192.168.0.0 - 192.168.255.255 (192.168/16 prefix)
- Con 65,536 direcciones disponibles, este rango es el más utilizado en redes domésticas y pequeñas oficinas.

Relación de la RFC 1918 con NAT

La relación entre la RFC 1918 y NAT (Network Address Translation) es intrínseca y vital por varias razones:

Uso Compartido de Direcciones Públicas:
- Dado que las direcciones definidas en la RFC 1918 no son enrutables en Internet, NAT es necesario para permitir que dispositivos con estas direcciones privadas accedan a recursos en Internet. NAT traduce estas direcciones privadas a direcciones IP públicas válidas durante la comunicación a través de Internet, y viceversa.
Conservación de Direcciones IP:
- NAT, junto con los rangos de la RFC 1918, permite que múltiples dispositivos compartan una única dirección IP pública. Esto es críticamente importante dada la limitación de direcciones IPv4 disponibles globalmente.
Seguridad y Aislamiento:
- Las direcciones de la RFC 1918 son inherentemente más seguras desde el punto de vista de que no son accesibles directamente desde Internet. NAT proporciona un nivel adicional de seguridad al no exponer las direcciones IP internas al mundo exterior, actuando como un componente de una configuración de firewall.
Flexibilidad en la Administración de Redes:
- Organizaciones y hogares pueden usar internamente cualquier estructura de direccionamiento IP de la RFC 1918 que deseen sin preocuparse por conflictos de direcciones con otras redes en Internet. Esto facilita la gestión de redes locales y la planificación de la expansión sin tener que solicitar más direcciones IP públicas.

Uso Práctico

En la práctica, casi cualquier red que accede a Internet usa NAT en combinación con direcciones IP de la RFC 1918 para optimizar el uso de las direcciones IP públicas disponibles, mantener la seguridad de la red y simplificar la administración de la red interna. Esto se implementa típicamente en routers residenciales, firewalls empresariales y en muchos otros dispositivos de red.

En resumen, la RFC 1918 y NAT son fundamentales para el funcionamiento eficiente y seguro de redes privadas en el contexto de una infraestructura global de Internet limitada en términos de direcciones IP disponibles.

Ejercicio 10

En la red de su casa o trabajo verifique la dirección IP de su computadora y luego acceda a www.cualesmiip.com. ¿Qué observa? ¿Puede explicar qué sucede?

Cuando verificas la dirección IP de tu computadora en la red de tu casa o trabajo, y luego comparas esa dirección con la que ves en un sitio como www.cualesmiip.com, es probable que observes dos direcciones IP diferentes. Aquí explicaré por qué sucede esto y qué significa:

Verificación de la Dirección IP Local

En Windows:
- Puedes abrir el Símbolo del sistema (CMD) y escribir ipconfig. Esto mostrará la configuración de IP de todas las interfaces de red de tu computadora. La dirección IP que ves bajo "IPv4 Address" para tu conexión activa (por ejemplo, Ethernet o Wi-Fi) es la dirección IP privada asignada a tu computadora dentro de tu red local.
En macOS:
- Abre Terminal y escribe ifconfig. Busca la interfaz activa (como en0 o en1 para Wi-Fi o Ethernet) y mira la entrada inet, que te dará la dirección IP privada de tu dispositivo.

Comparación con www.cualesmiip.com

Cuando visitas www.cualesmiip.com, el sitio muestra la dirección IP pública desde la cual tu tráfico de Internet parece estar originándose. Esta dirección es diferente de la dirección IP privada de tu computadora porque lo que estás viendo es la dirección IP que tu proveedor de Internet (ISP) asigna a tu conexión a Internet.

¿Por Qué Son Diferentes?

NAT (Network Address Translation):
- En la mayoría de los hogares y pequeñas empresas, múltiples dispositivos (como tu computadora, teléfono y tablet) se conectan a Internet a través de un router que usa NAT.
- NAT permite que todos los dispositivos en tu red local compartan una única dirección IP pública para acceder a Internet, mientras que cada dispositivo tiene su propia dirección IP privada dentro de la red local.
- Cuando accedes a un sitio como www.cualesmiip.com, el sitio no ve la dirección IP privada de tu computadora; en cambio, ve la dirección IP pública que tu ISP ha asignado a tu router.

Ejemplo Práctico

Supongamos que la dirección IP local de tu computadora es 192.168.1.10 y la dirección IP pública mostrada en www.cualesmiip.com es 203.0.113.45. Aquí está lo que sucede:

Dentro de tu red: Tu computadora usa 192.168.1.10 para comunicarse con otros dispositivos dentro de tu hogar o empresa, incluido tu router.
En Internet: Tu router usa la dirección IP pública 203.0.113.45 para comunicarse con todos los sitios web y servicios en línea. Así que, cuando tu computadora envía una solicitud a Internet, el router traduce tu dirección IP privada a la dirección IP pública usando NAT, y esa es la dirección que ven los sitios web.

Conclusión

Este proceso ilustra cómo NAT facilita una gestión eficiente de las direcciones IP, permitiendo que múltiples dispositivos compartan una única dirección IP pública. Además, NAT ayuda a proteger tus dispositivos al ocultar las direcciones IP privadas de la exposición directa a Internet. Esto es especialmente importante en el contexto actual donde las direcciones IPv4 son limitadas y la seguridad de la red es crucial.

Ejercicio 11

Resuelva las consignas que se dan a continuación.

a. En base a la siguiente topología y a las tablas que se muestran, complete los datos que faltan.

PC-A (ss)
Local Address:Port Peer Address:Port
192.168.1.2:49273 _________________
_________________ 190.50.10.63:25
192.168.1.2:_____ 190.50.10.81:8080

PC-B (ss)
Local Address:Port Peer Address:Port
192.168.1.3:52734 _________________
192.168.1.3:39275 _________________

SRV-A (ss)
Local Address:Port Peer Address:Port
190.50.10.63:80 205.20.0.29:25192
190.50.10.63:25 205.20.0.29:41823

SRV-B (ss)
Local Address:Port Peer Address:Port
190.50.10.81:8080 205.20.0.29:16345
190.50.10.81:8081 205.20.0.29:51091
190.50.10.81:8080 205.20.0.29:9123

RTR-1 (Tabla de NAT)
Lado LAN Lado WAN
192.168.1.2:49273 205.20.0.29:25192
192.168.1.2:51238 _________________
192.168.1.3:52734 205.20.0.29:51091
192.168.1.2:37484 205.20.0.29:41823
192.168.1.3:39275 205.20.0.29:9123

PC-A

Primera fila: Sabemos que el puerto local 49273 está siendo traducido a 25192 en el WAN. Buscamos una conexión que coincida con el puerto 25192 en el servidor.
- Desde SRV-A:
  - 190.50.10.63:80 205.20.0.29:25192 corresponde a la dirección de destino para 49273. Entonces, completamos:
```
192.168.1.2:49273 190.50.10.63:80
```
- La segunda fila está relacionada con una conexión hacia 190.50.10.63:25. Buscamos la entrada de NAT que muestra un puerto WAN que se conecta a este servicio.
  - 190.50.10.63:25 205.20.0.29:41823 indica que el puerto 37484 en PC-A está conectado a este puerto.
```
192.168.1.2:37484 190.50.10.63:25
```
- La tercera fila muestra una conexión a 190.50.10.81:8080. Sabemos por la tabla de SRV-B que existen tres conexiones WAN posibles. Debemos encontrar el puerto LAN correspondiente en PC-A que aún no se ha listado:
  - 192.168.1.2:51238 aún no está asignado y no hay otros detalles que nos ayuden a determinar la conexión exacta, así que se queda como desconocido por ahora.
```
192.168.1.2:51238 190.50.10.81:8080
```

PC-B

Ambas filas necesitan la dirección de destino:
- La conexión 192.168.1.3:52734 tiene su traducción WAN en 205.20.0.29:51091, que se conecta a 190.50.10.81:8081 en SRV-B.
```
192.168.1.3:52734 190.50.10.81:8081
```
- La conexión 192.168.1.3:39275 se traduce a 205.20.0.29:9123, que se conecta a 190.50.10.81:8080 en SRV-B.
```
192.168.1.3:39275 190.50.10.81:8080
```

RTR-1 (Tabla de NAT)

Para la entrada faltante de 192.168.1.2:51238, se necesita el puerto WAN correspondiente que aún no hemos determinado con precisión. Puede ser un puerto como 205.20.0.29:16345 que se muestra conectando a 190.50.10.81:8080 en SRV-B, haciendo una suposición lógica:

192.168.1.2:51238 205.20.0.29:16345

Estas son las inferencias basadas en la información disponible. Cualquier suposición incorrecta se debe a la falta de información explícita en las tablas proporcionadas.

PC-A (ss)
Local Address:Port Peer Address:Port
192.168.1.2:49273 190.50.10.63:80
192.168.1.2:37484 190.50.10.63:25
192.168.1.2:51238  190.50.10.81:8080

PC-B (ss)
Local Address:Port Peer Address:Port
192.168.1.3:52734 190.50.10.81:8081
192.168.1.3:39275 190.50.10.81:8080

SRV-A (ss)
Local Address:Port Peer Address:Port
190.50.10.63:80 205.20.0.29:25192
190.50.10.63:25 205.20.0.29:41823

SRV-B (ss)
Local Address:Port Peer Address:Port
190.50.10.81:8080 205.20.0.29:16345
190.50.10.81:8081 205.20.0.29:51091
190.50.10.81:8080 205.20.0.29:9123

RTR-1 (Tabla de NAT)
Lado LAN Lado WAN
192.168.1.2:49273 205.20.0.29:25192
192.168.1.2:51238 205.20.0.29:16345
192.168.1.3:52734 205.20.0.29:51091
192.168.1.2:37484 205.20.0.29:41823
192.168.1.3:39275 205.20.0.29:9123

b. En base a lo anterior, responda:

i. ¿Cuántas conexiones establecidas hay y entre qué dispositivos?

Para analizar cuántas conexiones establecidas hay y entre qué dispositivos, revisamos la información de las conexiones activas (ss) en los dispositivos PC-A, PC-B, y los servidores SRV-A y SRV-B, así como la tabla de NAT en el router RTR-1.

Paso a Paso del Análisis de Conexiones

Examinar conexiones en PC-A:
- Conexión 1: 192.168.1.2:49273 conecta con 190.50.10.63:80 - Esta es una conexión de PC-A hacia SRV-A usando HTTP.
- Conexión 2: 192.168.1.2:37484 conecta con 190.50.10.63:25 - Esta es una conexión de PC-A hacia SRV-A usando SMTP para enviar correo.
- Conexión 3: 192.168.1.2:(algún puerto) conecta con 190.50.10.81:8080 - Esta es una conexión de PC-A hacia SRV-B usando HTTP en un puerto no especificado localmente.
Examinar conexiones en PC-B:
- Conexión 4: 192.168.1.3:52734 conecta con un destino no especificado.
- Conexión 5: 192.168.1.3:39275 conecta con un destino no especificado.
Dado que los destinos específicos no se mencionan, necesitamos confirmar qué servicios están siendo utilizados revisando las conexiones entrantes en los servidores y la correspondencia en la tabla NAT.
Revisar conexiones en SRV-A (ss):
- Recibe Conexión 1 de 205.20.0.29:25192 que corresponde a la traducción NAT de PC-A 192.168.1.2:49273.
- Recibe Conexión 2 de 205.20.0.29:41823 que corresponde a la traducción NAT de PC-A 192.168.1.2:37484.
Revisar conexiones en SRV-B (ss):
- Recibe Conexión 3 desde 205.20.0.29:16345 que debe ser la traducción NAT de PC-A en un puerto no especificado.
- Recibe Conexión 4 desde 205.20.0.29:51091 que corresponde a la traducción NAT de PC-B 192.168.1.3:52734.
- Recibe Conexión 5 desde 205.20.0.29:9123 que corresponde a la traducción NAT de PC-B 192.168.1.3:39275.
Tabla de NAT en RTR-1:
- Confirma que las conexiones de PC-A y PC-B se están traduciendo correctamente a través del router usando direcciones externas.

Resumen de Conexiones Establecidas:

En total, hay cinco conexiones establecidas:

Tres conexiones desde PC-A a SRV-A y SRV-B: Dos hacia SRV-A (HTTP y SMTP) y una hacia SRV-B (HTTP).
Dos conexiones desde PC-B a SRV-B: Ambas conexiones son HTTP a diferentes servicios.

Estas conexiones reflejan las interacciones entre las computadoras personales y los servidores en diferentes puertos, facilitadas por el router RTR-1 a través de la traducción de direcciones de red (NAT).

ii. ¿Quién inició cada una de las conexiones? ¿Podrían haberse iniciado en sentido inverso? ¿Por qué? Investigue qué es port forwarding y si serviría como solución en este caso.

¿Quién inició cada una de las conexiones?

Las conexiones en redes TCP/IP generalmente se inician por el dispositivo que envía el primer paquete de sincronización (SYN) para establecer la conexión. Basándonos en los registros de la tabla de NAT y las capturas de las sesiones (ss), podemos determinar quién inició cada conexión:

Conexiones desde PC-A hacia SRV-A y SRV-B:
- PC-A inició todas las conexiones hacia los servidores (SRV-A y SRV-B), como se evidencia por las direcciones IP y los puertos locales en la tabla de NAT y las conexiones ss.
Conexiones desde PC-B hacia SRV-B:
- PC-B inició las conexiones hacia SRV-B, lo cual se refleja en la tabla de NAT donde PC-B usa puertos locales para conectarse a servicios en SRV-B.

¿Podrían haberse iniciado las conexiones en sentido inverso?

En general, los servidores están configurados para escuchar en puertos específicos y esperar conexiones de los clientes. Los clientes (como PC-A y PC-B) son quienes típicamente inician las conexiones hacia estos puertos conocidos en los servidores (por ejemplo, HTTP en el puerto 80 o SMTP en el puerto 25).

Servidores hacia PCs: Los servidores no suelen iniciar conexiones hacia las PC en una red, excepto en situaciones específicas como respuestas a solicitudes de los clientes o en arquitecturas push donde el servidor debe iniciar la comunicación (poco común en los contextos mencionados).

¿Qué es port forwarding y cómo podría aplicarse?

Port forwarding (reenvío de puertos) es una técnica utilizada en NAT para dirigir la comunicación externa a un puerto específico hacia un dispositivo dentro de la red local. Es especialmente útil en situaciones donde necesitas que servicios dentro de una red privada sean accesibles desde el exterior.

Aplicación de Port Forwarding en este escenario:

Si un servicio en PC-A o PC-B necesita ser accesible desde el exterior, port forwarding podría configurarse en RTR-1 para reenviar las solicitudes entrantes en puertos específicos a las direcciones IP internas correspondientes de PC-A o PC-B.

Viabilidad de iniciar conexiones desde servidores:

Sin port forwarding, no es factible que SRV-A o SRV-B inicien conexiones directamente a las PCs debido a la naturaleza de la NAT, que por defecto solo maneja conexiones iniciadas internamente. Sin embargo, si se configura port forwarding apropiadamente, los servidores externos podrían, en teoría, "iniciar" conexiones a servicios específicos dentro de la red que han sido expuestos explícitamente.

Conclusión:

En este caso, port forwarding serviría para permitir que servicios específicos en PCs sean accesibles desde el exterior, pero no alteraría el hecho de que las conexiones entre PCs y servidores generalmente se inician desde las PCs hacia servidores que están escuchando pasivamente.

Las siguientes eran mejor hacerlas en papel supongo

Ejercicio 12

Ejercicio 13

Ejercicio 14

Ejercicio 15

Practica 9 Redes | IPv6

Tue, 07 May 2024 00:00:00 GMT

Indice

Ejercicio 1
Ejercicio 2
Ejercicio 3
Ejercicio 4
Ejercicio 5
Ejercicio 6
Ejercicio 7
Ejercicio 8
Ejercicio 9
Ejercicio 10
Ejercicio 11

Ejercicio 1

¿Qué es IPv6? ¿Por qué es necesaria su implementación?

IPv6 (Internet Protocol version 6) es la versión más reciente del protocolo de comunicaciones Internet Protocol (IP), diseñado para reemplazar a IPv4, la versión que ha estado en uso desde 1983. IPv6 fue desarrollado por la Internet Engineering Task Force (IETF) para abordar la eventual escasez de direcciones IP disponibles bajo IPv4, así como para mejorar la eficiencia y la seguridad en la transmisión de datos en la red.

Características principales de IPv6:

Espacio de direcciones ampliado: Mientras que IPv4 utiliza direcciones de 32 bits, limitadas a aproximadamente 4.3 mil millones de direcciones únicas, IPv6 utiliza direcciones de 128 bits, lo que permite aproximadamente (3.4 \times 10^{38}) direcciones, un número casi ilimitado, suficiente para asignar direcciones únicas a cada dispositivo en el mundo.
Formato de direccionamiento simplificado: IPv6 tiene un sistema de notación hexadecimal que hace que las direcciones sean más fáciles de interpretar para los humanos y reduce la complejidad de las tablas de enrutamiento en los routers.
Autoconfiguración: Los dispositivos en una red IPv6 pueden configurarse automáticamente cuando se conectan a una red, gracias a la autoconfiguración sin estado y con estado, lo que simplifica la gestión de red.
Mejoras en el enrutamiento y en la gestión de paquetes: IPv6 incluye mejoras en el enrutamiento y en la gestión de paquetes que permiten una mayor eficiencia y un enrutamiento más directo entre los dispositivos de internet.
Seguridad integrada: IPv6 fue diseñado teniendo en cuenta la seguridad. El protocolo IPsec, que proporciona cifrado y autenticación, es un componente mandatorio en IPv6, a diferencia de IPv4, donde es opcional.

¿Por qué es necesaria su implementación?

La implementación de IPv6 es necesaria por varias razones clave:

Escasez de direcciones IPv4: El número de dispositivos en Internet ha crecido exponencialmente, y las direcciones IPv4 están prácticamente agotadas. IPv6, con su vasto espacio de direcciones, ofrece una solución a largo plazo a este problema.
Crecimiento de Internet de las Cosas (IoT): Con el aumento de dispositivos IoT, cada uno requiere una dirección IP. IPv6 hace posible que cada dispositivo tenga su propia dirección única, facilitando así su gestión y conectividad.
Necesidad de una conectividad más eficiente: IPv6 reduce la necesidad de técnicas como NAT (Network Address Translation), lo que permite una comunicación end-to-end más transparente y eficiente.
Soporte a nuevos servicios y experiencias de usuario: Con capacidades como la autoconfiguración y la mejor seguridad, IPv6 puede soportar mejor los servicios de próxima generación y mejorar la experiencia del usuario en aplicaciones críticas y en nuevos desarrollos tecnológicos.

En conclusión, la implementación de IPv6 es fundamental para el futuro de una Internet en expansión y cada vez más conectada, asegurando la conectividad global y la continua innovación en tecnologías de red.

Ejercicio 2

¿Por qué no es necesario el campo “Header Length” en IPv6?

El campo "Header Length" no es necesario en IPv6 debido a las siguientes razones principales:

Tamaño Fijo del Encabezado: A diferencia de IPv4, donde el encabezado tiene una longitud variable debido a las opciones que pueden o no estar presentes, IPv6 tiene un encabezado de tamaño fijo de 40 bytes. Este diseño simplificado elimina la necesidad de un campo específico que indique la longitud del encabezado, ya que siempre es constante.
Simplificación del Procesamiento: Al tener un tamaño de encabezado fijo, los dispositivos de red pueden procesar los paquetes de manera más eficiente. Esta uniformidad reduce la complejidad del procesamiento de paquetes en los routers y otros dispositivos de red, facilitando operaciones más rápidas y eficientes.
Extension Headers: En lugar de integrar todas las opciones directamente en el encabezado principal como en IPv4, IPv6 utiliza encabezados de extensión que se colocan entre el encabezado base y la carga útil. Cada encabezado de extensión tiene su propio campo de longitud, por lo que el tratamiento de opciones adicionales es modular y no afecta la longitud del encabezado base.
Optimización del Rendimiento: Al eliminar la variabilidad en la longitud del encabezado y al no requerir el procesamiento de un campo de longitud del encabezado, IPv6 puede mejorar el rendimiento en el procesamiento de paquetes, lo que es crítico para manejar el volumen y la velocidad del tráfico moderno de Internet.

En resumen, la eliminación del campo "Header Length" en IPv6 es un reflejo del diseño optimizado del protocolo, que busca eficiencia, velocidad en el procesamiento de paquetes y una mayor facilidad en la configuración y gestión de la red.

Ejercicio 3

¿En qué se diferencia el checksum de IPv4 e IPv6? Y en cuánto a los campos checksum de TCP y UDP, ¿sufren alguna modificación en cuanto a su obligatoriedad de cálculo?

IPv4 e IPv6 manejan el checksum (suma de verificación) de manera diferente, tanto en el encabezado del propio protocolo IP como en los protocolos de transporte como TCP y UDP. Aquí detallo las diferencias y las modificaciones en los campos de checksum para TCP y UDP cuando se transiciona de IPv4 a IPv6.

Checksum en IPv4:

Encabezado de IPv4: IPv4 incluye un campo de checksum que se utiliza para verificar la integridad del encabezado del paquete IP. Este checksum se recalcula en cada salto (por cada router que procesa el paquete) debido a que el campo TTL (Time to Live) del encabezado cambia, lo que implica una necesidad constante de recalculo del checksum para asegurar que no haya errores en el encabezado.

Checksum en IPv6:

Encabezado de IPv6: A diferencia de IPv4, IPv6 no incluye un campo de checksum en el encabezado. Esta decisión de diseño se tomó por varias razones:
- Reducción de la Carga del Procesador en los Routers: Eliminar el checksum del encabezado de IPv6 reduce la carga de procesamiento en los routers, ya que no necesitan recalcular el checksum en cada salto.
- Fiabilidad de las Capas Inferiores: Las capas de enlace de datos modernas (como Ethernet) ya incorporan sus propios mecanismos de detección de errores, lo que hace menos crítico un checksum en el encabezado de IP.
- Mejora del Rendimiento: Evitar el recalculo del checksum mejora la velocidad de procesamiento de los paquetes en los dispositivos de red.

Checksum de TCP y UDP en IPv4 e IPv6:

TCP y UDP: Tanto en IPv4 como en IPv6, los protocolos TCP y UDP utilizan un campo de checksum para verificar la integridad de toda la sección del paquete que incluye el encabezado y los datos de estos protocolos. Sin embargo, hay diferencias importantes en cómo se calcula este checksum en los dos contextos de protocolo IP.
Obligatoriedad en IPv6:
- En IPv4, el checksum para UDP es opcional; si se establece en cero, significa que no se está utilizando. Sin embargo, en IPv6, el cálculo del checksum es obligatorio tanto para TCP como para UDP. Esta obligatoriedad busca garantizar la integridad de los datos en la transmisión, considerando que no se realiza verificación de integridad en el encabezado de IPv6.
- Pseudo-Encabezado: Tanto en IPv4 como en IPv6, el checksum de TCP y UDP se calcula utilizando un pseudo-encabezado que incluye la dirección IP de origen y destino, el protocolo y la longitud del segmento. En IPv6, este pseudo-encabezado se modifica para incluir las direcciones IPv6 de origen y destino, la longitud del payload y un campo de "Next Header" que especifica el tipo de protocolo encapsulado (TCP o UDP).

Conclusión:

La principal diferencia en el manejo del checksum entre IPv4 e IPv6 es la eliminación del checksum del encabezado en IPv6, que simplifica el procesamiento en routers y mejora el rendimiento de la red. En cuanto a TCP y UDP, la transición a IPv6 hace obligatorio el cálculo del checksum para asegurar la integridad de los datos, reflejando la importancia de la fiabilidad en la entrega de datos en la red moderna.

Ejercicio 4

¿Qué sucede con el campo “Opciones” en IPv6? ¿Existe, en IPv6, alguna forma de enviar información opcional?

En IPv6, el manejo de opciones difiere significativamente en comparación con IPv4, principalmente para mejorar la eficiencia y la flexibilidad del procesamiento de paquetes en los dispositivos de red.

¿Qué sucede con el campo "Opciones" en IPv6?

El campo "Opciones", como existía en IPv4 en el encabezado de protocolo base, no se encuentra en el encabezado fijo de IPv6. En IPv4, este campo podía usarse para funciones adicionales como seguridad, pruebas de ruta, y más, pero podía complicar el procesamiento del encabezado debido a su variabilidad de longitud.

Forma de enviar información opcional en IPv6:

Encabezados de Extensión: IPv6 introduce los "encabezados de extensión" para manejar las opciones que en IPv4 se incluirían directamente en el encabezado del paquete. Estos encabezados de extensión son opcionales y se colocan entre el encabezado base de IPv6 y la carga útil del paquete. Esto permite que el encabezado base tenga una estructura fija y simple, facilitando el procesamiento rápido por parte de los routers.
Tipos de Encabezados de Extensión: Existen varios tipos de encabezados de extensión, cada uno diseñado para un propósito específico, como el manejo de rutas (Routing Header), la fragmentación (Fragment Header), opciones de seguridad (Hop-by-Hop Options Header), entre otros. Estos encabezados permiten la flexibilidad de enviar información adicional sin sobrecargar todos los paquetes con detalles innecesarios que solo algunos necesitan.
Procesamiento Eficiente: Los encabezados de extensión están diseñados para ser procesados solo por los nodos que necesitan interpretarlos. Por ejemplo, un encabezado de extensión de "Hop-by-Hop Options" debe ser procesado por cada router en la ruta del paquete, mientras que otros encabezados podrían ser inspeccionados solo por el destinatario final o por nodos específicos en la ruta.
Simplificación de la Cabecera Principal: Al trasladar las opciones a encabezados de extensión, IPv6 simplifica su cabecera principal. Esto agiliza el procesamiento en los routers, ya que no tienen que lidiar con la variabilidad de la longitud del encabezado principal durante el enrutamiento básico.

En resumen, IPv6 maneja las opciones de manera más modular y eficiente a través de los encabezados de extensión. Esta metodología permite una mayor flexibilidad y un procesamiento más rápido en comparación con IPv4, adecuándose mejor a las necesidades actuales y futuras de las redes globales de datos.

Ejercicio 5

Si quisiese que IPv6 soporte una nueva funcionalidad, ¿cómo lo haría?

Introducir una nueva funcionalidad en IPv6 generalmente implica el desarrollo y la implementación de un nuevo encabezado de extensión o la modificación de uno existente. Este proceso es parte del continuo esfuerzo de estandarización que realiza la comunidad de ingeniería de Internet, liderada por organizaciones como la IETF (Internet Engineering Task Force). Aquí te explico paso a paso cómo se podría agregar una nueva funcionalidad a IPv6:

Paso 1: Identificación de la Necesidad

Análisis de Requerimientos: Determinar qué necesidad específica debe ser cubierta por la nueva funcionalidad. Esto puede surgir de limitaciones tecnológicas actuales, nuevas aplicaciones de red, o requisitos de seguridad mejorados.
Evaluación Preliminar: Considerar si la funcionalidad puede ser implementada mediante los encabezados de extensión existentes o si es necesario desarrollar un nuevo tipo de encabezado.

Paso 2: Propuesta de Diseño

Diseño del Encabezado de Extensión: Si se necesita un nuevo encabezado de extensión, diseñar su estructura detallada. Esto incluye definir el formato del encabezado, los tipos de campos involucrados, y la lógica para su procesamiento.
Documentación: Redactar un borrador de propuesta detallada que describa la funcionalidad, el diseño del encabezado, casos de uso, y beneficios esperados. Este documento debería seguir las directrices de la IETF para las propuestas de nuevos estándares.

Paso 3: Revisión y Estándarización

Presentación a la IETF: Someter la propuesta al grupo de trabajo relevante dentro de la IETF, como el grupo de trabajo de IPv6 (IPv6 WG) o cualquier otro pertinente.
Revisión Comunitaria y Retroalimentación: La propuesta será revisada por expertos y otros miembros de la comunidad. Este proceso puede incluir discusiones en línea, presentaciones en reuniones de la IETF, y la solicitud de comentarios públicos (RFC).
Iteraciones de Diseño: Basándose en la retroalimentación, realizar modificaciones necesarias al diseño del encabezado de extensión. Este es un proceso iterativo que puede requerir varias rondas de revisión.

Paso 4: Aprobación y Implementación

Aprobación del Estándar: Una vez que la propuesta ha sido suficientemente revisada y mejorada, se busca la aprobación final de la IETF para que se convierta en un estándar.
Desarrollo de Software: Desarrolladores de sistemas operativos y fabricantes de dispositivos implementan el nuevo encabezado de extensión en sus productos. Esto incluye actualizaciones de firmware para routers y actualizaciones de software para sistemas operativos que soportan IPv6.
Despliegue y Monitoreo: Una vez implementada, la nueva funcionalidad comienza a desplegarse en redes operativas. Se realiza un seguimiento de su desempeño y se recolectan datos para asegurar que funciona como se esperaba sin introducir nuevos problemas en la red.

Agregar una nueva funcionalidad a IPv6 es un proceso que requiere un esfuerzo colaborativo a nivel internacional y un riguroso proceso de revisión para asegurar que las modificaciones beneficien a la infraestructura global de Internet sin comprometer su estabilidad o seguridad.

Ejercicio 6

¿Es necesario el protocolo ICMP en IPv6? ¿Cumple las mismas funciones que en IPv4?

Sí, el protocolo ICMP (Internet Control Message Protocol) es necesario en IPv6, y se conoce específicamente como ICMPv6 (ICMP versión 6). Aunque cumple muchas de las mismas funciones fundamentales que su predecesor en IPv4, ICMPv6 también incluye funcionalidades adicionales necesarias debido a las diferencias inherentes entre IPv4 e IPv6. Aquí se describen los detalles y funciones clave:

Funciones Comunes con IPv4

Diagnóstico de Red: Al igual que en IPv4, ICMPv6 se utiliza para reportar errores en el procesamiento de paquetes, como mensajes de destino inalcanzable, tiempo excedido (para tratar casos donde un paquete ha pasado demasiado tiempo en tránsito), y problemas de parámetros de paquetes.
Eco de Solicitud/Respuesta: Utilizado para probar la conectividad entre nodos, similar a la función de ping en IPv4.

Funciones Específicas de ICMPv6

Descubrimiento de Vecinos: Uno de los roles más significativos de ICMPv6 es su participación en el proceso de Descubrimiento de Vecinos (NDP, Neighbor Discovery Protocol). Este protocolo reemplaza y expande las funcionalidades de ARP en IPv4, gestionando la resolución de direcciones, detección de nodos alcanzables, y más. Esto incluye:
- Solicitud de Vecino y Anuncio de Vecino: Funciones para determinar la dirección de enlace de un nodo y para verificar su disponibilidad.
- Solicitud de Router y Anuncio de Router: Usados para descubrir y comunicarse con routers en la red local.
Autoconfiguración de Direcciones: ICMPv6 facilita la autoconfiguración sin estado de direcciones IPv6, permitiendo que los dispositivos en la red obtengan automáticamente direcciones IPv6 globales o locales basadas en los anuncios de router.

Mejoras en la Seguridad y Eficiencia

Mejor Integración con Seguridad: ICMPv6 está más estrechamente integrado con IPsec, ofreciendo mejores opciones de seguridad que las disponibles en ICMP para IPv4.
Gestión de Multicast: ICMPv6 maneja la pertenencia a grupos multicast a través de mensajes específicos, lo que es crucial dado el uso extensivo de multicast en IPv6.

Conclusión

Aunque ICMPv6 realiza muchas de las mismas funciones básicas que ICMP para IPv4, también aborda necesidades específicas de IPv6 que surgen de su diseño y requisitos operativos, como la autoconfiguración y el descubrimiento de vecinos, que son esenciales para la funcionalidad de la red. Por lo tanto, ICMPv6 es una pieza integral de IPv6, proporcionando herramientas cruciales para el mantenimiento y la operación de redes IPv6.

Ejercicio 7

El protocolo Neighbor Discovery (ND) es esencial para la operatividad de redes IPv6, y cumple varias funciones críticas que facilitan tanto la comunicación como la gestión de la red. Aquí te detallo sus funciones, y la importancia de su presencia para el funcionamiento adecuado de IPv6, así como el papel de las direcciones link-local.

Funciones del Protocolo Neighbor Discovery (ND):

Descubrimiento de Routers: ND permite a los hosts identificar los routers presentes en un enlace local. Los routers envían mensajes de anuncio de router (Router Advertisement) que informan a los hosts locales de su presencia y de varios parámetros de la red, como la disponibilidad de direcciones IP autoconfigurables.
Determinación de Direcciones: A través del proceso de autoconfiguración sin estado, ND permite a los hosts obtener direcciones IP automáticamente basadas en los anuncios de los routers. Este proceso elimina la necesidad de un servidor DHCP, aunque IPv6 también soporta DHCPv6 para configuraciones más específicas.
Descubrimiento de Vecinos: Similar al ARP en IPv4, pero más seguro y eficiente, ND permite a los hosts descubrir la dirección MAC (link-layer address) de otros hosts en la misma red local utilizando mensajes de solicitud de vecino (Neighbor Solicitation) y mensajes de anuncio de vecino (Neighbor Advertisement).
Detección de Direcciones Duplicadas (DAD): ND verifica si una dirección IP ya está en uso antes de asignarla a un dispositivo, lo que ayuda a prevenir conflictos de direcciones en la red.
Redireccionamiento: Los routers pueden informar a los hosts de un mejor camino hacia un destino más allá del enlace local utilizando mensajes de redirección.

¿Puede funcionar IPv6 sin el Protocolo Neighbor Discovery?

El funcionamiento de IPv6 estaría severamente comprometido sin Neighbor Discovery:

Sin ND, la autoconfiguración de direcciones, la detección de otros dispositivos en la red, y la detección de routers serían inviables, lo que requeriría mecanismos alternativos o manuales para todas estas funciones, reduciendo la eficiencia y aumentando la complejidad de gestión de la red.
DAD y la resolución de direcciones MAC serían también problemáticas, aumentando el riesgo de conflictos de direcciones y problemas de comunicación en la red.

¿Y sin una dirección de tipo link-local?

Las direcciones link-local en IPv6 son fundamentales para el funcionamiento de Neighbor Discovery:

Esenciales para la comunicación inicial en la red: Las direcciones link-local son utilizadas por los dispositivos para comunicarse con otros dispositivos en la misma red local antes de que se establezcan direcciones globales.
Funcionamiento de ND: Muchos aspectos del protocolo Neighbor Discovery, incluyendo el descubrimiento de routers y vecinos, dependen de la disponibilidad de direcciones link-local. Sin estas direcciones, un dispositivo no podría participar en estas actividades esenciales de configuración y mantenimiento de la red.

En resumen, tanto Neighbor Discovery como las direcciones link-local son cruciales para la operación normal de redes IPv6. Eliminar cualquiera de estos componentes resultaría en una red significativamente menos funcional y más difícil de administrar.

Ejercicio 8

¿Cuál de las siguientes direcciones IPv6 no son válidas?

2001:0:1019:afde::1
2001::1871::4
3ffg:8712:0:1:0000:aede:aaaa:1211
3::1
::
2001::
3ffe:1080:1212:56ed:75da:43ff:fe90:affe
3ffe:1080:1212:56ed:75da:43ff:fe90:affe:1001

Para determinar si las direcciones IPv6 proporcionadas son válidas o no, es esencial entender el formato estándar de una dirección IPv6 y las reglas asociadas con su estructura. Una dirección IPv6 estándar se compone de 8 grupos de 4 dígitos hexadecimales, y cada grupo está separado por dos puntos (:). A continuación, analizo cada dirección proporcionada:

1. 2001:0:1019:afde::1

Válida: Esta dirección utiliza la compresión válida de ceros (::), que solo aparece una vez para reemplazar grupos consecutivos de segmentos de cero. La dirección se expande a 2001:0000:1019:afde:0000:0000:0000:0001.

2. 2001::1871::4

No válida: El uso de :: más de una vez en una dirección IPv6 no es permitido porque introduce ambigüedad respecto a la cantidad de grupos de ceros que se están reemplazando.

3. 3ffg:8712:0:1:0000:aede:aaaa:1211

No válida: La presencia de g en el primer grupo (3ffg) es ilegítima porque no es un dígito hexadecimal válido. Los dígitos hexadecimales válidos son 0-9 y a-f.

4. 3::1

Válida: Esta es una forma válidamente comprimida. Se expande a 0003:0000:0000:0000:0000:0000:0000:0001. La compresión :: se usa correctamente para reemplazar múltiples grupos de ceros.

5. ::

Válida: Esta es una dirección especial que representa la dirección no especificada (equivalente a 0.0.0.0 en IPv4). Todos los grupos son ceros, y su uso es perfectamente válido.

6. 2001::

Válida: Representa 2001:0000:0000:0000:0000:0000:0000:0000. Aquí, :: indica que todos los grupos restantes son ceros, lo cual es un uso válido de la compresión.

7. 3ffe:1080:1212:56ed:75da:43ff:fe90:affe

Válida: Esta dirección no utiliza compresión y todos los segmentos son dígitos hexadecimales válidos. Tiene exactamente 8 grupos, que es el formato estándar completo para una dirección IPv6.

8. 3ffe:1080:1212:56ed:75da:43ff:fe90:affe:1001

No válida: Esta dirección tiene 9 grupos, lo cual excede el máximo de 8 grupos permitidos para una dirección IPv6 estándar.

En resumen, las direcciones IPv6 deben seguir reglas estrictas de formato, incluyendo el número de grupos, la validez de los caracteres como dígitos hexadecimales, y el uso adecuado de la compresión ::. Las direcciones 2, 3, y 8 son inválidas según estas reglas.

Ejercicio 9

¿Cuál sería una abreviatura correcta de 3f80:0000:0000:0a00:0000:0000:0000:0845?

3f80::a00::845
3f80::a:845
3f80::a00:0:0:0:845:4567
3f80:0:0:a00::845
3f8:0:0:a00::845

Para abreviar correctamente una dirección IPv6, se debe tener en cuenta que los ceros a la izquierda en cada grupo de cuatro dígitos hexadecimales se pueden omitir y que uno o más grupos de ceros consecutivos se pueden reemplazar por ::. Sin embargo, es importante recordar que :: solo puede usarse una vez en una dirección para evitar ambigüedades.

Dada la dirección completa 3f80:0000:0000:0a00:0000:0000:0000:0845, revisemos cada opción proporcionada para ver si son abreviaciones válidas:

Opción 1: 3f80::a00::845

No válida: Utiliza :: dos veces, lo cual no está permitido porque introduce ambigüedad en la dirección.

Opción 2: 3f80::a:845

No válida: Aunque usa :: una sola vez, la abreviatura da la impresión de que el tercer grupo es 000a y el cuarto grupo es 0845, lo que distorsiona la estructura original de la dirección.

Opción 3: 3f80::a00:0:0:0:845:4567

No válida: Esta opción añade un grupo extra al final (4567) que no existe en la dirección original, lo cual es incorrecto y modifica la dirección de manera significativa.

Opción 4: 3f80:0:0:a00::845

Válida: Esta es una abreviatura correcta. Los ceros iniciales dentro de los grupos han sido omitidos correctamente (0a00 a a00 y 0845 a 845), y :: se utiliza para reemplazar tres grupos de ceros, lo cual es correcto y no introduce ambigüedades.

Opción 5: 3f8:0:0:a00::845

No válida: Este es un error común en la abreviatura de direcciones IPv6. El grupo inicial 3f80 se ha truncado incorrectamente a 3f8, lo cual es incorrecto y altera la dirección.

De las opciones dadas, la Opción 4 (3f80:0:0:a00::845) es la única abreviatura correcta y válida de la dirección IPv6 proporcionada.

Ejercicio 10

Indique si las siguientes direcciones son de link-local, global-address, multicast, etc.

fe80::1/64
3ffe:4543:2:100:4398::1/64
::
::1
ff02::2
2818:edbc:43e1::8721:122
ff02::9

Las direcciones IPv6 se pueden clasificar en varios tipos basados en su prefijo y propósito. Vamos a analizar cada dirección proporcionada para determinar su tipo:

1. fe80::1/64

Tipo: Link-local
Descripción: Las direcciones link-local en IPv6 tienen un prefijo de fe80::/10. Estas direcciones son utilizadas para la comunicación entre nodos en el mismo enlace de red local y no son enrutable fuera de ese enlace.

2. 3ffe:4543:2:100:4398::1/64

Tipo: Global Unicast (deprecada)
Descripción: Esta dirección parece ser una global unicast address. Sin embargo, el prefijo 3ffe::/16 fue utilizado históricamente para direcciones de prueba durante la fase de despliegue inicial de IPv6 (parte de la red 6bone) y ya no está en uso general.

3. ::

Tipo: Unspecified address
Descripción: Esta dirección, que consiste completamente de ceros, es conocida como la dirección "unspecified". Se utiliza en contextos de software o protocolos cuando no hay dirección específica asignada o aplicable.

4. ::1

Tipo: Loopback
Descripción: Esta dirección se usa para pruebas de loopback dentro de un host. Es equivalente a la dirección 127.0.0.1 en IPv4 y se utiliza para que un nodo se comunique consigo mismo.

5. ff02::2

Tipo: Multicast
Descripción: Las direcciones que comienzan con ff son direcciones multicast. Esta dirección en particular, ff02::2, es una dirección de alcance de enlace local utilizada por todos los dispositivos routers en IPv6.

6. 2818:edbc:43e1::8721:122

Tipo: Global Unicast
Descripción: Este es el formato estándar para una dirección unicast global en IPv6, utilizada para la comunicación en internet. Las direcciones que no caen bajo los prefijos especiales y que están diseñadas para ser utilizadas en la red pública global generalmente son de este tipo.

7. ff02::9

Tipo: Multicast
Descripción: Al igual que la anterior dirección multicast, esta también es una dirección multicast y pertenece al alcance de enlace local. ff02::9 específicamente se utiliza para el protocolo de enrutamiento RIPv6.

Cada tipo de dirección IPv6 tiene un propósito específico y reglas asociadas para su uso, lo que asegura la correcta operación y configuración de la red conforme a las necesidades de conectividad y seguridad de la misma.

Ejercicio 11

Al autogenerarse una dirección IPv6 sus últimos 64 bits en muchas ocasiones no se deducen de la dirección MAC, se generan de forma random, ¿por qué sucede esto? ¿Qué es lo que se intenta evitar? (Ver direcciones temporarias, RFC 8981)

La autogeneración de direcciones IPv6 que utilizan los últimos 64 bits generados de forma aleatoria en lugar de derivarlos directamente de la dirección MAC del dispositivo es una práctica diseñada para mejorar la privacidad y seguridad de los usuarios en la red. Este enfoque se describe en varias RFCs, incluida la RFC 8981, y es una evolución de la configuración estándar del Protocolo de Descubrimiento de Vecinos (NDP) para IPv6.

¿Por qué se generan de forma aleatoria?

El uso de direcciones IPv6 generadas aleatoriamente, especialmente para la parte del identificador de interfaz (los últimos 64 bits de una dirección IPv6 en una red configurada para la Autoconfiguración sin Estado de Direcciones [SLAAC]), se promueve por las siguientes razones:

Privacidad Mejorada: Tradicionalmente, las direcciones IPv6 podían incluir la dirección MAC del dispositivo en el campo del identificador de interfaz (usando el formato EUI-64). Esto podría exponer información persistente sobre el hardware del dispositivo a cualquier parte con la que se comunica el dispositivo, permitiendo actividades de seguimiento o identificación del usuario a lo largo del tiempo y a través de diferentes redes. Al generar estos bits de forma aleatoria, se reduce el riesgo de que la dirección revele la identidad o ubicación física del usuario.
Seguridad Incrementada: La generación aleatoria dificulta que los atacantes adivinen las direcciones IPv6 de los dispositivos en una red, un factor importante en la mitigación de ciertos tipos de ataques de red, como aquellos que intentan mapear la red o dirigirse a dispositivos específicos dentro de ella.

RFC 8981 y Direcciones Temporales

La RFC 8981 detalla la generación de direcciones IPv6 temporales y privadas que son utilizadas por los dispositivos para comunicaciones externas, proporcionando un método para rotar periódicamente las direcciones y así mejorar la privacidad del usuario. Estas direcciones son conocidas como "direcciones temporales" o "direcciones de privacidad".

Funcionamiento de las Direcciones Temporales:

Generación: Las direcciones temporales se generan utilizando algoritmos de aleatorización que toman en cuenta el prefijo de la red y una semilla secreta que cambia con el tiempo.
Uso: Estas direcciones se utilizan para conexiones de salida, mientras que para la configuración de red y las conexiones entrantes se pueden utilizar direcciones más estables (aunque también privadas).
Caducidad: Las direcciones temporales tienen un tiempo de vida limitado, tras el cual son desechadas y reemplazadas por nuevas direcciones generadas.

Conclusión

La generación aleatoria de los últimos 64 bits de las direcciones IPv6 es una práctica importante para proteger la privacidad y seguridad de los usuarios en redes modernas. Mediante el uso de direcciones IPv6 temporales y privadas, como se detalla en la RFC 8981, los sistemas y dispositivos pueden minimizar los riesgos asociados con el rastreo y la identificación a través de sus direcciones IP.

TP Refactoring

Wed, 24 Apr 2024 00:00:00 GMT

Me quiero morir 💀

📌 Refactor 1
- Move Method
- Encapsulate Collection y Remove Method
📌 Refactor 2
- Replace Conditional with Polymorphism - Remove method - Remove Field - Encapsulate Field
- Factory Method
📌 Refactor 3
- Encapsulate Collection - Move Method - Hide Delegate
📌 Refactor 4
📌 Refactor 5
- Replace Conditional Logic with Strategy - Replace Magic Strings with Class Type

🚧 Refactor 1

🦨 Malos Olores

Feature Envy Se observa una mala asignación de responsabilidades en la clase Empresa, asociada a una evidente envidia de atributos.

Encontramos tareas en esta clase que deberían ser responsabilidad de GestorNumeroDisponibles().

Extracto del código original:

public class Empresa{
	public boolean agregarNumeroTelefono(String str) {
		boolean encontre = guia.getLineas().contains(str);
		if (!encontre) {
			guia.getLineas().add(str);
			encontre = true;
			return encontre;
		} else {
			encontre = false;
			return encontre;
		}
	}
}

🚧 Refactor 1 Move Method

En primer lugar, realizamos un Move method del método agregarNumeroTelefono(String str) a la clase GestorNumeroDisponibles().

public class GestorNumerosDisponibles {
	private SortedSet<String> lineas = new TreeSet<String>(); 

	public SortedSet<String> getLineas() {
		return lineas;
	}
	public boolean agregarNumeroTelefono(String numero) {
		boolean encontre = this.getLineas().contains(numero);
		if (!encontre) {
			this.getLineas().add(numero);
			encontre = true;
			return encontre;
		} else {
			encontre = false;
			return encontre;
		}
	}	
}
public class Empresa{
	public String agregarNumeroTelefono(String numero) {
		return guia.agregarNumeroTelefono(numero);
	}
}

🦨 Malos Olores

Inappropriate Intimacy: El método getLineas() expone directamente el conjunto interno lineas, lo cual permite a otras partes del código modificar directamente esta colección. Esto puede llevar a problemas de manejo de estado y viola el principio de encapsulamiento.

Feature Envy: Los métodos en GestorNumerosDisponibles hacen un uso excesivo del getter getLineas() en lugar de interactuar directamente con el campo lineas.

Duplicate Code: El uso de una variable booleana encontre para manejar el control de flujo es innecesariamente complicado y duplica la lógica de verificación de existencia y adición en el conjunto.

🚧 Refactor 1 Encapsulate Collection - Remove Method

Refactoring: Modificar getLineas() para que no retorne directamente la colección mutable. Mejor aún, eliminar este método si no es necesario y manejar toda la lógica de adición o eliminación a través de métodos específicos en GestorNumerosDisponibles.

Remove Method Eliminamos getLineas() para que no pueda ser modificado por fuera de la clase, aseguramos que toda manipulación de lineas se haga a través de métodos de la clase misma.

Refactor aplicado:

public class GestorNumerosDisponibles{
	private SortedSet<String> lineas = new TreeSet<String>(); 

	public boolean agregarNumeroTelefono(String numero) {
		return this.lineas.add(numero);
	}
}

public class Empresa{
	public String agregarNumeroTelefono(String numero) {
		return guia.agregarNumeroTelefono(numero);
	}
}

🚧 Refactor 2

🦨 Malos Olores Detectados

Duplicate Code: El código original tenía estructuras condicionales repetitivas para configurar objetos de Cliente, variando solo en la asignación de dni para clientes físicos y cuit para clientes jurídicos. Esto no solo duplica el código sino que también complica las modificaciones futuras.

Switch Statements: Aunque en tu refactoring final aún se utiliza un switch, este es movido a una fábrica, lo cual es un lugar más apropiado que dispersarlo por el código de negocio.

Large Class: La clase Cliente en el código original podría expandirse desproporcionadamente si se agregaran más tipos de clientes, con más condiciones y más campos.

Inappropriate Intimacy: La clase Empresa accede directamente a la lista de llamadas de Cliente. Esto viola el principio de encapsulación y crea una dependencia innecesaria entre las clases.

Dead Code (Código Muerto): El campo tipo de la clase Cliente no se utiliza en el código original, ya que el tipo de cliente se puede inferir a partir de la clase concreta que se esté utilizando. Además existen getters y setters que no se utilizan.

Speculative Generality: La clase Cliente tiene metodos que no se utiliza.

Incluimos constructores en nuestras clases para garantizar que cada objeto se inicialice con todos los datos necesarios. Esto evita errores y hace el código más claro y fácil de entender. Es fundamental para asegurar que todos los objetos comiencen en un estado válido y seguro.

extracto del código original:

public class Empresa{	
	public Cliente registrarUsuario(String data, String nombre, String tipo) {
		Cliente var = new Cliente();
		if (tipo.equals("fisica")) {
			var.setNombre(nombre);
			String tel = this.obtenerNumeroLibre();
			var.setTipo(tipo);
			var.setNumeroTelefono(tel);
			var.setDNI(data);
		} else if (tipo.equals("juridica")) {
			String tel = this.obtenerNumeroLibre();
			var.setNombre(nombre);
			var.setTipo(tipo);
			var.setNumeroTelefono(tel);
			var.setCuit(data);
		}
		clientes.add(var);
		return var;
	}
}

public class Cliente {
	public List<Llamada> llamadas = new ArrayList<Llamada>();
	private String tipo;
	private String nombre;
	private String numeroTelefono;
	private String cuit;
	private String dni;

	public String getTipo() {
		return tipo;
	}
	public void setTipo(String tipo) {
		this.tipo = tipo;
	}
	public String getNombre() {
		return nombre;
	}
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
	public String getNumeroTelefono() {
		return numeroTelefono;
	}
	public void setNumeroTelefono(String numeroTelefono) {
		this.numeroTelefono = numeroTelefono;
	}
	public String getCuit() {
		return cuit;
	}
	public void setCuit(String cuit) {
		this.cuit = cuit;
	}
	public String getDNI() {
		return dni;
	}
	public void setDNI(String dni) {
		this.dni = dni;
	}
}

🚧 Refactor 2 Replace Conditional with Polymorphism - Remove method - Remove Field - Encapsulate Field

Creamos dos subclases, ClientePersonaFisica y ClientePersonaJuridica, desde la clase original Cliente y la hacemos abstracta. Esto no solo eliminó la duplicación de código sino que también aseguró que cada subclase maneje sus propios datos específicos de manera encapsulada.

Agregamos un constructor a la clase Cliente para asegurarnos de que cada objeto se inicialice con todos los datos necesarios.
Eliminamos el campo tipo de la clase Cliente, ya que este puede ser inferido a partir del tipo de subclase que se esté utilizando.
Eliminamos los campos dni y cuit y sus respectivos getters y setters de la clase Cliente, ya que se movieron a las subclases ClientePersonaFisica y ClientePersonaJuridica, respectivamente.
Cambiamos la visibilidad de la colección de llamadas de Cliente a privada para evitar que otras clases la manipulen directamente.
Eliminamos el parametro tipo del constructor de Cliente, ya que este se puede inferir a partir del tipo de subclase que se esté utilizando.
Eliminamos metodos que no se utilizan en las subclases de Cliente (getNombre(), getCuit(), getDNI(), setDNI(), setCuit()).

Refactor aplicado:

public abstract class Cliente {
	public List<Llamada> llamadas = new ArrayList<Llamada>();
	private String nombre;
	private String numeroTelefono;

	public Cliente(String nombre, String numeroTelefono) {
		this.nombre = nombre; 
		this.numeroTelefono = numeroTelefono;
	}
	
	public String getNumeroTelefono() {
		return numeroTelefono;
	}
}

public class ClientePersonaJuridica extends Cliente{
	private String cuit;	
	public ClientePersonaJuridica(String nombre, String numeroTelefono, String cuit){
		super(nombre, numeroTelefono);
		this.cuit = cuit;
	}
}

public class ClientePersonaFisica extends Cliente{
	private String dni;
	public ClientePersonaFisica(String nombre, String numeroTelefono, String dni){
		super(nombre, numeroTelefono);
		this.dni = dni;
	}
}

🚧 Refactor 2 Factory Method

Creamos una clase ClienteFactory con un método crearCliente que se encarga de instanciar el tipo correcto de cliente según el tipo especificado. Esto centraliza la creación de objetos Cliente y facilita la extensión del sistema para incorporar nuevos tipos de clientes en el futuro.
Quedando el método registrarUsuario de la clase Empresa más limpio y desacoplado de la lógica de creación de clientes.

Refactor aplicado:

public class ClienteFactory{
	public static Cliente crearCliente(String tipo, String nombre, String numeroTelefono, String data){
		switch(tipo){
			case "fisica":
				return new ClientePersonaFisica(nombre, numeroTelefono, data);
			case "juridica":
				return new ClientePersonaJuridica(nombre, numeroTelefono, data);			
			default:
				throw new IllegalArgumentException("Tipo de cliente no válido");
		}		
	}
}

public class Empresa{
	public Cliente registrarUsuario(String data, String nombre, String tipo) {		
		Cliente cliente = ClienteFactory.crearCliente(tipo, nombre, this.obtenerNumeroLibre(), data);
		clientes.add(cliente);
		return cliente;
	}
}

🚧 Refactor 3

🦨 Malos Olores Detectados

Feature Envy: El método muestra envidia de atributos ya que accede directamente a la lista de llamadas del Cliente origen para agregar una nueva llamada. Esto indica una alta dependencia de la estructura interna de otra clase, lo cual va en contra del principio de encapsulación.
Inappropriate Intimacy: Manipular directamente la lista de llamadas del Cliente desde otra clase podría ser considerado una intimidad inapropiada, pues el método no solo conoce detalles internos de otra clase, sino que también los modifica directamente.

Extracto del código original:

public class Empresa {
	private List<Llamada> llamadas = new ArrayList<Llamada>();
	public Llamada registrarLlamada(Cliente origen, Cliente destino, String t, int duracion) {
		Llamada llamada = new Llamada(t, origen.getNumeroTelefono(), destino.getNumeroTelefono(), duracion);
		llamadas.add(llamada);
		origen.llamadas.add(llamada);
		return llamada;
	}
}

🚧 Refactor 3 Encapsulate Collection - Move Method - Hide Delegate

Encapsulamos la gestión de la colección de llamadas dentro de la clase Cliente. Esto implica crear métodos en la clase Cliente para añadir llamadas, en lugar de modificar la lista directamente desde fuera.

Consideramos mover parte de de la funcionalidad de registrarLlamada() de la clase Empresa a la clase Cliente creando un método agregarLlamada().

Rafactor aplicado

public class Cliente {
    private List<Llamada> llamadas = new ArrayList<>();

    public void agregarLlamada(Llamada llamada) {
        this.llamadas.add(llamada);
    }
}

public class Empresa {
    private List<Llamada> llamadas = new ArrayList<>();

    public Llamada registrarLlamada(Cliente origen, Cliente destino, String tipo, int duracion) {
        Llamada llamada = new Llamada(t, origen.getNumeroTelefono(), destino.getNumeroTelefono(), duracion);
        this.llamadas.add(llamada);
        origen.agregarLlamada(llamada);
        return llamada;
    }
}

🚧 Refactor 4

🦨 Malos Olores Detectados

Feature Envy y Inappropriate Intimacy: El método accede directamente a la lista interna de llamadas del Cliente.
String Comparison: Está utilizando == para comparar strings, lo cual es inapropiado en Java para comparaciones de contenido de strings. Debería usar .equals().
Duplicate Code: Hay código duplicado en la manera de calcular el costo de las llamadas, especialmente en cómo se añade el IVA y se calculan los descuentos.
Magic Numbers: El código contiene numeros mágicos como 3, 150, 0.21, 50, que hacen el código difícil de entender y mantener.

Extracto del código original:

public class Empresa{
	public double calcularMontoTotalLlamadas(Cliente cliente) {
		double c = 0;
		for (Llamada l : cliente.llamadas) {
			double auxc = 0;
			if (l.getTipoDeLlamada() == "nacional") {
				// el precio es de 3 pesos por segundo más IVA sin adicional por establecer la
				// llamada
				auxc += l.getDuracion() * 3 + (l.getDuracion() * 3 * 0.21);
			} else if (l.getTipoDeLlamada() == "internacional") {
				// el precio es de 150 pesos por segundo más IVA más 50 pesos por establecer la
				// llamada
				auxc += l.getDuracion() * 150 + (l.getDuracion() * 150 * 0.21) + 50;
			}
	
			if (cliente.getTipo() == "fisica") {
				auxc -= auxc * descuentoFis;
			} else if (cliente.getTipo() == "juridica") {
				auxc -= auxc * descuentoJur;
			}
			c += auxc;
		}
		return c;
	}
}

🚧 Refactor 4 Move Method - Rename Method

Movimos el metodo calcularCostoTotalLlamadas() de la clase Empresa a la clase Cliente para que sea responsabilidad de la clase Cliente calcular el costo total de sus llamadas.
Edita el método calcularCostoTotalLlamadas() de la clase Empresa para que llame al método calcularCostoTotalLlamadas() de la clase Cliente.

Refactor aplicado:

public class Empresa{
	public double calcularMontoTotalLlamadas(Cliente cliente) {		
		return cliente.calcularCostoTotalLlamadas();
	}
}

public class Cliente{
	public double calcularMontoTotalLlamadas() {
		for (Llamada l : this.llamadas) {
			double auxc = 0;
			if (l.getTipoDeLlamada() == "nacional") {
				// el precio es de 3 pesos por segundo más IVA sin adicional por establecer la
				// llamada
				auxc += l.getDuracion() * 3 + (l.getDuracion() * 3 * 0.21);
			} else if (l.getTipoDeLlamada() == "internacional") {
				// el precio es de 150 pesos por segundo más IVA más 50 pesos por establecer la
				// llamada
				auxc += l.getDuracion() * 150 + (l.getDuracion() * 150 * 0.21) + 50;
			}
	
			if (cliente.getTipo() == "fisica") {
				auxc -= auxc * descuentoFis;
			} else if (cliente.getTipo() == "juridica") {
				auxc -= auxc * descuentoJur;
			}
			c += auxc;
		}
	}
}

🚧 Refactor 4 Replace Conditional with Polymorphism - Remove Field

Creamos una clase abstracta Llamada con métodos abstractos para calcular el costo de la llamada. Luego, creamos subclases LlamadaNacional y LlamadaInternacional que implementan estos métodos de acuerdo a las reglas específicas de cada tipo de llamada.
Eliminamos el campo tipoDeLlamada y su getter de la clase Llamada ya que este se puede inferir a partir del tipo de subclase que se esté utilizando, tambien eliminamos el parametro tipoDeLlamada del constructor de Llamada.

public abstract class Llamada {	
	private String origen;
	private String destino;
	private int duracion;

	public Llamada(String origen, String destino, int duracion) { // quitamos el tipo de llamada		
		this.origen = origen;
		this.destino = destino;
		this.duracion = duracion;
	}

	public String getRemitente() {
		return destino;
	}

	public int getDuracion() {
		return this.duracion;
	}

	public String getOrigen() {
		return origen;
	}

}
public class LlamadaNacional extends Llamada{
    public LlamadaNacional(String numeroOrigen, String numeroDestino, int duracion) {
        super(numeroOrigen, numeroDestino, duracion);
    }
}

public class LlamadaInternacional extends Llamada{
	public LlamadaInternacional(String numeroOrigen, String numeroDestino, int duracion) {
		super(numeroOrigen, numeroDestino, duracion);
	}
}

🚧 Refactor 4 Factory Method - Rename Variables

Creamos una clase LlamadaFactory con un método crearLlamada que se encarga de instanciar el tipo correcto de llamada según el tipo especificado. Esto centraliza la creación de objetos Llamada y facilita la extensión del sistema para incorporar nuevos tipos de llamadas en el futuro.
Modificamos el método registrarLlamada() de la clase Empresa para que utilice la fábrica de llamadas para crear el objeto de llamada correspondiente.
Renombramos las variables poco descriptivas

public class LlamadaFactory {
    public static Llamada crearLlamada(String tipo, String numeroOrigen, String numeroDestino, int duracion) {
        switch (tipo) {
            case "nacional":
                return new LlamadaNacional(numeroOrigen, numeroDestino, duracion);
            case "internacional":
                return new LlamadaInternacional(numeroOrigen, numeroDestino, duracion);
            default:
                throw new IllegalArgumentException("Tipo de llamada no válido");
        }
    }
}
public class Empresa {
	public Llamada registrarLlamada(Cliente origen, Cliente destino, String tipo, int duracion) {
        Llamada llamada = LlamadaFactory.crearLlamada(t, origen.getNumeroTelefono(), destino.getNumeroTelefono(), duracion);
        this.llamadas.add(llamada);
        origen.agregarLlamada(llamada);
        return llamada;
    }
}

🚧 Refactor 4 Reinventando la rueda - Move field - Rename variables

Eliminamos el for loop de la clase Cliente y lo reemplazamos por un stream y una operación de suma, lo cual simplifica el cálculo del monto total de las llamadas.
Creamos un método computarMontoLlamada() en la clase Cliente para calcular el monto de una llamada específica, teniendo en cuenta el descuento correspondiente.
creamos un método getDescuento() en la clase Cliente para obtener el descuento correspondiente a cada cliente, cada subclase de Cliente implementará este método de acuerdo a sus reglas específicas.
Movimos los atributos estaticos descuentoFis y descuentoJur a las subclases de Cliente (descuentoFis a ClientePersonaFisica y descuentoJur a ClientePersonaJuridica), Les cambiamos el nombre y el modificador de acceso a private y les creamos un getter.
Creamos un método calcularMontoLlamada() en la clase Llamada para calcular el monto de la llamada, teniendo en cuenta el IVA y cualquier adicional.
Creamos un método getPrecioSegundo() en la clase Llamada para obtener el precio por segundo de la llamada, que será implementado por las subclases de Llamada.
Creamos un método getAdicional() en la clase Llamada para obtener cualquier adicional que se deba sumar al costo de la llamada, que será implementado por las subclases de Llamada.
Creamos una constante PORCENTAJE_IVA en la clase Llamada para representar el porcentaje de IVA que se debe sumar al costo de la llamada.

public abstract class Cliente {		
	public abstract double getDescuento();

	private double computarMontoLlamada(Llamada llamada) {
        return llamada.calcularMontoLlamada() * ( 1 - this.getDescuento());
    }
	public double calcularMontoTotalLlamadas() {
		return this.llamadas
				.stream()
				.mapToDouble(llamada -> this.computarMontoLlamada(llamada))
				.sum();
	}
}

public class ClientePersonaFisica extends Cliente{
	private	static final double DESCUENTO = 0;
	private String dni;

	public ClientePersonaFisica(String nombre, String numeroTelefono, String dni){
		super(nombre, numeroTelefono);
		this.dni = dni;
	}
	public String getDNI() {
		return dni;
	}
	public void setDNI(String dni) {
		this.dni = dni;
	}

	@Override
    public double getDescuento() {
        return ClientePersonaFisica.DESCUENTO;
    }
}

public class ClientePersonaJuridica extends Cliente{
	private static final double DESCUENTO = 0.15;
	private String cuit;

	public ClientePersonaJuridica(String nombre, String numeroTelefono, String cuit){
		super(nombre, numeroTelefono);
		this.cuit = cuit;
	}

	public String getCuit() {
		return cuit;
	}
	public void setCuit(String cuit) {
		this.cuit = cuit;
	}

	public double getDescuento() {
		return ClientePersonaJuridica.DESCUENTO;
	}
}

public abstract class Llamada{
	private static final double PORCENTAJE_IVA = 0.21;
	public abstract double getPrecioSegundo();

	public double getAdicional(){
		return 0;
	};

	public double calcularMontoLlamada() {		
        return ((this.duracion * this.getPrecioSegundo()) + ((this.duracion * this.getPrecioSegundo()) * PORCENTAJE_IVA)) + this.getAdicional();		
    }
}

public class LlamadaNacional extends Llamada{
	private static final double PRECIO_SEGUNDO = 3;
	
	@Override
	public double getPrecioSegundo() {
		return LlamadaNacional.PRECIO_SEGUNDO;
	}
}

public class LlamadaInternacional extends Llamada{
    private static final double PRECIO_SEGUNDO = 150;
    private static final double ADICIONAL = 50;
    public LlamadaInternacional(String numeroOrigen, String numeroDestino, int duracion) {
        super(numeroOrigen, numeroDestino, duracion);
    }

    @Override
    public double getPrecioSegundo() {
        return PRECIO_SEGUNDO;
    }

    @Override
    public double getAdicional() {
        return ADICIONAL; 
    }
}

public class Empresa {
	public double calcularMontoTotalLlamadas(Cliente cliente) {
		return cliente.calcularMontoTotalLlamadas();
	}
}

🚧 Refactor 5

🦨 Malos Olores

Switch Statements: El uso de switch para manejar diferentes formas de obtener un número (último, primero, aleatorio) puede complicar la extensión del código. Si decides agregar más formas de seleccionar un número, este switch crecerá en complejidad y tamaño.
Magic Strings: Las cadenas "ultimo", "primero", y "random" utilizadas en el switch son ejemplos de "magic strings". Estos valores están codificados directamente en la lógica, haciendo que el código sea más difícil de mantener y propenso a errores si se escribe incorrectamente en algún lugar.
Duplicated Code: Hay una lógica duplicada en cada caso del switch, particularmente en el proceso de remover un número de lineas después de seleccionarlo.

public class GestorNumerosDisponibles {
	private SortedSet<String> lineas = new TreeSet<String>(); 
	private String tipoGenerador = "ultimo";

	public String obtenerNumeroLibre() {
		String linea;
		switch (tipoGenerador) {
			case "ultimo":
				linea = lineas.last();
				lineas.remove(linea);
				return linea;
			case "primero":
				linea = lineas.first();
				lineas.remove(linea);
				return linea;
			case "random":
				linea = new ArrayList<String>(lineas)
						.get(new Random().nextInt(lineas.size()));
				lineas.remove(linea);
				return linea;
		}
		return null;
	}

	public void cambiarTipoGenerador(String valor) {
		this.tipoGenerador = valor;
	}

	public boolean agregarNumeroTelefono(String numero) {
		return this.lineas.add(numero);
	}	
}

🚧 Refactor 5 Replace Conditional Logic with Strategy - Replace Magic Strings with Class Type

Basandonos en el patrón Strategy, creamos la interfaz Generador que varian las implementaciones que encapsulan los diferentes comportamientos (último, primero, aleatorio).
Creamos tres implementaciones de la interfaz Generador: UltimoGenerador, PrimeroGenerador, y RandomGenerador. Cada una de estas clases implementa el método obtenerNumeroLibre() de acuerdo a su comportamiento específico.
En lugar de usar cadenas para determinar el comportamiento, usamos los tipos de las clases directamente. Esto elimina la necesidad de cadenas mágicas y reduce la posibilidad de errores en tiempo de ejecución debido a cadenas mal escritas.
En los test hicimos una minima modificacion, en vez de pasar un string, pasamos una instancia de la clase que implementa el comportamiento deseado.

public interface Generador {    
    public  String  obtenerNumeroLibre(SortedSet<String> lineas);	 
}

public class UltimoGenerador implements Generador {
    public String obtenerNumeroLibre(SortedSet<String> lineas) {
        String linea = lineas.last();
        lineas.remove(linea);
        return linea;
    }
}

public class PrimeroGenerador implements Generador {
    public String obtenerNumeroLibre(SortedSet<String> lineas) {
        String linea = lineas.first();
        lineas.remove(linea);
        return linea;
    }
}

public class RandomGenerador implements Generador {
    public String obtenerNumeroLibre(SortedSet<String> lineas) {
        List<String> lista = new ArrayList<>(lineas);
        String linea = lista.get(new Random().nextInt(lista.size()));
        lineas.remove(linea);
        return linea;
    }
}

public class GestorNumerosDisponibles {
	private SortedSet<String> lineas = new TreeSet<String>(); 
	private Generador tipoGenerador = new UltimoGenerador();

	public String obtenerNumeroLibre() {
		return tipoGenerador.obtenerNumeroLibre(lineas);
	}

	public void cambiarTipoGenerador(Genedor generador) {
		this.tipoGenerador = generador;
	}
}
class EmpresaTest {
	@Test
	void obtenerNumeroLibre() {
		// por defecto es el ultimo
		assertEquals("2214444559", this.sistema.obtenerNumeroLibre());
			
		this.sistema.getGestorNumeros().cambiarTipoGenerador(new PrimeroGenerador());
		assertEquals("2214444554", this.sistema.obtenerNumeroLibre());

		this.sistema.getGestorNumeros().cambiarTipoGenerador(new RandomGenerador());
		assertNotNull(this.sistema.obtenerNumeroLibre());
	}
}

🎁 Decorator

Sun, 21 Apr 2024 00:00:00 GMT

Introducción

El patrón de diseño Decorator se utiliza para agregar responsabilidades adicionales a un objeto de manera dinámica y transparente, es decir, sin afectar a otros objetos de la misma clase. A diferencia de la herencia, donde el comportamiento es estático y no se puede cambiar después de la compilación, el Decorator permite la adición y eliminación dinámica de comportamientos.

Objetivo del Decorator

El objetivo del Decorator es permitir la extensión de las funcionalidades de un objeto sin necesidad de heredar de él. Esto proporciona una alternativa flexible a la herencia para extender la funcionalidad.

Aplicabilidad

Usarías el Decorator para:

Agregar responsabilidades a objetos de forma individual y de manera que puedas agregar o quitar funcionalidad en tiempo de ejecución.
Evitar la creación de una gran cantidad de subclases que solo se diferencian en la funcionalidad que agregan.
Modificar el comportamiento de los objetos encapsulando la variabilidad dentro de clases dedicadas a tal fin.

Solución que Ofrece

El patrón Decorator resuelve este problema permitiendo envolver un objeto dentro de una "piel" de objetos decoradores. Estos decoradores implementan la misma interfaz que el objeto que están decorando y agregan su comportamiento antes o después de delegar la llamada al objeto envuelto.

Estructura del Decorator

La estructura típica de un patrón Decorator incluye:

Componente (Component):
- Una interfaz que define las operaciones que pueden ser decoradas.
Componente Concreto (ConcreteComponent):
- Clase que implementa Component y define un objeto que puede tener responsabilidades adicionales agregadas.
Decorador (Decorator):
- Clase abstracta que implementa Component y mantiene una referencia a un objeto Component. El Decorator delega las operaciones al objeto Component y puede añadir comportamiento antes o después de la delegación.
Decoradores Concretos (ConcreteDecorators):
- Clases que extienden Decorator y agregan responsabilidades específicas al Component.

Consecuencias

Flexibilidad: Al ser más flexible que la herencia, permite la adición y eliminación dinámica de responsabilidades.
Incrementalidad: Facilita la adición de funcionalidades incrementales sin afectar a otros objetos o clases.
Complejidad: Puede aumentar la cantidad de objetos pequeños en el sistema y complicar la estructura, especialmente si se anidan muchos decoradores.

Ejemplo en Código

En el contexto de entrada/salida de archivos (File I/O Streams), el patrón Decorator se utiliza para agregar comportamientos como buffering, compresión, encriptación, etc., de manera dinámica. Por ejemplo, puedes tener un FileInputStream y luego agregarle dinámicamente un BufferedInputStream y un GZipInputStream para obtener un stream que lee de un archivo, lo descomprime y además añade funcionalidad de buffering.

Resumen

El patrón Decorator es una herramienta poderosa que ofrece una alternativa flexible a la herencia para extender las funcionalidades de los objetos. Permite modificar comportamientos de forma dinámica y es ampliamente utilizado en la programación orientada a objetos para añadir funcionalidades a clases ya existentes sin alterar su estructura.

Estructura

Objetivo del Decorator

Aplicabilidad

Usarías el Decorator para:

Agregar responsabilidades a objetos de forma individual y de manera que puedas agregar o quitar funcionalidad en tiempo de ejecución.
Evitar la creación de una gran cantidad de subclases que solo se diferencian en la funcionalidad que agregan.
Modificar el comportamiento de los objetos encapsulando la variabilidad dentro de clases dedicadas a tal fin.

Solución que Ofrece

Estructura del Decorator

La estructura típica de un patrón Decorator incluye:

Componente (Component):
- Una interfaz que define las operaciones que pueden ser decoradas.
Componente Concreto (ConcreteComponent):
- Clase que implementa Component y define un objeto que puede tener responsabilidades adicionales agregadas.
Decorador (Decorator):
- Clase abstracta que implementa Component y mantiene una referencia a un objeto Component. El Decorator delega las operaciones al objeto Component y puede añadir comportamiento antes o después de la delegación.
Decoradores Concretos (ConcreteDecorators):
- Clases que extienden Decorator y agregan responsabilidades específicas al Component.

Consecuencias

Flexibilidad: Al ser más flexible que la herencia, permite la adición y eliminación dinámica de responsabilidades.
Incrementalidad: Facilita la adición de funcionalidades incrementales sin afectar a otros objetos o clases.
Complejidad: Puede aumentar la cantidad de objetos pequeños en el sistema y complicar la estructura, especialmente si se anidan muchos decoradores.

Ejemplo en Código

Resumen

📦 Composite

Sat, 20 Apr 2024 00:00:00 GMT

Introducción

Video de BettaTech

El patrón Composite es un patrón de diseño estructural que te permite componer objetos en estructuras de árbol para representar jerarquías parte-todo. Permite a los clientes tratar tanto a los objetos individuales como a las composiciones de objetos de manera uniforme.

Concepto Principal

El patrón Composite se basa en la idea de que tanto los objetos individuales (hojas) como los grupos de objetos (composites) deben ser tratados de manera similar. Es decir, deben poder ser manejados a través de una interfaz común.

Problema

El problema que resuelve el patrón Composite es cómo organizar los objetos en estructuras que incluyan tanto objetos simples como grupos de objetos que deberían ser tratados de la misma manera. Por ejemplo, piensa en una interfaz gráfica con figuras que pueden ser simples (como círculos o rectángulos) o compuestas (como un diagrama que está formado por múltiples figuras).

Estructura

Componente (Component): Es la interfaz o clase abstracta que declara las operaciones comunes tanto para los objetos simples como para los compuestos. Puede incluir métodos para agregar y eliminar hijos, así como operaciones específicas como move() o draw() que deben ser implementadas por todos los objetos concretos.
Hoja (Leaf): Representa los objetos finales de la composición que no tienen hijos. Realizan las operaciones solicitadas directamente.
Compuesto (Composite): Define comportamientos para los componentes que tienen hijos. Guarda los componentes hijos y delega a ellos las operaciones que se invocan en el objeto compuesto.

Consecuencias

Pros:
- Facilita la construcción de objetos complejos a partir de partes simples y composites.
- Simplifica el código de los clientes, ya que pueden tratar todos los objetos de la composición uniformemente.
- Facilita la adición de nuevos tipos de componentes, ya que los cambios son aislados y no afectan al código cliente.
Contras:
- Puede ser difícil restringir los tipos de componentes en una composición. Por ejemplo, no hay una forma sencilla de permitir solo ciertos componentes en un compuesto.
Cuestiones de Implementación:
- Se pueden tener referencias explícitas al padre para facilitar la navegación y la gestión de la estructura.
- Se debe decidir entre la transparencia y la seguridad en el manejo de las operaciones de los hijos (p. ej., debería Leaf tener operaciones para manejar hijos?).
- Es posible que necesites caching, ordenar los hijos, o manejar su borrado.
- Puedes elegir diferentes estructuras de datos para almacenar los componentes, dependiendo de las operaciones que necesites optimizar.

Ejemplo Aplicado

Imagina que estás diseñando un sistema para un Banco de Alimentos que necesita armar cajas con productos que cumplen ciertos requerimientos nutricionales. Puedes tener productos individuales como Leaf y composiciones como cajas o paquetes como Composite. El patrón Composite te permitiría tratar tanto un producto individual como una caja de productos de manera uniforme, por ejemplo, para calcular el valor nutricional total.

En resumen, el patrón Composite es muy útil para trabajar con estructuras que pueden ser tratadas de manera recursiva como si fueran un único objeto, facilitando el manejo de colecciones de objetos a través de una interfaz común.

| En la vida | En objetos :( | | --------- | --------- | | | |

Estructura

El diagrama UML que has subido representa el patrón de diseño Composite de una manera clásica y clara. A continuación, te detallo cada componente y su relación en el patrón:

Cliente (Client):
- Representa la parte del sistema que interactúa con la estructura compuesta. El cliente utiliza la interfaz 'Component' para trabajar con los objetos del árbol.
Componente (Component):
- Es una clase abstracta o interfaz que declara la interfaz común para todos los objetos en la composición, tanto simples (Leaf) como compuestos (Composite).
- Define las operaciones como Operation(), que debe ser implementada tanto por las hojas como por los compuestos.
- También declara operaciones para manipular los hijos (Add(Component), Remove(Component), GetChild(int)), aunque estos métodos no necesariamente tienen sentido o serán implementados en las hojas.
Hoja (Leaf):
- Representa los objetos finales de la composición que no tienen hijos (objetos simples). Las hojas implementan la operación Operation() que es común a todos los componentes del árbol.
Compuesto (Composite):
- Representa los objetos complejos del árbol que pueden tener hijos. Estos hijos pueden ser tanto hojas como otros compuestos, permitiendo así la recursividad y la formación de una estructura de árbol.
- La clase Composite implementa la operación Operation() y las operaciones de manejo de hijos (Add(Component), Remove(Component), GetChild(int)). Cuando se invoca Operation(), el Composite itera sobre sus hijos y les llama la operación Operation() a cada uno de ellos (forall g in children g.Operation();). Esto permite aplicar una operación a un grupo completo de objetos (hojas y/o compuestos) de manera transparente.
Relaciones:
- La relación de herencia/interfaz (línea con un triángulo vacío) desde 'Leaf' y 'Composite' hacia 'Component' significa que ambos, 'Leaf' y 'Composite', conforman la interfaz de 'Component'.
- La relación de agregación (línea con un diamante vacío) de 'Composite' a 'Component' indica que 'Composite' puede tener cero o más hijos de tipo 'Component'.
- La flecha punteada desde 'Composite' hacia la operación 'Operation()' de 'Component' denota la llamada a esta operación en cada hijo durante la ejecución de 'Composite's Operation()'.

Este diagrama UML es fundamental para entender cómo el patrón Composite permite manejar objetos simples y compuestos de manera uniforme a través de una interfaz común, lo cual simplifica el código del cliente y permite construir jerarquías complejas de objetos.

📡 Proxy

Sat, 20 Apr 2024 00:00:00 GMT

Estructura

El diagrama UML que proporcionaste muestra la estructura del patrón de diseño Proxy. Aquí está el detalle de cada parte del diagrama:

Cliente (Client):
- La clase que actúa como consumidor de los servicios proporcionados por el Subject. El cliente interactúa con el Subject sin necesariamente saber si está trabajando con un RealSubject o un Proxy.
Sujeto (Subject):
- Es una interfaz que define una operación común llamada Request() que debe ser implementada tanto por el Proxy como por el RealSubject. Representa la interfaz que el Client utiliza para trabajar con los objetos.
Sujeto Real (RealSubject):
- La clase que hereda o implementa la interfaz Subject y define el objeto real que el Proxy está destinado a representar. RealSubject implementa la operación real Request() que el cliente quiere invocar.
Proxy:
- Una clase que también implementa la interfaz Subject y contiene una referencia al RealSubject. Su propósito es controlar el acceso al RealSubject, posiblemente realizando tareas adicionales como carga perezosa, control de acceso, buffering, etc., cuando se invoca su método Request().
- El Proxy implementa el método Request() que es llamado por el Client. Dentro de este método, el Proxy puede realizar operaciones adicionales y, finalmente, delegar la llamada al RealSubject llamando a realSubject->Request().

Funcionamiento del Proxy

Cuando el Client invoca Request(), puede hacerlo a través de un objeto Proxy. El Proxy entonces tiene la oportunidad de interceder en la operación. Puede realizar acciones antes o después de pasar la llamada a Request() del RealSubject. Este enfoque es útil para:

Retrasar la creación del objeto real solo cuando se necesita realmente (Lazy Initialization).
Controlar el acceso al objeto real por razones de seguridad (Protection Proxy).
Gestionar la interacción con un objeto que está en un espacio de memoria diferente (Remote Proxy).

Ejemplo

Imagina que el RealSubject es un sistema de gestión de documentos y el Proxy proporciona un control de acceso seguro. Cuando un cliente solicita abrir un documento a través del método Request(), el Proxy puede verificar las credenciales del usuario antes de permitir o negar el acceso al documento solicitando el método Request() en el RealSubject.

En Resumen

El patrón Proxy es un patrón estructural esencial en el diseño de software que proporciona un objeto sustituto para otro objeto para controlar el acceso a él. Este patrón es particularmente útil para operaciones costosas o de seguridad, permitiendo que las operaciones se realicen de manera más eficiente o segura.

🗽 State

Sat, 20 Apr 2024 00:00:00 GMT

Introducción

El patrón State es un patrón de diseño de comportamiento que permite a un objeto cambiar su comportamiento cuando su estado interno cambia. Parece como si el objeto cambiara su clase. Es especialmente útil en el diseño de máquinas de estado, donde el comportamiento de un objeto puede cambiar drásticamente dependiendo de su estado actual.

Intención

El propósito del patrón State es encapsular los estados variables de un objeto en clases separadas y permitir al objeto cambiar de estado como si cambiara de clase. En lugar de estar lleno de condicionales para realizar diferentes acciones dependiendo del estado, el objeto delega las acciones al objeto de estado actual.

Uso

El patrón State es útil cuando tienes un objeto que se comporta de manera diferente según el estado en el que se encuentra, y hay muchas operaciones condicionales que dependen del estado.

Estructura

El patrón State se compone de varias partes clave:

Contexto (Context):
- Es la clase que tiene un estado que dicta cómo debe comportarse. Mantiene una referencia a una instancia de una subclase de State que representa el estado actual.
- El contexto delega las operaciones a la instancia de State para actuar de acuerdo con su estado actual.
Estado (State):
- Es una interfaz o clase abstracta que define la interfaz para encapsular el comportamiento asociado con un estado particular del contexto.
- Puede definir métodos que serán llamados por el contexto para realizar acciones que dependen del estado.
Estados Concretos (ConcreteStates):
- Son clases que implementan la interfaz State y definen el comportamiento real asociado con un estado del contexto.
- Cada ConcreteState sabe a qué otro estado debe cambiar el contexto bajo ciertas condiciones y puede realizar la transición al cambiar la referencia de State en el contexto.

Ventajas

Localización del Comportamiento de Estado: Centraliza el comportamiento de cada estado en clases correspondientes.
Cambios de Estado explícitos: Cambiar de un estado a otro se hace explícitamente cambiando la instancia de estado dentro del contexto, lo cual es más claro que usar múltiples condicionales.
Estado y Transiciones Encapsulados: Al aislar los estados en diferentes clases, se encapsulan tanto las acciones como las transiciones entre estados.

Desventajas

Aumento de Clases: Puede incrementar el número de clases en el sistema.
Dependencia entre Estados Concretos: Puede haber dependencia entre ConcreteStates si no se planifica adecuadamente, lo que puede llevar a un mantenimiento más difícil.

Ejemplo Aplicado

Un ejemplo común del patrón State es una máquina expendedora que tiene diferentes estados, como 'Esperando selección', 'Validando pago', 'Dispensando producto', y 'Dando cambio'. Cada estado determinará cómo responderá la máquina a diferentes entradas, como la selección de un producto o la inserción de dinero.

Resumen

El patrón State es esencial para situaciones donde el comportamiento de un objeto depende de su estado, y hay complejas reglas de transición entre estados. Este patrón oculta las complejidades de estado y transición en un marco de trabajo que es fácil de entender y mantener.

Estructura

Este diagrama UML describe el patrón de diseño State. A continuación, te detallo cada componente del diagrama y cómo interactúan entre sí:

Contexto (Context):
- La clase Context mantiene una referencia a una instancia de la clase State, que representa el estado actual del contexto.
- Contiene un método request() que es el punto de entrada para solicitar la operación. Este método luego delega la ejecución a la instancia de State actual llamando a state.handle().
- La asociación entre Context y State se muestra con una línea que tiene un círculo al final, indicando que Context mantiene una referencia a State.
Estado (State):
- La interfaz o clase abstracta State define un método handle(), que será implementado por las subclases concretas para realizar las acciones asociadas con un estado específico.
- Esta es la interfaz común que todas las clases concretas de estado implementarán.
Estados Concretos (ConcreteStateA y ConcreteStateB):
- ConcreteStateA y ConcreteStateB son implementaciones de la interfaz State. Cada una define una versión del método handle(), que contiene la lógica específica que debe ejecutarse cuando el objeto Context se encuentra en el estado correspondiente.
- Estos objetos de estado concreto pueden cambiar el estado del Context al reemplazar la instancia de estado actual por otra, lo que permite cambiar el comportamiento del Context dinámicamente.
Transiciones de Estado:
- En la práctica, la implementación de handle() en ConcreteStateA podría resultar en un cambio de estado al establecer una nueva instancia de State (por ejemplo, ConcreteStateB) en el Context. Esto no se muestra explícitamente en el diagrama, pero es parte central de cómo funciona el patrón State.

Cómo Funciona

Cuando un cliente invoca request() en el Context, el Context delega esa solicitud a su objeto de estado actual llamando a state.handle().
El objeto de State actual determina qué operaciones realizar y puede cambiar el estado actual del Context a otro estado, influyendo así en el comportamiento futuro del Context.
Este patrón permite al Context cambiar su comportamiento en tiempo de ejecución sin tener que recurrir a grandes cantidades de condicionales y sin violar el principio de abierto/cerrado, que promueve que las entidades (clases, módulos, funciones, etc.) deberían estar abiertas para su extensión, pero cerradas para su modificación.

El diagrama ilustra una estructura flexible que soporta cambios en el comportamiento de un objeto sin recurrir a múltiples sentencias if o switch a lo largo del código, facilitando así la mantenibilidad y escalabilidad.

State vs Strategy

El patrón State y el patrón Strategy son a menudo confundidos debido a que su estructura UML puede parecer similar y ambos patrones implican el uso de composición para cambiar el comportamiento de un objeto en tiempo de ejecución. Sin embargo, sus intenciones, uso y forma de gestionar el cambio de comportamiento son distintos.

State

El patrón State se utiliza cuando el comportamiento de un objeto debe cambiar de acuerdo con su estado interno. Cada estado es representado por una clase concreta que implementa una interfaz común, y el objeto cambia su comportamiento cambiando su estado interno a diferentes instancias de estas clases de estado.

Características del State:

Encapsula los posibles estados en diferentes clases.
Cambios de estado normalmente se ocultan dentro de las clases de estado y pueden ser automáticos en respuesta a eventos internos.
El objeto de contexto puede no saber qué clase de estado concreto está en uso, reflejando un cambio en el comportamiento de manera transparente.
El número y naturaleza de los estados pueden ser muchos y complejos, cada estado puede tener su propia lógica para determinar a qué estado cambiar después.
Se enfoca en el ciclo de vida de un objeto y cómo cambia su comportamiento a lo largo del tiempo y los eventos internos.

Strategy

El patrón Strategy se centra en definir una familia de algoritmos, encapsulando cada uno en su propia clase de estrategia, y haciendo los algoritmos intercambiables desde el contexto. Este patrón se utiliza principalmente para seleccionar un algoritmo de un grupo de algoritmos en tiempo de ejecución.

Características del Strategy:

Encapsula un algoritmo o estrategia específica en una clase.
Los cambios de estrategia suelen ser explícitos y controlados desde afuera, por el cliente del objeto de contexto.
El objeto de contexto sabe qué estrategia está utilizando y normalmente elige entre estrategias concretas predefinidas.
Los algoritmos no suelen cambiar automáticamente y no dependen del estado interno del objeto.
Se enfoca en operaciones o acciones que realiza el objeto y en cómo pueden variar independientemente del ciclo de vida del objeto.

Comparación

Cambios de Comportamiento: En el State, los cambios de comportamiento están ligados al estado interno del objeto. En el Strategy, los cambios de comportamiento se realizan cambiando la estrategia asignada al objeto desde el exterior.
Conocimiento de los Estados/Algoritmos: En el State, el objeto no necesita tener conocimiento de qué estado está activo. En Strategy, el cliente del contexto debe conocer las estrategias concretas para elegir una.
Control de Cambios: En State, los estados suelen controlarse y cambiar desde el interior de la clase de estado. En Strategy, el contexto o el cliente externo controla cuál estrategia se utiliza.

En Resumen

El State se ocupa de lo que un objeto es (estado interno), mientras que el Strategy se ocupa de lo que un objeto hace (comportamiento o algoritmo). Mientras que State puede conducir a un cambio en el comportamiento debido a un cambio en el estado interno del objeto, Strategy implica cambiar el comportamiento asignando un nuevo algoritmo, a menudo como resultado de decisiones tomadas fuera del objeto.

🔑 Strategy

Sat, 20 Apr 2024 00:00:00 GMT

Video de BettaTech

El patrón de diseño Strategy es un patrón de comportamiento que permite definir una familia de algoritmos, encapsular cada uno de ellos como un objeto, y hacerlos intercambiables. Strategy permite variar los algoritmos utilizados por un objeto de manera dinámica sin alterar el uso de los algoritmos por parte de los clientes.

Intención

El propósito del patrón Strategy es:

Desacoplar un algoritmo de su clase y esconder los detalles de implementación al cliente.
Permitir el cambio dinámico de comportamiento de un objeto cuando su estado interno cambia.

Uso

El patrón Strategy es especialmente útil cuando:

Varias versiones de un algoritmo existen, y el cliente no debe conocer los detalles de implementación.
La implementación de un algoritmo puede cambiar independientemente de los clientes que lo utilizan.
Hay múltiples comportamientos condicionales y quieres evitar múltiples sentencias condicionales.

Estructura

El patrón Strategy se compone de tres partes principales:

Contexto (Context):
- Mantiene una referencia a una estrategia concreta (ConcreteStrategy) y puede definir una interfaz que permite a la estrategia acceder a sus datos.
- Delega el trabajo a la estrategia asociada en lugar de ejecutarlo por sí mismo.
Estrategia (Strategy):
- Es una interfaz o clase abstracta común a todos los algoritmos concretos que forman parte de esta familia de algoritmos.
- Declara un método usualmente llamado execute() o perform() que será implementado por cada algoritmo concreto.
Estrategias Concretas (ConcreteStrategies):
- Son implementaciones concretas de la interfaz Strategy que encapsulan cada uno de los algoritmos.
- Cada uno define su propio método execute() o perform() con el comportamiento específico.

Ventajas

Flexibilidad: Al separar las estrategias y el contexto, puedes cambiar el comportamiento del contexto en tiempo de ejecución cambiando su estrategia.
Reutilización: Las estrategias pueden ser reutilizadas entre diferentes contextos.
Principios SOLID: Strategy favorece la programación orientada a interfaces y soporta el principio de inversión de dependencias, que dice que las clases de alto nivel no deberían depender de las clases de bajo nivel, sino de abstracciones.

Desventajas

Complejidad Adicional: Puede sobrecomplicar el código si se utiliza para casos que no requieren una variabilidad de comportamientos significativa.
Conocimiento de las Estrategias: Los clientes deben conocer las diferencias entre las estrategias para poder seleccionar la adecuada.

Ejemplo Aplicado

Un ejemplo común es un sistema de pago en línea donde puedes tener diferentes estrategias para procesar un pago (por ejemplo, con tarjeta de crédito, PayPal, criptomoneda). El cliente selecciona la estrategía de pago y el contexto (sistema de pago) utiliza la estrategia para procesar el pago sin conocer los detalles de la implementación.

Resumen

En conclusión, el patrón Strategy es fundamental para diseñar sistemas flexibles y fácilmente extensibles, permitiendo el cambio de algoritmos en tiempo de ejecución sin gran impacto en el código cliente. Permite separar la selección de un algoritmo de su ejecución, proporcionando una serie de alternativas para realizar una tarea específica.

Estructura

Este diagrama UML ilustra el patrón de diseño Strategy. Cada parte del diagrama se explica a continuación:

Contexto (Context):
- La clase Context es la clase que utiliza la estrategia y tiene un método que se refiere a la estrategia, a menudo llamado algo como ContextInterface(). En la práctica, este método utilizará un objeto de la estrategia para ejecutar una parte de su algoritmo.
- Posee una referencia a la interfaz Strategy que se muestra con una línea que termina en un rombo blanco, indicando una relación de asociación; la clase Context contiene o tiene acceso a un objeto Strategy.
Estrategia (Strategy):
- La clase Strategy es una interfaz o clase abstracta que define una operación común para todas las estrategias concretas, denominada aquí AlgorithmInterface(). Esta operación es el método que el Context va a ejecutar.
Estrategias Concretas (ConcreteStrategyA, ConcreteStrategyB, ConcreteStrategyC):
- Las clases ConcreteStrategyA, ConcreteStrategyB, y ConcreteStrategyC son implementaciones concretas de la interfaz Strategy. Cada una de ellas implementará AlgorithmInterface() de manera que realice un comportamiento específico del algoritmo.
- Aunque comparten la misma operación AlgorithmInterface(), cada implementación de la operación realizará probablemente acciones muy diferentes; estas diferencias representan las distintas estrategias que el Context puede utilizar.

La esencia de este diagrama es que el objeto Context puede cambiar su comportamiento en tiempo de ejecución al cambiar el objeto Strategy que está utilizando sin cambiar su interfaz. Esto le permite variar su comportamiento dinámicamente al delegar detalles operativos a los objetos de estrategia, en lugar de implementar múltiples comportamientos en sí mismo.

📃Template-Method

Sat, 20 Apr 2024 00:00:00 GMT

Ejemplo WTF

Esto es lo que no tenemos que hacer

Claro, aquí tienes un resumen conciso de los puntos clave del patrón de diseño Template Method:

Concepto Principal

El Template Method es un patrón de diseño que define el esqueleto de un algoritmo en un método, postergando algunos pasos algorítmicos a las subclases. Esto permite que las subclases puedan alterar ciertos pasos del algoritmo sin cambiar su estructura general.

Uso

Se utiliza cuando varios algoritmos tienen estructuras similares pero difieren en algunos pasos específicos.
Ayuda a evitar la duplicación de código y promueve la reutilización al centralizar el código común en una clase base.

Estructura

Clase Abstracta: Define un método plantilla (templateMethod()) que contiene un algoritmo con pasos definidos, algunos de los cuales son implementados por subclases.
Subclases Concretas: Implementan los detalles específicos de los pasos del algoritmo que varían entre las diferentes implementaciones.

Ventajas

Reutilización de Código: Centraliza el código común, reduciendo la duplicación.
Extensibilidad: Facilita la introducción de nuevas variantes de un algoritmo sin modificar el código existente.
Control: El flujo del programa es controlado desde el nivel superior, permitiendo una mejor gestión del comportamiento del software.

Desventajas

Rigidez: Puede resultar en jerarquías de clases rígidas si las subclases tienen que seguir una estructura de método plantilla muy estricta.
Complejidad: Puede ser difícil seguir el flujo de control cuando el algoritmo es complejo y distribuido a través de múltiples subclases.

Aplicaciones Típicas

Muy usado en frameworks y bibliotecas donde se define un algoritmo estándar con puntos de extensión específicos para que los usuarios los adapten según necesiten.

Este patrón es fundamental para diseñar aplicaciones robustas y fácilmente extensibles, manteniendo un alto nivel de coherencia y cohesión en el código base.

Estructura

La imagen que has proporcionado ilustra el patrón de diseño Template Method a través de un diagrama UML (Unified Modeling Language). Este diagrama muestra la relación entre una clase abstracta y una clase concreta en el contexto de este patrón. A continuación, te explico cada uno de los elementos del diagrama:

AbstractClass:
- Es una clase abstracta que define un método llamado TemplateMethod(). Este método es el método plantilla que dicta el algoritmo general. En el contexto del patrón, este método invoca una serie de operaciones en un orden específico.
- Contiene declaraciones de métodos llamados PrimitiveOperation1() y PrimitiveOperation2(). Estos son llamados dentro de TemplateMethod() y son los pasos del algoritmo que varían según la implementación específica. Por lo tanto, se definen como operaciones, pero su implementación exacta se deja a las subclases.
ConcreteClass:
- Esta es una subclase de AbstractClass y proporciona implementaciones concretas de los métodos PrimitiveOperation1() y PrimitiveOperation2().
- Cuando TemplateMethod() se ejecuta en una instancia de ConcreteClass, se llamarán las implementaciones de PrimitiveOperation1() y PrimitiveOperation2() de ConcreteClass.
Flecha de Herencia:
- La flecha sólida de ConcreteClass a AbstractClass indica que ConcreteClass hereda de AbstractClass.
Líneas discontinuas con marcadores de llamada:
- Las líneas discontinuas que apuntan a los métodos PrimitiveOperation1() y PrimitiveOperation2() desde TemplateMethod() indican que estos métodos son invocados (llamados) por TemplateMethod(). En UML, estas líneas discontinuas suelen representar llamadas a métodos o utilización de métodos definidos en otro lugar.

Este diagrama UML está comunicando que AbstractClass establece un algoritmo en TemplateMethod(), pero deja algunos de los detalles específicos de ese algoritmo para ser definidos por ConcreteClass. De esta manera, las clases concretas que extienden AbstractClass pueden alterar partes del algoritmo sin cambiar la estructura general del mismo.

Ejemplo Práctico (Ejercicio 4 Cálculo de sueldos)

Sea una empresa que paga sueldos a sus empleados, los cuales están organizados en tres tipos: Temporarios, Pasantes y Planta. El sueldo se compone de 3 elementos: sueldo básico, adicionales y descuentos.

| | Temporario | Pasante | Planta | |----------|-------------------------------------------------|------------------|-------------------------------| | básico | $ 20.000 + cantidad de horas que trabajo * $ 300| $20.000 | $ 50.000 | | adicional| $5.000 si está casado$2.000 por cada hijo | $2.000 por examen que rindió | $5.000 si está casado$2.000 por cada hijo$2.000 por cada año de antigüedad | | descuento| 13% del sueldo básico5% del sueldo adicional| 13% del sueldo básico5% del sueldo adicional | 13% del sueldo básico5% del sueldo adicional |

Tareas

Diseñe la jerarquía de Empleados de forma tal que cualquier empleado puede responder al mensaje #sueldo.
Desarrolle los test cases necesarios para probar todos los casos posibles.
Implemente en Java.

Diagrama

Codigo

Empleado

public abstract class Empleado {
	private String nombre;
	protected double cantidadHijos;
	protected Boolean estaCasado;
	
	public Empleado(String nombre) {
		this.nombre = nombre;
	}
	
	public double calcularSueldo() {
		return this.getBasico() + getAdicional() - getDescuento();
	}
	
	abstract double getBasico();
	abstract double getAdicional();
	
	double getDescuento() {
		return this.getBasico() * 0.13 + this.getAdicional() * 0.05;
	}
	
	public void setCasado(Boolean estaCasado) {
		this.estaCasado = estaCasado;
	}
	
	public void cantidadHijos(double cantidadHijos) {
		this.cantidadHijos = cantidadHijos;
	}
}

Empresa

public class Empresa {
	List<Empleado> empleados = new ArrayList<Empleado>();
	
	public void agregarEmpleado(Empleado e) {
		this.empleados.add(e);
	}
}

Pasante

public class Pasante extends Empleado{
	private double examenesRendidos;
	
	public Pasante(String nombre) {
		super(nombre);
	}

	@Override
	double getBasico() {
		return 20000;
	}

	@Override
	double getAdicional() {
		return 2000 * this.examenesRendidos;
	}
	
	public void setExamenesRendidos(double cantidadExamenes) {
		this.examenesRendidos = cantidadExamenes;
	}
}

Planta

public class Planta extends Empleado{
	private double antiguedad;
	
	public Planta(String nombre) {
		super(nombre);
		// TODO Auto-generated constructor stub
	}

	public void setAntiguedad(double antiguedad) {
		this.antiguedad = antiguedad;
	}
	
	@Override
	double getBasico() {
		return 50000;
	}

	@Override
	double getAdicional() {
		double total = 0;
		if (this.estaCasado) {
			total = total + 5000;
		}
		return total + (2000 * this.cantidadHijos) + (2000 * this.antiguedad);  
		
	}
}

Temporal

public class Temporal extends Empleado{
	private double cantidadHoras;
	
	public Temporal(String nombre) {
		super(nombre);
	}  

	public void setCantidadHoras(double horas) {
		this.cantidadHoras = horas;
	}
	
	@Override
	double getBasico() {
		return 20000 + (this.cantidadHoras * 300);
	}

	@Override
	double getAdicional() {
		if (this.estaCasado) {
			return 5000 + (2000 * this.cantidadHijos);
		}
		return 2000 * this.cantidadHijos;
		
	}
}

Test

public class EmpleadoTest {
	
	Pasante pasante;
	Planta planta;
	Temporal temporal;
	
	@BeforeEach
	void setUp() throws Exception {
		temporal = new Temporal("Temporal");
		pasante = new Pasante("Pasante");
		planta = new Planta("Planta");		
	}
	
    @Test
    public void testTemporal() {
    	temporal.setCantidadHoras(10);
    	temporal.setCasado(true);
    	temporal.cantidadHijos(1);
    	
        assertEquals(23000, temporal.getBasico());
        assertEquals(7000, temporal.getAdicional());
        assertEquals((23000 * 0.13) + (7000 * 0.05), temporal.getDescuento());
    }
    
    @Test
    public void testPasante() {
    	pasante.setExamenesRendidos(10);
    	
        assertEquals(20000, pasante.getBasico());
        assertEquals(20000, pasante.getAdicional());
        assertEquals((20000 * 0.13) + (20000 * 0.05), pasante.getDescuento());
    }
    
    @Test
    public void testPlanta() {
    	planta.setCasado(true);
    	planta.cantidadHijos(1);
    	planta.setAntiguedad(1);
    	
        assertEquals(50000, planta.getBasico());
        assertEquals(9000, planta.getAdicional());
        assertEquals((50000 * 0.13) + (9000 * 0.05), planta.getDescuento());
    }
}

🔌 Adapter

Fri, 19 Apr 2024 00:00:00 GMT

Ejemplo Practico

Supongamos que tienes un sistema de figuras geométricas 2D y deseas extenderlo para manejar figuras 3D. Las figuras 3D tienen métodos distintos para dibujar y moverse (por ejemplo, 3dDraw() y 3dMove()). Podrías crear un adaptador que permita manejar estas figuras 3D como si fueran figuras 2D, proporcionando así una interfaz uniforme en el editor de figuras.

Este patrón es especialmente útil en sistemas donde no puedes controlar el código fuente de las clases que necesitas usar, facilitando la integración y la extensibilidad sin modificar el comportamiento existente.

| Sistema | Implementación a Agregar | | --------- | --------- | | | |

Transformación

Ahora que sabemos cual es el problema y no podemos modificar nada, vamos a crear un adaptador entre los dos sistemas. El adapter termina heredando los meotodos de la interfaz que se quiere adaptar.

| Sistema | Implementación a Agregar | | --------- | --------- | | | |

Una vez que entendemos este concepto, vamos a identificar los respectivos roles futuras explicaciones.

Estructura

Ejemplo: Integración de figuras 3D en un sistema de figuras 2D

Escenario: Supongamos que tienes un sistema de edición gráfico que hasta ahora ha trabajado solo con figuras 2D (como círculos y rectángulos), y necesitas extenderlo para soportar figuras 3D (como esferas y cubos). El sistema de figuras 2D utiliza métodos como draw() y move(). Las figuras 3D, en cambio, tienen métodos como draw3D() y move3D().

Objetivo: Queremos que las figuras 3D sean tratadas como figuras 2D por el editor gráfico, sin cambiar la interfaz de usuario ni el código del cliente que maneja las figuras 2D.

Descripción de los componentes:

Target (Figura2D):
- Esta es la interfaz que el cliente espera usar. Define métodos como draw() y move().
Client (Editor):
- Utiliza objetos que implementan la interfaz Figura2D. Este cliente quiere usar figuras 3D pero sin alterar su forma de interactuar con figuras 2D.
Adapter (Adaptador3D):
- Implementa la interfaz Figura2D y adapta la interfaz de las figuras 3D al mundo de las figuras 2D.
- Contiene una instancia de Figura3D y traduce las llamadas de los métodos draw() y move() de la interfaz Figura2D a draw3D() y move3D() respectivamente.
Adaptee (Figura3D):
- Clase que define una interfaz que necesita ser adaptada para ser utilizada por el cliente. En este caso, Figura3D tiene métodos como draw3D() y move3D() que son incompatibles directamente con el sistema existente de figuras 2D.

Funcionamiento:

Cuando el Editor (cliente) necesita dibujar o mover una figura, llama a draw() o move() en la interfaz Figura2D.
El Adaptador3D recibe estas llamadas y las traduce a draw3D() y move3D() del objeto Figura3D.
La Figura3D realiza las acciones necesarias y el resultado se refleja en la interfaz del usuario como si se estuviese manejando una figura 2D convencional.

Este enfoque permite que el sistema original de figuras 2D se extienda a nuevas dimensiones sin alterar el código cliente existente, garantizando que los nuevos tipos de figuras se integren de manera transparente y manteniendo la cohesión y modularidad del sistema.

Ejemplo Practico

Usted ha implementado una clase Media player, para reproducir archivos de audio y video en formatos que usted ha diseñado. Cada Media se puede reproducir con el mensaje play(). Para continuar con el desarrollo, usted desea incorporar la posibilidad de reproducir Video Stream. Para ello, dispone de la clase VideoStream que pertenece a una librería de terceros y usted no puede ni debe modificarla. El desafío que se le presenta es hacer que la clase MediaPlayer pueda interactuar con la clase VideoStream. La situación se resume en el siguiente diagrama UML:

Tareas:

Modifique el diagrama de clases UML para considerar los cambios necesarios. Si utiliza patrones de diseño indique los roles en las clases utilizando estereotipos.
Implemente en Java

Diagrama

El uml lo corregi pero el codigo no

public class Audio extends Media{
	
	public String play() {
		String nombre = "audio";
		return nombre;
	}
}

public class Media {
	public String play() {
		String nombre = "media";
		return nombre;
	}
}

public class VideoFile extends Media{
	public String play() {
		String nombre = "video file";
		return nombre;
	}
}

public class VideoStream extends VideoFile{
	public String reproduce() {
		String nombre = "video stream";
		return nombre;
	}
}

adapterVideoStream

public class adapterVideoStream extends VideoFile{
	private VideoStream vs = new VideoStream();
	
	public String play() {
		return vs.reproduce();
	}
}

MediaPlayer

public class MediaPlayer {
	private List<Media> media = new ArrayList<Media>(); 
	
	public void play() {
		System.out.println("Play");
	}
	
	public void agregarMedia(Media m) {
		this.media.add(m);
	}
	
	public String concatenarNombresMedia() {
        String nombresConcatenados = "";
        for (int i = 0; i < media.size(); i++) {
            nombresConcatenados += media.get(i).play(); 
            if (i < media.size() - 1) {
                nombresConcatenados += ", "; 
            }
        }
        return nombresConcatenados;
    }
}

Test

public class MediaPlayerTest {
	
	MediaPlayer mp;
	Audio a;
	VideoFile vf;
	VideoStream vs;
	AdapterVideoStream adapter;
	
	@BeforeEach
	void setUp() throws Exception {
		mp = new MediaPlayer();
		a = new Audio();
		vf = new VideoFile();
		adapter = new AdapterVideoStream();
		
		mp.agregarMedia(a);
		mp.agregarMedia(vf);
		mp.agregarMedia(adapter);
	}
	
    @Test
    public void testNombreCompleto() {
    	assertEquals("audio, video file, video stream", mp.concatenarNombresMedia());
    }
}

Final DBD

Sun, 31 Mar 2024 00:00:00 GMT

😎 ESPACIO PUBLICITARIO 😎

En esta pagina tenes preguntas para poder simular el final (Las preguntas de DBD estan sacadas de este blog, solo que en este no las respondi)

Modelado De Datos
procesamiento de Consultas
Seguridad e Integridad de los Datos

Modelado de Datos

Capitulo 9. `Introducción al modelado de Datos`

Es un conjunto de herramientas conceptuales que permiten describir la información que es necesaria administrar para un SI (Sistema de Información), las relaciones existen entre estos datos, la semántica asociada y las restricciones de consistencia

Es desarrollado durante la etapa de adquisición de conocimiento del problema; el analista se independiza del tipo de SGBD (Sistema de Gestión de Bases de Datos) a utilizar y, por consiguiente, dedl producto de mercado. Así, el modelo conceptual se desarrolla independientemente de su implementación final.

El analista debe determinar el tipo de SGBD, debido a que las decisiones que debe tomar dependen de esa elección.

Es necesario tomar decisiones específicas. Estas últimas tienen que ver con el producto de mercado a utilizar, es decir, el SGBD específico.

Capitulo 10. `Modelado Entidad Relación Conceptual`

Ejemplos

Ejemplo

Cardinalidades

Ejemplo

Identificador Simple

Identificador Compuesto

Identificador Externo

Capitulo 11. `Modelado Entidad Relación Lógico`

Ejemplo de como deberian verse los atributos polivalentes

Primer Ejemplo de Relacion de Jerarquia (P-E)

Sobre el mismo ejemplo pero aplicando la 3ra opción

Segundo Ejemplo de Relacion de Jerarquia (T-E)

Resolución con la 3era opción

Las otras dos opciones aunque se pueden aplicar, no son rentables en este caso ya que perdemos mucha legibilidad y mantenibilidad en el modelo.

Capitulo 12. `Modelado Fisico (Relacional)`

No entiendo muy bien cuando hablan de un id Auto Incremental

Capitulo 13. `Conceptos de Normalización`

Procesamiento de Consultas

Capitulo 14. `Lenguajes de Procesamientom de Datos (Algebra y Calculo)`

Los lenguajes de procesamiento de datos permiten operar con la información contenida en una BD

Selección

Proyección

Producto Cartesiano

Resultado

Renombre

Resultado

Union

Tablas

Resultado

Diferencia

Tablas

Resultado

Producto Natural

Resultado

Seria esto sin las tablas repetidas

Intersección

Resultado

Asignación

División

Altas

Bajas

Modificaciones

Capitulo 15. `SQL y QBE`

Me tengo que hacer algun apunte sobre todo SQL no porque sea mucho que lo es, sino que es mucho de forma muy distina, muchas operaciones.

Capitulo 16. `Optimización de Consultas`

Seguridad e Integridad de los Datos

Capitulo 17. `Concecptos de Transacciones`

Capitulo 18. `Transacciones en Entornos Concurrentes`

Capitulo 19. `Seguridad e Integridad`

Finales

Final de Marzo 2024

1) Por que se debe remover la jerarquia del modelo logico relacional

2) Que cardinalidad deben poseer los atributos derivados?

3) Para que se define la Integridad Referencial y que ventajas trae?

4) porque el modelo conceptual es independiente del tipo de dbms?

5) Por que el DBMS es el encargado de hacer la optimizacion

6) Que diferencia hay entre lenguaje procedural y no procedural

7) Durabilidad en entornos monousuario

8) Por que no hay agregacion en el Where

9) crear tu pregunta

Finales

[!NOTE]
Es un recopilatorio de preguntas, algunas pueden que esten bien y otras mal porque depende de la interpretación o justificación de cada uno, en este caso vamos a tratar justificar todo en base al libro

Temario de Preguntas

[!TIP] Responder todo, ya fuee

Sacado del libro

Las funciones de agregación en una consulta

[ ] a) Pueden ir en el SELECT
[ ] b) Pueden ir en el WHERE
[ ] c) Pueden ir en el HAVING (SI O SI)
[ ] d) Pueden aparecer sin otros atributos en el select
[ ] e) Todas son correctas
[ ] f) A, C y D son correctas
[ ] g) A, B y C son correctas
[ ] h) A y C son correctas

En el SELECT si, en el WHERE no

[ ] f) A, C y D son correctas

Registro historico / Bitacora

Un checkPoint en ambientes concurrentes

[ ] a) Solo se genera si se utiliza el protocolo de HDE
[ ] b) Solo se genera si se utiliza el protocolo de dos fases
[ ] c) Se aplica en el protocolo de doble paginación
[ ] d) Se coloca siempre entre dos transacciones, cuando ninguna esta activa
[ ] e) Todas las anteriores
[ ] f) Algunas de las anteriores
[ ] g) Ninguna de las anteriores

[ ] g) Ninguna de las anteriores

La propiedad de aislamiento

[ ] a) No se aplica en un ambiente concurrente
[ ] b) Se aplica en un ambiente concurrente
[ ] c) No se aplica en un ambiente monousuario
[ ] d) Se aplica en un ambiente monousuario
[ ] e) Algunas de las anteriores
[ ] f) Ninguna de las anteriores

Es la B y la D

Se aplica en ambos ambientes

Se tiene una jerarquia total exclusiva en el modelo conceptual. Al pasar dicho modelo al logico se debe decidir que hacer con la misma

[ ] a) Se puede dejar solo al padre
[ ] b) Se puede dejar solo a los hijos
[ ] c) Se puede dejar todas las entidades
[ ] d) Todas las anteriores son validas
[ ] e) Algunas de las anteriores son validas
[ ] f) No tengo datos suficientes para responder

[!IMPORTANT] En la foto de donde lo saque estaba corregida

Todas las anteriores son validas

En las otras, solo se puede dejar al padre o toda la estructura

Una dependencia multivaluada

[ ] a) Puede generar repetición innecesaria de información
[ ] b) Genera repetición de información si no es una dependencia multivaluada trivial
[ ] c) Genera repetición innecesaria de información
[ ] d) Todas las anteriores son correctas
[ ] e) Algunas de las anteriores son correctas
[ ] f) Ninguna de las anteriores es correcta

Falta responder

Preguntar

Trivial es que no se puede eliminar del esquema

Un esquema fisico que no tiene dependencias parciales esta en:

[ ] a) 3FN
[ ] b) 5FN
[ ] c) 2FN
[ ] d) 1FN
[ ] e) 4FN
[ ] f) BCNF
[ ] g) Todas las anteriores
[ ] h) Algunas de las anteriores
[ ] i) Ninguna de las anteriores

Falta responder

Un atributo depende de un subconjunto (Una parte) de otro atributo

[ ] i) Ninguna de las anteriores

Suponga que tiene tablas

Alumnos = (idAlumno, nombre, edad)
Materias = (idMateria, nombre, año)
Inscribe = (idAlumno, idMateria)

Indique cual sentencia AR muestra al alumno con las materias en las que se inscribió.

Como referencia

P proyeccción, S selección, I Intersección, R renombre

[ ] a) Pnombre (alumnos |x| materias |x| inscribe)
[ ] b) Pnombre (alumnos) |x| Pnombre (materias)
[ ] c) Pnombre (alumnos) |x| Pnombre (materias) |x| inscribe)
[ ] d) Palumnos.nombre, materias.nombre (alumnos |x| materias)
[ ] e) Ninguna de las anteriores

[!IMPORTANT] En la foto de donde lo saque estaba corregida

Ninguna de las anteriores

La siguiente consulta SQL: SELECT * FROM B INNER JOIN A ON (A.id = B.id)

[ ] a) Retorna solo las filas de A que tengan coincidencia con las filas de B en el atributo id.
[ ] b) Retorna solo las filas de B que no tengan coincidencia con las filas de A en el atributo id.
[ ] c) Proyecta solo las columnas de A
[ ] d) Retorna todas las filas de B
[ ] e) Proyecta solo las columnas de B
[ ] f) Hay más de una respuesta correcta
[ ] g) Todas las anteriores son correctas
[ ] h) Ninguna de las anteriores es correcta

Falta responder
[ ] h) Ninguna de las anteriores es correcta

Modificada

[ ] a) Retorna solo las filas de B que tengan coincidencia con las filas de A en el atributo id.

La función de agregación SUM de SQL:

[ ] a) Requiere de una cláusula GROUP BY.
[ ] b) Calcula el máximo para una columna de la tabla.
[ ] c) Cuenta los valores distintos para una fila de la tabla
[ ] d) Se puede utilizar en la clausula HAVING sin utilizar un GROUP BY
[ ] e) Hay más de una opcion válida
[ ] f) Todas las anteriores son correctas
[ ] g) Ninguna de las anteriores es correcta

Falta responder
[ ] g) Ninguna de las anteriores es correcta

Ninguna funcion de agregación necesita el GROUP BY

La operación de proyección en Álgebra Relacional:

[ ] a) Es un operador binario
[ ] b) Es un operador unitario
[ ] c) Es equivalente a la clausula "Where" de SQL
[ ] d) Es equivalente a la clausula "Order By" de SQL
[ ] e) Puede proyectar elementos repetidos
[ ] f) Hay más de una opción valida
[ ] g) Todas las opciones anteriores son válidas
[ ] h) Ninguna de las opciones anteriores es válida

[ ] b) Es un operador unitario

Si una entrada en el registro bitácora tiene el siguiente formato: "<T1, dato, valor anterior, valor nuevo>"

[ ] a) Utiliza bitácora con modificación diferida
[ ] b) Utiliza el protocolo de hora de hora de entrada (Este se usa en concurrente)
[ ] c) Utiliza bítacora con modificación inmediata
[ ] d) Utiliza el protocolo de página en la sombra (nada que ver)
[ ] e) Hay más de una opción valida
[ ] f) Todas las opciones anteriores son válidas
[ ] g) Ninguna de las opciones anteriores es válida

[ ] c) Utiliza bítacora con modificación inmediata

Diferida no tiene el valor anterior

Dada una transacción T1 que obtiene un bloqueo exclusivo sobre el dato D1 y otra transacción T2 que obtiene un bloque exclusivo sobre el dato D2, entonces:

[ ] a) T1 no deberá esperar a que T2 libere el dato si desea leer D2
[ ] b) T2 no deberá esperar a que T1 libere el dato si desea leer D1
[ ] c) T1 no debera esperar a que T2 libere el dato para poder escribir D2
[ ] d) T2 no deberá esperar a que T1 libere el dato para poder escribir D1
[ ] e) T1 deberá esperar a que T2 libere el dato si desea leer D2
[ ] f) T2 deberá esperar a que T1 libere el dato si desea leer D1
[ ] g) Hay más de una opción valida
[ ] h) Todas las opciones anteriores son válidas
[ ] i) Ninguna de las opciones anteriores es válida

Falta responder
[ ] g) Hay más de una opción valida (e y f)

Cualquier bloqueo esclusivo va a tener que esperar si o si por todo, y si es compartido, solo puede leer.

Una jerarquía con cobertura Parcial y Exclusiva (P, E), al pasar al modelo lógico:

[ ] a) No es posible dejar solamente las entidades hijas
[ ] b) No se puede quitar la entidad generalizadora// Esto es el padre???
[ ] c) Se deja la jerarquia completa sin relacionar las entidades que la componen
[ ] d) No se realiza cambio alguno
[ ] e) Hay más de una opción válida
[ ] f) Todas las opciones anteriores son válidas
[ ] g) Ninguna de las opciones anteriores es válida

[ ] e) Hay más de una opción válida
[ ] a) No es posible dejar solamente las entidades hijas
[ ] b) No se puede quitar la entidad generalizadora// Esto es el padre???

Una relación entre dos entidades en un modelo conceptual:

[ ] a) Puede no tener cardinalidad
[ ] b) No puede contener un atributo opcional polivalente (En logico NO)
[ ] c) No puede contener un atributo compuesto monovalente (En logico NO)
[ ] d) No debe contener atributos
[ ] e) No puede contener más de un atributo opcional monovalente
[ ] f) Puede contener un atributo identificador (WTF)
[ ] g) Hay más de una opción válida
[ ] h) Todas las opciones anteriores son válidas
[ ] i) Ninguna de las opciones anteriores es válida

[ ] i) Ninguna de las opciones anteriores es válida

Un identificador compuesto de una entidad en el modelo conceptual, cuando se realiza el pasaje al logico relacional: Como que no existe.

Vamos a suponer que hablan del modelo entidad relación logico. Y que estan hablando con propiedad.

[ ] a) Se debe transformar debido a que el modelo lógico relacional no acepta este tipo de identificadores
[ ] b) Se deja sin modificación alguna
[ ] c) Se debe separar en distintos atributos y uno de ellos será elegido identificador de la entidad
[ ] d) Se elimina del modelo lógico relacional
[ ] e) Hay más de una opción válida
[ ] f) Todas las opciones anteriores son válidas
[ ] g) Ninguna de las opciones anteriores es válida

[ ] b) Se deja sin modificación alguna

Una clave foránea en el modelo físico

[ ] a) No puede ser opcional
[ ] b) No acepta valores repetidos
[ ] c) Puede ser clave primaria y foránea al mismo tiempo y en la misma tabla (wtf)
[ ] d) Hay más de una opción válida
[ ] e) Todas las opciones anteriores son válidas
[ ] f) Ninguna de las opciones anteriores es válida

Decime si es opcional o no

[ ] b) No acepta valores repetidos (esta es falsa)

DEJAMOS HASTA ACA

En el algebra Relacional la expresión A U B

[ ] a) Requiere que A y B contengan la misma cantidad de elementos (esta incompleta)
[ ] b) Requiere que el esquema de B se encuentre contenido en el esquima de A //div
[ ] c) Requiere que el esquima de A se encuentre contenido en el esquema de B //div
[ ] d) Hay más de una opción valida
[ ] e) Todas las opciones anteriores son válidas
[ ] f) Ninguna de las opciones anteriores es válida

[ ] f) Ninguna de las opciones anteriores es válida

¿Cuál de las siguientes afirmaciones es cierca acerca de la normalización de base de datos?

[ ] a) La normalización es el proceso de agregar redundancia a una base de datos para mejorar la eficiencia de las consultas
[ ] b) La normalización es el proceso de eliminar la redundancia en una base de datos para evitar problemas de inconsistencia de datos
[ ] c) La normalización es el proceso de crear copias de seguridad de una base de datos para protegerla de pérdidas de datos
[ ] d) La normalización es el proceso de cifrar los datos en una base de datos para proteger su confidencialidad
[ ] e) Todas las opciones anteriores son verdaderas
[ ] f) Algunas de las opciones anteriores son verdaderas
[ ] g) Ninguna de las opciones anteriores es verdadera

Falta responder

¿Cuál de las siguientes afirmaciones es verdadera sobre el modelo Entidad-Relación(ER)?

[ ] a) El modelo ER es un modelo lógico que se enfoca en la implementación física de la base de datos
[ ] b) Las entidades en el modelo ER representan relaciones entre los datos
[ ] c) Las relaciones en un modelo ER representan vínculos entre las entidades
[ ] d) El modelo ER no incluye atributos para las entidades y relaciones
[ ] e) Todas las opciones anteriores son verdaderas
[ ] f) Algunas de las opciones anteriores son verdaderas
[ ] g) Ninguna de las opciones anteriores es verdadera

Falta responder

¿Cuál de las siguientes técnicas es útil para optímizar consultas SQL en una base de datos?

[ ] a) Usar subconsultas en lugar de productos de tablas
[ ] b) Evitar el uso de índices para las claves primarias
[ ] c) Usar funciones de agregación en lugar de GROUP BY
[ ] d) Usar el operador LIKE en lugar de igualdad para comparaciones de cadenas
[ ] e) Todas las opciones anteriores son verdaderas
[ ] f) Algunas de las opciones anteriores son verdaderas
[ ] g) Ninguna de las opciones anteriores es verdadera

Falta responder

¿Cuál de las siguientes afirmaciones es verdadera sobre el modelo lógico relacional?

[ ] a) Se pueden tener atributos compuestos
[ ] b) Se pueden tener atributos derivados
[ ] c) No se pueden tener identificadores compuestos
[ ] d) Se pueden tener atributos polivalentes
[ ] e) Todas las opciones anteriores son verdaderas
[ ] f) Algunas de las opciones anteriores son verdaderas
[ ] g) Ninguna de las opciones anteriores es verdadera

Falta responder

¿Cuál de las siguientes afirmaciones es cierta acerca de la integridad referencial en una base de datos relacional?

[ ] a) La integridad referencial garantiza que cada registro en una tabla tenga un valor único en su clave primaria.
[ ] b) La integridad referencial asegura que los valores en una tabla sean válidos en referencia a otra tabla.
[ ] c) La integridad referencial solo se aplica a las tablas que tienen una clave foránea.
[ ] d) La integridad referencial no es necesaria en una base de datos relacional.
[ ] e) Todas las opciones anteriores son verdaderas
[ ] f) Algunas de las opciones anteriores son verdaderas
[ ] g) Ninguna de las opciones anteriores es verdadera

Falta responder

Un atributo derivado posee información disponible en una entidad. Si esa información no estuviera sería posible aún calcularla. Entonces

[ ] a) Contiene información redundante y puede quitarse del modelo
[ ] b) Contiene información redundante y debe quitarse del modelo
[ ] c) No contiene información redundante y debe dejarse en el modelo
[ ] d) No contiene información redundante
[ ] e) Todas las anteriores son correctas
[ ] f) Algunas de las anteriores son correctas
[ ] g) Ninguna de las anteriores es correcta

Falta responder

¿Cuáles de las siguientes cláusulas son necesarias para una consulta de selección de datos en SQL?

[ ] a) SELECT
[ ] b) FROM
[ ] c) WHERE
[ ] d) Todas las anteriores
[ ] e) Algunas de las anteriores
[ ] f) Ninguna de las anteriores

Falta responder

¿Qué afirmación describe mejor la relacion entre la cantidad de tuplas o filas generadas por las cláusulas LEFT JOIN e INNER JOIN en una consulta SQL?

[ ] a) Generan igual cantidad de tuplas o filas
[ ] b) LEFT JOIN genera menos cantidad de tuplas o filas que INNER JOIN
[ ] c) LEFT JOIN genera más cantidad de tuplas o filas que INNER JOIN
[ ] d) LEFT JOIN puede generar igual cantidad de tuplas o filas que INNER JOIN
[ ] e) Todas las anteriores son correctas
[ ] f) Algunas de las anteriores son correctas
[ ] g) Ninguna de las anteriores es correcta

Falta responder

¿Cuál de las siguientes afirmaciones es verdadera acerca de las tablas en una base de datos?

[ ] a) Tienen una clave primaria
[ ] b) No pueden tener claves candidatas
[ ] c) Deben tener al menos una clave foránea
[ ] d) No pueden tener claves foráneas
[ ] e) Todas las anteriores son correctas
[ ] f) Algunas de las anteriores son correctas
[ ] g) Ninguna de las anteriores es correcta

Falta responder

¿Qué significa la condición de idempotencia en el contexto de las transacciones en una base de datos?

[ ] a) Garantiza que una transacción se pueda ejecutar varias veces con el mismo resultado
[ ] b) Garantiza que una transacción que ha fallado se pueda ejecutar varias veces con el mismo resultado
[ ] c) Garantiza que una transacción que se ha registrado de transacciones se pueda ejecutar varias veces con el mismo resultado
[ ] d) Todas las anteriores son correctas
[ ] e) Algunas de las anteriores son correctas
[ ] f) Ninguna de las anteriores es correcta

Falta responder

Una jerarquia con cobertura Parcial y Exclusiva (P, E), al pasar al modelo lógico:

[ ] a) Es posible dejar solamente las entidades hijas
[ ] b) Se puede quitar la entidad generalizadora
[ ] c) Se deja la jerarquia completa sin relacionar las entidades que la componen
[ ] d) No se realiza cambio alguno
[ ] e) Hoy más de una opción válida
[ ] f) Todas las opciones anteriores son válidas
[ ] g) Ninguna de las opciones anteriores es válida

Falta responder

Una relación entre dos entidades en un modelo conceptual:

[ ] a) Puede no tener cardinalidad
[ ] b) No puede contener un atributo opcional polivalente
[ ] c) No puede contener un atributo compuesto monovalente
[ ] d) No debe contener atributos
[ ] e) Puede contener más de un atributo opcional monovalente
[ ] f) Puede contener un atributo identificador
[ ] g) Hay más de una opción válida
[ ] h) Todas las opciones anteriores son válidas
[ ] i) Ninguna de las opciones anteriores es válida

Falta responder

Una clave foránea en una tabla del modelo físico

[ ] a) No puede ser opcional
[ ] b) No acepta valores repetidos
[ ] c) No es clave primaria en ninguna tabla del modelo físico
[ ] d) Hay mas de una opción válida
[ ] e) Todas las opciones anteriores son válidas
[ ] f) Ninguna de las opciones anteriores es válida

Falta responder

En el algebra Relacional la expresión A U B

[ ] a) Requiere que A y B contengan la misma cantidad de elementos
[ ] b) Requiere que el esquema de B se encuentre contenido en el esquema de A
[ ] c) Requiere que el esquema de A se encuentre contenido en el esquema de B
[ ] d) Hay más de una opción válida
[ ] e) Todas las opciones anteriores son válidas
[ ] f) Ninguna de las opciones anteriores es válida

Falta responder

La función de agregación AVG de SQL:

[ ] a) Requiere de una cláusula GROUP BY.
[ ] b) Calcula el máximo para una columna de la tabla.
[ ] c) Cuenta los valores distintos para una fila de la tabla
[ ] d) Se puede utilizar en la clausula HAVING sin utilizar un GROUP BY
[ ] e) Hay más de una opcion válida
[ ] f) Todas las anteriores son correctas
[ ] g) Ninguna de las anteriores es correcta

Falta responder

La operación de diferencia (-) en Álgebra Relacional:

[ ] a) Es un operador binario
[ ] b) Es un operador unitario
[ ] c) Es equivalente a la clausula "Where" de SQL
[ ] d) Es equivalente a la clausula "Order By" de SQL
[ ] e) Puede proyectar elementos repetidos
[ ] f) Hay más de una opción válida
[ ] g) Todas las opciones anteriores son válidas
[ ] h) Ninguna de las opciones anteriores es válida

Falta responder

El algebra relacional

[ ] a) Es un lenguaje de consultas teorico de BD relacional que define como hacer las operaciones de manipulacion de datos
[ ] b) Es un lenguaje de consultas teorico de BD entidad relación que define como hacer las operaciones de manipulación de datos
[ ] c) Es un lenguaje de consultas teorico de BD relacional que define solamente el resultado esperado en la respuesta
[ ] d) Es un lenguaje de consultas teorico de BD entidad relación que define solamente el resultado esperado en la respuesta.

Falta responder

La clausula EXIST en SQL

[ ] a) Solo se aplica en una operación de consulta
[ ] b) Necesita necesariamente una subconsulta
[ ] c) No utiliza en el select que la contiene una función de agregación
[ ] d) Todas las anteriores
[ ] e) Algunas de las anteriores
[ ] f) Ninguna de las anteriores

Falta responder

La clausula DELETE en SQL

[ ] a) Es una clausula de definicion de datos
[ ] b) Es una clausula de manipulacion de datos
[ ] c) Puede alcanzar el estado Cometido
[ ] d) Todas las anteriores
[ ] e) Ninguna de las anteriores

Falta responder

Una transacción que alcanza el espacio de fallada

[ ] a) Puede volver a activarse
[ ] b) Puede alcanzar el estado Abortada
[ ] c) Puede alcanzar el estado Cometido
[ ] d) Todas las anteriores
[ ] e) Ninguna de las anteriores

Falta responder

Ante dos transacciones concurrentes que generan un problema de integridad contra la BD

[ ] a) Es preferible que haya un deadlock a tener inconsistencia
[ ] b) Es preferible que haya inconsistencia si el deadlock produce inanición
[ ] c) Es preferible que haya inconsistencia antes que tener deadlock
[ ] d) Todas las anteriores
[ ] e) Ninguna de las anteriores

Falta responder

Un atributo derivado

[ ] a) Representa un dato que está presente de otra forma en el modelo
[ ] b) Puede estar en el modelo logico
[ ] c) Puede estar en el modelo fisico
[ ] d) Hay más de una opción válida
[ ] e) Todas las opciones anteriores son válidas
[ ] f) Ninguna de las opciones anteriores es válida

Falta responder

Un atributo polivalente sobre el modelo conceptual

[ ] a) Indica que el atributo esta formado por varios atributos simples
[ ] b) Indica que el atributo puede tener multiples valores, pero no puede ser nulo
[ ] c) Indica que el atributo puede tener multiples valores, pero debe aceptar ser nulo
[ ] d) Todas las anteriores son correctas
[ ] e) Algunas de las anteriores son correctas
[ ] f) Ninguna de las anteriores es correcta

Falta responder

Una relación del modelo lógico cuando se pasa al fisico

[ ] a) Siempre se convierte en tabla
[ ] b) En algún caso puede no convertirse en tabla
[ ] c) No se convierte en tabla
[ ] d) Todas las anteriores son correctas
[ ] e) Algunas de las anteriores son correctas
[ ] f) Ninguna de las anteriores es correcta

Falta responder

Una jerarquia parcial superpuesta, donde el padre tiene tres hijos, cuando se convierte al modelo fisico

[ ] a) Puede quedar solo el padre
[ ] b) Puede quedar solo los hijos
[ ] c) Puede quedar todo con relaciones es un
[ ] d) Todas las anteriores son correctas
[ ] e) Algunas de las anteriores son correctas
[ ] f) Ninguna de las anteriores es correcta

Falta responder

Un identificador simple de una tabla

[ ] a) Puede ser un atributo con valor nulo
[ ] b) Puede ser un atributo polivalente
[ ] c) Puede ser un atributo derivado
[ ] d) Todas las anteriores son correctas
[ ] e) Algunas de las anteriores son correctas
[ ] f) Ninguna de las anteriores es correcta

Falta responder

Un identificador de una entidad sobre el modelo lógico, cuando dicha entidad se convierte en tabla sobre el fisico

[ ] a) Puede ser clave primaria
[ ] b) Puede ser clave candidata
[ ] c) Puede ser clave secundaria
[ ] d) Todas las anteriores son correctas
[ ] e) Algunas de las anteriores son correctas
[ ] f) Ninguna de las anteriores es correcta

Falta responder

Una clave primaria en el esquema fisico de una BD

[ ] a) Puede haber sido clave candidata
[ ] b) No ha sido clave candidata
[ ] c) Ha sido identificador en el esquema lógico
[ ] d) No ha sido identificador en el esquema conceptual
[ ] e) Ninguna de las anteriores

Falta responder

Para la construcción del modelo ER-Conceptual, es necesario

[ ] a) Contar con la definición del DBMS a utilizar
[ ] b) Contar con la descripción detallada de las necesidades de usuario
[ ] c) Contar con un DBA experimentado en el DBMS a utilizar
[ ] d) Todas las anteriores son correctas
[ ] e) Ninguna de las anteriores

Falta responder

Un ciclo de entidades

[ ] a) Representa una solución donde se repite información
[ ] b) Debe ser quitado del modelo logico
[ ] c) Aparece en el modelo fisico y repite información
[ ] d) Todas las anteriores son correctas
[ ] e) Ninguna de las anteriores

Falta responder

Una entidad en el esquema fisico

[ ] a) No puede tener atributos polivalentes
[ ] b) No puede tener atributos compuestos
[ ] c) Tiene al menos un identificador
[ ] d) Puede tener más de un identificador
[ ] e) Algunas de las anteriores
[ ] f) Ninguna de las anteriores

[!IMPORTANT] En la foto de donde lo saque estaba corregida

Ninguna de las anteriores

Una relación recursiva en el esquema lógico

[ ] a) Solo tiene un identificador
[ ] b) Puede tener más de un identificador
[ ] c) Puede tener más de un atributo
[ ] d) No puede tener atributos con cardinalidad máxima N
[ ] e) Algunas de las anteriores
[ ] f) Ninguna de las anteriores

Falta responder

Un ciclo de relaciones en el esquema conceptual

[ ] a) Puede generar redundancia
[ ] b) Si genera redundacia, luego debe eliminar el ciclo del proceso d(se corta)
[ ] c) Siempre es entre 4 o más entidades
[ ] d) Algunas de las anteriores
[ ] e) Ninguna de las anteriores

[!IMPORTANT] En la foto de donde lo saque estaba corregida

Puede generar redundancia

Un atributo derivado

[ ] a) Puede ser clave
[ ] b) Puede tener valor nulo
[ ] c) Puede ser polivalente
[ ] d) Todas las anteriores son correctas
[ ] e) Ninguna de las anteriores

Falta responder

La operación de proyección en Álgebra Relacional

[ ] a) Es un operador binario
[ ] b) Es un operador unitario
[ ] c) Es equivalente a la clausula "Where" de SQL
[ ] d) Es equivalente a la clausula "Order By" de SQL
[ ] e) Puede proyectar elementos repetidos
[ ] f) Hay más de una opción válida
[ ] g) Todas las opciones anteriores son válidas
[ ] h) Ninguna de las opciones anteriores es válida

[!IMPORTANT] En la foto de donde lo saque estaba corregida

Es un operador unitario

Dada una transacción T1 que obtiene un bloqueo exclusivo sobre el dato D1 y otra transacción T2 que obtiene un bloqueo exclusivo sobre el dato D2, entonces:

[ ] a) T1 no deberá esperar a que T2 libere el dato si desea leer D2
[ ] b) T2 no deberá esperar a que T1 libere el dato si desea leer D1
[ ] c) T1 no debera esperar a que T2 libere el dato para poder escribir D2
[ ] d) T2 no deberá esperar a que T1 libere el dato para poder escribir D1
[ ] e) T1 deberá esperar a que T2 libere el dato si desea leer D2
[ ] f) T2 deberá esperar a que T1 libere el dato si desea leer D1
[ ] g) Hay más de una opción valida
[ ] h) Todas las opciones anteriores son válidas
[ ] i) Ninguna de las opciones anteriores es válida

[!IMPORTANT] En la foto de donde lo saque estaba corregida

Hay más de una opción valida

¿Cuál de las siguientes afirmaciones es verdadera sobre el modelo lógico relacional?

[ ] a) Se pueden tener atributos compuestos
[ ] b) Se pueden tener atributos derivados
[ ] c) No se pueden tener identificadores compuestos
[ ] d) Se pueden tener atributos polivalentes
[ ] e) Todas las opciones anteriores son verdaderas
[ ] f) Algunas de las opciones anteriores son verdaderas
[ ] g) Ninguna de las opciones anteriores es verdadera

[!IMPORTANT] En la foto de donde lo saque estaba corregida

Se pueden tener atributos derivados

Si en una consulta SQL se utiliza la cláusula GROUP BY

[ ] a) Se debe utilizar la cláusula HAVING
[ ] b) Se puede indicar la condición del grupo en la cláusula WHERE
[ ] c) Se debe utilizar al menos una función de agregación
[ ] d) Todas las anteriores
[ ] e) Algunas de las anteriores
[ ] f) Ninguna de las anteriores

[!IMPORTANT] En la foto de donde lo saque estaba corregida

Se debe utilizar al menos una función de agregación

En algebra relacional la empresa A |x| B da el mismo resultado que:

[ ] a) A x B
[ ] b) A x B si entre las tablas A y B no hay atributo común
[ ] c) B |x| A
[ ] d) Todas las anteriores
[ ] e) Ninguna de las anteriores

[!IMPORTANT] En la foto de donde lo saque estaba corregida

B |x| A

En el algebra relacional la expresión A - B

[ ] a) Requiere que A y B contengan la misma cantidad de elementos
[ ] b) Requiere que el esquema de B se encuentre contenido en el esquema de A
[ ] c) Requiere que el esquema de A se encuentre contenido en el esquema de B
[ ] d) Hay más de una opción válida
[ ] e) Todas las opciones anteriores son válidas
[ ] f) Ninguna de las opciones anteriores es válida

[!IMPORTANT] En la foto de donde lo saque estaba corregida

ESTA CORREGIDA COMO ERROR

Hay más de una opción válida

La función de agregación SUM() de SQL:

[ ] a) Necesita de una cláusula GROUP BY
[ ] b) Calcula el máximo para una columna de la tabla
[ ] c) Puede contar los valores distintos para una fila de la tabla
[ ] d) Se puede utilizar en la clausula HAVING sin utilizar un GROUP BY
[ ] e) Hay más de una opcion válida
[ ] f) Todas las anteriores son correctas
[ ] g) Ninguna de las anteriores es correcta

[!IMPORTANT] En la foto de donde lo saque estaba corregida

Ninguana de las anteriores es correcta

Una clave candidata en una tabla del modelo físico

[ ] a) Es un atributo o conjunto de atributos que juntos se pueden repetir dentro de la misma tabla.
[ ] b) Es un atributo o conjunto de atributos que juntos conforman un atributo opcional
[ ] c) No puede estar conformada por más de un atributo
[ ] d) Puede estar conformada por más de un atributo opcional
[ ] e) Puede estar conformada por más de un atributo monovalente obligatorio
[ ] f) Hay más de una opción válida
[ ] g) Todas las opciones anteriores son válidas
[ ] h) Ninguna de las opciones anteriores es válida

[!IMPORTANT] En la foto de donde lo saque estaba corregida

Puede estar conformada por más de un atributo monovalente obligatorio

Preguntas del ostin

Los profes dijeron que solo estudiemos de las preguntas con fotos

Cuál de las siguientes afirmaciones es cierta acerca de la normalización de base de datos?

[ ] a) La normalización es el proceso de agregar redundancia a una base de datos para mejorar la eficiencia en las consultas
[ ] b) La normalización es el proceso de eliminar la redundancia en una base de datos para evitar problemas de inconsistencia de datos.
[ ] c) La normalización es el proceso de crear copias de seguridad de una base de datos para protegerla de pérdidas de datos.
[ ] d) La normalización es el proceso de cifrar los datos en una base de datos para proteger su confidencialidad.
[ ] e) Todas las opciones anteriores son verdaderas.
[ ] f) Algunas de las opciones anteriores son verdaderas.
[ ] g) Ninguna de las opciones anteriores es verdadera.

b) La normalización es el proceso de eliminar la redundancia en una base de datos para evitar problemas de inconsistencia de datos.

¿Cuál de las siguientes afirmaciones es verdadera sobre el modelo Entidad-Relación (ER)?

[ ] a) El modelo ER es un modelo lógico que se enfoca en la implementación física de la base de datos.
[ ] b) Las entidades en el modelo ER representan relaciones entre los datos.
[ ] c) Las relaciones en un modelo ER representan vínculos entre las entidades.
[ ] d) El modelo ER no incluye atributos para las entidades y relaciones.
[ ] e) Todas las opciones anteriores son verdaderas.
[ ] f) Algunas de las opciones anteriores son verdaderas.
[ ] g) Ninguna de las opciones anteriores es verdadera.

c) Las relaciones en un modelo ER representan vínculos entre las entidades.

¿Cuál de las siguientes técnicas es útil para optimizar consultas SQL en una base de datos?

[ ] a) Usar subconsultas en lugar de productos de tablas.
[ ] b) Evitar el uso de índices para las claves primarias.
[ ] c) Usar funciones de agregación en lugar de GROUP BY.
[ ] d) Usar el operador LIKE en lugar de igualdad para comparaciones de cadenas.
[ ] e) Todas las opciones anteriores son verdaderas.
[ ] f) Algunas de las opciones anteriores son verdaderas.
[ ] g) Ninguna de las opciones anteriores es verdadera.

Lo unico que sabemos es que NINGUNA esta puesta como mal en el parcial, alguna tiene que ser

¿Cuál de las siguientes afirmaciones es verdadera sobre el modelo lógico relacional?

[ ] a) Se pueden tener atributos compuestos.
[ ] b) Se pueden tener atributos derivados.
[ ] c) No se pueden tener identificadores compuestos.
[ ] d) Se pueden tener atributos polivalentes.
[ ] e) Todas las opciones anteriores son verdaderas.
[ ] f) Algunas de las opciones anteriores son verdaderas.
[ ] g) Ninguna de las opciones anteriores es verdadera.

Se pueden tener atributos derivados

¿Cuál de las siguientes afirmaciones es cierta acerca de la integridad referencial en una base de datos relacional?

[ ] a) La integridad referencial garantiza que cada registro en una tabla tenga un valor único en su clave primaria.
[ ] b) La integridad referencial asegura que los valores en una tabla sean válidos en referencia a otra tabla.
[ ] c) La integridad referencial solo se aplica a las tablas que tienen una clave foránea.
[ ] d) La integridad referencial no es necesaria en una base de datos relacional.
[ ] e) Todas las opciones anteriores son verdaderas.
[ ] f) Algunas de las opciones anteriores son verdaderas.
[ ] g) Ninguna de las opciones anteriores es verdadera.

Sabemos que algunas no es

Ya me canse de escribir

Final AYED

Sat, 23 Dec 2023 00:00:00 GMT

Final Ayed

Bueno, por lo que me dijeron este final es full teorico. Aca dejo uno que me pasaron.

Imagenes

Final FOD

Tue, 12 Dec 2023 00:00:00 GMT

😎 ESPACIO PUBLICITARIO 😎

En esta pagina tenes preguntas para poder simular el final

El objetivo de este blog es poder tener la información necesaria para aprobar el final y que no dependa de si conseguiste finales o si no sabes donde encontrar información para estudiar.

Final de septiembre (07/09/2023)

En cada caso marcar una sola opción correcta. Cada respuesta correcta suma 1 punto, cada respuesta incorrecta resta 0.5 y un inciso sin responder es neutro.

Pregunta 1)

Dado el siguiente árbol B+ es de 5. La operación de baja del valor 52:

Nodo 0: 4, i, 1(23) 2(52) 3(73) 4(88) 5
Nodo 1: 4, h, (5) (9) (15) (20)
Nodo 2: 3, h, (25) (32) (41)
Nodo 3: 2, h, (53) (62)
Nodo 4: 1, h, (78)
Nodo 5: 1, h, (90)

Respuestas

a) Genera: lectura nodo 0, lectura nodo 5 y ninguna escritura.
b) Genera: lectura nodo 0, lectura nodo 5, lectura nodo 4 y escritura solo del nodo 0.
c) El árbol desciende de nivel.
d) Genera: lectura nodo 0, lectura nodo 5, lectura nodo 4, escritura nodos 5 y escritura nodo 4.
e) Hay más de una opción valida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

Pregunta 2)

La siguiente secuencia de instrucciones en un archivo con al menos un registro y la siguiente estructura: código de producto y precio:

assign (arch, "archivo.dat");
reset(arch);
read(arch, producto);
producto.codigo:= 1;
producto.precio:= 5000;
write(arch, producto);
close(arch);
reset(arch);
writeln(filesize(arch));

Respuestas

a) Pierde la información del primer registro del archivo.
b) Modifica el código y el precio del primer registro existente en el archivo y lo escribe en su misma posición.
c) Puede imprimir 2 en pantalla
d) Puede imprimir 1 en pantalla
e) Puede imprimir 0 en pantalla
f) Hay más de una opción valida.
g) Todas las opciones anteriores son correctas.
h) Ninguna de las opciones anteriores es correcta.

Pregunta 3)

Se tiene el siguiente archivo para dispersión estática, con la técnica de saturación progresiva encadenada. Si llega la clave B que genera por función de dispersión la dirección 1 (F(B) = 1). Entonces:

| Dir | Clave | Enlace | |-----|--------|--------| | 0 | | -1 | | 1 | A | 3 | | 2 | Z | -1 | | 3 | W | -1 | | 4 | | -1 | | 5 | D | -1 | | 6 | | -1 | | 7 | | -1 |

Respuestas

a) La clave B se almacena en la dirección 0 con enlace a la dirección 3.
b) La clave B se almacena en la dirección 4 con enlace a la dirección 3.
c) La clave B se almacena en la dirección 3 y la clave W se quita del archivo.
d) La clave B se almacena en la dirección 3 y la clave W se mueve a la dirección 4 con enlace a la dirección 3.
e) Hay más de una opción valida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

Esta pregunta no esta corregida.

Pregunta 4)

Dado un archivo organizado con una lista invertida interna al mismo archivo para recuperación de espacio libre:

a) Ante una nueva alta, se debe recorrer el archivo de forma secuencial buscando un espacio libre.
b) La búsqueda de un elemento en el archivo puede realizarse secuencialmente.
c) Ante una nueva alta, siempre se modifica el registro de la posición 0.
d) Ante una baja de un elemento existente en el archivo, siempre se modifica el registro de la posición 0.
e) Hay más de una opción valida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

No hay respuesta

Pregunta 4 Alternativa)

La misma Pregunta

a) Ante una nueva alta, se debe recorrer el archivo de forma secuencial buscando un espacio libre.
b) Ante una nueva alta, siempre se modifica el registro de la posición 0.
c) Ante una baja de un elemento existente en el archivo, siempre se modifica el registro de la posición 0.
d) Si se eliminan todos los registros del archivo, la operación de filesize imprime 0. //Esta no es
e) Hay más de una opción valida.
f) Todas las opciones anteriores son correctas.

Pregunta 5)

Según el estado de un archivo directo para dispersión estensible y bloques o cubetas con capacidad para 3 registros:"

Tabla:

0 (0): 1
1 (1): 0

Claves de registros en Bloques:

0: 1 | 13525(0011010011010101), 12829(0011001000011101), 11541(0010110100010101)
1: 0 | 55344(1101100000110000), 37502(1001001001111110), 20642(0101000010100010)

Respuestas

a) El proceso de alta de la clave 19825 (100110101110001) no produce overflow
b) El proceso de alta de la clave 19825 (100110101110001) produce overflow y no es necesario duplicar la tabla
c) El proceso de alta de la clave 19825 (100110101110001) produce más de un overflow y se duplica la tabla una única vez, quedando la misma con 2 bits asociados (4 entradas)
d) Hay más de una opción valida.
e) Todas las opciones anteriores son correctas.
f) Ninguna de las opciones anteriores es correcta.

No hay respuesta

Pregunta 6) No estan ordenados

Dado un archivo maestro que almacena código ded producto y stock, y dando dos archivos de detalle que almacenan fecha de venta, código de producto y cantidad vendida. El archivo maestro y los detalles no están ordenados, entonces en la implementación de un algoritmo de actualización maestro/detalle:

a) Se aplica un algoritmo de corte de control para procesar ambos archivos de detalle simultáneamente.
b) No es necesario procesar todos los registros del archivo maestro.
c) No es posible actualizar el archivo maestro con los archivos de detalle.
d) Es necesario procesar todos los registros en los archivos detalle
e) Hay más de una opción valida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

Pregunta 6 Alternativa) Estan ordenados

Dado un archivo maestro que almacena código ded producto y stock, y dando dos archivos de detalle que almacenan fecha de venta, código de producto y cantidad vendida. El archivo maestro y los detalles están ordenados por codigo de producto, entonces en la implementación de un algoritmo de actualización maestro/detalle:

a) Se pueden procesar ambos archivos de detalle simultáneamente.
b) Puede no ser necesario procesar todos los registros del archivo maestro.
c) Es necesario procesar todos los registros de los archivos de detalle.
d) Hay más de una opción valida.
e) Todas las opciones anteriores son correctas.
f) Ninguna de las opciones anteriores es correcta.

Pregunta 7)

Dada una función de dispersión

a) Se utiliza saturación progresiva para ubicar registros en overflow.
b) Se utiliza saturación progresiva encadenada para ubicar registros en overflow.
c) Se utiliza saturación progresiva encadenada en áreas separadas para ubicar registros en overflow.
d) Se utiliza dispersión doble para ubicar registros en overflow.
e) Todas las opciones anteriores son correctas.
f) Algunas de las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

Pregunta 8)

Cuando se busca un elemento en un árbol B+

a) Puede necesitar la creación de un nodo.
b) No es necesario acceder al nivel hoja.
c) Puede ser necesario realizar una actualización en un nodo interno.
d) Es necesario acceder al nivel hoja.
e) Hay más de una opción válida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

No hay respuesta

Pregunta 9)

Cuando se busca un elemento en un árbol B (Pueden preguntar lo mismo con árbol B+):

a) Puede necesitar la creación de un nodo.
b) Puede no ser necesario acceder al nivel hoja.
c) Puede ser necesario realizar una actualización en un nodo interno.
d) Es necesario acceder al nivel hoja.
e) Hay más de una opción válida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

Pregunta 10)

Cuando se realiza una baja en un árbol B+:
Cuando se realiza una baja en un árbol B:

Respuestas

a) Puede ocurrir overflow
b) Ocurre underflow
c) Puede ser necesario liberar un nodo.
d) Puede no ser necesario acceder al nivel hoja.
e) Hay más de una opción válida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

No hay respuesta

Pregunta 8)

Un indice secundario es:

a) Una estructura de datos adicional que permite asociar una o varias claves primarias con una clave candidata.
b) Una estructura de datos adicional que contiene el mismo volumen de información que el archivo original
c) Una estructura de datos adicional que permite asociar una o varias claves secundarias con una clave primaria.
d) Hay más de una opción válida.
e) Todas las opciones anteriores son correctas.
f) Ninguna de las opciones anteriores es correcta.

Pregunta 7)

Un árbol AVL es un (utilizar sólo 5 palabras, no más):

Otro Final

Pregunta 1)

Cuando se produce un desborde en dispersión dinámica:

a) En algunos casos aumenta la cantidad de bits asociado al bloque en donde sucede el desborde.
b) Siempre se duplica la tabla asociada al archivo de datos.
c) No es necesario generar un nuevo bloque para el archivo de datos.
d) Puede no ser necesario escribir en el archivo de datos.
e) Hay más de una opción válida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

Pregunta 2)

La siguiente secuencia de instrucciones en un archivo vacío con la siguiente estructura: código de producto y precio:

assign (arch, "archivo.dat");
rewrite(arch);
producto.codigo:= 1;
producto.precio:= 5000;
close(arch);
reset(arch);
writeln(filesize(arch));

Respuestas

a) Pierde Información
b) Modificar el código y el precio del último registro existente en el archivo.
c) Puede imprimir 0 en pantalla
d) Puede imprimir 1 en pantalla //Esta no es
e) No realiza cambio alguno sobre el archivo.
f) Hay más de una opción valida.
g) Todas las opciones anteriores son correctas.
h) Ninguna de las opciones anteriores es correcta.

Pregunta 3)

Final de septiembre (07/09/2023) Pregunta 6 Alternativa

Pregunta 4)

Un árbol AVL

a) Es un árbol binario en donde cada nodo puede tener más de un nodo padre.
b) Es un árbol B balanceado en altura
c) Es una estructura de datos lineal que se puede desbalancear.
d) Puede ser árbol B balanceado en altura.
d) Puede ser árbol B+ balanceado en altura.
e) Hay más de una opción válida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

No hay respuesta

Pregunta 5)

Un índice secundario es:

a) Una estructura de datos adicional que permite asociar una o varias claves primarias con una clave secundaria.
b) Una estructura de datos adicional que contiene el mismo volumen de información que el archivo original
c) Una estructura de datos adicional que permite asociar una o varias claves secundarias con una clave primaria.
d) Una estructura de datos adicional que establece un orden lógico del archivo original.
e) Una estructura de datos adicional que permite relacionar una clave primaria con otra clave candidata.
f) Hay más de una opción válida.
g) Todas las opciones anteriores son correctas.
h) Ninguna de las opciones anteriores es correcta.

No hay respuesta

Pregunta 6)

Cuando se realiza una baja en un árbol B+ de prefijos simples:

a) Necesita la creación de más de un nodo.
b) Siempre se accede al nivel hoja.
c) Es necesario realizar una actualización en un nodo interno.
d) Nunca puede aumentar el nivel del árbol
e) Se promociona una copia de la expresión en un nodo interno. //Esta no es
f) Hay más de una opción válida.
g) Todas las opciones anteriores son correctas.
h) Ninguna de las opciones anteriores es correcta.

Pregunta 7)

Cuando se realiza un alta en un árbol B:

a) El nuevo elemento debe ir en un nodo interno.
b) Ocurre un overflow
c) Puede ocurrir un underflow. //Esta no es
d) Puede ser necesario liberar un nodo.
e) El árbol nunca puede descender de nivel.
f) No es necesario acceder al nivel hoja.
g) Hay más de una opción válida.
h) Todas las opciones anteriores son correctas.
i) Ninguna de las opciones anteriores es correcta.

Pregunta 8)

Cuando se realiza un alta y produce una colisión en dispersión estática:

a) Siempre se genera desborde.
b) Nunca se genera desborde.
c) Se puede generar desborde..
d) Se puede generar una colisión.
e) Hay más de una opción válida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

Pregunta 9)

Dado un archivo organizado con una lista invertida interna al mismo archivo para recuperación de espacio libre:

a) Ante una nueva alta, se recorre el archivo de forma secuencial buscando un espacio libre.
b) Ante una nueva alta, se modifica el registro de la posición 0.
c) Ante una baja de un elemento existente en un archivo, se modifica el registro de la posición 0.
d) Si se eliminan todos los registros del archivo, entonces se debe eliminar el registro en la posición 0 del archivo. //Esta no es
e) La lista invertida interna no puede estar vacía.
f) Hay más de una opción válida.
g) Todas las opciones anteriores son correctas.
h) Ninguna de las opciones anteriores es correcta.

Pregunta 10)

Cuando una clave x y otra clave y generan, por Función de Dispersión, la misma dirección, entonces:

a) Puede ocurrir un desborde.
b) Puede ocurrir una colisión.
c) x e y no son claves sinónimas.
d) Todas las opciones anteriores son correctas. //Esta no es
e) Hay más de una opción válida.
f) Ninguna de las opciones anteriores es correcta.

Final de Julio (06/07/2023)

En cada caso marcar una sola opción correcta. Cada respuesta correcta suma 1 punto, cada respuesta incorrecta resta 0.5 y un inciso sin respuesta es neutro.

Pregunta 1)

Dado un archivo maestro que almacena código de producto y stock, y dado dos archivos de detalle que almacenan fecha de venta, código de producto y cantidad vendida. El archivo maestro ordenado por stock y los detalles por código ded producto, entonces en la implementación de un algoritmo ded actualización maestro/detalle:

a) No se pueden procesar ambos archivos de detalle simultáneamente. //Esta no es
b) No es necesario procesar todos los registros del archivo maestro.
c) Puede no ser necesario procesar todos los registros de los archivos detalle.
d) Hay más de una opción válida.
e) Todas las opciones anteriores son correctas.
f) Ninguna de las opciones anteriores es correcta.

Pregunta 2)

La siguiente secuencia de instrucciones en un archivo con al menos un registro y con la siguiente estructura: código de producto y precio:

assign (arch, "archivo.dat");
rewrite(arch);
producto.codigo:= 1;
producto.precio:= 5000;
write(arch, producto);
close(arch);
reset(arch);
writeln(filesize(arch));

Respuestas

a) Puede perder información. //Esta no es
b) Modifica el código y el precio del último registro existente en el archivo.
c) Imprime 0 en pantalla
d) Imprime 1 en pantalla
e) No realiza cambio alguno sobre el archivo.
f) Hay más de una opción válida.
g) Todas las opciones anteriores son correctas.
h) Ninguna de las opciones anteriores es correcta.

Pregunta 3)

Dado un archivo organizado con una lista invertida interna al mismo archivo para recuperación de espacio libre:

a) El registro ubicado en la posición 1 se considera un registro especial que se utiliza como inicio de la lista.
b) Ante una nueva alta, se recorre el archivo de forma secuencial buscando un espacio libre.
c) Ante una nueva alta, si la lista interna de espacio libre está vacía se recorre el archivo secuencialemnte hasta el final y ahí se agrega el nuevo registro.
d) Ante una baja, no es necesario actualizar la lista interna de espacio libre.
e) Si se eliminan todos los registros del archivo, entonces se debe eliminar el registro en la posición 0 del archivo.
f) La lista invertida interna no puede estar vacía.
g) Hay más de una opción válida. //Esta no es
h) Todas las opciones anteriores son correctas.
i) Ninguna de las opciones anteriores es correcta.

Pregunta 4)

Un índice primario es:

a) Una estructura de datos adicional que permite asociar una o varias claves primarias con una clave secundaria.
b) Una estructura de datos adicional que contiene el mismo volumen de información que el archivo original
c) Una estructura de datos adicional que permite asociar una o varias claves secundarias con una clave primaria.
d) Una estructura de datos adicional que establece un orden lógico del archivo original.
e) Una estructura de datos adicional que permite relacionar una clave primaria con otra clave candidata.
f) Hay más de una opción válida.
g) Todas las opciones anteriores son correctas.
h) Ninguna de las opciones anteriores es correcta.

Pregunta 5)

Un árbol AVL

a) Es un árbol binario en donde cada nodo puede tener más de un nodo padre.
b) Es un árbol B balanceado en altura
c) Es una estructura de datos lineal que se puede desbalancear.
d) Puede ser árbol B balanceado en altura.
d) Puede ser árbol B+ balanceado en altura.
e) Hay más de una opción válida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta. //Esta no es

Pregunta 6)

Cuando se realiza un alta en un árbol B+ de prefijos simples:

a) No necesita la creación de más de un nodo.
b) Siempre se accede al nivel hoja.
c) Puede no ser necesario realizar una actualización en un nodo interno.
d) Nunca puede aumentar el nivel del árbol
e) Siempre se promociona una copia de la expresión minima de la clave.
f) Hay más de una opción válida.
g) Todas las opciones anteriores son correctas.
h) Ninguna de las opciones anteriores es correcta.

Pregunta 7)

Cuando se realiza una baja en un árbol B:

a) El elemento que se elimina no puede estar en un nod interno del árbol.
b) Puede existir underflow y no propagarse hasta el nodo raíz.
c) Puede existir underflow y progagarse hasta el nodo raíz.
d) Siempre es necesario liberar un nodo.
e) El árbol desciende de nivel.
f) No es necesario acceder al nivel hoja.
g) Hay más de una opción válida.
h) Todas las opciones anteriores son correctas.
i) Ninguna de las opciones anteriores es correcta.

Pregunta 8)

Cuando se realiza un alta se produce una colisión en dispersión estática:

a) Siempre se genera desborde.
b) Nunca se genera desborde.
c) Se puede generar desborde.
d) Se puede generar una colisión.
e) Hay más de una opción válida.
f) Todas las opciones anteriores son correctas.
g) Ninguna de las opciones anteriores es correcta.

Pregunta 9)

Cuando una clave x y otra clave y generan, por Función de Dispersión, distinta dirección, entonces:

a) Puede ocurrir un desborde.
b) Puede ocurrir una colisión.
c) x e y no son claves sinónimas. //Esta no es
d) Todas las opciones anteriores son correctas.
e) Hay más de una opción válida.
f) Ninguna de las opciones anteriores es correcta.

Pregunta 10)

Cuando se produce un desborde en dispersión dinámica:

a) En algunos casos aumenta la cantidad de bits asociado al bloque en donde sucede el desborde.
b) Siempre se duplica la tabla asociada al archivo de datos.
c) Se debe generar un nuevo bloque para el archivo de datos.
d) Puede no ser necesario duplicar la tabla asociada al archivo de datos.
e) Puede no ser necesario escribir en el archivo de datos.
f) Hay más de una opción válida. //Esta no es
g) Todas las opciones anteriores son correctas.
h) Ninguna de las opciones anteriores es correcta.

Mas Finales

Final Taller de Programación

Tue, 12 Dec 2023 00:00:00 GMT

En esta página voy a tratar de explicar todo lo que se necesita para aprobar el final independientemente del tema. Hay muchas cosas que uno lo puede deducir, pero en esta cátedra el más mínimo error es motivo para un 2(dos).

💀 Final Taller de Programación

Final Pascal

Video para instalar pascal en vs-code

Si te toca este final, tenes 2 opciones nada más.

Merge acumulador
Arboles

Para ambos temas te tenes que saber si o si:

Agregar Adelante
Agregar Atras
Insertar Ordenado

Agregar Adelante

Procedure AgregarAdelante (var L:lista; x:integer);
Var 
    nue:Lista;
Begin  
    New(nue);  
    nue^.datos:=x;  
    nue^.sig:=L;  
    L:=nue; 
End;

Agregar Atras

procedure AgregarAlFinal(var l,ult:lista;x:integer); 
var  
    nue : lista;
begin 
    new (nue);
    nue^.dato:= x;
    nue^.sig := NIL;
    if l <> Nil then 
        ult^.sig := nue
    else 
        l := nue;
    ult := nue;
end;

Insertar Ordenado

Procedure InsertarElemento ( var pri: lista; x: Integer);
var 
    ant, nue, act: lista;
begin
    new (nue);
    nue^.dato := x;
    act := pri;
    ant := pri;
    while (act<>NIL) and (act^.dato < x) do 
    begin
        ant := act;
        act := act^.sig ;
    end;
    if (ant = act)  then 
        pri := nue   
    else  
        ant^.sig  := nue; 
    nue^.sig := act ;
end;

Mira, para probar los codigos yo lo que hago es hacer una lista de numeros enteros y, insertando lo que quiera probar y despues imprimo la lista para ver si esta bien.

procedure ImprimirLista (L:lista);
begin
    while (L <> nil) do 
    begin
        writeln (L^.dato);
        L:= L^.sig;
    end;
end;

IMPORTANTE: Yo no avanzaria hasta saber bien estos codigos, ya que si tenes algun error en estos es causa de desaprobar :,(

Y con esto nos aseguramos de tener todo en orden.

Bien, una vez que sabemos que funcionan los codigos, vamos a resolver el siguiente final.

Final Merge Acumulador

En este final no me acordaba el insertar ordenado y el modulo recursivo del punto c, lo habia hecho mal

Tenemos los datos relevantes con colores que seria denuncia que contiene lo siguiente:

Categoria de denuncia 1..6
DNI
Direccion
- Numero de calle
- Numero de altura
Mes
Dia
Hora

Bien una vez que tenemos estos datos, podemos empezar a ver los puntos dados.

Punto A

Al decirnos que estan agrupadas por categoria nos indica que es un vector de listas (un vector de 6 agrupa las denuncias por categoria).
Tambien nos dice que estan ordenadas por numero de calle, por lo que usaremos el proceso de InsertarOrdenado

Punto B

Al decir que recibe un vector de listas y devuelve una sola lista nos indica que tenemos que usar un merge y por defecto usamos un agregarAtras en el modulo de minimo.
Cuando nos dice que para cada nro de calle en especifica, ya sabemos que es un merge acumulador (un merge normal pero con un corte de control)
Para los merges acumuladores es recomendable crear una estructura de datos aparte, que tenga los datos solicidatos, en este caso, nro de calle, cantidad total de denuncias y cantidad de denuncias realizadas en el mes de julio

Punto C

Bien, en este caso, yo lo que hago siempre es hacer el module en forma iterativa, para probar y despues lo paso a recursivo. Basicamente cambias el while por el if y despues llavas cambias en donde se incrementa la variable, por una llamada a la funcion con el incremento o modificación correspondiente.

Codigo Completo (No lo probe)

program imperativo;
const
    DIMF = 6;
type
    categoria = 1..DIMF;
    direccion = record
        nroCalle:integer;
        nroAltura:integer;
    end;
    denuncia = record
        cat:categoria;
        DNI:integer;
        dir:direccion;
        mes:integer;
        dia:integer;
        hora:integer;
    end;
    lista = ^nodo;
    nodo = record
        dato:denuncia;
        sig:lista;
    end;
    vectorContador = array [1..DIMF] of lista;

    datoNuevo = record
        nroCalle:integer;
        denunciasTotales:integer;
        denunciasJulio:integer;
    end;
    listaNueva = ^nodoNuevo;
    nodoNuevo = record
        dato:datoNuevo;
        sig:listaNueva;
    end;

procedure insertarOrdenado(var l:lista;d:denuncia);
var
    act,ant,nue:lista;
begin
    new(nue);
    nue^.dato:=d;
    act:=l;
    ant:=l;
    while (act <> nil) and (act^.dato.DNI < d.DNI) do
    begin
        ant:=act;
        act:=act^.sig;
    end;
    if (act = ant) then
        l:=nue
    else
        ant^.sig:=nue;
    nue^.sig:=act;
end;

procedure imprimirLista(l:lista);
begin
    while l <> nil do
    begin
        WriteLn(l^.dato.DNI);
        l:=l^.sig;
    end;
end;

procedure agregarAtras(var l,ult:listaNueva; nro:datoNuevo);
var
    nue:listaNueva;
begin
    new(nue);
    nue^.dato:=nro;
    nue^.sig:=nil;
    if (l = nil) then
        l:=nue
    else
        ult^.sig:=nue;
    ult:=nue;    
end;

procedure leerDenuncia(var d:denuncia);
begin
    
    writeln('Ingresar dni: '); ReadLn(d.DNI);

    if (d.DNI <> 0) then
    begin
        writeln('Ingresar categoria: '); ReadLn(d.cat);
        writeln('Ingresar nroCalle: '); ReadLn(d.dir.nroCalle);
        writeln('Ingresar nroAltura: '); ReadLn(d.dir.nroAltura);
        writeln('Ingresar mes: '); ReadLn(d.mes);
        writeln('Ingresar dias: '); ReadLn(d.dia);
        writeln('Ingresar hora: '); ReadLn(d.hora);
    end;
end;

procedure cargarDenuncias(var vc:vectorContador);
var
    d:denuncia;
begin
    leerDenuncia(d);
    while (d.DNI <> 0) do
    begin
        insertarOrdenado(vc[d.cat],d);
        leerDenuncia(d);
    end;
end;
procedure inicializarVector (var vc:vectorContador);
var
    i:integer;
begin
    for i:=1 to DIMF do
    begin
        vc[i]:=nil;
    end;
end;

procedure minimo(vc:vectorContador; var min:denuncia);
var
    posMin:integer;
    i:integer;
begin
    posMin:=-1;
    min.DNI:=9999;
    for i:=1 to DIMF do
    begin
        if (vc[i] <> nil) and (vc[i]^.dato.DNI < min.DNI) then
        begin
            min.DNI:=vc[i]^.dato.DNI;
            posMin:=i;
        end;
    end;
    if (posMin <> -1) then
    begin
        min:=vc[posMin]^.dato;
        vc[posMin]:=vc[posMin]^.sig;
    end;
end;
procedure mergeAcumulador(vc:vectorContador;var ln:listaNueva);
var
    min:denuncia;
    actual:datoNuevo;
    ult:listaNueva;
begin
    ult:=nil;
    minimo(vc,min);
    while (min.DNI <> 9999) do
    begin
        actual.nroCalle:=min.DNI;
        actual.denunciasTotales:=0;
        actual.denunciasJulio:=0;
        while (min.DNI <> 9999) and (actual.nroCalle = min.DNI)  do
        begin
            actual.denunciasTotales:=actual.denunciasTotales + 1;
            if (min.mes = 6) then
                actual.denunciasJulio:=actual.denunciasJulio + 1;
            minimo(vc,min);  
        end;
        agregarAtras(ln,ult,actual);
    end;
end;
procedure calleDenuncias(l:listaNueva;var nroCalle:integer;calleMax:integer);
begin
    if l <> nil then
    begin
        if (calleMax < l^.dato.denunciasTotales) then
        begin
            calleMax:=l^.dato.denunciasTotales;
            nroCalle:=l^.dato.nroCalle;
        end;
        calleDenuncias(l^.sig,nroCalle,calleMax)
    end;
end;
var
    vc:vectorContador;
    l:listaNueva;
    calleDenuncias:integer;
    calleMaxima:integer;
begin
    inicializarVector(vc);
    cargarDenuncias(vc);
    mergeAcumulador(vc,l);
    calleDenuncias:=0;
    calleMaxima:=-1;
    calleMasDenuncias(l,calleDenuncias,calleMaxima);
    writeln('La calle con mas denuncias es: ', calleDenuncias);
end.

Final Arboles

En este final tenia mal el recorrido del arbol, lo puse dos condicionales en la condicion base. (Y siempre va <> nil en la condicion base)

IMPORTANTE: Primero te diria que resuelvas este parcial con full enteros y despues le agregues los datos compuestos, ya que es mas facil/rapido de testear

En los teoricos suelen tomar el recorrido optimo del arbol

Tenemos recital con los siguientes datos

Nombre de la Banda
Fecha del recital
Cantidad de canciones tocadas
Monto recaudado por la venta de entradas

Bien, una vez que tenemos estos datos, podemos empezar a ver los puntos dados.

Punto A

En el momento que nos dice que tienen que estar en una estructura que permite el recorrido optimo por monto recaudado, usamos un arbol

Punto B

Mira, esta parte puede ser la menos intuitiva, ya que NO tenemos que recorrer el arbol completo, tenemos que recorrer las ramas, hasta estar en el rango de numeros
Tenemos que usar un agregarAtras, ya que el arbol al estar ordenado, mantenemos el orden.

Punto C

Aca simplemente hacemos el modulo iterativo, cambiamos el while por el if y despues cambiamos el incremento de la variable, por la llamada al proceso con el incremento como parametro.

Codigo Completo (No lo probe)

program arboles;
type
    recital = record
        nombreBanda:String;
        fecha:String;
        cantTocadas:integer;
        montoRecaudado:real;
    end;
    arbol = ^nodo;
    nodo = record
        dato:recital;
        HI:arbol;
        HD:arbol;
    end;
    lista = ^nodoNuevo;
    nodoNuevo = record
        dato:recital;
        sig:lista;
    end;

procedure crearArbol(var abb:arbol;nro:recital);
begin
    if (abb = nil) then
    begin
        new(abb);
        abb^.dato:=nro;
        abb^.HI:=nil;
        abb^.HD:=nil;
    end
    else
        if (abb^.dato.montoRecaudado > nro.montoRecaudado) then
            crearArbol(abb^.HI,nro)
        else
            crearArbol(abb^.HD,nro);
end;

procedure leerRecital(var r:recital);
begin
    Write('Ingresar nombreBanda: '); ReadLn(r.nombreBanda);
    if (r.nombreBanda <> 'ZZZ') then
    begin
        Write('Ingresar fecha: '); ReadLn(r.fecha);
        Write('Ingresar cantTocadas: '); ReadLn(r.cantTocadas);
        Write('Ingresar monto Recaudado: '); ReadLn(r.montoRecaudado);
    end;
end;
procedure LeerRecitales(var abb:arbol);
var
    dato:recital;
begin
    leerRecital(dato);
    while dato.nombreBanda <> 'ZZZ' do
    begin
        crearArbol(abb,dato);
        leerRecital(dato);
    end;
end;
procedure agregarAdelante(var l:lista; r:recital);
var
    nue:lista;
begin
    new(nue);
    nue^.dato:=r;
    nue^.sig:=l;
    l:=nue;
end;

procedure entreRango(abb:arbol;nro1,nro2:integer;var l:lista);
begin
    if (abb <> nil)then
    begin
        if (abb^.dato.montoRecaudado < nro1) then
            entreRango(abb^.HD,nro1,nro2,l)
        else if (abb^.dato.montoRecaudado > nro2) then
            entreRango(abb^.HI,nro1,nro2,l)
        else
            begin
                entreRango(abb^.HI,nro1,nro2,l);
                agregarAdelante(l,abb^.dato);
                entreRango(abb^.HD,nro1,nro2,l);
            end;
    end;
end;
procedure recitalesMas12Canciones(l:lista; var cantMas12:integer);
begin
    if (l <> nil) then
    begin
        if (l^.dato.cantTocadas >= 12) then
          cantMas12:= cantMas12 + 1;
        recitalesMas12Canciones(l^.sig,cantMas12);
    end;    
end;
var
    abb:arbol;
    nro1,nro2:integer;
    l:lista;
    cantMas12:integer;
begin
    abb:=nil;
    LeerRecitales(abb);
    nro1:=3;
    nro2:=8;
    l:=nil;
    entreRango(abb,nro1,nro2,l);
    cantMas12:=0;
    recitalesMas12Canciones(l,cantMas12);
    WriteLn('La cantidad de recitales que tocaron mas de 12 canciones son:', cantMas12);
end.

Final Objetos

Video para instalar Java

En todos los finales de objetos son mas o menos lo mismo, con resolver bien este final creo que abarcas todos los temas de objetos.

Cuando rendi este final me dijieron que tenia un 10 en el practico, pero me fue mal en las preguntas teoricas.

IMPORTANTE en este tipo de finales NO tenes collecciones, nos manejamos siempre con arrays

Lo mas importante es identificar los objetos con sus atributos y herencias que tenemos.

Tenista
- Nombre
- Cantidad de Partidos Ganados
- Premios obtenidos en toda su carrera (un array de reales)
Partido
- Fecha (string)
- Lugar
- Resultado
  - SetsEquipo1
  - SetsEquipo2
Partido Single (Heredan de Partido)
- 2 tenistas
Partido Doble (Heredan de Partido)
- 4 tenistas

Una vez que definimos todos los tipos de datos. Empezamos a ver los puntos y definimos los metodos segun el objeto.

Cuando decimos que debe instanciarse con todos sus datos, nos referimos al constructor.

Main (Falta el de dobles pero me estoy durmiendo y no tengo muchas ganas)

public class Ultimo {

    public static void main(String[] args) {

        Tenista t1 = new Tenista("Fabian",2,12);
        Tenista t2 = new Tenista("Fernando",1,1);
        
        String fecha = "1-1-2023";
        String lugar = "La Plata";
        
        Single partidoS = new Single(fecha,lugar,t1,t2); 
        partidoS.registrarResultado(1, 2);
        partidoS.registrarResultado(1, 2);
        partidoS.registrarResultado(1, 2);
        
        partidoS.otorgarPremio(100000);
    }
}

Tenista

public class Tenista {
    private String nombre;
    private int partidosGanados;
    private double premios;
    
    public Tenista(String nombre, int partidosGanados, double premios){
        this.nombre = nombre;
        this.partidosGanados = partidosGanados;
        this.premios = premios;
    }
    
    public void ganoPartido(){
        this.partidosGanados++;
    }
    
    public void agregarPremio(double premio){
        this.premios = this.premios + premio;
    }
    
    public int getPartidosGanados(){
        return this.partidosGanados;
    }
}

Partido

public abstract class Partido {
    private String fecha;
    private String lugar;
    private int lado1;
    private int lado2;
    
    public Partido(String fecha, String lugar){
        this.fecha = fecha;
        this.lugar = lugar;
        this.lado1 = 0;
        this.lado2 = 0;
    }
    
    public void registrarResultado(int lado1, int lado2){
        if (lado1 > lado2) {
            this.lado1++;
        }
        else{
            this.lado2++;
        }
    }
    
    public boolean finalizo(){
        if ((this.lado1 == 3) || (this.lado2 == 3)) {
            return true;
        }
        return false;
    }
    
    abstract public void otorgarPremio(double premio);
    
    public boolean ganoLado1(){
        if (this.lado1 == 3){
            return true;
        }
        return false;
    }
}

Single

public class Single extends Partido {
    private Tenista t1;
    private Tenista t2;
    
    public Single(String fecha, String lugar,Tenista t1, Tenista t2){
        super(fecha,lugar);
        this.t1 = t1;
        this.t2 = t2;
    }

    @Override
    public void otorgarPremio(double premio) {
        //Suponemos que el partido termino (algun lado tiene 3 sets ganados)
        if (this.ganoLado1()){
            this.t1.ganoPartido();
            this.t1.agregarPremio(premio);
        }
        else{
            this.t2.ganoPartido();
            this.t2.agregarPremio(premio);
        }
    }
}

Doble

public class Doble extends Partido {
    Tenista t1E1;
    Tenista t2E1;
    Tenista t1E2;
    Tenista t2E2;
    
    public Doble (String fecha, String lugar, Tenista t1E1, Tenista t2E1, Tenista t1E2, Tenista t2E2){
        super(fecha, lugar);
        this.t1E1 = t1E1;
        this.t2E1 = t2E1;
        this.t1E2 = t1E1;
        this.t2E2 = t1E2;
    }

    public double calcularPremio(int ganadosJ1, int ganadosJ2){
        return (ganadosJ1 / (ganadosJ1 + ganadosJ2));
    }
    @Override
    public void otorgarPremio(double premio) {
        double premio1,premio2 = 0;
        if (this.ganoLado1()){
            premio1 = premio * this.calcularPremio(this.t1E1.getPartidosGanados(), this.t2E1.getPartidosGanados());
            this.t1E1.agregarPremio(premio1);
            premio2 = premio * this.calcularPremio(this.t2E1.getPartidosGanados(), this.t1E1.getPartidosGanados());
            this.t2E1.agregarPremio(premio2);
        }
        else{
            premio1 = premio * this.calcularPremio(this.t1E2.getPartidosGanados(), this.t2E2.getPartidosGanados());
            this.t1E2.agregarPremio(premio1);
            premio2 = premio * this.calcularPremio(this.t2E2.getPartidosGanados(), this.t1E2.getPartidosGanados());
            this.t2E2.agregarPremio(premio2);
        }
    }
}

Final Concurrente

Archivo para programar

El programa tiene la siguiente estructura:

programa NombrePrograma
procesos
- proceso x()
areas
- area1 : AreaP(5, 1, 5, 10) // Recorre la avenida 5, desde la calle 1 hasta la 10
robots
- robot RECOLECTOR
variables
- R1 : RECOLECTOR
comenzar
- AsignarArea(R1, area1)
- Iniciar(R1, 5, 1)
fin

Extraemos los datos del enunciado

programa final
procesos
  proceso VaciarBolsa
  comenzar
    mientras (HayFlorEnLaBolsa)
      depositarFlor
    mientras (HayPapelEnLaBolsa)
      depositarPapel
  fin
  proceso recorrerAvenida
  comenzar
    derecha
    mover
    repetir 18
      mover
      si HayFlorEnLaEsquina
        tomarFlor
  fin
  proceso depositarFlores
  variables
    av:numero
    ca:numero
  comenzar
    av:=PosAv
    ca:=PosCa
    mientras HayFlorEnLaBolsa
      BloquearEsquina(1,6)
      Pos(1,6)
      depositarFlor
      Pos(av,ca)
      LiberarEsquina(1,6)
  fin
areas
  area1: AreaP(1,1,20,1)
  area2: AreaP(1,2,20,2)
  area3: AreaP(1,3,20,3)
  area4: AreaP(1,4,20,4)
  area5: AreaP(1,5,1,5)
  areaMulti: AreaPC(1,6,1,6)
robots
  robot TIPO1
  variables
    av:numero
    ca:numero
    id:numero
  comenzar
    RecibirMensaje(id,RF)
    av:=PosAv
    ca:=PosCa
    VaciarBolsa
    recorrerAvenida
    depositarFlores
    EnviarMesanje(id,RF)
    Pos(av,ca)
  fin
  robot FISCALIZADOR
  variables
    idFinal1:numero
    idFinal2:numero
    id:numero
  comenzar
    EnviarMensaje(1,R1)
    EnviarMensaje(2,R2)
    EnviarMensaje(3,R3)
    EnviarMensaje(4,R4)

    RecibirMensaje(idFinal1,*)
    RecibirMensaje(idFinal2,*)
    RecibirMensaje(id,*)
    RecibirMensaje(id,*)

  fin
variables
  R1:TIPO1
  R2:TIPO1
  R3:TIPO1
  R4:TIPO1
  RF:FISCALIZADOR
comenzar
  AsignarArea(R1,area1)
  AsignarArea(R1,areaMulti)
  AsignarArea(R2,area2)
  AsignarArea(R2,areaMulti)
  AsignarArea(R3,area3)
  AsignarArea(R3,areaMulti)
  AsignarArea(R4,area4)
  AsignarArea(R4,areaMulti)
  AsignarArea(RF,area5)
  
  Iniciar(R1,1,1)
  Iniciar(R2,1,2)
  Iniciar(R3,1,3)
  Iniciar(R4,1,4)
  Iniciar(RF,1,5)
fin

La primera parte la hice mas o menos asi, para simular cuando lleguen todos, se podria usar un repetir o un recibirMensaje en el fiscalizador 4 veces, para saber que estan todos listos

Hay varios parciales que son mas faciles en mi github

Link

Aprobe :D 8

En el teorico me preguntaron sobre el recorrido de un arbol de forma optima, que es lo que esta arriba y tambien que tenia mal el codigo de r-info (El robot jefe recibia el id y despues las flores o algo asi).

Bueno en cuanto a la practica hice tres objetos nada mas, sin herencia ni nada, un objeto Sistema con dos arreglos, uno para partidos y otro para apuestas (Partidos y Apuestas son los otros 2 objetos)

Parciales Objetos 1

Sun, 11 Jun 2023 00:00:00 GMT

Bueno, como primer paso, identificamos todos los objetos, sin los metodos. No hace falta crear el objeto sistema. Con sistema se refiere al conjunto completo de objetos. Una forma de darnos cuenta de que hicimos una buena distribución es que podamos ejecutar todos los metodos desde los test.

Primer Parcial

Uml

Sistema

import java.util.*;
import java.util.stream.Collectors;

public class Sistema {
  private List<Contribuyente> contribuyentes = new ArrayList<>();

  public void altaContribuyente(Contribuyente c) {
    this.contribuyentes.add(c);
  }

  public List<Contribuyente> masPagan(Integer n){
    return this.contribuyentes.stream().limit(n)
      .sorted((ex1, ex2) -> Double.compare (
      ex1.impuestosAPagar(),ex2.impuestosAPagar()
      ))
      .collect(Collectors.toList());
  }
}

Contribuyente

import java.util.*;

public class Contribuyente {
  private String nombre;
  private String apellido;
  private String email;
  private String localidad;
  private List<Bien> bienes = new ArrayList<>();

  public Contribuyente(String nombre, String apellido, String email, String localidad) {
    this.nombre=nombre;
    this.apellido=apellido;
    this.email=email;
    this.localidad=localidad;
  }

  public void altaBien(Bien b){
    this.bienes.add(b);
  }
  public double impuestosAPagar() {
    return this.bienes.stream()
      .mapToDouble(bien -> bien.calcularImpuesto())
      .sum();
  }
  }

Bien

public interface Bien {
  public double calcularImpuesto();
}

Inmueble

public class Inmueble implements Bien{
  private Integer nroPartida;
  private double valorLote;
  private double valorEdificacion;

  public Inmueble(Integer nroPartida, double valorLote, double valorEdificacion) {
    this.nroPartida=nroPartida;
    this.valorLote=valorLote;
    this.valorEdificacion=valorEdificacion;
  }
  @Override
  public double calcularImpuesto() {
    return (this.valorEdificacion + this.valorEdificacion)/100;
  }
}

Vehiculo

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

  public abstract class Vehiculo implements Bien{
  private String patente;
  private LocalDate fechaFabricacion;
  private double valor;
  private Contribuyente contribuyente;

  public Vehiculo(String patente, LocalDate fechaFabricacion, double valor, Contribuyente c) {
    this.patente=patente;
    this.fechaFabricacion=fechaFabricacion;
    this.valor=valor;
    this.contribuyente=c;
  }
  public int antiguedad() {
    return (int) ChronoUnit.YEARS.between(this.fechaFabricacion, LocalDate.now());
  }

  @Override
  public double calcularImpuesto() {
    if (this.antiguedad() > 10) {
      return this.valor;
    }
    return this.valor + ((this.valor/100)*porcentaje());
  }

  public double getValor() {
    return this.valor;
  }

  abstract public int porcentaje();
  }

Embarcación

import java.time.LocalDate;

  public class Embarcacion extends Vehiculo{
  private String nombre;
  public Embarcacion(String patente, LocalDate fechaFabricacion, double valor, Contribuyente c,String nombre) {
    super(patente, fechaFabricacion, valor, c);
    this.nombre=nombre;
  }
  @Override
  public int porcentaje() {
    if (super.getValor() < 1000000) {
      return 10;
    }
    return 15;
  }
}

Automotor

import java.time.LocalDate;

public class Automotor extends Vehiculo{
  public Automotor(String patente, LocalDate fechaFabricacion, double valor, Contribuyente c) {
    super(patente, fechaFabricacion, valor, c);
    this.marca=marca;
    this.modelo=modelo;
  }

  private String marca;
  private String modelo;

  @Override
  public int porcentaje() {
    return 15;
  }
  }

Test

  import static org.junit.jupiter.api.Assertions.assertEquals;

  import java.time.LocalDate;

  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;

  public class VehiculoTest {
  Embarcacion embarcacion;
  Embarcacion embarcacion2;
  Embarcacion embarcacion3;
  Automotor automotor;

  Contribuyente c;
  Sistema sistema;
  LocalDate fecha;
  LocalDate fecha2;

  @BeforeEach
  void setup() throws Exception{
    c = new Contribuyente("Fabian", "777", "fab@gmail.com", "Los Hornos");
    sistema = new Sistema();
    sistema.altaContribuyente(c);
    
    fecha = LocalDate.of(2000, 1, 1);
    fecha2 = LocalDate.of(2022, 1, 1);
  }

  @Test
  public void embarcacionTest() {
    embarcacion = new Embarcacion("1",fecha, 10, c,"Barquito");
    embarcacion2 = new Embarcacion("1",fecha2, 10, c,"Barquito");
    embarcacion3 = new Embarcacion("1",fecha2, 1000000, c,"Barquito");
    
    assertEquals(10, embarcacion.calcularImpuesto());
    assertEquals(11, embarcacion2.calcularImpuesto());
    assertEquals(1150000, embarcacion3.calcularImpuesto()); //El valor mas el 15%
  }
  }

Primer Recuperatorio

Sistema

import java.util.*;

public class Sistema {
private List<Empleado> empleados = new ArrayList<>();

public void altaEmpleado(Empleado e) {
  this.empleados.add(e);
}

public Boolean aplicarDescuento(Orden orden) {
  return empleados.stream()
    .anyMatch(empleado -> empleado.tieneOrden12Meses(orden));
}
}

Empleado

import java.util.*;
import java.util.stream.Collectors;

  public class Empleado {
  private String nombre;
  private double valorHora;
  private List<Orden> ordenes = new ArrayList<>();

  public Empleado(String nombre, double valorHora) {
    this.nombre=nombre;
    this.valorHora=valorHora;
  }

  public void registrarOrden(Orden o) {
    this.ordenes.add(o);
  }

  public double getValorHora() {
    return this.valorHora;
  }

  public List<Factura> facturarOrdenes(List<Orden> ordenes ){
    return ordenes.stream()
      .map(orden -> orden.generarFactura())
      .collect(Collectors.toList());
  }

  public Boolean tieneOrden12Meses(Orden o) {
    return this.ordenes.stream()
      .allMatch(orden -> (
        orden.equals(o) && orden.antiguedad() == 1
        ));
  }
}

Orden

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.List;

public abstract class Orden {
  private String patente;
  private LocalDateTime fecha = LocalDateTime.now();
  protected List<Repuesto> repuestos;

  public Orden(String patente) {
    this.patente=patente;
  }
  public Factura generarFactura() {
    return new Factura(LocalDate.now(),this.patente, this.costoOrden(),getDescuento());
  }

  public double totalRepuesto() {
    return this.repuestos.stream()
    .mapToDouble(repuesto -> repuesto.getCosto())
    .sum();
  }

  public int getDescuento() {
    return 0;
  }

  public int antiguedad() {
    return (int) ChronoUnit.YEARS.between(this.fecha, LocalDateTime.now());
  }
  abstract public double costoOrden();
}

Reparación

import java.time.LocalTime;
import java.util.*;

public class reparacion extends Orden{
  private String descripcion;
  private List<Empleado> empleados = new ArrayList<>();
  private Integer horasNecesarias;
  private LocalTime hora;

  public reparacion(String patente, String descripcion, List<Empleado> empleados, Integer horasNecesarias) {
    super(patente);
    this.descripcion=descripcion;
    this.empleados=empleados;
    this.horasNecesarias=horasNecesarias;
    this.hora=LocalTime.now();
  }

  public double totalEmpleados() {
    return this.empleados.stream()
        .mapToDouble(empleado -> empleado.getValorHora())
        .sum() * this.horasNecesarias;
  }

  @Override
  public double costoOrden() {
    return (super.totalRepuesto() + this.totalEmpleados()) * 1.1;
  }
}

Compra De Repuesto

public class CompraDeRepuesto extends Orden {

  public CompraDeRepuesto(String patente) {
    super(patente);
    // TODO Auto-generated constructor stub
  }

  public Boolean aplicarDescuento() {
    return super.repuestos.stream()
        .anyMatch(repuesto -> repuesto.antiguedad()>5);
  }

  public double incremento() {
    if (this.aplicarDescuento()) {
      return 1.08;
    }
    return 1.15;
  }

  @Override
  public double costoOrden() {
    return super.totalRepuesto()*this.incremento();
  }
}

Factura

import java.time.LocalDate;

public class Factura {
  private LocalDate fecha;
  private String patente;
  private double montoTotal;
  private int descuento;

  public Factura(LocalDate fecha, String patente, double montoTotal, int descuento) {
    this.fecha=fecha;
    this.patente=patente;
    this.montoTotal=montoTotal;
    this.descuento=descuento;
  }
}

Repuesto

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class Repuesto {
  private String nombre;
  private LocalDate fechaFabricacion;
  public double costo;

  public Repuesto(String nombre, LocalDate fechaFabricacion, double costo) {
    this.nombre=nombre;
    this.fechaFabricacion=fechaFabricacion;
    this.costo=costo;
  }

  public double getCosto() {
    return this.costo;
  }

  public int antiguedad() {
    return (int) ChronoUnit.YEARS.between(this.fechaFabricacion, LocalDate.now());
  }
}

Segundo Recuperatorio

Parciales Ingenieria de Software 1

Sun, 07 May 2023 00:00:00 GMT

Podemos extraer todos los datos de nuestro enunciado de la siguiente forma. Tener en cuenta que los roles y actores son los mismos, solo que en HU no tomamos en cuenta el servidor y los actores que surgen por herencia. Las HI y CU son las mismas tambien, solo que no tenemos las que interactuan unicamente con el servidor. Ejemplo, validar DNI o Cargar Noticias.

Tambien podes ver los ejercicios de las practicas en los repositorios de arriba. Sugiero que los intentes hacer por tu cuenta antes de mirar el ejercicio

Quiero aclarar que estos colores los elegi yo porque a mi me gustaron, no es nada especifico de la catedra

| Colores Para identificar | !Color Picker Boxes| | --- | --- | | Roles/Actores | Yellow Color | | Historias de Usuario/Casos de uso | Orange Color | | Datos solicitados o que debe realizar | Purple Color | | Reglas de negocios/Verifica el sistema | Cyan Color |

Vamos a extraer los datos del primer y segundo parcial en 2022

Primera Fecha

En el parcial recomiendo empezar con HU y despues CU para extraer todo lo que hace el sistema y no confundirnos.

Roles

Persona (Usuario no registrado)
Usuario

Historias de Usuario Resueltas

Actores

Persona(Usuario no registrado)
Usuario
Otro
Servidor

Casos de Uso Resueltos

Paso alterno 4: Usuario no registrado. Se informa. Vuelve al paso 2.
Paso alterno 5: Usuario Bloqueado. Se informa. Fin del cu
Paso alterno 6: Contraseña incorrecta. Se informa y se incrementa en un intento
Paso alterno 6: Contraseña incorrecta en el intento 3. Se informa y se bloquea la cuenta. Fin del Cu

Curso Normal: Acciones del actor Acciones del Sistema

Paso 1: El usuario selecciona la opción "Cerrar Sesión" Paso 3: El usuario confirma la operación

Paso 2: El sistema solicita confirmación del usuario Paso 4: El sistema realiza el cierre de sesión y deshabilita las opciones para el acceso a los detalles

Paso alterno 3: No acepta la confirmación. Se notifica. Fin del CU

Curso Normal: Acciones del actor Acciones del Sistema

Paso 1: El usuario selecciona la opción Acceder detalle

Paso 2: El sistema valida la cantidad de accesos

Paso 3: El sistema ejecuta el cu "Recibir Noticias"

Paso 4: El sistema muestra la noticias e incrementa los accesos del usuario

Curso Normal: Acciones del actor Acciones del Sistema

Paso 2: El servidor acepta la conexión y valida el tokem Paso 3: El servidor retorna un conjunto de noticias

Paso 1: El sistema solicita conexión con el servidor y envia tokem Paso 4: El sistema valida noticias recibidas Paso 5: El sistema muestra las noticias en recibidas en pantalla y cierra la conexión con el servidor

Segunda Fecha

Extraemos los datos como en el parcial anterior, la fotocopia esta super borrosa, pero bueno.

Roles

Persona (Cliente no registrado)
Cliente

Historias de Usuario Resueltas

En este parcial hablamos que otro sistema se encarga de liberar la reserva pasadas las 48hs, esto lo pregunte y me dijeron que es una abstracción más y que solo pregunte si esta disponible o no.

Actores

Persona(Usuario no registrado)
Usuario
Otro
Servidor

Casos de Uso Resueltos

El iniciar sesión y cerrar sesión no se implementan

Curso Normal: Acciones del actor Acciones del Sistema

Paso 1: La persona selecciona la opcion "registrar Persona"

Paso 3: La persona ingresa datos solicitados

Paso 2: El sistema solicita nombre, apellido, fecha de nacimiento, dni, dirección de correo electronico y contraseña

Paso 4: El sistema verifica dni no registrado

Paso 5: El sistema valida que la contraseña no tenga mas de 6 caracteres

Paso 6: El sistema valida que la persona no tenga mas de 21 años

Paso alterno 4: dni registrado. Se informa. Fin del cu
Paso alterno 5: contraseña con menos de 6 caracteres. Se notifica. Vuelve al paso 2.
Paso alterno 6: persona menor de 21 años. Se informa. Fin del cu

Curso Normal: Acciones del actor Acciones del Sistema

Paso 1: Otro selecciona "Pedir Presupuesto"

Paso 3: Otro ingresa datos solicitados

Paso 2: El sistema solicita un tipo de carpa, cantidad de personas y fecha del evento.

Paso 4: El sistema valida que la fecha se encuentre en el año actual

Paso 5: El sistema valida que la fecha este disponible

Paso 6: El sistema genera un codigo, imprime el presupuesto y reserva la carpa por 48hs

Paso alterno 4: La fecha no se encuentra en el año actual. Se notifica. Vuelve al paso 2
Paso alterno 5: La carpa no esta disponible. Se notifica. Vuelve al paso 2.

Curso Normal: Acciones del actor Acciones del Sistema

Paso 1: El usuario selecciona la opción "alquilar Carpa"

Paso 3: El usuario ingresa datos solicitados

Paso 2: El sistema solicita codigo de presupuesto, dirección y la seña a pagar

Paso 4: El sistema valida que la seña no sea menor al 50% del monto

Paso 5: El sistema valida que la seña no sea mayor al 100% del monto

Paso 6: El sistema ejecuta el cu "Pagar con tarjeta"

Paso 7: El sistema registra el pago, envia un comprobante con el nro de alquiler y monto restante a pagar al correo

Paso alterno 4: La seña es menor al 50%. Se informa. Fin del Cu
Paso alterno 5: La seña es mayor al 100%. Se informa. Fin del Cu
Paso alterno 6: El pago no se realiza. Se notifica. Fin del CU

Curso Normal: Acciones del actor Acciones del Sistema

Paso 1: El usuario selecciona la opción "Pagar resto"

Paso 3: El usuario ingresa datos solicitados

Paso 2: El sistema solicita numero de alquiler

Paso 4: El sistema valida que no se pago el 100% del pago

Paso 5: El sistema ejecuta el cu "Pagar con tarjeta"

Paso 6: El sistema registra el pago completo del alquiler

Paso alterno 1: Ya se pago el 100% del alquiler

Curso Normal: Acciones del actor Acciones del Sistema

Paso 2:

Paso 1:

Parciales DBD

Sun, 27 Nov 2022 00:00:00 GMT

Conceptual

Parcial Conceptual

Diseño de Bases De Datos- Examen práctico- Primer Fecha- Tema 1- 8/11/2022 Importante: Consignar en primer hoja: nombre, apellido, legajo, tema de examen, turno de práctica, temas rendidos y cantidad de hojas entregadas, En restantes hojas poner legajo y nro hoja/total hojas ¿Modelado conceptual - (Tema 1) Se debe modelar mediante modelo conceptual la información necesaria para un sistema encargado de las ventas de una papelera. La papelera cuenta con varios puntos de venta de los cuales se conoce: número único de punto de venta, dirección detallada, teléfonos y empleados que trabajan en el punto de venta. Un empleado puede ser repositor, vendedor o administrativo. De todos los empleados se conoce: D.N.I, apellidos, nombres y C.U.LT. De los repositores se conoce además la edad; de los vendedores se conocen los títulos, en caso de que posean y de los administrativos se registra el número de pasaporte. Un empleado trabaja en un único punto de venta en un momento determinado pero puede rotar entre los diferentes puntos de venta a lo largo del tiempo. Es necesario conocer el historial de rotaciones de cada empleado en los diferentes puntos de venta de manera cronológica. Cada punto de venta tiene información de los productos que comercializa, de cada producto se registra: precio actual [precio de compra] código de producto (puede repetirse para diferentes puntos de ventas pero no en el mismo punto de venta)| stock actual] stock mínimo, descripción y ubicación. Para las ventas es necesario almacenar: nro ticket fiscal, precio total de la venta, fecha de la venta, iproductos comprados, vendedor que realizó la venta, cliente involucrado y una descripción de la forma de pago. Si la venta es con tarjeta de crédito es necesario además, guardar la cantidad de ¡cuotas en que se realiza el pago y el interés aplicado. Tenga en cuenta que es posible que en un futuro se consulte a cuánto se vendió un determinado producto en una venta determinada. En cambio, para las compras se debe almacenar código único de comprá, fecha, productos involucrados, precio total y proveedor. Tenga en cuenta que es posible que en un futuro se consulte a cuánto se compró un determinado producto en una compra X. De cada proveedor se conoce: razón social, C.U.I.T, posición frente a la afip, nombre de fantasía (puede no tener), dirección detallada, teléfono y mail. Por último de los clientes se conoce D.N.I, apellidos, nombres y C.U.1,T. Los empleados de la papelera pueden ser clientes.

📚 Contexto Resuelto

Punto de venta
- número unico (Identificador)
- dirección detallada
- (0,n) teléfonos
- 1,n <trabaja> empleados
- 1,n <tiene> productos
Persona
- D.N.I
- apellidos
- nombres
- C.U.I.T
Cliente
Empleado
- +repositor
  - edad
- +vendedor
  - (0,n) titulos
- +administrativo
  - nroPasaporte
- <trabaja> 1,1 punto de venta
<trabaja>
- FechaInicio
- (0,1) FechaFin
Producto
- precio actual
- precio de compra
- código de producto (puede repetirse para diferentes puntos de ventas pero no en el mismo punto de venta) <idExterno>
- stock actual
- stock mínimo
- descripción
- ubicación.
Venta
- nro ticket fiscal (Identificador)
- precio total de la venta
- fecha de la venta
- 1,n productos comprados
- 1,1 vendedor que realizó la venta
  - Fecha
- 1,1 cliente involucrado
- descripción forma de pago
- (0, 1) cantidad de cuotas
- (0, 1) interés aplicado
Compra
- código único de comprá
- fecha
- <compro> productos involucrados
  - Precio Compra
- precio total
- (1, 1) proveedor
proveedor
- razón social (identificador)
- C.U.I.T (identificador)
- posición frente a la afip
- (0, 1) nombre de fantasía (puede no tener)
- dirección detallada
- teléfono
- mail

Logico|Fisico

Logico

Solo en (T,E) se puede dejar solo a los hijos, en el resto se puede realizar cualquier opearción.

Fisico Entidades

Los atributos son siempre propios
(0, 1) Solo subrayas el id propio (no importa el caso)
(1, 1)
- (0, 1) Forkeas el identificador y subrayas el id propio
- (1, 1) Lo de arriba pero se puede hacer para uno de los dos lados
- (1, n) Forkeas el identificador y subrayas el id propio
(0, n) - Solo subrayas el id propio (no importa el caso)

Fisico Relaciones

Cuando hablamos de (0, n), hablamos de las dos formas (0, n) y (1, n)

Se generan cuando hay (0, 1) o (0, n) de cualquier lado
(0, 1)
- (0, 1) Junto los dos identificadores y subrayo cualquiera de los dos
- (0, n) Junto los dos identificadores y subrayo el id del lado del (0, 1)
(0, n), (0, n) Junto los dos identificadores y los subrayo los dos (dependiendo del dominio, puedo subrayar el atributo de la relación o no como en el caso del historial)

Parcial

Parcial Logico

Tramos y posee tiene relacion (1, 1)

Parcial Fisico

Entidades

Telefono = (nro)
Persona = (Dni, fk(nombre, distancia), Ny Ap, Dirección, Tipo, Antecedentes Medicos?)
Mail = (mail)
Tramos = (Distancia, fk(nombre), Recaudado)
Carrera = (nombre, Dir Fin, Dia Comienzo)

Relaciones

Llega = (Dni, nombre, Distancia, puesto)
Tiene = (nro, dni)
Tiene2 = (mail, dni)

Algebra y Sql

Algebra Relacional Operaciones importantes

Parcial Algebra y Sql

SOCIO=(nro_socio, DNI, Apellido, Nombre, Fecha_Nacimiento, Fecha_ingreso)
LIBRO=(ISBN, Titulo, Cod_Genero, Descripcion)
COPIA=(ISBN(FK), Nro_Ejemplar, Estado)
EDITORIAL=(Cod_Editorial, Denominación, Telefono, Calle, Numero, Piso, Dpto)
LIBRO-EDITORIAL=(ISBN(FK), Cod_Editorial(FK), Año_Edicion)
GENERO=(Cod_Genero, Nombre_genero)
PRESTAMO= (Nro_Prestamo, nro_Socio(FK), ISBN(FK), Nro_Ejemplar(FK), Fecha_Prestamo, Fecha_Devolucion)

ISBN(FK) y Nro_Ejemplar son foraneas de copia

1) Listar el titulo, género (el Nombre del Género) y descripción de aquellos libros editados por la editorial "Nueva Editorial". Dicho listado deberá estar ordenado por titulo.

Select Distinct (L.Titulo, G.Nombre_genero, L.Descripcion)
from LIBRO L 
    INNER JOIN LIBRO-EDITORIAL LE (L.ISBN = LE.ISBN)
    INNER JOIN EDITORIAL E (LE.Cod_Editorial = E.Cod_Editorial)
    INNER JOIN GENERO G (L.Cod_Genero = G.Cod_Genero)
where (E.Denominacion = Nueva Editorial)
ORDER BY T.Titulo

2) Listar el apellido y nombre de aquellos socios cuya fecha de ingreso esté entre el 01/9/2022 y el 30/09/2022. Dicho listado debera estar ordenado por apellido y nombre.
```
Select s.Apellido, Nombre
from SOCIO s
WHERE (s.Fecha_ingreso BETWEEN "01-9-2022" and "30-09-2022")
ORDER BY s.Apellido, s.Nombre
```
3) Listar el nombre, apellido, fecha de Nacimiento y cantidad de prestamos de aquellos socios que hayan solicitado más de 5 prestamos. Dicho listado deberá estar ordenado por Apellido.

    Select s.Nombre, s.Apellido, Fecha_Nacimiento, CONT(*)
    from SOCIO s
        INNER JOIN PRESTAMO P()

4) Listar el DNI, apellido, y nombre de aquellos socios que no tengan préstamos de libros editados por la editorial "Gran Editorial". Dicho listado deberá estar ordenado por Apellido y Nombre
5) Mostrar que cantidad de socios tienen actualmente libros prestados cuyo estado sea "Bueno"
6) Listar el titulo, genero, denominación de la editorial y año de edición de aquellos libros editados entre los años 1980 y 2015.

Resultado GENERO, LIBRO, LIBRO-EDITORIAL, EDITORIAL

π Titulo, Nombre_genero , Denominación, Año_Edicion(
    GENERO ⨝ LIBRO ⨝ (
        σ Año_Edicion >= '01-1-1980' ʌ Año_Edicion <= '01-1-2015' 
        (LIBRO-EDITORIAL)
    )
    ⨝
    EDITORIAL
    )

7) Agregar un nuevo socio con el nro_socio, DNI, Apellido, Nombre y Fecha de nacimiento que prefiera.

Resultado

SOCIO <= SOCIO ∪ {(1234, 777, "Rey", "Vegeta", 1-1-2000, 1-1-2022)}

8) Modificar el titulo del libro cuyo ISBN es 2152-2020 por el titulo "El Código X"
```
δTITULO <= 'El codigo x' (σ ISBN = 2152-2020 (Libro))
```

Final Organización de Computadoras

Fri, 15 Jul 2022 00:00:00 GMT

Final

⚠️ Las Algunas preguntas estan hechas bajo mi criterio, pueden estar mal, si detectan que algo esta mal, no duden en contactarme por mail:fabianmartinezrincon.123@gmail.com o por discord: fabomartinez

Indice

Finales Echos por mi
Otros Finales Resueltos
Ejemplos de youtube
- Punto Flotante

Practica 1

Ejercicio 1

Vamos a añadir el sistema Ex2 a las representaciones. En el sistema Ex2, sumamos un exceso de (2^{n-1}) (en 8 bits, el exceso es 128) antes de representar el número en binario.

0:
- BSS: 00000000
- BCS: 00000000
- Ca1: 00000000
- Ca2: 00000000
- Ex2: 10000000 (0 + 128)
1:
- BSS: 00000001
- BCS: 00000001
- Ca1: 00000001
- Ca2: 00000001
- Ex2: 10000001 (1 + 128)
127:
- BSS: 01111111
- BCS: 01111111
- Ca1: 01111111
- Ca2: 01111111
- Ex2: 11111111 (127 + 128)
128: //Este esta mal
- BSS: No se puede representar, ya que el rango es de 0 a 255.
- BCS: No se puede representar.
- Ca1: No se puede representar.
- Ca2: No se puede representar.
- Ex2: 00000000 (128 + 128 = 256, pero en 8 bits es 00000000)
255:
- BSS: 11111111
- BCS: No se puede representar.
- Ca1: No se puede representar.
- Ca2: No se puede representar.
- Ex2: 01111111 (255 + 128 = 383, pero en 8 bits es 01111111)
256: No se puede representar en ninguno de los sistemas de 8 bits.
- BSS: No se puede representar
- BCS: No se puede representar
- Ca1: No se puede representar
- Ca2: No se puede representar
- Ex2: No se puede representar
-1:
- BSS: No se puede representar
- BCS: 11111111
- Ca1: 11111110
- Ca2: 11111111
- Ex2: 01111111 (-1 + 128)
-7:
- BSS: No se puede representar
- BCS: 11111001
- Ca1: 11111000
- Ca2: 11111001
- Ex2: 01111001 (-7 + 128)
-127:
- BSS: No se puede representar
- BCS: 10000001
- Ca1: 10000000
- Ca2: 10000001
- Ex2: 00000001 (-127 + 128)
-128:
- BSS: No se puede representar
- BCS: 10000000
- Ca1: 01111111
- Ca2: 10000000
- Ex2: 00000000 (-128 + 128)
-139: No se puede representar en ninguno de los sistemas de 8 bits.
- BSS: No se puede representar
- BCS: No se puede representar
- Ca1: No se puede representar
- Ca2: No se puede representar
- Ex2: No se puede representar
-56:
- BSS: No se puede representar
- BCS: 11001000
- Ca1: 10110111
- Ca2: 10111000
- Ex2: 01001000 (-56 + 128)
130: No se puede representar en BCS, Ca1, ni Ca2 porque el rango permitido es de -128 a 127.
- BSS: 10000010
- BCS: No se puede representar
- Ca1: No se puede representar
- Ca2: No se puede representar
- Ex2: 10000010 (130 + 128 = 258, pero en 8 bits es 00000010)
45:
- BSS: 00101101
- BCS: 00101101
- Ca1: 00101101
- Ca2: 00101101
- Ex2: 10101101 (45 + 128)
90:
- BSS: 01011010
- BCS: 01011010
- Ca1: 01011010
- Ca2: 01011010
- Ex2: 11011010 (90 + 128)
-90:
- BSS: No se puede representar
- BCS: 10100110
- Ca1: 01011001
- Ca2: 01011010
- Ex2: 00100110 (-90 + 128)
0.75 y 2.5: No se pueden representar en sistemas enteros de 8 bits.

Ejemplo de Bogado

Ejercicio 2

Para interpretar las cadenas de 8 bits en los sistemas BSS, BCS, Ca1, Ca2 y Ex2, vamos a analizar cada cadena por separado en cada sistema:

00000000:
- BSS: 0
- BCS: 0
- Ca1: 0
- Ca2: 0
- Ex2: (0 - 128 = -128)
00000001:
- BSS: 1
- BCS: 1
- Ca1: 1
- Ca2: 1
- Ex2: (1 - 128 = -127)
11111110:
- BSS: No se puede representar (número negativo en BSS)
- BCS: -126
- Ca1: -1 (invertir bits de 00000001 que es 1)
- Ca2: -2 (invertir bits de 00000001 que es 1 y sumar 1)
- Ex2: (254 - 128 = 126)
01111111:
- BSS: 127
- BCS: 127
- Ca1: 127
- Ca2: 127
- Ex2: (127 - 128 = -1)
11111111:
- BSS: No se puede representar (número negativo en BSS)
- BCS: -127
- Ca1: -0 (invertir bits de 00000000 que es 0)
- Ca2: -1 (invertir bits de 00000000 que es 0 y sumar 1)
- Ex2: (255 - 128 = 127)
00010001:
- BSS: 17
- BCS: 17
- Ca1: 17
- Ca2: 17
- Ex2: (17 - 128 = -111)
10011001:
- BSS: No se puede representar (número negativo en BSS)
- BCS: -25
- Ca1: -102 (invertir bits de 01100110 que es 102)
- Ca2: -103 (invertir bits de 01100110 que es 102 y sumar 1)
- Ex2: (153 - 128 = 25)
10101010:
- BSS: No se puede representar (número negativo en BSS)
- BCS: -86
- Ca1: -85 (invertir bits de 01010101 que es 85)
- Ca2: -86 (invertir bits de 01010100 que es 85 y sumar 1)
- Ex2: (170 - 128 = 42)
01100110:
- BSS: 102
- BCS: 102
- Ca1: 102
- Ca2: 102
- Ex2: (102 - 128 = -26)

Resumen de los resultados:

| Cadena | BSS | BCS | Ca1 | Ca2 | Ex2 | |------------|-----------|------|------|------|--------| | 00000000 | 0 | 0 | 0 | 0 | -128 | | 00000001 | 1 | 1 | 1 | 1 | -127 | | 11111110 | 254 | -126 | -1 | -2 | 126 | | 01111111 | 127 | 127 | 127 | 127 | -1 | | 11111111 | 255 | -127 | -0 | -1 | 127 | | 00010001 | 17 | 17 | 17 | 17 | -111 | | 10011001 | 153 | -25 | -102 | -103 | 25 | | 10101010 | 170 | -86 | -85 | -86 | 42 | | 01100110 | 102 | 102 | 102 | 102 | -26 |

Ejercicio 3

Ejercicio 4

Vamos a representar los números dados en los sistemas de punto fijo del ejercicio 3 y, si no es posible obtener una representación exacta, indicaremos cuál es la más próxima y calcularemos el error cometido. Si el número está fuera del rango del sistema, lo señalaremos.

Sistema de punto fijo en BSS (7 bits de parte entera y 3 bits de parte fraccionaria)

7:
- Representación: 7
- Error: 0
15.125:
- Representación: 15.125
- Error: 0
2.2:
- Más próxima: 2.25
- Error: (2.25 - 2.2 = 0.05)
8.001:
- Más próxima: 8
- Error: (8 - 8.001 = -0.001)
123.25:
- Representación: 123.25
- Error: 0
50.50:
- Más próxima: 50.5
- Error: 0
120:
- Representación: 120
- Error: 0
1.2:
- Más próxima: 1.25
- Error: (1.25 - 1.2 = 0.05)
1.25:
- Representación: 1.25
- Error: 0
35:
- Representación: 35
- Error: 0
-1.25:
- No se puede representar (fuera del rango)
1.0625:
- Más próxima: 1.125
- Error: (1.125 - 1.0625 = 0.0625)
-1.5625:
- No se puede representar (fuera del rango)
-35.5:
- No se puede representar (fuera del rango)

Sistema de punto fijo en BCS (1 bit de signo, 5 bits de parte entera y 4 bits de parte fraccionaria)

7:
- Representación: 7
- Error: 0
15.125:
- Representación: 15.125
- Error: 0
2.2:
- Más próxima: 2.1875
- Error: (2.2 - 2.1875 = 0.0125)
8.001:
- Más próxima: 8
- Error: (8 - 8.001 = -0.001)
123.25:
- No se puede representar (fuera del rango)
50.50:
- No se puede representar (fuera del rango)
120:
- No se puede representar (fuera del rango)
1.2:
- Más próxima: 1.1875
- Error: (1.2 - 1.1875 = 0.0125)
1.25:
- Representación: 1.25
- Error: 0
35:
- No se puede representar (fuera del rango)
-1.25:
- Representación: -1.25
- Error: 0
1.0625:
- Representación: 1.0625
- Error: 0
-1.5625:
- Representación: -1.5625
- Error: 0
-35.5:
- No se puede representar (fuera del rango)

Resumen

| Número | BSS Representación | Error BSS | BCS Representación | Error BCS | | |----------|--------------------|-----------|--------------------|-----------|---| | 7 | 7 | 0 | 7 | 0 | | | 15.125 | 15.125 | 0 | 15.125 | 0 | | | 2.2 | 2.25 | 0.05 | 2.1875 | 0.0125 | | | 8.001 | 8 | -0.001 | 8 | -0.001 | | | 123.25 | 123.25 | 0 | No se puede representar | - | | | 50.50 | 50.5 | 0 | No se puede representar | - | | | 120 | 120 | 0 | No se puede representar | - | | | 1.2 | 1.25 | 0.05 | 1.1875 | 0.0125 | | | 1.25 | 1.25 | 0 | 1.25 | 0 | | | 35 | 35 | 0 | No se puede representar | - | | | -1.25 | No se puede representar | - | -1.25 | 0 | | | 1.0625 | 1.125 | 0.0625 | 1.0625 | 0 | | | -1.5625 | No se puede representar | - | -1.5625 | 0 | | | -35.5 | No se puede representar | - | No se puede representar | - | |

Con esto, hemos representado los números en los sistemas de punto fijo de acuerdo a las restricciones y características mencionadas en el ejercicio 3.

Ejercicio 5

Interpretación de las cadenas

00000000:
- BSS:
  - Parte entera: 0000000 (0)
  - Parte fraccionaria: 000 (0)
  - Valor: 0
- BCS:
  - Bit de signo: 0 (positivo)
  - Parte entera: 00000 (0)
  - Parte fraccionaria: 0000 (0)
  - Valor: 0
01010101:
- BSS:
  - Parte entera: 0101010 (42)
  - Parte fraccionaria: 101 (0.625)
  - Valor: 42.625
- BCS:
  - Bit de signo: 0 (positivo)
  - Parte entera: 10101 (21)
  - Parte fraccionaria: 0101 (0.3125)
  - Valor: 21.3125
10000000:
- BSS:
  - Parte entera: 1000000 (64)
  - Parte fraccionaria: 000 (0)
  - Valor: 64
- BCS:
  - Bit de signo: 1 (negativo)
  - Parte entera: 00000 (0)
  - Parte fraccionaria: 0000 (0)
  - Valor: -16
11111110:
- BSS:
  - Parte entera: 1111111 (127)
  - Parte fraccionaria: 110 (0.75)
  - Valor: 127.75
- BCS:
  - Bit de signo: 1 (negativo)
  - Parte entera: 11111 (31)
  - Parte fraccionaria: 1110 (0.9375)
  - Valor: -0.0625
11111111:
- BSS:
  - Parte entera: 1111111 (127)
  - Parte fraccionaria: 111 (0.875)
  - Valor: 127.875
- BCS:
  - Bit de signo: 1 (negativo)
  - Parte entera: 11111 (31)
  - Parte fraccionaria: 1111 (0.9375)
  - Valor: -0.0625
10101010:
- BSS:
  - Parte entera: 1010101 (85)
  - Parte fraccionaria: 010 (0.25)
  - Valor: 85.25
- BCS:
  - Bit de signo: 1 (negativo)
  - Parte entera: 01010 (10)
  - Parte fraccionaria: 1010 (0.625)
  - Valor: -5.375
01111111:
- BSS:
  - Parte entera: 0111111 (63)
  - Parte fraccionaria: 111 (0.875)
  - Valor: 63.875
- BCS:
  - Bit de signo: 0 (positivo)
  - Parte entera: 11111 (31)
  - Parte fraccionaria: 1111 (0.9375)
  - Valor: 31.9375
01101101:
- BSS:
  - Parte entera: 0110110 (54)
  - Parte fraccionaria: 110 (0.75)
  - Valor: 54.75
- BCS:
  - Bit de signo: 0 (positivo)
  - Parte entera: 11011 (27)
  - Parte fraccionaria: 0110 (0.375)
  - Valor: 27.375

Resumen de los resultados:

| Cadena | BSS | BCS | |------------|-----------|------------| | 00000000 | 0 | 0 | | 01010101 | 42.625 | 21.3125 | | 10000000 | 64 | -16 | | 11111110 | 127.75 | -0.0625 | | 11111111 | 127.875 | -0.0625 | | 10101010 | 85.25 | -5.375 | | 01111111 | 63.875 | 31.9375 | | 01101101 | 54.75 | 27.375 |

Ejercicio 6

Link de la clase Link de la clase

Ejemplo de Como deberia Ser

Vamos a revisar las sumas en BCD desempaquetado y empaquetado según los ejemplos proporcionados.

Números a representar:

0, 1, 3, 8, 12, 13, 22, 35, 99, 100, 1255

BCD desempaquetado (cada dígito decimal utiliza 1 byte)

0: 0000 0000
1: 0000 0001
3: 0000 0011
8: 0000 1000
12: 0000 0001 0000 0010
13: 0000 0001 0000 0011
22: 0000 0010 0000 0010
35: 0000 0011 0000 0101
99: 0000 1001 0000 1001
100: 0000 0001 0000 0000 0000 0000
1255: 0000 0001 0000 0010 0000 0101 0000 0101

BCD empaquetado (1 byte representa 2 dígitos decimales)

0: 0000 0000
1: 0000 0001
3: 0000 0011
8: 0000 1000
12: 0001 0010
13: 0001 0011
22: 0010 0010
35: 0011 0101
99: 1001 1001
100: 0001 0000 0000
1255: 0001 0010 0101 0101

Procedimiento para calcular sumas en BCD empaquetado

Convertir los números decimales a BCD empaquetado.
Sumar los números como si fueran números binarios normales.
Si algún dígito excede 9 (1001 en binario), agregar 6 (0110 en binario) para corregirlo.

Sumas en BCD desempaquetado y empaquetado

Sumas en BCD empaquetado:

32 + 45:
- BCD empaquetado: 0011 0010 + 0100 0101 = 0111 0111
- Decimal: 77
22 + 89:
- BCD empaquetado: 0010 0010 + 1000 1001 = 0001 0100 0001
- Decimal: 111
1307 + 708:
- BCD empaquetado: 0001 0011 0000 0111 + 0111 0000 1000 = 0100 0011 1000 0111
- Decimal: 2015

Ejercicio 7

Lamento la confusión. Entiendo que BSS es binario sin signo. Vamos a corregir las representaciones teniendo en cuenta que BSS utiliza el mínimo número de bits necesarios para representar los números sin signo.

Representación en BCD, BCD empaquetado y BSS

Números a representar:

13160
2988
927
87127

BCD desempaquetado (cada dígito decimal utiliza 1 byte)

Cada dígito decimal se representa con 4 bits (1 byte por dígito).

13160:
- 1: 0000 0001
- 3: 0000 0011
- 1: 0000 0001
- 6: 0000 0110
- 0: 0000 0000
- Total: 0000 0001 0000 0011 0000 0001 0000 0110 0000 0000 (40 bits)
2988:
- 2: 0000 0010
- 9: 0000 1001
- 8: 0000 1000
- 8: 0000 1000
- Total: 0000 0010 0000 1001 0000 1000 0000 1000 (32 bits)
927:
- 9: 0000 1001
- 2: 0000 0010
- 7: 0000 0111
- Total: 0000 1001 0000 0010 0000 0111 (24 bits)
87127:
- 8: 0000 1000
- 7: 0000 0111
- 1: 0000 0001
- 2: 0000 0010
- 7: 0000 0111
- Total: 0000 1000 0000 0111 0000 0001 0000 0010 0000 0111 (40 bits)

BCD empaquetado (1 byte representa 2 dígitos decimales)

13160:
- 13: 0001 0011
- 16: 0001 0110
- 0: 0000 0000
- Total: 0001 0011 0001 0110 0000 0000 (24 bits)
2988:
- 29: 0010 1001
- 88: 1000 1000
- Total: 0010 1001 1000 1000 (16 bits)
927:
- 09: 0000 1001
- 27: 0010 0111
- Total: 0000 1001 0010 0111 (16 bits)
87127:
- 87: 1000 0111
- 12: 0001 0010
- 7: 0000 0111
- Total: 1000 0111 0001 0010 0000 0111 (24 bits)

BSS (Binario Sin Signo)

Utilizamos el mínimo número de bits necesarios para representar el número en binario sin signo.

13160:
- Binario: 11001101111000
- Total: 11001101111000 (14 bits)
2988:
- Binario: 101110101100
- Total: 101110101100 (12 bits)
927:
- Binario: 1110011111
- Total: 1110011111 (10 bits)
87127:
- Binario: 10101010001101111
- Total: 10101010001101111 (17 bits)

Resumen de bits necesarios

| Número | BCD (bits) | BCD empaquetado (bits) | BSS (bits) | |---------|------------|-------------------------|------------| | 13160 | 40 | 24 | 14 | | 2988 | 32 | 16 | 12 | | 927 | 24 | 16 | 10 | | 87127 | 40 | 24 | 17 |

Conclusiones sobre BCD y BSS

Ventajas de BCD:

Facilidad de Conversión: La conversión entre BCD y decimal es directa y sencilla.
Precisión: No hay errores de redondeo como en las conversiones binario a decimal.
Compatibilidad: Es útil en aplicaciones donde la salida debe ser en decimal, como en pantallas de siete segmentos.

Desventajas de BCD:

Ineficiencia: BCD no es eficiente en términos de uso de bits, ya que cada dígito decimal se representa con 4 bits, lo que resulta en una mayor cantidad de bits necesarios.
Operaciones Aritméticas: Las operaciones aritméticas son más complejas y requieren ajustes adicionales para cada dígito mayor que 9.

Ventajas de BSS:

Eficiencia de Bits: La representación en BSS es más eficiente en términos de cantidad de bits utilizados.
Operaciones Aritméticas Simples: Las operaciones aritméticas son más directas en binario.

Desventajas de BSS:

Conversión: La conversión entre BSS y decimal es menos intuitiva que BCD.
Errores de Redondeo: Pueden ocurrir errores de redondeo en conversiones entre binario y decimal.

En resumen, BCD es más adecuado para aplicaciones que requieren una interacción frecuente con números decimales, mientras que BSS es más eficiente para el almacenamiento y procesamiento de datos en sistemas digitales.

Ejercicio 8

Vamos a resolver el ejercicio de convertir de binario a hexadecimal y de hexadecimal a BCD en forma directa, sin utilizar el sistema decimal. También explicaremos por qué el sistema hexadecimal es muy utilizado.

Conversión de binario a hexadecimal

Para convertir de binario a hexadecimal, dividimos el número binario en grupos de 4 bits, empezando desde la derecha, y luego convertimos cada grupo de 4 bits en su equivalente hexadecimal.

101000001000:
- Agrupamos: 1010 0000 1000
- Convertimos:
  - 1010 -> A
  - 0000 -> 0
  - 1000 -> 8
- Resultado: A08
1110001011101:
- Agrupamos: 0001 1100 0101 1101
- Convertimos:
  - 0001 -> 1
  - 1100 -> C
  - 0101 -> 5
  - 1101 -> D
- Resultado: 1C5D
111010011001011:
- Agrupamos: 0001 1101 0011 0011
- Convertimos:
  - 0001 -> 1
  - 1101 -> D
  - 0011 -> 3
  - 0011 -> 3
- Resultado: 1D33
1001111100000011:
- Agrupamos: 1001 1111 0000 0011
- Convertimos:
  - 1001 -> 9
  - 1111 -> F
  - 0000 -> 0
  - 0011 -> 3
- Resultado: 9F03
1110101010101010:
- Agrupamos: 1110 1010 1010 1010
- Convertimos:
  - 1110 -> E
  - 1010 -> A
  - 1010 -> A
  - 1010 -> A
- Resultado: EAAA
101101101011010:
- Agrupamos: 0001 0110 1101 1010
- Convertimos:
  - 0001 -> 1
  - 0110 -> 6
  - 1101 -> D
  - 1010 -> A
- Resultado: 16DA

Conversión de hexadecimal a BCD

Para convertir de hexadecimal a BCD (Binary Coded Decimal), convertimos cada dígito hexadecimal a su equivalente binario de 4 bits y luego concatenamos estos valores.

2801:
- Convertimos cada dígito:
  - 2 -> 0010
  - 8 -> 1000
  - 0 -> 0000
  - 1 -> 0001
- Resultado: 0010 1000 0000 0001
1C5D:
- Convertimos cada dígito:
  - 1 -> 0001
  - C -> 1100
  - 5 -> 0101
  - D -> 1101
- Resultado: 0001 1100 0101 1101
78AB:
- Convertimos cada dígito:
  - 7 -> 0111
  - 8 -> 1000
  - A -> 1010
  - B -> 1011
- Resultado: 0111 1000 1010 1011
F79A:
- Convertimos cada dígito:
  - F -> 1111
  - 7 -> 0111
  - 9 -> 1001
  - A -> 1010
- Resultado: 1111 0111 1001 1010
7EF1:
- Convertimos cada dígito:
  - 7 -> 0111
  - E -> 1110
  - F -> 1111
  - 1 -> 0001
- Resultado: 0111 1110 1111 0001
324A:
- Convertimos cada dígito:
  - 3 -> 0011
  - 2 -> 0010
  - 4 -> 0100
  - A -> 1010
- Resultado: 0011 0010 0100 1010

Resumen de la conversión

| Binario | Hexadecimal | |--------------------|-------------| | 101000001000 | A08 | | 1110001011101 | 1C5D | | 111010011001011 | 1D33 | | 1001111100000011 | 9F03 | | 1110101010101010 | EAAA | | 101101101011010 | 16DA |

| Hexadecimal | BCH | |-------------|------------------------| | 2801 | 0010 1000 0000 0001 | | 1C5D | 0001 1100 0101 1101 | | 78AB | 0111 1000 1010 1011 | | F79A | 1111 0111 1001 1010 | | 7EF1 | 0111 1110 1111 0001 | | 324A | 0011 0010 0100 1010 |

Utilización del sistema hexadecimal

Ventajas del sistema hexadecimal:

Compacto y Legible: El sistema hexadecimal es más compacto que el binario, reduciendo la longitud de las cadenas de bits, lo que facilita la lectura y escritura de valores binarios.
Conversión Directa: La conversión entre hexadecimal y binario es directa y fácil, ya que cada dígito hexadecimal corresponde exactamente a 4 bits.
Utilización en Programación: Es ampliamente utilizado en programación y sistemas digitales para representar direcciones de memoria, valores de colores en gráficos, y otros datos binarios.

El sistema hexadecimal es muy utilizado debido a su eficiencia en la representación y facilidad de conversión con el sistema binario.

Ejercicio 9

Vamos a realizar las operaciones de suma (ADD) y resta (SUB) indicadas y calcular los flags para cada operación.

Notación de Flags:

C: Carry (acarreo)
B: Borrow (préstamo)
Z: Zero (resultado cero)
V: Overflow (desbordamiento)
N: Negative (negativo)

Operaciones y Cálculos:

1. ADD 00011101 00110111

  00011101
+ 00110111
-----------
  01010010

Flags: Carry=0, Zero=0, Negative=0, Overflow=0

2. ADD 01110000 11110001

  01110000
+ 11110001
-----------
  01100001

Flags: Carry=1, Zero=0, Negative=0, Overflow=1

3. ADD 10011101 01101010

  10011101
+ 01101010
-----------
  00000111

Flags: Carry=1, Zero=0, Negative=0, Overflow=1

4. ADD 01010110 01110010

  01010110
+ 01110010
-----------
  11001000

Flags: Carry=0, Zero=0, Negative=1, Overflow=0

5. ADD 01101110 01100001

  01101110
+ 01100001
-----------
  11001111

Flags: Carry=0, Zero=0, Negative=1, Overflow=0

6. ADD 10111101 11100001

  10111101
+ 11100001
-----------
  10011110

Flags: Carry=1, Zero=0, Negative=1, Overflow=1

7. ADD 00001110 00001111

  00001110
+ 00001111
-----------
  00011101

Flags: Carry=0, Zero=0, Negative=0, Overflow=0

Restas (SUB):

8. SUB 00111011 00101101

  00111011
- 00101101
-----------
  00001110

Flags: Borrow=0, Zero=0, Negative=0, Overflow=0

9. SUB 01110000 11110001

  01110000
- 11110001
-----------
  01111111

Flags: Borrow=1, Zero=0, Negative=0, Overflow=1

10. SUB 10101110 01110010

  10101110
- 01110010
-----------
  00111100

Flags: Borrow=0, Zero=0, Negative=0, Overflow=1

11. SUB 10111101 11100001

  10111101
- 11100001
-----------
  11011100

Flags: Borrow=1, Zero=0, Negative=1, Overflow=0

12. SUB 01101110 01100001

  01101110
- 01100001
-----------
  00001111

Flags: Borrow=0, Zero=0, Negative=0, Overflow=0

13. SUB 10000000 10000000

  10000000
- 10000000
-----------
  00000000

Flags: Borrow=0, Zero=1, Negative=0, Overflow=0

Resumen de Resultados y Flags:

| Operación | Resultado | Flags | |------------------------|-----------|-------------------------------| | ADD 00011101 00110111 | 01010010 | Carry=0, Zero=0, Negative=0, Overflow=0 | | ADD 01110000 11110001 | 01100001 | Carry=1, Zero=0, Negative=0, Overflow=1 | | ADD 10011101 01101010 | 00000111 | Carry=1, Zero=0, Negative=0, Overflow=1 | | ADD 01010110 01110010 | 11001000 | Carry=0, Zero=0, Negative=1, Overflow=0 | | ADD 01101110 01100001 | 11001111 | Carry=0, Zero=0, Negative=1, Overflow=0 | | ADD 10111101 11100001 | 10011110 | Carry=1, Zero=0, Negative=1, Overflow=1 | | ADD 00001110 00001111 | 00011101 | Carry=0, Zero=0, Negative=0, Overflow=0 | | SUB 00111011 00101101 | 00001110 | Borrow=0, Zero=0, Negative=0, Overflow=0 | | SUB 01110000 11110001 | 01111111 | Borrow=1, Zero=0, Negative=0, Overflow=1 | | SUB 10101110 01110010 | 00111100 | Borrow=0, Zero=0, Negative=0, Overflow=1 | | SUB 10111101 11100001 | 11011100 | Borrow=1, Zero=0, Negative=1, Overflow=0 | | SUB 01101110 01100001 | 00001111 | Borrow=0, Zero=0, Negative=0, Overflow=0 | | SUB 10000000 10000000 | 00000000 | Borrow=0, Zero=1, Negative=0, Overflow=0 |

Estos cálculos muestran los resultados de las operaciones y el estado de los diferentes flags (Carry, Zero, Negative, Overflow) después de cada operación.

Ejercicio 10

Claro, aquí tienes un resumen de lo anterior:

Representación y Verificación de Operaciones en Distintos Sistemas

BSS (Binario Sin Signo):
- Representa números positivos sin signo.
- Ejemplo Operación:
```
  01110000 (112) + 11110001 (241) = 11000111 (199)
```
- Flags: Carry=0, Zero=0, Negative=0, Overflow=0
BCS (Binario Complemento de Signo):
- Utiliza el bit más significativo como bit de signo (0 para positivo, 1 para negativo).
- Ejemplo Operación:
```
  01110000 (112) + 11110001 (-15) = 01100111 (71)
```
- Flags: Carry=1, Zero=0, Negative=1, Overflow=1
Ca1 (Complemento a 1):
- Se obtiene invirtiendo todos los bits del número en BCS.
- Ejemplo Operación:
```
  01110000 (112) + 11110001 (-14) = 01100110 (70)
```
- Flags: Carry=1, Zero=0, Negative=1, Overflow=1
Ca2 (Complemento a 2):
- Se obtiene sumando 1 al complemento a 1 del número.
- Ejemplo Operación:
```
  01110000 (112) + 11110001 (-15) = 01100111 (71)
```
- Flags: Carry=1, Zero=0, Negative=1, Overflow=1
Exceso2:
- Se suma un exceso fijo (generalmente 2^(n-1)) y luego se representa como BSS.
- Ejemplo Operación:
```
  01110000 (112-64) + 11110001 (-15-64) = 11000111 (199-128)
```
- Flags: Carry=0, Zero=0, Negative=0, Overflow=0

Conclusiones:

BSS (Binario Sin Signo):
- Representa números positivos sin signo.
- Fácil de interpretar y manipular.
- No se usa para números negativos.
BCS (Binario Complemento de Signo):
- Usa el bit más significativo como bit de signo.
- Representa números negativos.
- La aritmética requiere manejo del bit de signo.
Ca1 (Complemento a 1):
- Inversión de todos los bits para obtener el número negativo.
- Menos eficiente para aritmética de números negativos.
Ca2 (Complemento a 2):
- Agrega 1 al complemento a 1 para obtener el número negativo.
- Más eficiente para operaciones aritméticas.
- Común en sistemas binarios modernos.
Exceso2:
- Suma de un exceso fijo para representar números negativos.
- Utilizado en ciertas aplicaciones de hardware.

Cada sistema de representación tiene ventajas y desventajas según el contexto de uso. La interpretación correcta de los resultados y el manejo de los flags son cruciales en operaciones aritméticas binarias.

Ejercicio 11

Para abordar el ejercicio 11, vamos a analizar las operaciones de suma (ADD) realizadas en el ejercicio 9 y establecer una regla para determinar la correctitud de la operación ADD en el sistema BSS observando solo los flags. En el sistema BSS (Binario Sin Signo), los números son siempre positivos, y el bit más significativo no es un bit de signo.

Análisis de Resultados y Flags

Resultados del Ejercicio 9 con Flags:

ADD 00011101 00110111
- Resultado: 01010010
- Flags: Carry=0, Zero=0, Negative=0, Overflow=0
ADD 01110000 11110001
- Resultado: 01100001
- Flags: Carry=1, Zero=0, Negative=0, Overflow=1
ADD 10011101 01101010
- Resultado: 00000111
- Flags: Carry=1, Zero=0, Negative=0, Overflow=1
ADD 01010110 01110010
- Resultado: 11001000
- Flags: Carry=0, Zero=0, Negative=1, Overflow=0
ADD 01101110 01100001
- Resultado: 11001111
- Flags: Carry=0, Zero=0, Negative=1, Overflow=0
ADD 10111101 11100001
- Resultado: 10011110
- Flags: Carry=1, Zero=0, Negative=1, Overflow=1
ADD 00001110 00001111
- Resultado: 00011101
- Flags: Carry=0, Zero=0, Negative=0, Overflow=0

Observaciones

En el contexto de BSS, los números deben ser interpretados como valores sin signo. Aquí están las reglas y observaciones basadas en los flags:

Carry (C): Indica que hubo un acarreo fuera del bit más significativo. Para números sin signo, un carry (C=1) sugiere que la suma de los números excedió la capacidad del número de bits usados. Esto indica que el resultado es incorrecto para BSS.
Zero (Z): Indica que el resultado de la operación es cero. Este flag es menos relevante para verificar errores en BSS.
Negative (N): En BSS, este flag no se utiliza porque todos los números son positivos.
Overflow (V): Indica desbordamiento cuando el resultado excede la capacidad del sistema. En el contexto de BSS, esto puede ser indicativo de un error similar al carry.

Regla para Determinar la Correctitud de la Operación ADD en BSS

Para determinar la correctitud de la operación ADD en el sistema BSS, la mera observación del flag Carry (C) es suficiente:

Si C=1, el resultado es incorrecto.
Si C=0, el resultado es correcto.

Aplicación de la Regla

ADD 00011101 00110111 (C=0) → Correcto
ADD 01110000 11110001 (C=1) → Incorrecto
ADD 10011101 01101010 (C=1) → Incorrecto
ADD 01010110 01110010 (C=0) → Correcto
ADD 01101110 01100001 (C=0) → Correcto
ADD 10111101 11100001 (C=1) → Incorrecto
ADD 00001110 00001111 (C=0) → Correcto

Conclusión

En el sistema BSS, la presencia de un acarreo (C=1) es suficiente para indicar que el resultado de una operación ADD es incorrecto. Esta regla es simple y efectiva para determinar la correctitud de las sumas en BSS sin necesidad de verificar la operación en el sistema decimal.

Ejercicio 12

Vamos a trabajar con las operaciones de resta (SUB) para el sistema Ca2 (Complemento a 2) y establecer reglas para determinar la correctitud de las operaciones ADD y SUB observando los flags.

Ejemplos de Operaciones SUB del Ejercicio 9

Restas (SUB):

SUB 00111011 00101101
- Operación: 00111011 - 00101101
- Resultado: 00001110
- Flags: Borrow=0, Zero=0, Negative=0, Overflow=0
SUB 01110000 11110001
- Operación: 01110000 - 11110001
- Resultado: 01111111
- Flags: Borrow=1, Zero=0, Negative=0, Overflow=1
SUB 10101110 01110010
- Operación: 10101110 - 01110010
- Resultado: 00111100
- Flags: Borrow=0, Zero=0, Negative=0, Overflow=1
SUB 10111101 11100001
- Operación: 10111101 - 11100001
- Resultado: 11011100
- Flags: Borrow=1, Zero=0, Negative=1, Overflow=0
SUB 01101110 01100001
- Operación: 01101110 - 01100001
- Resultado: 00001111
- Flags: Borrow=0, Zero=0, Negative=0, Overflow=0
SUB 10000000 10000000
- Operación: 10000000 - 10000000
- Resultado: 00000000
- Flags: Borrow=0, Zero=1, Negative=0, Overflow=0

Análisis de Resultados y Flags en Ca2

Para determinar la correctitud de las operaciones ADD y SUB en el sistema Ca2, observamos los flags de cada operación.

Observaciones:

Borrow (B):
- En las restas, el flag de Borrow indica que hubo un préstamo.
- Si Borrow (B=1), generalmente sugiere un problema en la operación para Ca2.
Zero (Z):
- Indica que el resultado de la operación es cero.
- No es tan relevante para verificar errores en Ca2.
Negative (N):
- En Ca2, el flag negativo indica que el resultado es negativo.
- Importante para operaciones con signo.
Overflow (V):
- Indica desbordamiento cuando el resultado excede la capacidad del sistema.
- En Ca2, un overflow (V=1) puede sugerir un error en la operación.

Reglas para Determinar la Correctitud de ADD y SUB en Ca2

Sumas (ADD):

Si Overflow (V=1) y Carry (C=1), el resultado es incorrecto.
Si Overflow (V=0) y Carry (C=0), el resultado es correcto.

Restas (SUB):

Si Borrow (B=1) o Overflow (V=1), el resultado es incorrecto.
Si Borrow (B=0) y Overflow (V=0), el resultado es correcto.

Aplicación de las Reglas:

Operaciones ADD:

ADD 00011101 00110111:
- Flags: C=0, Z=0, N=0, V=0 → Correcto
ADD 01110000 11110001:
- Flags: C=1, Z=0, N=0, V=1 → Incorrecto
ADD 10011101 01101010:
- Flags: C=1, Z=0, N=0, V=1 → Incorrecto
ADD 01010110 01110010:
- Flags: C=0, Z=0, N=1, V=0 → Correcto
ADD 01101110 01100001:
- Flags: C=0, Z=0, N=1, V=0 → Correcto
ADD 10111101 11100001:
- Flags: C=1, Z=0, N=1, V=1 → Incorrecto
ADD 00001110 00001111:
- Flags: C=0, Z=0, N=0, V=0 → Correcto

Operaciones SUB:

SUB 00111011 00101101:
- Flags: B=0, Z=0, N=0, V=0 → Correcto
SUB 01110000 11110001:
- Flags: B=1, Z=0, N=0, V=1 → Incorrecto
SUB 10101110 01110010:
- Flags: B=0, Z=0, N=0, V=1 → Incorrecto
SUB 10111101 11100001:
- Flags: B=1, Z=0, N=1, V=0 → Incorrecto
SUB 01101110 01100001:
- Flags: B=0, Z=0, N=0, V=0 → Correcto
SUB 10000000 10000000:
- Flags: B=0, Z=1, N=0, V=0 → Correcto

Conclusión

En el sistema Ca2:

Para ADD:
- Si V=1 y C=1, el resultado es incorrecto.
- Si V=0 y C=0, el resultado es correcto.
Para SUB:
- Si B=1 o V=1, el resultado es incorrecto.
- Si B=0 y V=0, el resultado es correcto.

Estas reglas permiten verificar la correctitud de las operaciones sin necesidad de convertir los resultados al sistema decimal.

Ejercicio 13

Para abordar el ejercicio 13, vamos a considerar las operaciones de suma (ADD) y resta (SUB) del ejercicio 9, suponiendo que el punto o coma fraccionaria se encuentra entre el bit 2 y el bit 3. Interpretaremos los valores de las cadenas de bits como BSS (Binario Sin Signo) y como Ca2 (Complemento a 2) y observaremos los flags correspondientes.

Operaciones del Ejercicio 9:

ADD 00011101 00110111
ADD 01110000 11110001
ADD 10011101 01101010
ADD 01010110 01110010
ADD 01101110 01100001
ADD 10111101 11100001
ADD 00001110 00001111
SUB 00111011 00101101
SUB 01110000 11110001
SUB 10101110 01110010
SUB 10111101 11100001
SUB 01101110 01100001
SUB 10000000 10000000

Interpretación con Punto Fraccionario entre Bit 2 y Bit 3

Operación 1: ADD 00011101 00110111

Operandos:
- 0001.1101 -> 1.78125 (BSS)
- 0011.0111 -> 3.4375 (BSS)
Suma:
- 0101.0100 -> 5.21875 (BSS)

Flags:

Carry: 0
Zero: 0
Negative: 0
Overflow: 0

Operación 2: ADD 01110000 11110001

Operandos:
- 0111.0000 -> 7.0 (BSS)
- 1111.0001 -> -1.9375 (Ca2)
Suma:
- 0110.0001 -> 6.0625 (Ca2)

Flags:

Carry: 1
Zero: 0
Negative: 0
Overflow: 1

Operación 3: ADD 10011101 01101010

Operandos:
- 1001.1101 -> -6.0625 (Ca2)
- 0110.1010 -> 6.625 (BSS)
Suma:
- 0000.0111 -> 0.4375 (Ca2)

Flags:

Carry: 1
Zero: 0
Negative: 0
Overflow: 1

Operación 4: ADD 01010110 01110010

Operandos:
- 0101.0110 -> 5.375 (BSS)
- 0111.0010 -> 7.125 (BSS)
Suma:
- 1100.1000 -> -4.5 (Ca2)

Flags:

Carry: 0
Zero: 0
Negative: 1
Overflow: 0

Operación 5: ADD 01101110 01100001

Operandos:
- 0110.1110 -> 6.875 (BSS)
- 0110.0001 -> 6.0625 (BSS)
Suma:
- 1100.1111 -> -4.125 (Ca2)

Flags:

Carry: 0
Zero: 0
Negative: 1
Overflow: 0

Operación 6: ADD 10111101 11100001

Operandos:
- 1011.1101 -> -4.125 (Ca2)
- 1110.0001 -> -1.9375 (Ca2)
Suma:
- 1001.1110 -> -6.0625 (Ca2)

Flags:

Carry: 1
Zero: 0
Negative: 1
Overflow: 1

Operación 7: ADD 00001110 00001111

Operandos:
- 0000.1110 -> 0.875 (BSS)
- 0000.1111 -> 0.9375 (BSS)
Suma:
- 0001.1101 -> 1.8125 (BSS)

Flags:

Carry: 0
Zero: 0
Negative: 0
Overflow: 0

Operación 8: SUB 00111011 00101101

Operandos:
- 0011.1011 -> 3.71875 (BSS)
- 0010.1101 -> 2.8125 (BSS)
Resta:
- 0000.1110 -> 0.90625 (BSS)

Flags:

Borrow: 0
Zero: 0
Negative: 0
Overflow: 0

Operación 9: SUB 01110000 11110001

Operandos:
- 0111.0000 -> 7.0 (BSS)
- 1111.0001 -> -1.9375 (Ca2)
Resta:
- 0111.1111 -> 7.9375 (BSS)

Flags:

Borrow: 1
Zero: 0
Negative: 0
Overflow: 1

Operación 10: SUB 10101110 01110010

Operandos:
- 1010.1110 -> -5.125 (Ca2)
- 0111.0010 -> 7.125 (BSS)
Resta:
- 0011.1100 -> 3.75 (BSS)

Flags:

Borrow: 0
Zero: 0
Negative: 0
Overflow: 1

Operación 11: SUB 10111101 11100001

Operandos:
- 1011.1101 -> -4.125 (Ca2)
- 1110.0001 -> -1.9375 (Ca2)
Resta:
- 1101.1100 -> -2.25 (Ca2)

Flags:

Borrow: 1
Zero: 0
Negative: 1
Overflow: 0

Operación 12: SUB 01101110 01100001

Operandos:
- 0110.1110 -> 6.875 (BSS)
- 0110.0001 -> 6.0625 (BSS)
Resta:
- 0000.1111 -> 0.8125 (BSS)

Flags:

Borrow: 0
Zero: 0
Negative: 0
Overflow: 0

Operación 13: SUB 10000000 10000000

Operandos:
- 1000.0000 -> -4.0 (Ca2)
- 1000.0000 -> -4.0 (Ca2)
Resta:
- 0000.0000 -> 0 (BSS)

Flags:

Borrow: 0
Zero: 1
Negative: 0
Overflow: 0

Conclusión

Flags en Ca2:
- Carry (C) y Borrow (B): Importantes para determinar errores en operaciones aritméticas.
- Overflow (V): Indica desbordamiento y posibles errores en representación.
- Zero (Z): Indica que el resultado es cero.
- Negative (N): Indica si el resultado es negativo.
Interpretación en Ca2 y BSS con Punto Fraccionario:
- Los valores fraccionarios permiten una precisión adicional en las operaciones.
- En Ca2, se necesita tener cuidado con los signos y desbordamientos.
- En BSS, el rango es más simple, y los resultados son siempre positivos.
Reglas para Determinar Correctitud en Ca2:
- Si V=1 y C=1 en ADD, el resultado es incorrecto.
- Si B=1 o V=1 en SUB, el resultado es incorrecto.

Estas reglas son útiles para verificar la correctitud de las operaciones sin necesidad de convertir los resultados al sistema decimal, asegurando precisión en las operaciones binarias con punto fraccionario.

Ejercicio 14

Vamos a considerar todas las cadenas posibles en los sistemas BSS, BCS, Ca1, Ca2, y Exceso2, restringidos a 4 bits. Además, vamos a considerar el punto fijo en cada una de todas las posiciones posibles y obtener el rango y resolución de cada uno de los sistemas.

Sistema BSS (Binario Sin Signo)

En BSS, todos los números son positivos. Con 4 bits, los valores posibles son de 0 a 15.

Posiciones del Punto Fijo:

A la izquierda del MSB (X.XXX):
- Valores: 0.000, 0.001, 0.010, ..., 1.111
- Rango: 0 a 1.875
- Resolución: 0.125
Entre el MSB y el segundo bit (XX.XX):
- Valores: 00.00, 00.01, 00.10, ..., 11.11
- Rango: 0 a 3.75
- Resolución: 0.25
Entre el segundo y tercer bit (XXX.X):
- Valores: 000.0, 000.1, 001.0, ..., 111.1
- Rango: 0 a 7.5
- Resolución: 0.5
Entre el tercer y cuarto bit (XXXX.):
- Valores: 0000., 0001., 0010., ..., 1111.
- Rango: 0 a 15
- Resolución: 1
A la derecha del LSB (XXXX0):
- Valores: 00000, 00001, 00010, ..., 11111
- Rango: 0 a 30
- Resolución: 2

Sistema BCS (Binario Complemento de Signo)

En BCS, el bit más significativo es el bit de signo. Con 4 bits, los valores posibles van de -8 a 7.

Posiciones del Punto Fijo:

A la izquierda del MSB (X.XXX):
- Valores: 0.000, 0.001, 0.010, ..., 1.111
- Rango: -1 a 0.875
- Resolución: 0.125
Entre el MSB y el segundo bit (XX.XX):
- Valores: 00.00, 00.01, 00.10, ..., 11.11
- Rango: -2 a 1.75
- Resolución: 0.25
Entre el segundo y tercer bit (XXX.X):
- Valores: 000.0, 000.1, 001.0, ..., 111.1
- Rango: -4 a 3.5
- Resolución: 0.5
Entre el tercer y cuarto bit (XXXX.):
- Valores: 0000., 0001., 0010., ..., 1111.
- Rango: -8 a 7
- Resolución: 1
A la derecha del LSB (XXXX0):
- Valores: 00000, 00001, 00010, ..., 11111
- Rango: -16 a 14
- Resolución: 2

Sistema Ca1 (Complemento a 1)

En Ca1, los valores negativos se obtienen invirtiendo todos los bits del número en BCS.

Posiciones del Punto Fijo:

A la izquierda del MSB (X.XXX):
- Valores: 0.000, 0.001, 0.010, ..., 1.111
- Rango: -1 a 0.875
- Resolución: 0.125
Entre el MSB y el segundo bit (XX.XX):
- Valores: 00.00, 00.01, 00.10, ..., 11.11
- Rango: -2 a 1.75
- Resolución: 0.25
Entre el segundo y tercer bit (XXX.X):
- Valores: 000.0, 000.1, 001.0, ..., 111.1
- Rango: -4 a 3.5
- Resolución: 0.5
Entre el tercer y cuarto bit (XXXX.):
- Valores: 0000., 0001., 0010., ..., 1111.
- Rango: -8 a 7
- Resolución: 1
A la derecha del LSB (XXXX0):
- Valores: 00000, 00001, 00010, ..., 11111
- Rango: -16 a 14
- Resolución: 2

Sistema Ca2 (Complemento a 2)

En Ca2, los valores negativos se obtienen sumando 1 al complemento a 1 del número.

Posiciones del Punto Fijo:

A la izquierda del MSB (X.XXX):
- Valores: 0.000, 0.001, 0.010, ..., 1.111
- Rango: -1 a 0.875
- Resolución: 0.125
Entre el MSB y el segundo bit (XX.XX):
- Valores: 00.00, 00.01, 00.10, ..., 11.11
- Rango: -2 a 1.75
- Resolución: 0.25
Entre el segundo y tercer bit (XXX.X):
- Valores: 000.0, 000.1, 001.0, ..., 111.1
- Rango: -4 a 3.5
- Resolución: 0.5
Entre el tercer y cuarto bit (XXXX.):
- Valores: 0000., 0001., 0010., ..., 1111.
- Rango: -8 a 7
- Resolución: 1
A la derecha del LSB (XXXX0):
- Valores: 00000, 00001, 00010, ..., 11111
- Rango: -16 a 14
- Resolución: 2

Sistema Exceso2

En Exceso2, se suma un exceso (en n bits será (2^{n-1})) y luego se representa como BSS.

Posiciones del Punto Fijo:

A la izquierda del MSB (X.XXX):
- Valores: 0.000, 0.001, 0.010, ..., 1.111
- Rango: -0.5 a 1.375
- Resolución: 0.125
Entre el MSB y el segundo bit (XX.XX):
- Valores: 00.00, 00.01, 00.10, ..., 11.11
- Rango: -1 a 3.25
- Resolución: 0.25
Entre el segundo y tercer bit (XXX.X):
- Valores: 000.0, 000.1, 001.0, ..., 111.1
- Rango: -2 a 7
- Resolución: 0.5
Entre el tercer y cuarto bit (XXXX.):
- Valores: 0000., 0001., 0010., ..., 1111.
- Rango: -4 a 15
- Resolución: 1
A la derecha del LSB (XXXX0):
- Valores: 00000, 00001, 00010, ..., 11111
- Rango: -8 a 30
- Resolución: 2

Resumen

| Sistema | Posición del Punto | Rango | Resolución | |---------|---------------------|-------------------|------------| | BSS | X.XXX | 0 a 1.875 | 0.125 | | | XX.XX | 0 a 3.75 | 0.25 | | | XXX.X | 0 a 7.5 | 0.5 | | | XXXX. | 0 a 15 | 1 | | | XXXX0 | 0 a 30 | 2 | | BCS | X.XXX | -1 a 0.875 | 0.125 | | | XX.XX | -2 a 1.75 | 0.25 | | | XXX.X | -4 a 3.5 | 0.5 | | | XXXX. | -8 a 7 | 1 | | | XXXX0 | -16 a 14 | 2 | | Ca1 | X.XXX | -1 a 0

.875 | 0.125 | | | XX.XX | -2 a 1.75 | 0.25 | | | XXX.X | -4 a 3.5 | 0.5 | | | XXXX. | -8 a 7 | 1 | | | XXXX0 | -16 a 14 | 2 | | Ca2 | X.XXX | -1 a 0.875 | 0.125 | | | XX.XX | -2 a 1.75 | 0.25 | | | XXX.X | -4 a 3.5 | 0.5 | | | XXXX. | -8 a 7 | 1 | | | XXXX0 | -16 a 14 | 2 | | Exceso2 | X.XXX | -0.5 a 1.375 | 0.125 | | | XX.XX | -1 a 3.25 | 0.25 | | | XXX.X | -2 a 7 | 0.5 | | | XXXX. | -4 a 15 | 1 | | | XXXX0 | -8 a 30 | 2 |

Conclusión

Cada sistema tiene su propio rango y resolución dependiendo de la posición del punto fijo. La cantidad de cadenas y los números que se pueden representar varían según el sistema y la posición del punto fijo. En general, mientras más a la derecha se encuentre el punto fijo, mayor es el rango y menor la resolución, y viceversa.

Ejercicio 15

Ejercicio 16

Mecanismos para Sumar y Restar en BCS, Ca1 y Exceso

Para abordar este problema, vamos a describir los mecanismos para realizar operaciones de suma y resta en los sistemas BCS (Binario Complemento de Signo), Ca1 (Complemento a 1) y Exceso, utilizando el análisis de los resultados y flags del punto 9.

Sistema BCS (Binario Complemento de Signo)

En BCS, el bit más significativo (MSB) se utiliza como bit de signo: 0 para positivo y 1 para negativo. Las operaciones aritméticas deben considerar este bit de signo para obtener resultados correctos.

Suma en BCS:

Interprete los operandos:
- Si el MSB es 0, el número es positivo.
- Si el MSB es 1, el número es negativo.
Realice la suma binaria normal de los operandos.
Determine los flags:
- Carry (C): Indica acarreo fuera del bit más significativo.
- Overflow (V): Se produce si hay un cambio de signo incorrecto.
- Zero (Z): El resultado es cero.
- Negative (N): El resultado es negativo.
Corrija el resultado si es necesario, considerando los flags.

Resta en BCS:

Interprete los operandos.
Convierta la resta a suma del complemento:
- Resta (A - B) se convierte en (A + (-B)).
- Encuentre el complemento a 2 de B y sume a A.
Determine los flags.
Corrija el resultado si es necesario.

Sistema Ca1 (Complemento a 1)

En Ca1, el complemento a 1 de un número se obtiene invirtiendo todos los bits.

Suma en Ca1:

Interprete los operandos.
Realice la suma binaria normal de los operandos.
Determine los flags.
Corrija el resultado si es necesario, añadiendo 1 si hay un acarreo fuera del MSB.

Resta en Ca1:

Interprete los operandos.
Convierta la resta a suma del complemento:
- Resta (A - B) se convierte en (A + (-B)).
- Encuentre el complemento a 1 de B y sume a A.
Determine los flags.
Corrija el resultado si es necesario.

Sistema Exceso

En el sistema Exceso, un valor de exceso se suma a cada número para obtener su representación binaria.

Suma en Exceso:

Convierta los números del formato Exceso a formato binario.
Realice la suma binaria normal de los operandos.
Ajuste el resultado sumando el valor del exceso.
Determine los flags.

Resta en Exceso:

Convierta los números del formato Exceso a formato binario.
Convierta la resta a suma del complemento:
- Resta A - B se convierte en A + (-B).
- Encuentre el complemento a 2 de B y sume a A.
Ajuste el resultado restando el valor del exceso.
Determine los flags.

Análisis de Resultados y Flags

Operación de Ejemplo (ADD):

ADD 01110000 11110001 (BCS)
- Paso 1: Interprete los operandos.
  - 01110000 (112)
  - 11110001 (-15)
- Paso 2: Realice la suma binaria.
  - 01110000 + 11110001 = 01100001
- Paso 3: Determine los flags.
  - Carry=1, Zero=0, Negative=0, Overflow=1
- Paso 4: Corrija el resultado si es necesario.
  - La suma es correcta, considerando los flags.

Operación de Ejemplo (SUB):

SUB 10101110 01110010 (Ca1)
- Paso 1: Interprete los operandos.
  - 10101110 (-81)
  - 01110010 (58)
- Paso 2: Convierta la resta a suma del complemento.
  - 10101110 + 10001101 = 00111011
- Paso 3: Determine los flags.
  - Borrow=0, Zero=0, Negative=0, Overflow=1
- Paso 4: Corrija el resultado si es necesario.
  - La suma es correcta, considerando los flags.

Conclusiones

BCS: Utiliza el bit de signo para la representación y necesita manejar correctamente el overflow y carry.
Ca1: Requiere la inversión de todos los bits para representar números negativos y puede necesitar un ajuste adicional en la suma.
Exceso: Involucra un ajuste de exceso para representar los números y necesita correctas conversiones antes y después de las operaciones.

Reglas para Determinar Correctitud:

Suma en BCS y Ca1:
- Si V=1 y C=1, el resultado es incorrecto.
- Si V=0 y C=0, el resultado es correcto.
Resta en BCS y Ca1:
- Si B=1 o V=1, el resultado es incorrecto.
- Si B=0 y V=0, el resultado es correcto.

Aplicar estas reglas permite verificar la correctitud de las operaciones sin necesidad de convertir los resultados al sistema decimal.

Ejercicio 17

El análisis demuestra cómo el sistema de complemento a 2 maneja la representación y el cálculo de números negativos y el caso especial del valor más negativo posible.

Ejercicio 18

Practica 2

Ejercicio 1

Ejercicio 2

Ejercicio 3

Ejercicio 4

Ejercicio 5

Ejercicio 6

Ejercicio 7

Ejercicio 8

Ejercicio 9

Ejercicio 10

Ejercicio 11

Ejercicio 12

Ejercicio 13

Finales Echos por mi

Final 1

Ejercicio 1

Dado un sistema en punto flotante con 6 bits de mantisa fraccionaria normalizada en BCS y exponente de 4 bits en exceso 8 (en ese orden de izq a der)

a) ¿Cuál es el valor del minimo positivo representable en ese sistema?

b) Representante en punto flotante el número decimal 32.25

Ejercicio 2

a) ¿Cuáles son las 3 formas que se pueden utilizar para representar una función lógica?

Tablas de Verdad:
- Una tabla de verdad es una representación tabular que muestra todas las posibles combinaciones de las entradas a una función lógica y los correspondientes resultados de salida. Cada fila de la tabla representa una combinación única de las entradas y su resultado de salida asociado.
Diagramas de Circuitos Lógicos:
- Los diagramas de circuitos lógicos son representaciones gráficas de una función lógica usando compuertas lógicas. Estos diagramas muestran cómo se conectan las compuertas lógicas (AND, OR, NOT, NAND, NOR, XOR, etc.) para realizar una operación lógica específica. Cada compuerta tiene un símbolo estándar y las conexiones entre ellas indican el flujo de las señales lógicas.
Ecuaciones Booleanas:
- Las ecuaciones booleanas usan álgebra booleana para representar una función lógica. Estas ecuaciones describen la relación entre las variables de entrada y la salida usando operadores booleanos como AND (multiplicación), OR (suma), y NOT (complemento). Las expresiones booleanas se pueden simplificar usando las leyes del álgebra booleana para optimizar el diseño del circuito.

b) Describa el método de diseño de circuitos de circuitos lógicos combinacionales denominado "Suma de productos".

Video Explicativo

Resumen

Tablas de Verdad: Enumeran todas las combinaciones de entradas y salidas.
Diagramas de Circuitos Lógicos: Utilizan compuertas lógicas para representar visualmente la función.
Ecuaciones Booleanas: Describen la función lógica usando operadores booleanos. El método SOP garantiza que todas las combinaciones de entradas que producen una salida '1' se representen en el circuito final, asegurando la correcta implementación de la función lógica.

Ejercicio 3

a) ¿Qué se representa con el formato de instrucción?

El formato de instrucción es una representación específica que define cómo se codifican las instrucciones dentro de una computadora. Incluye varios componentes clave que son necesarios para que la Unidad Central de Procesamiento (CPU) pueda interpretar y ejecutar las instrucciones correctamente. Los componentes principales del formato de instrucción suelen incluir:

Código de Operación (Opcode): Este es un conjunto de bits que especifica la operación que debe realizar la CPU (por ejemplo, adición, sustracción, carga, almacenamiento, etc.). El opcode indica a la CPU qué tipo de instrucción se debe ejecutar.
Operando(s): Estos son los datos sobre los cuales se debe realizar la operación especificada por el opcode. Los operandos pueden ser:
- Inmediatos: Valores constantes incluidos en la instrucción.
- Registros: Direcciones de registros internos de la CPU.
- Direcciones de memoria: Ubicaciones en la memoria donde se encuentran los datos.
Modo de Direccionamiento: Especifica cómo se deben interpretar los operandos. Hay varios modos de direccionamiento, como:
- Directo: La dirección del operando está explícitamente dada.
- Indirecto: La dirección del operando está en un registro o en otra dirección de memoria.
- Inmediato: El operando está incluido en la instrucción.
- Indexado: La dirección del operando es calculada sumando un desplazamiento a un registro base.

Un ejemplo simplificado de una instrucción podría ser:

ADD R1, R2, R3

Donde ADD es el opcode que indica una operación de suma, y R1, R2, y R3 son los operandos que indican los registros que contienen los valores a sumar y donde se almacenará el resultado.

b) Describa los pasos del ciclo de instrucción de un salto incondicional

El ciclo de instrucción de un salto incondicional es el proceso que sigue la CPU para ejecutar una instrucción de salto que siempre se realiza sin condiciones. A continuación se detallan los pasos típicos de este ciclo:

Fetch (Búsqueda):
- La CPU obtiene (fetch) la instrucción de salto desde la memoria. La dirección de la instrucción a ser buscada es indicada por el contador de programa (Program Counter, PC).
Decode (Decodificación):
- La instrucción de salto obtenida es decodificada por la unidad de control de la CPU. Durante este paso, la CPU identifica que la instrucción es un salto incondicional y determina la dirección de salto (la dirección a la que se debe transferir el control).
Execution (Ejecución):
- En el caso de un salto incondicional, la CPU simplemente carga la nueva dirección de la instrucción (especificada por la instrucción de salto) en el contador de programa (PC). Esto implica que la próxima instrucción a ser ejecutada no es la siguiente en secuencia, sino la instrucción ubicada en la dirección especificada por el salto.
Writeback (Escritura):
- En un salto incondicional, generalmente no hay necesidad de una fase de escritura ya que no se está modificando el contenido de los registros o memoria, solo el valor del contador de programa (PC).
Increment Program Counter (Actualización del Contador de Programa):
- Aunque en muchos ciclos de instrucción se incrementa el PC para apuntar a la siguiente instrucción, en un salto incondicional el PC es actualizado directamente con la dirección de salto especificada.

Ejemplo de Salto Incondicional

Supongamos que la instrucción de salto es JMP 0x0040:

Fetch: La CPU busca la instrucción JMP 0x0040 desde la memoria.
Decode: La instrucción es decodificada y se identifica como un salto incondicional a la dirección 0x0040.
Execution: La CPU actualiza el contador de programa (PC) con el valor 0x0040.
Writeback: No se realiza ninguna operación de escritura adicional.
Increment Program Counter: En este caso, el PC ya se ha actualizado con la dirección de salto, por lo que el ciclo de instrucción continuará con la nueva dirección en el siguiente ciclo.

Estos pasos aseguran que la CPU salte incondicionalmente a una nueva posición de memoria y continúe la ejecución desde allí.

Ejercicio 4

a) ¿Cuales son los valores típicos de tiempo de acceso a los niveles de una "jerarquia de memoria"?

La jerarquía de memoria en una computadora está diseñada para balancear la velocidad, costo y capacidad de almacenamiento. Cada nivel en la jerarquía tiene características diferentes en cuanto a estos aspectos. Aquí hay una lista de los niveles típicos de la jerarquía de memoria y sus tiempos de acceso aproximados:

Registros de la CPU:
- Tiempo de acceso: 1 ciclo de reloj de la CPU (menos de 1 nanosegundo, típicamente en el rango de picosegundos a nanosegundos).
Caché L1:
- Tiempo de acceso: 1-2 ciclos de reloj de la CPU (alrededor de 1-2 nanosegundos).
Caché L2:
- Tiempo de acceso: 3-10 ciclos de reloj de la CPU (aproximadamente 3-10 nanosegundos).
Caché L3:
- Tiempo de acceso: 10-20 ciclos de reloj de la CPU (aproximadamente 10-20 nanosegundos).
Memoria Principal (RAM, DRAM):
- Tiempo de acceso: 50-100 nanosegundos.
Almacenamiento en estado sólido (SSD):
- Tiempo de acceso: 50-150 microsegundos.
Disco Duro (HDD):
- Tiempo de acceso: 10-15 milisegundos.
Memoria Secundaria (Cintas, almacenamiento en la nube, etc.):
- Tiempo de acceso: segundos a minutos, dependiendo de la tecnología y la ubicación.

b) ¿Porque la organización 2 1/2D de memoria semiconductora requiere 'refresco'?

La organización 2 1/2D de memoria semiconductora se refiere a un diseño en el que la memoria está estructurada en varios niveles (capas) y utiliza una técnica que permite una mayor densidad de almacenamiento. Este diseño es común en la memoria DRAM (Dynamic Random Access Memory). La razón por la que la memoria DRAM requiere "refresco" es fundamentalmente debido a la naturaleza de su tecnología de almacenamiento.

Funcionamiento de la DRAM

Almacenamiento de Datos en Capacitores: En la DRAM, cada bit de información se almacena en un pequeño capacitor. Un capacitor puede estar cargado (representando un bit '1') o descargado (representando un bit '0').
Pérdida de Carga: Los capacitores en la DRAM no pueden retener su carga indefinidamente; la carga se fuga con el tiempo debido a la naturaleza de los materiales y las imperfecciones en los componentes electrónicos.
Refresco de Datos: Para evitar la pérdida de datos, cada bit de la DRAM debe ser refrescado periódicamente. Esto implica leer el estado del capacitor y luego reescribir el mismo valor para restaurar la carga completa.

Organización 2 1/2D y Necesidad de Refresco

Alta Densidad de Almacenamiento: La organización 2 1/2D permite almacenar una mayor cantidad de datos en un área más pequeña, lo que implica que hay más capacitores por unidad de área.
Más Capas y Mayor Integración: Con más capas de almacenamiento y mayor integración, la complejidad del sistema aumenta y la tasa de fuga de los capacitores puede ser más pronunciada debido a la proximidad de los componentes y la interferencia potencial.
Refresco Periódico Necesario: Debido a la fuga de carga en los capacitores, la memoria DRAM en una configuración 2 1/2D, al igual que cualquier DRAM, requiere ciclos de refresco periódicos para asegurar que los datos almacenados no se pierdan. Estos ciclos de refresco son gestionados por el controlador de memoria y ocurren cientos de veces por segundo.

En resumen, la necesidad de refresco en la organización 2 1/2D de memoria semiconductora se debe a la naturaleza inherente de la tecnología DRAM, donde los datos se almacenan en capacitores que pierden su carga con el tiempo y deben ser periódicamente recargados para mantener la integridad de los datos almacenados.

Ejercicio 5

Una imagen de pantalla de 100 cm por 50 cm posee una resolución de 100 puntos por centimetro:

a) ¿Cuántos bytes de memoria se necesitan para almacenar una imagen en True Color?

Dimensiones de la imagen:
- Ancho: 100 cm
- Alto: 50 cm
- Resolución: 100 puntos por centímetro
Calcular la resolución total de la imagen en píxeles:
- Ancho en píxeles: 100 cm * 100 puntos/cm = 10,000 píxeles
- Alto en píxeles: 50 cm * 100 puntos/cm = 5,000 píxeles
- Total de píxeles: 10,000 píxeles * 5,000 píxeles = 50,000,000 píxeles
True Color:
- En True Color, cada píxel se representa con 24 bits (8 bits por canal para los colores rojo, verde y azul).
- Convertir 24 bits a bytes: 24 bits / 8 = 3 bytes por píxel
Calcular la memoria total en bytes:
- Memoria total: 50,000,000 píxeles * 3 bytes/píxel = 150,000,000 bytes

Por lo tanto, se necesitan 150,000,000 bytes de memoria para almacenar una imagen en True Color.

b) Cuantas imágenes podria almacenar en esa memoría si la imagen a almacenar fuera monocromatica?

Monocromática:
- Una imagen monocromática (en blanco y negro) se representa con 1 bit por píxel.
Calcular la memoria necesaria para una imagen monocromática:
- Memoria necesaria por píxel: 1 bit
- Convertir bits a bytes: 1 bit / 8 = 0.125 bytes por píxel
Calcular la memoria total en bytes para una imagen monocromática:
- Memoria total para una imagen: 50,000,000 píxeles * 0.125 bytes/píxel = 6,250,000 bytes
Calcular el número de imágenes monocromáticas que se pueden almacenar:
- Memoria disponible: 150,000,000 bytes (de la parte a)
- Número de imágenes: 150,000,000 bytes / 6,250,000 bytes/imagen = 24 imágenes

Por lo tanto, en la misma cantidad de memoria, se podrían almacenar 24 imágenes monocromáticas.

Resumen

a) Se necesitan 150,000,000 bytes de memoria para almacenar una imagen en True Color.

b) Se podrían almacenar 24 imágenes monocromáticas en esa misma memoria.

Final 2 08-22

Ejercicio 1

Dado un sistema en punto flotante con 6 bits de mantisa fraccionaria en BCS y exponente de 4 bits en exceso 8 (en ese orden de izq a der):

A) ¿Cuál es el rango de representación del sistema?.

Para determinar el rango de representación de un sistema en punto flotante, necesitamos entender cómo se representan tanto la mantisa como el exponente.

Mantisa fraccionaria en BCS (Binary Coded Sign):
- La mantisa tiene 6 bits, con el formato 1.xxx...xx (donde x puede ser 0 o 1).
- Esto significa que la mantisa puede representar valores en el rango de 1 a 1.11111 en binario (equivalente a 1 a (2 - 2^-6) en decimal).
Exponente de 4 bits en exceso 8:
- El exponente se representa con 4 bits en exceso 8.
- Esto significa que el exponente puede variar de 0000 a 1111 en binario, que en decimal representa de 0 a 15.
- En exceso 8, el exponente real se calcula restando 8. Por lo tanto, el exponente real varía de -8 a 7.

B) Represente en punto flotante el número decimal 322.

Para representar el número decimal 322 en el sistema de punto flotante dado:

Entonces, la representación en punto flotante del número 322 es:

0 1111 010000

Espero que esto ayude a resolver el ejercicio. Si tienes más preguntas o necesitas más aclaraciones, no dudes en decírmelo.

Ejercicio 2

A) ¿Cuáles son las 3 formas que se pueden utilizar para representar una función lógica?

Tablas de Verdad:
- Una tabla de verdad es una representación tabular que muestra todas las posibles combinaciones de las entradas a una función lógica y los correspondientes resultados de salida. Cada fila de la tabla representa una combinación única de las entradas y su resultado de salida asociado.
Diagramas de Circuitos Lógicos:
- Los diagramas de circuitos lógicos son representaciones gráficas de una función lógica utilizando compuertas lógicas. Estos diagramas muestran cómo se conectan las compuertas lógicas (AND, OR, NOT, NAND, NOR, XOR, etc.) para realizar una operación lógica específica. Cada compuerta tiene un símbolo estándar y las conexiones entre ellas indican el flujo de las señales lógicas.
Ecuaciones Booleanas:
- Las ecuaciones booleanas usan álgebra booleana para representar una función lógica. Estas ecuaciones describen la relación entre las variables de entrada y la salida usando operadores booleanos como AND (multiplicación), OR (suma), y NOT (complemento). Las expresiones booleanas se pueden simplificar usando las leyes del álgebra booleana para optimizar el diseño del circuito.

B) Describa el método de diseño de circuitos lógicos combinacionales denominado "Suma de productos".

El método de "Suma de productos" (SOP) es una técnica estándar en el diseño de circuitos lógicos combinacionales. Consiste en representar una función lógica como una suma (OR) de productos (AND) de variables de entrada. Aquí están los pasos generales para diseñar un circuito utilizando el método SOP:

Ejemplo

Ejercicio 3

A) ¿Qué es el ciclo de instrucción?

El ciclo de instrucción es el proceso que sigue una CPU para ejecutar una instrucción de un programa almacenado en la memoria. Este ciclo es repetitivo y se compone de varios pasos que incluyen la búsqueda (fetch), decodificación (decode), ejecución (execute) y escritura (write back) de las instrucciones. Cada ciclo de instrucción permite que la CPU lea una instrucción de la memoria, la interprete y realice la operación correspondiente.

El ciclo de instrucción se puede descomponer en las siguientes fases:

Fetch (Búsqueda):
- La CPU obtiene la instrucción desde la memoria. La dirección de la instrucción a ser buscada es indicada por el contador de programa (PC).
Decode (Decodificación):
- La instrucción buscada es decodificada por la unidad de control de la CPU para determinar qué operación debe realizarse y qué operandos son necesarios.
Execute (Ejecución):
- La CPU realiza la operación especificada por la instrucción utilizando los operandos apropiados. Esto puede incluir operaciones aritméticas, lógicas, de control, etc.
Write Back (Escritura):
- Los resultados de la operación se almacenan en la memoria o en los registros de la CPU según lo especificado por la instrucción.
Increment Program Counter (Actualización del Contador de Programa):
- El contador de programa (PC) se incrementa para apuntar a la siguiente instrucción a ser ejecutada en el ciclo siguiente.

B) Describa los pasos del ciclo de instrucción de una operación aritmética.

Veamos los pasos del ciclo de instrucción para una operación aritmética, como una suma. Supongamos que tenemos una instrucción de suma ADD R1, R2, R3, donde R1, R2, y R3 son registros de la CPU.

Fetch (Búsqueda):
- La CPU busca la instrucción ADD R1, R2, R3 desde la memoria. La dirección de la instrucción a ser buscada es indicada por el contador de programa (PC).
Decode (Decodificación):
- La unidad de control decodifica la instrucción ADD R1, R2, R3. Se determina que la operación a realizar es una suma y que los operandos son los registros R2 y R3, con el resultado que se almacenará en el registro R1.
Fetch Operands (Búsqueda de Operandos):
- La CPU busca los valores almacenados en los registros R2 y R3.
Execute (Ejecución):
- La unidad aritmético-lógica (ALU) de la CPU realiza la operación de suma utilizando los valores de R2 y R3. Por ejemplo, si R2 tiene el valor 5 y R3 tiene el valor 10, la ALU suma estos valores para obtener el resultado 15.
Write Back (Escritura):
- El resultado de la operación (15) se almacena en el registro R1.
Increment Program Counter (Actualización del Contador de Programa):
- El contador de programa (PC) se incrementa para apuntar a la siguiente instrucción a ser ejecutada.

Ejemplo Visual del Ciclo de Instrucción de una Suma

Fetch:
- PC -> Memory[PC] -> Instruction Register (IR)
- Instrucción: ADD R1, R2, R3
Decode:
- IR -> Control Unit
- Control Unit decodifica ADD y determina los operandos R2, R3 y el destino R1.
Fetch Operands:
- R2 -> Operand 1
- R3 -> Operand 2
Execute:
- ALU: Operand 1 + Operand 2
- Resultado: 15
Write Back:
- Result (15) -> R1
Increment PC:
- PC + 1 -> PC

Este ciclo se repite para cada instrucción del programa, permitiendo que la CPU ejecute secuencialmente todas las instrucciones almacenadas en la memoria.

Si necesitas más detalles o ejemplos específicos, no dudes en decírmelo.

Ejercicio 4

A) ¿Cómo está compuesta una "jerarquía de memoria"?

La jerarquía de memoria en una computadora está organizada en varios niveles que varían en velocidad, tamaño y costo. Cada nivel está diseñado para optimizar el rendimiento general del sistema al balancear estos factores. La jerarquía de memoria típica incluye los siguientes niveles, desde el más rápido y costoso hasta el más lento y económico:

Registros de la CPU:
- Los registros son la forma más rápida de memoria dentro del procesador. Son muy pequeños y se utilizan para almacenar datos temporales que la CPU necesita de inmediato.
Caché:
- Caché L1: Es la más rápida y está directamente integrada en el núcleo del procesador. Tiene una capacidad pequeña, típicamente entre 32KB y 256KB.
- Caché L2: También está integrada en el procesador pero es más grande y ligeramente más lenta que la L1, con capacidades típicas entre 256KB y 2MB.
- Caché L3: Puede estar compartida entre varios núcleos del procesador. Es más grande y más lenta que las cachés L1 y L2, con capacidades típicas entre 2MB y 64MB.
Memoria Principal (RAM):
- La memoria RAM (DRAM) es más lenta que la caché, pero tiene una capacidad mucho mayor, típicamente en el rango de gigabytes (GB). Se utiliza para almacenar datos y programas que están siendo utilizados activamente por el sistema.
Almacenamiento Secundario:
- Discos Duros (HDD) y Unidades de Estado Sólido (SSD): Estos dispositivos de almacenamiento son mucho más lentos que la memoria RAM, pero tienen una capacidad mucho mayor, en el rango de terabytes (TB). Se utilizan para almacenar datos y programas a largo plazo.
- Memoria Externa (cintas, almacenamiento en la nube, etc.): Estos son los medios de almacenamiento más lentos pero también los más grandes y económicos. Se utilizan para copias de seguridad y almacenamiento de archivos que no se necesitan con frecuencia.

B) ¿Porqué la organización 2D de memoria semicondutora NO requiere 'refresco'?

La organización 2D de memoria semiconductora generalmente se refiere a la memoria SRAM (Static Random Access Memory), en contraste con la memoria DRAM (Dynamic Random Access Memory), que suele utilizar una organización más compleja (a veces denominada 2.5D o 3D debido a las múltiples capas de almacenamiento).

SRAM (2D) vs DRAM (2.5D o 3D):

SRAM:
- Celdas de Memoria: Las celdas de memoria SRAM están compuestas por flip-flops, que son circuitos de almacenamiento estático formados por transistores.
- Estabilidad: Una vez que los flip-flops almacenan un bit de información (0 o 1), mantienen su estado sin necesidad de ser refrescados periódicamente mientras haya alimentación eléctrica.
- Velocidad y Consumo: La SRAM es muy rápida y consume menos energía en estado activo, pero es más costosa y tiene menor densidad de almacenamiento en comparación con la DRAM.
DRAM:
- Celdas de Memoria: Las celdas de memoria DRAM están formadas por un transistor y un capacitor. El capacitor almacena la carga eléctrica que representa el bit de información.
- Pérdida de Carga: Los capacitores pierden su carga con el tiempo debido a la fuga eléctrica, lo que significa que la información almacenada en una celda DRAM se degrada rápidamente.
- Refresco Necesario: Para evitar la pérdida de datos, cada bit en la DRAM debe ser refrescado periódicamente, lo que implica leer y reescribir el contenido del capacitor. Este proceso de refresco consume tiempo y energía adicionales.

Conclusión:

SRAM (Organización 2D): No requiere refresco porque utiliza flip-flops que mantienen su estado de manera estable mientras haya energía. La organización 2D en SRAM es suficiente para mantener los datos sin necesidad de refresco periódico.
DRAM (Organización 2.5D o 3D): Requiere refresco debido a la naturaleza de los capacitores que pierden carga con el tiempo. La organización 2.5D o 3D en DRAM permite una mayor densidad de almacenamiento, pero a costa de la necesidad de refrescar los datos periódicamente.

Por lo tanto, la organización 2D de memoria semiconductora (SRAM) no requiere refresco porque las celdas de memoria estática (flip-flops) mantienen su estado sin necesidad de intervención adicional.

Ejercicio 5

Una imagen en una pantalla de 100 cm por 50 cm posee una resolución de 100 puntos por centímetro:

A) ¿Cuántos bytes de memoria se necesitan para almacenar una imagen en True Color?

Para calcular cuántos bytes de memoria se necesitan para almacenar una imagen en True Color, seguimos estos pasos:

Dimensiones de la imagen:
- Ancho: 100 cm
- Alto: 50 cm
- Resolución: 100 puntos por centímetro
Calcular la resolución total de la imagen en píxeles:
- Ancho en píxeles: 100 cm * 100 puntos/cm = 10,000 píxeles
- Alto en píxeles: 50 cm * 100 puntos/cm = 5,000 píxeles
- Total de píxeles: 10,000 píxeles * 5,000 píxeles = 50,000,000 píxeles
True Color:
- En True Color, cada píxel se representa con 24 bits (8 bits por canal para los colores rojo, verde y azul).
- Convertir 24 bits a bytes: 24 bits / 8 = 3 bytes por píxel
Calcular la memoria total en bytes:
- Memoria total: 50,000,000 píxeles * 3 bytes/píxel = 150,000,000 bytes

Por lo tanto, se necesitan 150,000,000 bytes de memoria para almacenar una imagen en True Color.

B) ¿Cuántas imágenes podría almacenar en esa memoria si la imagen a almacenar fuera 'monocromática'?

Para calcular cuántas imágenes monocromáticas se pueden almacenar en la misma cantidad de memoria, seguimos estos pasos:

Monocromática:
- Una imagen monocromática (en blanco y negro) se representa con 1 bit por píxel.
Calcular la memoria necesaria para una imagen monocromática:
- Memoria necesaria por píxel: 1 bit
- Convertir bits a bytes: 1 bit / 8 = 0.125 bytes por píxel
Calcular la memoria total en bytes para una imagen monocromática:
- Memoria total para una imagen: 50,000,000 píxeles * 0.125 bytes/píxel = 6,250,000 bytes
Calcular el número de imágenes monocromáticas que se pueden almacenar:
- Memoria disponible: 150,000,000 bytes (de la parte a)
- Número de imágenes: 150,000,000 bytes / 6,250,000 bytes/imagen = 24 imágenes

Por lo tanto, en la misma cantidad de memoria, se podrían almacenar 24 imágenes monocromáticas.

Resumen

A) Se necesitan 150,000,000 bytes de memoria para almacenar una imagen en True Color.

B) Se podrían almacenar 24 imágenes monocromáticas en esa misma memoria.

Final 3 sin fecha

Ejercicio 1

4186H (en hexadecimal) punto flotante 8 bits mantisa BCS y bit implícito y exponente 8 bits en exceso 128 (de izq a der)

a) Determine el valor decimal representado

b) Calcule el error absoluto máximo

Ejercicio 2

¿Qué es una puerta lógica?

Describa el circuito lógico secuencial "Biestable RS".

Realice la tabla de comportamiento y un gráfico de interconexión de puertas lógicas que lo represente

Ejercicio 3

¿Qué es un ciclo de instrucción?

El ciclo de instrucción es el proceso completo que sigue una CPU para ejecutar una instrucción de un programa almacenado en la memoria. Este ciclo es repetitivo y consta de varias fases, cada una de las cuales realiza una tarea específica para procesar y ejecutar una instrucción. Las fases del ciclo de instrucción son:

Fetch (Búsqueda):
- La CPU obtiene la instrucción desde la memoria. La dirección de la instrucción a ser buscada es indicada por el contador de programa (PC).
Decode (Decodificación):
- La instrucción buscada es decodificada por la unidad de control de la CPU. En esta fase, se determina qué operación debe realizarse y cuáles son los operandos necesarios.
Execute (Ejecución):
- La CPU realiza la operación especificada por la instrucción utilizando los operandos apropiados. Esto puede incluir operaciones aritméticas, lógicas, de control, etc.
Write Back (Escritura):
- Los resultados de la operación se almacenan en la memoria o en los registros de la CPU según lo especificado por la instrucción.
Increment Program Counter (Actualización del Contador de Programa):
- El contador de programa (PC) se incrementa para apuntar a la siguiente instrucción a ser ejecutada en el ciclo siguiente.

Estas fases se repiten continuamente mientras el programa está en ejecución, permitiendo que la CPU ejecute secuencialmente todas las instrucciones almacenadas en la memoria.

Describa el funcionamiento del modo de direccionamiento indirecto vía registro con desplazamiento

El modo de direccionamiento indirecto vía registro con desplazamiento es una técnica utilizada en la arquitectura de computadoras para acceder a datos en la memoria. Este modo de direccionamiento combina el uso de un registro base, un desplazamiento y la memoria principal para calcular la dirección efectiva del operando. Aquí está el funcionamiento detallado:

Registro Base:
- Un registro en la CPU (por ejemplo, el registro base o el registro índice) contiene una dirección base. Este registro se utiliza como punto de partida para calcular la dirección efectiva del operando.
Desplazamiento:
- Un valor constante (desplazamiento) se suma al valor contenido en el registro base para obtener la dirección efectiva. El desplazamiento puede ser positivo o negativo y se especifica en la instrucción.
Dirección Indirecta:
- La dirección efectiva calculada en el paso anterior apunta a una ubicación en la memoria. En esta ubicación de memoria se encuentra la dirección real del operando.
Acceso al Operando:
- La CPU utiliza la dirección real obtenida en el paso anterior para acceder al operando en la memoria.

Ejemplo de Funcionamiento

Supongamos que tenemos la siguiente instrucción en ensamblador:

LOAD R1, [R2 + 10]

Donde LOAD es la operación que carga un valor en el registro R1 desde la memoria.

Registro Base (R2):
- El registro R2 contiene la dirección base. Supongamos que R2 tiene el valor 1000.
Desplazamiento (10):
- El desplazamiento es 10.
Calcular la Dirección Efectiva:
- Dirección efectiva = Valor de R2 + Desplazamiento = 1000 + 10 = 1010.
Dirección Indirecta:
- La dirección efectiva 1010 apunta a una ubicación en la memoria. Supongamos que en la dirección 1010 en la memoria se encuentra el valor 2000, que es la dirección real del operando.
Acceso al Operando:
- La CPU utiliza la dirección real 2000 para acceder al operando en la memoria. Supongamos que en la dirección 2000 se encuentra el valor 50.
Cargar el Operando:
- El valor 50 se carga en el registro R1.

Tabla de Ejemplo

| Registro | Valor | |----------|----------------| | R2 | 1000 | | Mem[1010]| 2000 (Dirección real) | | Mem[2000]| 50 (Valor del operando) | | R1 | 50 (Después de LOAD) |

Resumen

Ciclo de Instrucción: Es el proceso completo que sigue una CPU para buscar, decodificar, ejecutar y escribir una instrucción de un programa.
Modo de Direccionamiento Indirecto Vía Registro con Desplazamiento: Es un método que utiliza un registro base y un desplazamiento para calcular una dirección efectiva, la cual apunta a una dirección en memoria donde se encuentra la dirección real del operando. Este modo es útil para acceder a estructuras de datos como arreglos y tablas de manera eficiente.

Ejercicio 4

a) Describa las características principales de la organización 2D de memoria semiconductora

La organización 2D de memoria semiconductora se refiere a la disposición de celdas de memoria en una configuración bidimensional (filas y columnas) sobre un chip de silicio. Esta disposición es común en tecnologías de memoria como SRAM (Static Random Access Memory) y DRAM (Dynamic Random Access Memory). Las características principales son:

Disposición en Matriz:
- Las celdas de memoria están organizadas en una matriz de filas y columnas, donde cada celda se encuentra en la intersección de una fila y una columna.
Acceso mediante Decodificadores:
- La selección de una celda específica se realiza mediante decodificadores de fila y columna. El decodificador de fila selecciona una fila específica y el decodificador de columna selecciona una columna específica.
Tipos de Memoria:
- SRAM: Utiliza celdas de memoria basadas en flip-flops (generalmente 6 transistores por celda), lo que permite un acceso muy rápido y sin necesidad de refresco.
- DRAM: Utiliza celdas de memoria basadas en un transistor y un capacitor. Requiere refresco periódico para mantener la carga en el capacitor y, por lo tanto, los datos.
Velocidad y Consumo de Energía:
- SRAM: Es más rápida y consume menos energía durante la operación activa, pero ocupa más espacio y es más costosa de fabricar debido al mayor número de transistores por celda.
- DRAM: Tiene una mayor densidad de almacenamiento y es más económica, pero es más lenta y requiere energía adicional para los ciclos de refresco.
Aplicaciones:
- SRAM: Utilizada en cachés de CPU y registros internos debido a su alta velocidad.
- DRAM: Utilizada como memoria principal (RAM) en computadoras debido a su alta densidad de almacenamiento y menor costo.

b) Realice el esquema del chip con esta organización

Un esquema simplificado de un chip de memoria con organización 2D podría verse así:

       Columna 0  Columna 1  Columna 2  ...  Columna N
       ---------------------------------------------
Fila 0 |  Celda  |  Celda  |  Celda  |  ...  |  Celda  |
       ---------------------------------------------
Fila 1 |  Celda  |  Celda  |  Celda  |  ...  |  Celda  |
       ---------------------------------------------
Fila 2 |  Celda  |  Celda  |  Celda  |  ...  |  Celda  |
       ---------------------------------------------
...    |  ...    |  ...    |  ...    |  ...  |  ...    |
       ---------------------------------------------
Fila M |  Celda  |  Celda  |  Celda  |  ...  |  Celda  |
       ---------------------------------------------

Cada "Celda" representa una celda de memoria que puede almacenar un bit de información (0 o 1).

c) Mencione valores típicos de capacidad de almacenamiento y de tiempo de acceso

Capacidad de Almacenamiento:
- SRAM:
  - Capacidades típicas varían desde unos pocos kilobytes (KB) hasta varios megabytes (MB). Ejemplos incluyen 32KB a 64MB.
- DRAM:
  - Capacidades típicas varían desde 1 gigabyte (GB) hasta varios terabytes (TB). Ejemplos comunes son 4GB, 8GB, 16GB, y 32GB.
Tiempo de Acceso:
- SRAM:
  - Muy rápida, con tiempos de acceso típicos en el rango de 1 a 10 nanosegundos (ns).
- DRAM:
  - Más lenta que SRAM, con tiempos de acceso típicos en el rango de 50 a 100 nanosegundos (ns). Las memorias DRAM modernas (como DDR4) pueden tener latencias menores, pero aún así son más lentas que las SRAM.

Resumen

Organización 2D de Memoria Semiconductora:
- Disposición en matriz de celdas de memoria.
- Selección de fila y columna mediante decodificadores.
- Diferentes tecnologías como SRAM y DRAM con características específicas.
Esquema del Chip:
- Disposición de filas y columnas con celdas de memoria en cada intersección.
Valores Típicos:
- Capacidades de almacenamiento: Desde KB a MB para SRAM, y GB a TB para DRAM.
- Tiempos de acceso: 1-10 ns para SRAM, y 50-100 ns para DRAM.

Ejercicio 5

Un video musical monocromático de youtube dura 200 seg

a. Calcule cuántos bytes de memoria se necesitan para almacenar el video completo si cada imagen es de 800 x 500 px

b. ¿Cuál debería ser la velocidad de transferencia (en bytes/seg) si la imagen debe ser cambiada 25 veces en 1 seg?

Final 4 11-22

Ejercicio 1

Dado un sistema en punto flotante con 5 bits de mantisa en BCS con bit implicito y exponente de 5 bits en exceso 16 (en ese orden de izq a der):

A) ¿Cuál es el valor decimal del mínimo positivo representable por el sistema?

B) Represente en el sistema de punto flotante dado el número decimal 2,625

Ejercicio 2

¿Cuáles son las 3 funciones lógicas elementales y cómo las puede representar?

b) Describa el método de diseño de circuitos lógicos combinacionales denominado "Suma de productos"

Ejercicio 3

A) ¿Cómo es el formato de instrucción de una máquina de 3 direcciones?

b) Describa la diferencia en los pasos del ciclo de instrucción de una instrucción SUB y una CMP

Ejercicio 4

A) ¿Cuáles son los principios que rigen el funcionamiento de una "jerarquía de memoría"?

b) ¿Porqué la organización 2 1/2D de memoria semiconductora utiliza 2 decodificadores?

Ejercicio 5

Una imagen en una pantalla de 100cm por 50cm posee una resolución de 100 puntos por centímetro:

a) ¿Cuántos bytes de memoria se necesitan para almacenar una imagen en True Color?

b) ¿Cuántas imágenes "monocromo" se podrían almacenar en esa memoria?

Final 5 Mesa febrero 2º llamado | 21/02/2022

Ejercicio 1

Sistema de punto flotante 7 bits mantisa BCS y bit implícito y 8 bits exponente en exceso /128 (en ese orden de izq a der)

a) Representar tu número de alumno (sin el nro después de la barra "/6").

b) Calcular error absoluto.

Ejercicio 2

a) Las 3 formas que se pueden utilizar para representar una función lógica.

b) Suma de productos.

Ejercicio 3

Elementos que debe poseer una instrucción.

b) Modo de direccionamiento utilizado en las instrucciones de salto condicional.

Ejercicio 4

a) ¿Qué función debe cumplir un "punto de memoria"?

b) ¿Por qué la organización 2/1D requiere refresco?

Final 6 FEBRERO 2022 1ERA FECHA

Ejercicio 1

Dado el número A188 en BCH donde 8 bits representan la mantisa en BCS con bit implícito y 8 bits para exponente en exceso 128.

a) Calcular el valor en decimal.

b) Calcular el error absoluto máximo.

Ejercicio 2

a) ¿Qué es un circuito combinatorio?

b) Explicar que es "sumador completo". Realizar tabla de verdad y gráfico.

Ejercicio 3

a) MSX88 representa una máquina de 2 direcciones?

b) Explicar máquina de 1 dirección.

Ejercicio 4

a) Dar 3 características principales de la organización de memoria semiconductor (2^1/2 D)

b) Realizar una tabla con valores típicos de capacidad de almacenamiento y tiempo de acceso de cada nivel de jerarquía de memoria.

Ejercicio 5

Dado un vídeo monocromático de 15 segundos donde cada imagen tiene 500*800 pixeles:

a) Cuantos bytes se necesitan por cada imagen?

b) Que velocidad de transferencia a periférico debe haber si cada imagen debe ser cambiada 25 veces en 1 segundo?

Final 7 Organización de Computadoras 08-23

Ejercicio 1

Dado un sistema en punto flotante con 6 bits de mantisa fraccionaria en BCS y exponente de 4 bits en exceso 8 (en ese orden de izq a der):

A) ¿Cuál es el rango de representación del sistema?

B) Represente en punto flotante el número decimal 32,2.

Ejercicio 2

A) ¿Cuáles son las 3 formas que se pueden utilizar para representar una función lógica?

B) Describa el funcionamiento del circuito lógico secuencial denominado 'D'.

Ejercicio 3

A) ¿Qué es un ciclo de instrucción?

B) Describa los pasos del ciclo de instrucción de una operación aritmética.

Ejercicio 4

A) ¿Cómo está compuesta una "jerarquía de memoria"?

B) ¿Por qué la organización 2D de memoria semiconductora NO requiere 'refresco'?

Ejercicio 5

Una imagen en una pantalla de 100 cm por 50 cm posee una resolución de 100 puntos por centímetro:

A) ¿Cuántos bytes de memoria se necesitan para almacenar una imagen en True Color?

B) ¿Cuántas imágenes podría almacenar en esa memoria si la imagen a almacenar fuera 'monocromática'?

Final 8 - Abril 2023 (10/04)

Ejercicio 1

a) Características de coma flotante IEEE 754 simple precisión.

b) Representar el número 1 en el modelo del inciso a).

Ejercicio 2

a) Explicar qué es la suma de productos.

b) Usar suma de productos para representar una función de cuatro entradas (A,B,C,D) cuya salida de 1 cuando dos de las entradas sea cero (cabeza ecuación gráfico).

Ejercicio 3

a) Explicar el modo de direccionamiento indirecto por registro con desplazamiento.

b) Dar ejemplos de instrucciones de sus variantes.

Ejercicio 4

a) Explicar los principios de la jerarquía de memoria.

b) Describir la organización 2^(1/2) D y realizar el gráfico para esa memoria con capacidad de almacenamiento de 1024 bits.

Ejercicio 5

a) Describir el disco rígido teniendo en cuenta su comunicación con la CPU, el formato de almacenamiento, cantidad de información, etc.

Final 9 Organización de Computadoras 23-Feb1

Ejercicio 1

Dada la representación A188H (en BCH) de un sistema en punto flotante con 8 bits de mantisa en BCS y bit implícito y exponente de 8 bits en exceso 128 (en ese orden de izq a der):

A) Determine el valor decimal representado en ese sistema.

B) Calcule el Error Absoluto Máximo de esa representación.

Ejercicio 2

A) ¿Qué es un circuito combinatorio?

B) Describa el circuito lógico denominado “sumador completo”. Realice la tabla de verdad y un gráfico de interconexión de puertas lógicas que lo represente.

Ejercicio 3

A) ¿El MSX88 simula una máquina de 2 direcciones? Justifique.

B) Describa el formato de instrucción de una máquina de 1 dirección.

Ejercicio 4

A) Describa 3 características fundamentales de un ‘chip’ de memoria semiconductor para una organización 2 1/2D

B) En una tabla, escriba los valores típicos de capacidad de almacenamiento y tiempo de acceso de cada nivel de una jerarquía de memoria.

Ejercicio 5

Un video monocromático de Tik-Tok dura 15 segundos y cada imagen es de 500 por 800 píxeles.

A) ¿Cuántos bytes de memoria se necesitan para almacenar una imagen del video?

B) ¿Cuál debe ser la velocidad de transferencia a periférico (en bytes/segundo) si para 'percibir movimiento' cada imagen 'visible' debe ser cambiada 25 veces en un segundo?

Final 10 Feb20b

Ejercicio 1

¿Qué define el Teorema Fundamental de la Numeración?.

Determine el rango de representación y resoluciones de:

a) Un sistema en Punto Fijo en BCS con 4 bits para parte entera y 4 bits para parte fraccionaria

b) Un sistema en Punto Flotante con 4 bits para mantisa con bit implícito en BCS y 4 bits para exponente en BCS

Ejercicio 2

a) Describa las diferencias entre un circuito combinatorio y uno secuencial.

b) Describa el método ‘Suma de Productos’ para determinar la ecuación algebraica de un circuito lógico.

c) Ejemplifique el uso de SOP con la función OR Exclusiva.

Ejercicio 3

Describa las características que tienen las máquinas que ejecutan instrucciones con 1 dirección.

Suponiendo que se poseen las instrucciones adecuadas y que varA, varB, varC y varD son las direcciones de memoria donde se almacenan los valores A, B, C y D respectivamente:

a) Resuelva mediante programa en pseudo-assembly la ecuación D = (A-B)*(C+A) para la máquina de una dirección.

b) Determine la cantidad de instrucciones y la de accesos a memoria (de instrucciones y de datos) requeridos por la solución programada.

Ejercicio 4

¿Cuáles son los principios que sustentan el funcionamiento de la jerarquía de un sistema de memoria?.

En una tabla, escriba valores típicos de capacidad de almacenamiento en bytes, tiempo de acceso y tecnología de soporte de cada nivel.

Ejercicio 5

a) ¿Qué son y para qué sirven los modos de direccionamiento?.

b) Explique el funcionamiento que tendrán las instrucciones en assembly JMP Dir y POP AX. La CPU es la del MSX88, Dir es una dirección de 16 bit y AX un registro de 16 bits.

Final 11 Octubre del 2023

Ejercicio 1

a- Describa características de IEEE 754 simple precisión.

b- Representar el valor hexadecimal 62000000H en el sistema.

Ejercicio 2

a- ¿Que es un circuito lógico combinatorial?

b- Describa suma de productos e implemente la función XOR utilizando el mismo.

Ejercicio 3

a- Describa el funcionamiento de las instrucciones de Mov. de datos.

b- ¿Qué modos de direccionamiento pueden ser utilizados en ellos?

Ejercicio 4

a- ¿Cuáles son los principios que permiten el funcionamiento de un sistema de memoria basado en jerarquía?

b- Describa y realice un esquema de organización 2D y con capacidad de almacenamiento de 1024 palabras de 16 bits

Ejercicio 5

a- Describa características de un disco rígido. Mencione medio de almacenamiento, tiempo de acceso, formato y capacidad, etc.

b- ¿Qué son los RAID?

Final 12 23Dicb

Ejercicio 1

a) Describa las características del sistema de representación en coma flotante estándar IEEE 754 de simple precisión.

b) Represente el número decimal 1 en el formato de la parte a).

Ejercicio 2

a) Describa el método de implementación de funciones booleanas denominado SoP.

b) Use el método descrito en a) para la función lógica S con 4 entradas (A, B, C, D) cuya salida es '1' cuando dos de las entradas están en '1' (Tabla-Ecuación-Gráfico).

Ejercicio 3

a) Describa el modo de direccionamiento indirecto por Registro con desplazamiento.

b) Use el método descrito en a) para el modo de direccionamiento Sim) que usen las variantes de la parte a).

Ejercicio 4

a) Describa el funcionamiento del proceso (para MSX88 o Viento) de un sistema de memoria basado en jerarquía?

b) ¿Cuáles son los principios que permiten el funcionamiento 2 ½ D con capacidad de almacenamiento de 1024 bits.

Ejercicio 5

Describa las características del almacenamiento externo conocido como disco rígido. Considerar el tipo de comunicación entre CPU y el periférico, el formato de almacenamiento, cantidad de información almacenada etc..

Final 13 FEBRERO 2022 1ERA FECHA

Ejercicio 1

Dado el numero A188 en BCH donde 8 bits representan la mantisa en BCS con bit implícito y 8 bits para exponente en exceso 128.

a) Calcular el valor en decimal.

b) Calcular el error absoluto máximo.

Ejercicio 2

a) ¿Que es un circuito combinatorio?

b) Explicar que es "sumador completo". Realizar tabla de verdad y gráfico.

Ejercicio 3

a) MSX88 representa una maquina de 2 direcciones?

b) Explicar maquina de 1 direccion.

Ejercicio 4

a) Dar 3 características principales de la organización de memoria semiconductor (2^1/2 D)

b) Realizar una tabla con valores típicos de capacidad de almacenamiento y tiempo de acceso de cada nivel de jerarquía de memoria.

Ejercicio 5

Dado un video monocromático de 15 segundos donde cada imagen tiene 500*800 píxeles

a) ¿Cuantos bytes se necesitan por cada imagen?

b) Que velocidad de transferencia a periférico debe haber si cada imagen debe ser cambiada 25 veces en 1 segundo?

Final 14 08-23

Ejercicio 1

Dado un sistema en punto flotante con 6 bits de mantisa fraccionaria en BCS y exponente de 4 bits en exceso 8 (en ese orden de izq a der):

A) ¿Cuál es el rango de representación del sistema?

B) Represente en el sistema de punto flotante dado el número decimal 32,2.

Ejercicio 2

A) ¿Cuáles son las 3 formas que se pueden utilizar para representar una función lógica?

B) Describa el funcionamiento del circuito lógico secuencial denominado 'D'.

Ejercicio 3

A) ¿Qué es un ciclo de instrucción?

B) Describa los pasos del ciclo de instrucción de una operación aritmética.

Ejercicio 4

A) ¿Cómo está compuesta una 'jerarquía de memoria'?

B) ¿Porqué la organización 2D de memoria semiconductor NO requiere 'refresco'?

Ejercicio 5

Una imagen en una pantalla de 100 cm por 50 cm posee una resolución de 100 puntos por centímetro:

A) ¿Cuántos bytes de memoria se necesitan para almacenar una imagen en 'True Color'?

B) ¿Cuántas imágenes podría almacenar en esa memoria si la imagen a almacenar fuera 'monocromática'?

Final 15 11-22

Ejercicio 1

Dado un sistema en punto flotante con 5 bits de mantisa en BCS con bit implícito y exponente de 5 bits en exceso 16 (en ese orden de izq a der):

A) ¿Cuál es el valor decimal del mínimo positivo representable por el sistema?

B) Represente en el sistema de punto flotante dado el número decimal 2,625.

Ejercicio 2

A) ¿Cuáles son las 3 funciones lógicas elementales y cómo las puede representar?

B) Describa el método de diseño de circuitos lógicos combinacionales denominado "Suma de productos".

Ejercicio 3

A) ¿Cómo es el formato de instrucción de una máquina de 3 direcciones? B) Describa la diferencia en los pasos del ciclo de instrucción de una instrucción SUB y una CMP.

Ejercicio 4

A) ¿Cuáles son los principios que rigen el funcionamiento de una "jerarquía de memoria"? B) ¿Porqué la organización 2 1/2D de memoria semiconductor utiliza 2 decodificadores?

Ejercicio 5

Una imagen en una pantalla de 100 cm por 50 cm posee una resolución de 100 puntos por centímetro: A) ¿Cuántos bytes de memoria se necesitan para almacenar una imagen en True Color? B) ¿Cuántas imágenes "monocromo" se podrían almacenar en esa memoria?

Final 16 04-24

Ejercicio 1

Dada la representación 4885H (en BCH) de un sistema en punto flotante con 8 bits de mantisa en BCS y bit implícito y exponente de 8 bits en exceso 128 (en ese orden de izq a der):

A) Determine el valor decimal representado.

B) Calcule el Error Absoluto Máximo.

Ejercicio 2

A) ¿Cuáles son las formas de representar o describir la función lógica NOR?

B) Describa el circuito lógico secuencial denominado "biestable RS". Realice la tabla de comportamiento y el gráfico de interconexión de puertas lógicas que lo represente.

Ejercicio 3

A) ¿Qué es el modo de direccionamiento de un operando?

B) Describa cómo se determina la dirección efectiva del operando cuando se utiliza el modo de direccionamiento indirecto via registro con desplazamiento.

Ejercicio 4

A) ¿Porqué funciona la jerarquía de memoria?

B) Describa 3 características principales de la organización 2 1/2D de memoria semiconductor.

Ejercicio 5

Un video musical en blanco y negro dura 100 segundos y cada imagen es de 500 por 800 píxeles:

A) ¿Cuál debe ser la velocidad de transferencia a periférico (en bytes/segundo) si para "percibir movimiento" cada imagen "visible" debe ser cambiada 25 veces en un segundo?

B) ¿Cuántos bytes de memoria se necesitan para almacenar el video completo?

Final 17 Abr23

Ejercicio 1

a) Describa las características del sistema de representación en coma flotante estándar IEEE 754 de simple precisión.

b) Represente el número decimal 1 en el formato de la parte a).

Ejercicio 2

a) Describa el método de implementación de funciones booleanas denominado SoP.

b) Use el método descripto en a) para la función lógica S con 4 entradas (A, B, C, D) cuya salida es '1' cuando dos de las entradas están en '0' (Tabla-Ecuación-Gráfico).

Ejercicio 3

a) Describa el funcionamiento del modo de direccionamiento Indirecto por Registro con desplazamiento.

b) Escriba instrucciones como ejemplo de uso de las variantes que conozca.

Ejercicio 4

a) ¿Cuáles son los principios que permiten el funcionamiento de un sistema de memoria basado en jerarquía?

b) Describa y realice un esquema de memoria con organización 2 ½ D con capacidad de almacenamiento de 1024 bits.

Ejercicio 5

Final 18 5-23

Ejercicio 1

Dada la representación 4185H (en hexadecimal) de un sistema en punto flotante con 8 bits de mantisa en BCS y bit implícito y exponente de 8 bits en exceso 128 (en ese orden de izq a der):

a) Determine el valor decimal representado.

b) Calcule el Error Absoluto máximo.

Ejercicio 2

¿Qué es una puerta lógica?

Describa el circuito lógico secuencial denominado "biestable RS".

Realice la tabla de comportamiento y un gráfico de interconexión de puertas lógicas que lo represente.

Ejercicio 3

¿Qué es un ciclo de instrucción?

Describa el funcionamiento del modo de direccionamiento indirecto via registro con desplazamiento.

Ejercicio 4

a) Describa las características principales de la organización 21/2D de memoria semiconductor.

b) Realice un esquema del chip con esta organización.

c) Mencione valores típicos de capacidad de almacenamiento y de tiempo de acceso.

Ejercicio 5

Un video musical monocromático de youtube dura 200 segundos.

a) Calcule cuántos bytes de memoria se necesitan para almacenar el video completo si cada imagen es de 800 por 500 píxeles.

b) ¿Cuál debe ser la velocidad de transferencia (en bytes/segundo) si la imagen debe ser cambiada 25 veces en un segundo?

Final 19

Ejercicio 1

4185H (en hexadecimal) Punto flotante 8 bits mantisa BCS y bit implícito y exponente 8 bits en exceso 128 (de izq a der)

a. Determine el valor decimal representado

b. Calcule el error absoluto máximo

Ejercicio 2

¿Qué es una puerta lógica? Describa el circuito lógico secuencial "Biestable RS". Realice la tabla de comportamiento y un gráfico de interconexión de puertas lógicas que lo represente.

Ejercicio 3

¿Qué es un ciclo de instrucción?

Describa el funcionamiento del modo de direccionamiento indirecto vía registro con desplazamiento.

Ejercicio 4

a. Describa las características principales de la organización 2D de memoria semiconductora

b. Realice el esquema del chip con esta organización

c. Mencione valores típicos de capacidad de almacenamiento y de tiempo de acceso

Ejercicio 5

Un video musical monocromático de Youtube dura 200 seg

a. Calcule cuántos bytes de memoria se necesitan para almacenar el video completo si cada imagen es de 800 x 500 px

b. ¿Cuál debería ser la velocidad de transferencia (en bytes/seg) si la imagen debe ser cambiada 25 veces en 1 seg?

Final 20 08-22

Ejercicio 1

Dado un sistema en punto flotante con 6 bits de mantisa fraccionaria en BCS y exponente de 4 bits en exceso 8 (en ese orden de izq a der):

A) ¿Cuál es el rango de representación del sistema?

B) Represente en el sistema de punto flotante dado el número decimal 32,2.

Ejercicio 2

A) ¿Cuáles son las 3 formas que se pueden utilizar para representar una función lógica?

B) Describa el método de diseño de circuitos lógicos combinacionales denominado "Suma de productos".

Ejercicio 3

A) ¿Qué es el ciclo de instrucción?

B) Describa los pasos del ciclo de instrucción de una operación aritmética.

Ejercicio 4

A) ¿Cómo está compuesta una "jerarquía de memoria"?

B) ¿Porqué la organización 2D de memoria semiconductor NO requiere "refresco"?

Ejercicio 5

Una imagen en una pantalla de 100 cm por 50 cm posee una resolución de 100 puntos por centímetro:

A) ¿Cuántos bytes de memoria se necesitan para almacenar una imagen en "True Color"?

B) ¿Cuántas imágenes podría almacenar en esa memoria si la imagen a almacenar fuera "monocromática"?

Final 21 09-22

Ejercicio 1

Dado un sistema en punto flotante con 6 bits de mantisa fraccionaria normalizada en BCS y exponente de 4 bits en exceso 8 (en ese orden de izq a der):

A) ¿Cuál es el valor del mínimo positivo representable en ese sistema?

B) Represente en punto flotante el número decimal 32,25.

Ejercicio 2

A) ¿Cuáles son las 3 formas que se pueden utilizar para representar una función lógica?

B) Describa el método de diseño de circuitos lógicos combinacionales denominado "Suma de productos".

Ejercicio 3

A) ¿Qué se representa con el formato de instrucción?

B) Describa los pasos del ciclo de instrucción de un salto incondicional.

Ejercicio 4

A) ¿Cuáles son los valores típicos de tiempo de acceso en los niveles de una "jerarquía de memoria"?

B) ¿Porqué la organización 2 1/2D de memoria semiconductor requiere "refresco"?

Ejercicio 5

Una imagen en una pantalla de 100 cm por 50 cm posee una resolución de 100 puntos por centímetro:

A) ¿Cuántos bytes de memoria se necesitan para almacenar una imagen en True Color?

B) ¿Cuántas imágenes podría almacenar en esa memoria si la imagen a almacenar fuera "monocromática"?

Otros Finales Resueltos

¿Qué es una puerta lógica? Describe el método para la obtención del circuito combinatorio de una tabla de verdad con cuatro variables de entrada que produce una salida “1” solo cuando una de las 4 entradas esta en 1.

Una puerta lógica es un dispositivo electrónico que produce como señal de salida una operación booleana a partir de las señales de entrada. Las puertas básicas usadas en lógica digital son: AND OR NOT, y en base a estas se derivan XOR, NAND y NOR. Cada puerta tiene una o mas entradas que cuando cambian, la señal de salida aparece casi instantáneamente, retrasada solo por el retardo de puerta. La puerta se define de tres formas:

Simbólica: es el convenio gráfico conocido universalmente para representar la puerta
Función algebraica: es la ecuación con la que se puede definir una puerta.
Tabla de verdad: enumera el valor de una operación para cada combinación posible de los valores de los operandos.

El método consiste en usar la técnica de suma de productos, primero se arma la tabla de verdad:

| A | B | C | D | F | |---|---|---|---|---| | 0 | 0 | 0 | 0 | 0 | | 0 | 0 | 0 | 1 | 1 | | 0 | 0 | 1 | 0 | 1 | | 0 | 0 | 1 | 1 | 0 | | 0 | 1 | 0 | 0 | 1 | | 0 | 1 | 0 | 1 | 0 | | 0 | 1 | 1 | 0 | 0 | | 0 | 1 | 1 | 1 | 0 | | 1 | 0 | 0 | 0 | 1 | | 1 | 0 | 0 | 1 | 0 | | 1 | 0 | 1 | 0 | 0 | | 1 | 0 | 1 | 1 | 0 | | 1 | 1 | 0 | 0 | 0 | | 1 | 1 | 0 | 1 | 0 | | 1 | 1 | 1 | 0 | 0 | | 1 | 1 | 1 | 1 | 0 |

Tomar las filas en las que la salida es “1”, y armar la función algebraica. Los “0” serán la variable negada.

F= [(~A).(~B).(~C).D]+[(~A).(~B).C.(~D)]+[(~A).B.(~C).(~D)]+[A.(~B).(~C).(~D)]

Así de esta forma queda dibujar el circuito lógico que van a ser tres AND unidas a un OR. Las negaciones se realizan agregando una NOT antes. Se unen todas las salidas de las compuertas AND con una OR porque solo se va a cumplir una de las condiciones a la vez.

Describa las características principales de la organización 2 ½ D de memoria semiconductora. Defina los valores de capacidad de almacenamiento y tiempo acceso.

Los bits se almacenan en una matriz cuadrada de N filas por M columnas. Se accede de un bit a la vez, que tiene asociada una dirección que puede ser leída o escrita según la señal de control. Están hechas de transistores en lugar de flip-flops como la memoria 2D, lo que permite poder fabricarlas de mayor capacidad. El problema de los transistores es que pierden la carga y por lo tanto pierden el valor almacenado, por lo cual se debe usar una técnica de refresco. Esto puede provocar cuello de botella. Tiene dos decodificadores, la dirección se divide en dos. Hoy en día se comercializan memorias de 1 a 8 GB, con tiempos de acceso entre 50 y 70 ns.

Enumere todos los elementos a tener en cuenta para el diseño del repertorio de instrucciones de un procesador. Describa dos de ellos.

Para el repertorio de instrucciones hay que tener en cuenta:

Tipos de operaciones: cuantas y cuales
Tipos de datos: cuales
Formato de instrucciones: longitud (bits), N° de direcciones, tamaño de cada campo.
Registros: cantidad que se pueden referenciar mediante instrucciones y su uso.
Direccionamiento: la manera de especificar la dirección de un operando o una instrucción (la próxima)

Dos ejemplo podrían ser, las maquinas de dos direcciones y las de una dirección.

Tipos de operaciones

Transferencia de datos: MOV (load/store)
Aritméticas: ADD, SUB, INC, DEC, MUL, DIV.
Lógicas: AND, OR, XOR, NOT.
Conversión
E/S: In, Out.
Transferencia de control: salto, bifurcación.
Control del sistema: usadas por el sistema operativo.

Tipos de datos Los mas importantes:

Direcciones
Números: enteros, punto fijo, punto flotante.
Caracteres: ASCII, BCD.
Datos lógicos

Modos de direccionamiento En una instrucción se utilizan bits para expresar el código de operación: nos dicen qué hacer. También se necesitan una gran cantidad de bits para especificar de donde provienen los datos. Los modos de direccionamiento tienen como objetivo:

Disminuir la cantidad de bits en la instrucción.
La dirección puede que no se conozca hasta el momento de ejecutar el programa.
Manejo mas eficiente de los datos (arreglos).

Los modos de direccionamiento que existen son:

Inmediato
Directo
Por registro
Indirecto por memoria
Indirecto por registro
Por desplazamiento
Del stack

Mdd Inmediato El operando se obtiene automáticamente de la memoria al mismo tiempo que la instrucción. No requiere una referencia extra a memoria. La desventaja es que el tamaño del operando está limitado por el tamaño del campo de direccionamiento.

Mdd Directo El campo de direccion tiene la direccion efectiva del operando. Es simple pero tiene un espacio limitado de direcciones por cantidad de bits del campo.

Mdd por registro Conceptualmente es igual al Directo, pero se especifica un registro en lugar de una posición de memoria. La referencia a registro usa menos bits que la especificación de la dirección y no requiere acceso a memoria de datos. La desventaja es que son pocos.

Mdd Indirecto por memoria En la instrucción está la dirección de la dirección del operando. Trata de solucionar el problema del Directo. Así, con una dirección de menos bits en la instrucción, se apunta a una dirección de mas bits. La ventaja es que es espacio de direccionamiento es mayor. La principal desventaja es que realiza múltiples accesos a memoria.

Mdd Indirecto por registro En la instrucción se especifica el registro que tiene almacenada la dirección. La ventaja de esto es que necesita menos bits para especificar el registro que la posición de memoria.

Mdd por desplazamiento Combina capacidades de Indirecto y Directo. Requiere que la instrucción tenga dos campos de dirección. Estos dos campos se suman para producir la dirección efectiva. Los mas comunes son Relativo, De registro base e Indexado.

Mdd Del stack El stack o pila es un arreglo lineal de localidades de memoria. Es una lista o cola donde el ultimo en entrar es el primero en salir. Es una zona de memoria reservada. Asociado con la pila o stack hay un registro apuntador (SP) cuyo valor es la dirección tope de pila o stack.

Se requiere mostrar en “True Color” de 1024x1024 píxeles, un vídeo que posee 20 imágenes por cada segundo ¿podría usar la memoria cuyos valores de capacidad y tiempo de acceso definió en el punto 3? justifiquen.

1024 x 1024 x 3 Bytes x 20 = 62.914.560 Bytes = 60 MB

1 Byte _________ 50 ns 62.914.560______ x ns

(62.914.560 x 50) / 1 = 3,14 seg. aprox. Por lo tanto la memoria especificada en el punto 3 no nos sirve para mostrar las 20 imágenes en un segundo.

¿Qué características determinan que un circuito lógico sea combinacional? Describa el método para implementar el circuito lógico de la función booleana F de cuatro entradas (a, b, c y d) cuya tabla de verdad posee valor de salida “1” cuando solo una de sus variables esta en “1”. realice el gráfico correspondiente de interconexión de compuertas resultantes.

Para que un circuito lógico sea combinacional se necesitan un conjunto de dos o mas puertas interconectadas. Responden a los valores logicos de las entradas, la salida esta determinada exclusivamente por los valores de las entradas en ese instante. Si cambia la entrada cambia la salida. Lo valores pasados de las entradas no influyen en los valores de las salidas.

¿Qué es un ciclo de instrucción? Describa los diferentes pasos del ciclo si la instrucción a realizar es XOR AL, 55H (or exclusivo entre registro y operando inmediato). Si AL contenía 5AH, ¿Que resultado queda en AL luego de la ejecución de la instrucción?

El ciclo de instrucción es el procedimiento requerido para una sola instrucción. Se puede decir que un ciclo de instrucción incluye subciclos: captación o búsqueda, interpretación y ejecución e interrupción. La ejecución del programa se detiene sólo si la computadora se desconecta, se produce una error o se encuentra una instrucción que la detiene. La secuencia exacta de eventos que tiene lugar durante un ciclo de instrucción depende del diseño de la CPU.

Los pasos de la instrucción XOR AL, 55H son:

Busca el código de operación.
Incrementa el PC.
Decodifica la instrucción y detecta que tiene que ir a buscar la otra parte.
Busca la otra parte del código de operación.
Incrementa el PC.
Decodifica la instrucción y detecta que es una operación lógica XOR, por lo que tendrá que usar la ALU.
Busca el operando que en este caso es el 55H.
Incrementa el PC.
Realiza la operación XOR entre el valor almacenado en AL y el 55H.
Almacena el resultado en AL.

El resultado que quedaría en AL seria 00001111 = 0FH

¿Que operaciones de tipo aritmético podemos encontrar en un repertorio de instrucciones? ¿Porque los distintos tipos de datos que deseen utilizarse en esas operaciones condicionan el hardware necesario para operar?

El conjunto de operaciones de tipo aritmético que podemos encontrar son la suma, resta, multiplicación, división, incremento, decremento, valor absoluto y negación. Los tipos de datos condicionan al hardware por una serie de cosas:

Si se esta diseñando un sistema que valla a multiplicar muchos números seria conveniente seria conveniente incluir un multiplicador por hardware.
Si se va a utilizar números muy grandes debe disponerse de una cantidad adecuada de bits para los buses en general, memoria, CPU, etc. Por ejemplo, una maquina de 4 bits no se podría utilizar para un software que trabaja con números de miles de millones.

Describa los métodos de acceso a la información almacenada en memoria secundaria. ¿que ventaja y/o usos puede mencionar del almacenamiento en RAID?

Los métodos de acceso son:

Secuencial: la memoria se organiza en unidades (registros). Para acceder a uno se debe ir trasladando desde la posición actual a la deseada por todos los registros intermedios. Ej.: discos.
Directo: se accede directamente a una vecindad dada de registros o bloques, luego una búsqueda secuencial contando o esperando alcanzar la posición. Ej.: discos.
Aleatorio-Random: cada posición direccionable tiene un único mecanismo de acceso. Ej.: memoria principal y cache.
Asociativa: de tipo aleatoria donde se hace una comparación de ciertos bits de una palabra buscando coincidencias de valores dados, y esto para todas las palabras simultáneamente. Una palabra accedida basándose en una parte de su contenido y no de su dirección o posición.

Las ventajas y/o usos de RAID depende de cada nivel:

NIVEL 0: En este nivel los datos del usuario y del sistema están distribuidos a lo largo de todos los discos del conjunto, a través de la tira de datos (las cuales pueden ser bloques físicos, sectores o alguna otra entidad) y se proyectan cíclicamente en dispositivos consecutivos. Al conjunto de tiras lógicamente consecutivas, que se proyecta exactamente sobre una misma tira en cada miembro del conjunto, se las denomina franja.
NIVEL 1: Consigue la redundancia duplicando todos los datos, proporcionando una copia de seguridad en tiempo real. Se hace una distribución de datos como en el nivel 0, pero cada franja lógica se proyecta en dos discos físicos separados. De esta forma cada disco tiene un espejo que tiene la misma información.

Esto trae tres ventajas:

Una petición de lectura puede ser servida por cualquier de los dos discos que contienen los datos pedidos.
La petición de escritura, que requiere que las dos tiras correspondientes se actualicen, se hace en paralelo.
Cuando una unidad falla, se puede acceder inmediatamente a los datos de la otra.

La principal desventaja es el costo de su implementación, ya que se requiere el doble del espacio de disco del disco lógico. Ej.: Para organizar un RAID 1 de 4 discos físicos se usaran 2 para el espacio lógico y 2 para el espejado.

NIVEL 2: utiliza una técnica de acceso en paralelo, que consiste en que todos los discos miembros, participan en la ejecución de cada E/S. Dado que el giro de cada unidad esta sincronizado, para que cada cabezal este en la misma posición en cada disco.

En este nivel las tiras son muy pequeñas, y la redundancia y corrección de errores, se logran a través de una ecuación de paridad, que consiste en calcular los bits de cada posición de cada disco, y almacenarlos en las correspondientes posiciones en los discos de paridad.

Cuando se produce un error en un solo bit, el controlador del conjunto lo reconoce, realiza el calculo para saber el valor correspondiente y lo corrige instantáneamente.

En cuanto a las operaciones E/S, una petición de lectura no conlleva un tiempo adicional, sin embargo, la petición de escritura debe acceder a todos los discos de datos y de paridad. La ventaja de este RAID esta en que se necesita una menor cantidad de discos para almacenar la información. Y su desventaja recae en el costo. Su uso esta destinado en entornos en los que haya muchos errores de disco y la seguridad no sea alta.

NIVEL 3: se organiza de manera similar que el de nivel 2 y utiliza una acceso en paralelo, pero se diferencia de él en que solo requiere de un disco redundante, sin importar lo grande que sea el conjunto de disco.

En este nivel la corrección es simple, se calcula un sencillo bit de paridad para el conjunto de bit individuales que están en la misma posición, en todos los discos de datos. En caso de que falle una unidad, se accede a disco de paridad y se reconstruye la información desde el resto de los dispositivos.

Las ventajas de este RAID se encuentran en el ahorro de espacio, ya que solo se necesita un disco de paridad y en las altas velocidades de transferencias de datos. Su desventaja esta en que solo se puede recuperar un disco dañado por ves, si se dañaran dos al mismo tiempo, no podría reconstruir la información.

Su uso esta destinado en entornos no orientados en transacciones.

NIVEL 4: Este nivel, así como el 5 y el 6, usan una técnica de acceso independiente, por lo que las diferentes E/S se pueden atender en paralelo. (es más adecuado para sistemas que requieran velocidades de petición de E/S altas, que para los que necesiten velocidades de transferencia altas)

Las tiras de datos son relativamente grandes, y se realiza una paridad bit a bit que se guarda en la tira correspondiente del disco de paridad. Esto trae aparejado un cuello de botella sobre el disco de paridad, ya que debe actualizarse cada vez que se haga una escritura en cualquiera de los discos de datos.

NIVEL 5: Este nivel es muy similar al nivel 4, pero las tiras de paridad se distribuyen a lo largo de todos los discos. Se distribuye de manera cíclica: para un conjunto de n discos, la tira de paridad está en diferentes discos para las primeras n tiras, y este patrón se repite. O sea que la tira de paridad siempre está en otro disco que su correspondiente tira de datos.

Esta distribución evita el cuello de botella que se produce el nivel 4, ya que la actualización de la paridad se distribuye sobre todos los discos.

NIVEL 6: El nivel 6 agrega otro algoritmo de comprobación de datos, y se distribuyen de la misma manera que el nivel 5. Uno es el algoritmo de los niveles 3, 4 y 5 que calcula la XOR, y otro es un algoritmo independiente. Esto hace posible la regeneración de los datos incluso si dos de los discos que contienen los datos de los usuarios fallan.

Es una solución perfecta para aplicaciones con objetivos críticos, pero tiene un gran costo de cálculo y escritura de paridades.

Describa como se puede construir un sumador binario completo. Defina cuales son las funciones lógicas que se pueden utilizar, tabla de verdad y realice un esquema de interconexión de compuertas de dicho sumador.

Un sumador binario completo se puede construir armando la tabla de verdad con los valores booleanos de la suma binaria, y la tabla de verdad de la suma con acarreo. Una vez realizadas estas tablas, se puede hacer las funciones de salida. Para que funcione un sumador de varios bits cada uno de los sumadores de un bit deben tener 3 entradas, incluyendo el acarreo del sumador inmediato inferior.

Suma = (-A . -B . C) + (-A . B . -C) + (A.B.C) + (A.-B.-C) Acarreo = A.B + A.C + B.C

¿Qué mejoras podemos obtener en el funcionamiento de máquina que ejecuta instrucciones debido al principio de localidad de referencia?

La principal mejora que podemos obtener cuando se cumple el principio de localidad de referencia es la disminución de la frecuencia de acceso a los niveles inferiores de la jerarquía de memoria. Es gracias a este principio que dicha jerarquía puede implementarse. El principio de localidad de referencia nos dice que en el curso de la ejecución de un programa, las referencias a memoria por parte del procesador, tanto para instrucciones como para datos, tienden a estar agrupadas. Los programas normalmente contienen un numero de bucles iterativos y subrutinas. Cada vez que se entra en un bucle a una subrutina, hay repetidas referencias a un pequeño conjunto de instrucciones. Esto también se cumple al trabajar con matrices o arreglos.

¿En qué momento del ciclo de instrucciones se fija la CPU si hay pedido de interrupciones? ¿Por qué? Describa los pasos que se llevan a cabo cuando se encuentra el pedido.

Después de la ejecución de la instrucción.

Pasos

1. Suspende la ejecución del programa en curso y guarda su contexto. Esto significa almacenar la dirección de la siguiente instrucción a ejecutar y cualquier otro dato relacionado con la actividad en curso del procesador.
1. Carga el PC con la dirección de comienzo de una rutina de gestión de interrupción.

A continuación el procesador prosigue con el ciclo de captación y accede a la primera instrucción del programa de gestión de interrupción, que dará servicio a la interrupción. Generalmente el programa de gestión de interrupción forma parte del sistema operativo. Normalmente, este programa determina el origen de la interrupción y realiza todas las acciones que sea necesarias. Cuando la rutina de gestión de interrupción se completa, el procesador puede proseguir la ejecución del programa de usuario en el punto en el que se interrumpió.

¿Qué objetivo persigue la existencia del registro puntero de pila (stack pointer) en el CPU? ¿Para qué serviría tener más de uno?

El objetivo del stack pointer es contener el valor de la dirección del tope de la pila.

Tener más de un Stack Pointer serviría para poder tener una pila para el usuario y una para el sistema. Esto evitaría que el usuario tenga que estar pendiente de los cambios que realiza el sistema en la pila.

Completada la instrucción add AX, meno1. ¿Qué instrucción deberá ejecutar a continuación para determinar si el resultado obtenido es correcto o no? Considere los casos de representación de números sin signos y en ca2.

Para números sin signo debería ejecutar: 
		JNC correcto
		MOV CX, 1
		JMP fin
correcto:	MOV CX, 0
fin:		HLT

Para números en ca2 debería ejecutar: 
		JNO correcto
		MOV CX, 1
		JMP fin
correcto:	MOV CX, 0
fin:		HLT

Describa los componentes que definen el tiempo de acceso de un disco magnético. ¿Cómo se podría calcular un tiempo de acceso promedio?

Los componentes que definen el tiempo de acceso son: Por un lado, la cabeza de lectura, que tiene una cierta velocidad para alcanzar el cilindro buscado (tiempo de seek). También los discos en si, que tienen una determinada velocidad de giro. Esto determina el tiempo de latencia, que ocurre desde que la cabeza de lectura se posiciona sobre el cilindro, hasta que el sector buscado pasa por debajo de la cabeza.

Para calcular el tiempo de acceso promedio debemos sumar el tiempo de seek y el tiempo de latencia promedio. Este último se puede calcular como el tiempo de giro de una pista dividido dos. Otra manera podría ser midiendo el tiempo de acceso de una gran cantidad de accesos y hacer un promedio.

¿Qué es un JK? Describa las características de funcionamiento con tabla de comportamiento y gráfico del circuito lógico.

Es un circuito secuencial, por lo tanto la salida depende de la entrada como del estado interno del circuito. Es un tipo de flip-flop que tiene dos entradas al igual que es SR, pero todas las combinaciones posibles son validas. La entrada J sola realiza la función de puesta a 1, causando que la salida sea 1. La entrada K solo realiza la función de puesta a 0. Cuando J y K son 1 la función realizada es de conmutación: la salida se invierte.

Describa paso a paso el ciclo de instrucción correspondiente a la ejecución JMP memo1. Dicha instrucción ocupa 3 bytes en memoria. La memoria almacena palabras de 8 bits y direcciona con 16 bits.

Busca el código de operación
Incrementa el Program Counter
Decodifica y detecta que se trata de un salto
Busca la parte baja de la dirección a la que tiene que saltar
Incrementa el PC
Busca la parte alta de la dirección a la que tiene que saltar
Incrementa el PC
Carga el PC con el valor de la dirección a la que tiene que saltar

Enumere las instrucciones de tipo transferencia de control que posee el MSX-88 y explique el modo de direccionamiento de c/u de ellas.

Las instrucciones de tipo transferencia de control que posee el MSX-88 son: Los saltos (JMP, JZ, JNZ, JS, JNS, JC, JNC, JO, JNO) Las llamadas a subrutinas (Call, Ret) También son de transferencia de control las de interrupciones.

Los modos de direccionamiento que usan son: Relativos al PC, donde se tiene un número que debe ser sumado al contenido del PC. Directo, cuando la etiqueta representa una dirección a la que se debe saltar.

¿Que es un módem? Para que sirve, porque se utiliza? Cuales son los parámetros de un módem?

MODEM: MOdulador, DEModulador. Convierte señales '0' y'1' en tono de audio y viceversa. La tasa de Bits/seg (bps) es el numero de bits enviados por segundo. Tasa de baudio es el numero de cambio de señal por segundo. Su principal uso es para telecomunicaciones: convierte señales analógicas provenientes de un sistema telefónico a cadenas binarias. Es una de las tecnologías más usadas para conectarse a internet.

Describa los mecanismos de impresión que conozca, compare calidad obtenible, cantidad de copias por vez, tamaño de papel utilizable, cantidad de colores y velocidad de impresión de los mecanismos que mencione.

Impresora de impacto: Los caracteres son impresos golpeando los moldes de los caracteres o una cinta entintada sobre la hoja. En la disposición “Margarita” todos los caracteres sobre relieve están dispuestos en forma de flor e impactan de a uno contra la hoja, golpeando una cinta entintada que les permite marcar el carácter. La ventaja es que cada carácter individual se imprime con buena calidad, pero no puede imprimir nada que no sea cadenas de caracteres. En cambio, las impresoras por matriz de puntos, marcan los caracteres sobre una cinta al igual que las de margarita, pero usando punzones manejados por solenoides. Tiene tantos punzones como sea el alto de la matriz de caracteres. Produce muy baja resolución. Ambos tipos de impresoras son muy lentas y por lo general ruidosas. Según el fabricante, pueden usar algunos colores, pero muy limitados y de baja calidad y resolución.
Impresora láser: Es el tipo de impresora con mayor resolución, llegando hasta 1200dpi. Permite usar todos los colores y puede imprimir páginas completas de texto o gráfico a gran velocidad. Permite realizar muchas copias en menos tiempo que los demás sistemas. La desventaja es que son costosas.
Impresora Ink-jet ó de inyección de tinta: Tienen un trasductor ultrasónico que lanza pequeños chorros de tinta a los puntos correctos con la cabeza moviéndose sobre el papel.

Permite tanto blanco y negro como color. El precio, resolución, y velocidad se encuentra entre las anteriores. Esto hace que sean las más comunes para uso cotidiano.

Con respecto a al tamaño utilizable, puede que las impresoras de impacto estén limitadas por el tamaño físico de los punzones o martillos. En los otros tipos, depende del tamaño de bandeja que incorpore el fabricante. Los tamaños más comunes son los estándares “A4”, “Oficio”, “carta”, etc.

La cantidad de copias por vez va depender de la velocidad de impresión del dispositivo, siendo las más rápidas las láser.

Describa las diferencias que tendremos entre una computadora con teclado y monitor como periféricos y una que posee un equipo denominado terminal como periférico. Puede considerar cantidad y ubicación de la memoria de video, cantidad y tipo de puertas de E/S, tipo de comunicación entre CPU y periférico.

En una computadora tradicional con teclado y monitor, tendremos un monitor de video con memoria de visualización que está mapeada en la memoria principal del equipo. En cambio, en un esquema con terminales, cada terminal se compone de un teclado y un monitor con su propia memoria de visualización dedicada a ese terminal. Esto evita que se llene la memoria principal del computador que centraliza a los terminales. Cada terminal puede estar alejado físicamente del CPU, por ejemplo, se puede tener el computador principal en una habitación y poner un terminal en cada una de las demás habitaciones.

La terminal conecta sus periféricos con la computadora a través de una conexión en serie, que tiene poco ancho de banda, por lo que los monitores de los terminales suelen estar orientados a caracteres para ahorrar transferencia de datos. En cambio, las computadoras con video mapeado en memoria conectan los periféricos directamente al bus de memoria, que permite cambios rápidos. Esto hace que tenga solo 1 E/S para el monitor, a diferencia de el computador con terminales, que va a tener 1 conexión de E/S para cada terminal, a pesar de que no necesite mapear la memoria de visualización en su memoria principal.

¿Qué define el Teorema fundamental de la numeración?

El teorema fundamental de la numeración establece la forma general de construir números en un sistema de numeración posicional.

Donde:

N es el número decimal
d es un dígito que puede variar entre {0,1,..., (b-1)}
b es la base de representación
-k es la posición del dígito menos significativo, y n es la posición del dígito más significativo.

Ejemplos

Numeros en Punto Flotante

Mantisa Entera BCS restringido a 4 bits y el Exponente BSS restringido a 3 bits. (0110010)

Explicación Numeros en Punto Flotante Parte 1

Mantisa Entera BCS restringido a 4 bits y el Exponente BSS restringido a 3 bits. (1011111)

ExplicaciónNumeros en Punto Flotante Parte 2

Mantisa Entera BCS restringido a 4 bits y el Exponente BSS restringido a 3 bits. (1010011)

Explicación Numeros en Punto Flotante Parte 3

Mantisa Fraccionaria BCS restringido a 4 bits y el Exponente BSS restringido a 3 bits. (1010011)

Explicación Numeros En Punto Flotante Parte 4

Sistema en Punto Flotante cuya mantisa es fraccionaria, con 6 bits, está expresada en BSS (en el inciso a) o BCS (en el insciso b) y su exponente en BCS con 4 bits, escriba el significado de las siguientes cadenas de bits (mantisa a la izquierda)

Explicación Practica Punto Flotante Parte 1

Explicación Practica Punto Flotante Parte 2

Parte A)

Parte B)

Explicación Punto Flotante Ejercicio 1 Rango y Resolución Parte 1

Calcular El Rango

Esto es un ejemplo para ver el maximo anterior y lo demas continua en la siguiente clase

Explicación Punto Flotante Ejercicio 1 Rango y Resolución Parte 2

Introducción a los sitemas Operativos

Fri, 15 Jul 2022 00:00:00 GMT

El objetivo de esta práctica es que el alumno se familiarice con los conceptos básicos del sistema operativo GNU/Linux, así como con su entorno y comandos principales.

1) Características de GNU/Linux:

Es multiusuario: Cumple simultáneamente las necesidades de dos o más usuarios que comparten los mismos recursos, un sistema multiusuario permite que los usuarios accedan a los datos o procesos de una única maquina, desde diferentes computadoras o termínales

Es multitarea y multiprocesador: Puede realizar varias operaciones, funciones o ejecuciones al mismo tiempo

Los SO multitarea permiten realizar varias operaciones gracias a una operación denominada cambio de contexto que actúa de la siguiente manera, quita un proceso del CPU, ingresa uno nuevo, y luego vuelve a ingresar el proceso que quitó del CPU en una especie de cola de ejecución, sin que el procesador se entere de todo lo que está pasando, de modo, que pueda realizar varias tareas simultáneas. Es como una especie de engaño, que permite mejorar el rendimiento de los ordenadores y facilitar el trabajo a los usuarios.

Multiprocesador se refiere al número de procesadores del sistema, que es más de uno y éste es capaz de usarlos todos para distribuir su carga de trabajo.

Es altamente portable: Se puede usar en cualquier ordenador que tenga el SO para el que fue programado sin la necesidad de una instalación previa; significa que no hace falta la instalación de bibliotecas adicionales en el sistema para que pueda funcionar.

Posee diversos intérpretes de comandos, de los cuales algunos son programables

Es el método de interacción entre el usuario y la máquina (shell)
CLI (interfaz de línea de comando) un ejemplo seria la terminal bash.

Permite el manejo de usuarios y permisos: Nos permite darle permisos particulares a usuarios y archivos del file system.

Todo es un archivo (hasta los dispositivos y directorios): Todo es un fichero. Los directorios son ficheros, los ficheros son ficheros, y los dispositivos son ficheros. A veces a los dispositivos se les llama nodos, pero siguen siendo ficheros.

Los sistemas de ficheros de GNU/Linux se organizan en una estructura jerárquica, de tipo árbol.

El nivel más alto del sistema de ficheros es / o directorio raíz. Todos los demás ficheros y directorios están bajo el directorio raíz. Por ejemplo, /home/jebediah/cheeses.odt muestra la ruta completa al fichero cheeses.odt que está en el directorio jebediah, que a su vez está bajo el directorio home, que por su parte está bajo el directorio raíz (/).

Cada directorio puede estar en una partición diferente (/temp, /home, etc.): En Linux, el sistema de archivos se organiza en una estructura de árbol con una raíz denominada "/" (barra). Dentro de esta estructura de árbol, cada partición puede montarse en un directorio diferente, lo que significa que los archivos y directorios que se encuentran dentro de esa partición se harán accesibles a través del directorio montado.

Por ejemplo, si tienes una partición llamada /dev/sda1 y quieres montarla en el directorio /home, los archivos y directorios en esa partición estarán disponibles en el directorio /home. Si tienes otra partición llamada /dev/sda2 y quieres montarla en /temp, los archivos y directorios en esa partición estarán disponibles en el directorio /temp.

En resumen, en Linux, cada partición puede montarse en un directorio diferente en la estructura de árbol de archivos del sistema, lo que permite una mejor organización y gestión de los datos.

Es case sensitive: Sensible a las mayúsculas y minúsculas

Es código abierto: Software cuyo código fuente y otros derechos que normalmente son exclusivos para quienes poseen los derechos de autor, son publicados bajo una licencia de código abierto o forman parte del dominio público. En las licencias compatibles con la Open Source Definition el propietario de los derechos de autor permite a los usuarios utilizarlo, modificarlo, estudiarlo, aprovechar su documentación, redistribuir el software, a cualquiera, para cualquier propósito, ya sea en su forma modificada o en su forma original etc.

A diferencia de Windows y Mac, Linux no pertenece a ninguna compañía, sino que su desarrollo depende de la colaboración de un gran número de empresas y profesionales.
Su uso esta mas enfocado a programadores dado que sus interfaces son menos amigables.
Los demás sistemas suelen ser en su mayoría pagos y enfocados mas a lo comercial
El manejo de permisos de Linux vuelve mas difícil la creación de un virus para dicho sistema mientras que en Windows es mas común.

GNU es un SO de tipo Unix pero libre, diseñado por miles de programadores, así como una gran colección de programas informáticos que componen al sistema, desarrollado por y para el GNU.

Está formado en su totalidad por software libre, mayoritariamente bajo términos de copyleft. GNU es el acrónimo recursivo de "GNU's Not Unix" (GNU no es Unix), nombre elegido debido a que GNU sigue un diseño tipo Unix y se mantiene compatible con este, pero se distingue de Unix por ser software libre y por no contener código de Unix.

El proyecto GNU fue iniciado por Richard M. Stallman con el propósito de crear un sistema operativo completo y libre: el sistema GNU.
Se baso principalmente en 4 libertades
- Libertad 1: la libertad para ejecutar el programa con cualquier fin.
- Libertad 2: La libertad de estudiar cómo trabaja el programa y de adecuarlo para que haga lo que usuario desee
- Libertad 3: la libertad de redistribuir el programa de manera de colaborar con el resto de la sociedad.
- Libertad 4: la libertad de hacer pública y distribuir a terceros la versión mejorada.

Pondria más pero a nadie le importa la historia de linux salu2.

Puede realizar varias operaciones, funciones o ejecuciones al mismo tiempo

Linux es Multitarea: La multitarea no consiste en hacer que el procesador realice más de un trabajo al mismo tiempo (un solo procesador no tiene esa capacidad), lo único que realiza es presentar las tareas de forma intercalada para que se ejecuten varias simultáneamente. Por lo tanto en Linux es posible ejecutar varios programas a la vez sin necesidad de tener que parar la ejecución de cada aplicación.

GNU/Linux si es multitarea.

POSIX (Interfaz de sistema operativo portátil) es un conjunto de interfaces de sistema operativo estándar basadas en el sistema operativo Unix .

Definen una interfaz y un entorno estándar que puede utilizar un sistema operativo para proporcionar acceso a aplicaciones compatibles con POSIX.

El estándar también define un intérprete de comandos ( shell ) y programas de utilidad comunes . POSIX admite la portabilidad de aplicaciones en el nivel del código fuente , por lo que las aplicaciones se pueden crear para ejecutarse en cualquier sistema operativo compatible con POSIX.

2) Distribuciones de GNU/Linux:

Una distribución es un conjunto de software de GNU, así como programas de sistema, librerías y aplicaciones de usuario, con también software de terceros (a veces), con una versión de un kernel de Linux, todo compilado, empaquetado, configurado y preparado para su instalación en una computadora.

En resumen una distribución de GNU/Linux es el sistema operativo preparado para ser instalado y usado en una computadora.

Desarrollar una distribución es elegir de entre todos los programas de sistema (compiladores, intérpretes, etc.) y aplicaciones de usuario (entornos gráficos de escritorio, editores de texto, paquetes de ofimática, etc.) de GNU y de software de terceros (a veces, no siempre), los que se crean convenientes según la distribución que se quiera crear, más pesada, más ligera, etc., sumado a una versión de un kernel de Linux.

Distribución GNU/Linux = Software GNU + Software de terceros (no siempre) + Kernel de Linux.

Cualquier persona con conocimientos de programación puede crear una distribución GNU/Linux, por eso hay cientos de ellas.

Es tan indispensable el kernel de Linux como el conjunto de programas y librerías de GNU. Por ello cuando a una distribución GNU/Linux se le llama Linux a secas, es una falta de respeto hacia todo el software que GNU ha desarrollado y continua desarrollando como software libre y gratuito.

Debian, Opensuse, Fedora, Ubuntu.

Debian: Se orienta a la estabilidad, en términos de ciclo de desarrollo. Sus actualizaciones y versiones se liberan cuando están listas y bien probadas. Lo cual es bueno para servidores, pero por otra parte nos limita compatibilidad con dispositivos de hardware más novedosos. Son muy exigentes en lo que respecta a Software Libre.
Fedora: Se orienta a innovación con un ciclo de desarrollo corto de seis meses, y un tiempo de soporte de un año sobre sus paquetes. Lo más nuevo se encuentra en Fedora, a veces la gente desconfía de la solidez de sus paquetes sin embargo lo que sucede es que están en fase de maduración y se le integran mejores funcionalidades. Por ahí leí que Fedora es como probar lo que Linux ofrecerá dentro de seis meses.
Opensuse: Novel se quedó sin sistema operativo para su plataforma de servidores y redes, así que compro Suse. Su panel de control para configuración lo hace fácil de configurar. Es un buena elección para aprender de servidores, pero posiblemente para cosas más sofisticadas dejarán las herramientas de configuración y harán ajustes personalizados. El mundo de Software Libre les critica fuertemente sus acuerdos de interoperabilidad con Microsoft.
Ubuntu: Se propuso cambiarle la cara al mundo Linux y ciertamente lo ha logrado. Apuntando a ser fácil de usar hace bien simple la instalación de drivers y decodificadores privativos, cosa que se le critican los fundamentalistas del software libre. Su programa de enviar discos gratis hasta la puerta de tu casa ha significado su creciente popularidad. Tiene ciclo de desarrollo rápido, pero sus versiones tienen ciclos de soporte alternado, entre periodos largos y cortos, tratando de tener estabilidad de soporte y flexibilidad de desarrollo.

Las mayores diferencias se encuentran sobre todo en distribuciones comerciales, donde se han introducido herramientas para una fácil instalación, detección de software etc...

Diferencias:

Proceso de instalación.
Ayudantes o wizard que te ayuden en la configuración de tu máquina.
Gestores de paquetes.
Secuencia en el proceso de arranque.

Debian es una comunidad de desarrolladores , que mantiene un sistema operativo GNU basado en software libre. El sistema se encuentra precompilado, empaquetado y en formato deb para múltiples arquitecturas de computador y para varios núcleos.

El proyecto Debian fue anunciado inicialmente 1993 por Ian Murdock. Debian 0.01 fue lanzado el 16 de agosto de 1993 y la primera versión estable fue hecha en 1996.

Nació como una apuesta por separar en sus versiones el software libre del software no libre. El modelo de desarrollo del proyecto es ajeno a motivos empresariales o comerciales, siendo llevado adelante por los propios usuarios, aunque cuenta con el apoyo de varias empresas en forma de infraestructuras.

Debian no vende directamente su software, lo pone a disposición de cualquiera en Internet, aunque sí permite a personas o empresas distribuirlo comercialmente mientras se respete su licencia.

La primera adaptación del sistema Debian, siendo también la más desarrollada, es Debian GNU/Linux, basada en el núcleo Linux, y como siempre utilizando herramientas de GNU

Los nombres de las versiones de Debian son tomados de la película Toy Story. Hasta la fecha, hay quince versiones estables (con sus respectivas revisiones) enumeradas en la tabla adjunta:

3) Estructura de GNU/Linux:

Kernel, shell y Filesystem.

Estructura. Nos ocuparemos de tres componentes principales:

Kernel: El núcleo se podría definir como el corazón de este sistema operativo. Es a grandes rasgos, el encargado de que el software y el hardware de una computadora puedan trabajar juntos.
Shell: Es un programa que recibe lo que se escribe en una terminal de texto y lo convierte en instrucciones para el sistema operativo.
Filesystem: Es la forma lógica en que dentro de un SO se organizan y se administran los archivos.

4) Kernel:

El kernel es la estructura principal del SO, es el que se encarga de que el software y el hardware puedan trabajar juntos.

Es un núcleo monolítico hibrido, y esta licenciado bajo la licencia GPL v2.

Evolución

En 1991 Linus Torvalds inicia la programación del kernel Linux basándose en Minix (un clon de Unix desarrollado por Tenembaum en 1987).

En octubre de 1991 sale la primera versión oficial Linux(0.02) .

En 1992 se une Linux con el proyecto Gnu de Richard Stallman , la versión 1.0 aparece el 14 de marzo del 94’ , luego el desarrollo de Gnu/Linux se sigue desarrollando por miles de programadores, en el 96’ adoptan como mascota oficial a Tux (pingüinito).

En julio de 1996 se lanza la versión 2.0 y se define la nomenclatura de versionado. Se desarrollo hasta febrero de 2004 y termino con la 2.0.40. En enero de 1999 se lanza la versión 2.2, que provee mejoras de portabilidad entre otras y se desarrolla hasta febrero de 2004 terminando en la versión 2.2.26.

En 2001 se lanza la versión 2.4 y se deja de desarrollar a fines del 2010 con la 2.4.37.11. La versión 2.4 fue la que catapulto a GNU/Linux como un SO estable y robusto.

Durante este período es que se comienza a utilizar Linux más asiduamente Núcleo.

A fines del 2003 se lanza la versión 2.6, Esta versión ha tenido muchas mejoras para el SO dentro de las que se destacan soporte de hilos, mejoras en la planificación y soporte de nuevo hardware.

El 3 de agosto de 2011 se lanza la versión 2.6.39.4 anunciándose la misma desde meses previos como la última en su revisión.

El 17 de julio de 2011 se lanza la versión 3.01, No agrega mayores cambios.

La decisión del cambio son los 20 años del SO y no superar los 40 números de revisión. Totalmente compatible con 2.6. La última versión estable es la 5.19.6 (agosto de 2022).

Funciones principales: Administrar la memoria, CPU y E/S, administración de procesos y comunicación y concurrencia.

La versión del kernel actual es 5.16. Lo demas a nadie le importa

En la versión 2.0 se define la nomenclatura del versionado:

Modo de Versionar: A.B.C.[D]

A) Denota Versión. Cambia con menor Frecuencia. en 1994 (versión 1.0), en 1996 (versión 2.0) y en 2010(3.0).
B) Denota Mayor revisión. Antes de la versión 2.6, los números impares indicaban desarrollo, los pares producción.
C) Denota Menor revisión. Solo cambia cuando hay nuevos drivers o características. -------------------------- la D se agrega a partir de la visión 2.4 ------------------------------------------
D) Cambia cuando se corrige un grave error sin agregar nueva funcionalidad. (casi no se usan en la rama de versiones 3.x, 4.x y 5.x viéndose reflejado en el componente C del SO).

Ejemplo actualidad: versión 5.19.6

Antes de la versión 2.6, los números impares indicaban desarrollo, los pares producción.

Sí. Se puede instalar en la misma máquina, pero 2 núcleos corriendo simultáneamente en Linux es imposible

Se encuentra ubicado el /lib/: librerías esenciales compartidas y módulos de kernel

Directorio raíz de toda la jerarquía de archivos del sistema.

\ Jerarquia Primaria

/bin/ Comandos binarios esenciales de usuario
/boot/ Archivos estáticos del selector de arranque
/dev/ Archivos de unidades
/etc/ Configuración del sistema de Host Especifico
/home/ Directorio "home" de usuario
/lib/ Librerias esenciales compartidas y módulos de Kernel
/media/ Punto de Montaje para medios removibles
/mnt/ Punto de Montaje temporal para sistemas de archivos
/opt/ Agregados de paquetes de Software y Aplicaciones
/sbin/ Binarios de Sistema
/srv/ Datos para los servicios provistos por este sistema
/tmp/ Archivos temporales
/usr/ Unidades y aplicaciones de (Multi) usuario
/var/ Variables de archivo
/root/ Directorio "Home" del usuario Root
/proc/ Documentación del sistema de archivos virtual del Kernel y las condiciones de los procesos en archivos de texto

El kernel Gnu/Linux si es monolítico.

Kernel monolítico quiere decir que toda funcionalidad que implementa el SO se ejecuta en modo kernel o supervisor, ejemplo cuando un usuario quiere ejecutar un proceso se pasa a modo kernel se resuelve todo ahí y después regresa a modo usuario cuando esa resolución termino, toda la lógica se encuentra en el modo kernel.

Ventajas el modelado, el diseño implica menos tiempo en la resolución de las cosas. (cambio de modo - resuelvo lo que tengo que resolver - vuelvo a modo usuario).

También existe el kernel microkernel, se trata de que el modo kernel o supervisor este el menos tiempo posible y trata de dejar en modo usuario diferentes componentes para que se ejecuten en modo usuario y que hagan de apoyo al modo kernel.

Ejemplo: el SO tiene un conjunto de procesos que van a ir cambiando cada 3 segundos, cada vez que cambia de proceso eso debe estar en modo kernel, ahora la selección de cuál de esos 3 procesos va a ser seleccionado para a entrar a ejecutarse se puede hacer en modo usuario.

Básicamente el kernel microkernel reduce al máximo el uso del modo kernel y delega cosas al modo usuario cosa que no sucede con el modo kernel.

5) Intérprete de comandos (Shell):

La shell también conocida como CLI (interfaz de línea de comando), es el que gestiona la interacción entre el usuario y el sistema operativo.

(es solo un programa que hará de mediador entre nosotros y el kernel del SO. Puede ser tanto gráfico Ej. La interfase X-Window, como de texto Linux (Ej. El bash).

La Shell no forma parte básico del sistema operativo si no que la misma dialogo con el kernel.
La shell es iniciada por un proceso llamado login y dado que cada usuario tiene asignado una shell por defecto la misma se inicia cada vez que un usuario comienza a trabajar en su estación de trabajo, es decir se loguea en una terminal. Dentro del contenido del archivo /etc/passwd, se puede ver cual es la shell que cada usuario tiene asignada por defecto.

Es el encargado de ejecutar programas a partir del ingreso de comandos.

Ejemplo: control de procesos, redirección de entrada/salida, listado y lectura de ficheros, protección, comunicaciones y un lenguaje de órdenes para escribir programas por lotes o (scripts o guiones).

Bourne Shell (sh) Creado por S. Bourne, es el más utilizado en la actualidad. Su símbolo del sistema es $. Es el shell estándar y el que se monta en casi todos los sistemas UNIX/Linux.
Korn Shell (ksh) Escrito por David Korn, amplía el shell del sistema añadiendo historial de órdenes, edición en línea de órdenes y características ampliadas de programación.
Bourne Again Shell (bash) Fue creado para usarlo en el proyecto GNU. BASH, por lo tanto, es un shell o intérprete de comandos GNU que incorpora la mayoría de distribuciones de Linux. Es compatible con el shell sh. Además, incorpora algunas características útiles de ksh y csh, y otras propias como la edición de línea de comandos, tamaño ilimitado del historial de comandos, control de los trabajos y procesos, funciones y alias, cálculos aritméticos con números enteros, etc. Su símbolo del sistema es nombre_usuario@nombre_equipo.

Los intérpretes se diferencian entre sí básicamente en la sintaxis de sus comandos y en la interacción con el usuario.

PATH: es una variable y su contenido es una cadena que contiene rutas de directorios separadas por dos puntos.

Por ejemplo, para mostrar el valor de una variable en la shell se debe escribir:

echo $ nombrevariable
en el caso de la variable path seria
echo$ PATH

la variable PATH contiene una lista de directorios separados por dos puntos. Estos son los directorios en los que el shell busca el comando que el usuario escribe desde el teclado.

La búsqueda no se realiza en el orden en el que están los directorios en la variable PATH.

Los comandos propios, también conocidos como built-in commands, son aquellos que están integrados en la propia shell. Estos comandos suelen ser los más básicos y necesarios para la gestión de la sesión y del sistema, como por ejemplo: cd (para cambiar de directorio), echo (para imprimir texto en la pantalla), exit (para salir de la sesión), entre otros.
Por otro lado, los comandos externos son aquellos que se encuentran en el sistema operativo y que son invocados desde la shell. Estos comandos pueden ser programas completos o scripts que realizan una tarea específica. Ejemplos de comandos externos son ls (para listar los archivos en un directorio), cat (para mostrar el contenido de un archivo), grep (para buscar patrones en un archivo), entre otros.

En resumen, los comandos propios están integrados en la propia shell y los comandos externos son programas o scripts que se ejecutan desde la shell.

La principal razon es que es muy remplazable, en caso de que falle, se puede reiniciar y todo tendria que seguir andando.

Y tambien

La shell no forma parte del kernel de Linux porque es una aplicación que proporciona una interfaz de línea de comandos para interactuar con el sistema operativo, mientras que el kernel es la parte central del sistema operativo que administra los recursos del hardware y proporciona servicios básicos al software. Aunque la shell y el kernel trabajan juntos, son dos componentes distintos con diferentes funciones y responsabilidades.

Si, es posible.

¿Desde dónde se define?

Se definen en etc/passwd

¿Cualquier usuario puede realizar dicha tarea?

No, cada usuario puede definir su o sus intérpretes

6) Sistema de Archivos (File System):

Es la forma en que dentro de un SO se organizan y se administran los archivos.

Los usuarios de Linux hacen una distinción del filesystem. Dicen que un filesystem es un esquema de programación que se utiliza para organizar y buscar archivos en una partición. Mientras que el sistema de archivos se refiere a todos los archivos de la computadora.

Lo que esto significa, básicamente, es que el filesystem es la estructura que se utiliza para ver, buscar y usar los archivos mediante Ubuntu. Mientras que el sistema de archivos son todos los archivos separados de esa estructura y el formato de esos archivos.

A continuación veremos una lista con algunos filesystem utilizados hoy en día:

ext2
ext3
ReiserFS
XFS

Si. En estos momentos existen distribuciones de GNU-Linux que pueden realizar operaciones de lectura y escritura sobre ellas.

Mencione los directorios más importantes e indique qué tipo de información se encuentra en ellos.

/ Tope de la estructura de directorios. Es como el C:\ (raíz).
/home Se almacenan archivos de usuarios (Mis documentos)
/var Información que varía de tamaño (logs, BD, spools)
/etc Archivos de configuración del sistema.
/bin Archivos binarios y ejecutables.
/dev Enlace a dispositivos.
/usr Aplicaciones de usuarios

(Filesystem Hierarchy Standard - Estándar de jerarquía del sistema de archivos).

FHS: es el estándar que siguen todos los sistemas operativos unix, para organizar el sistema de archivos.

7) Particiones:

Es el nombre que recibe cada división de una sola unidad física de almacenamiento de datos. (es un pedazo de una unidad ).

Toda partición tiene su propio sistema de archivos (formato); generalmente, casi cualquier sistema operativo interpreta, utiliza y manipula cada partición como un disco físico independiente, a pesar de que dichas particiones estén en un solo disco físico.

Existen 3 tipos diferentes de particiones:

Partición primaria Son las divisiones crudas o primarias del disco, solo puede haber 4 de éstas o 3 primarias y una extendida. Depende de una tabla de particiones. Un disco físico completamente formateado consiste, en realidad, de una partición primaria que ocupa todo el espacio del disco y posee un sistema de archivos. A este tipo de particiones, prácticamente cualquier sistema operativo puede detectarlas y asignarles una unidad, siempre y cuando el sistema operativo reconozca su formato (sistema de archivos).
Partición extendida También conocida como partición secundaria es otro tipo de partición que actúa como una partición primaria; sirve para contener múltiples unidades lógicas en su interior. Fue ideada para romper la limitación de 4 particiones primarias en un solo disco físico. Solo puede existir una partición de este tipo por disco, y solo sirve para contener particiones lógicas. Por lo tanto, es el único tipo de partición que no soporta un sistema de archivos directamente.
Partición lógica Ocupa una porción de la partición extendida o la totalidad de la misma, la cual se ha formateado con un tipo específico de sistema de archivos (FAT32, NTFS, ext2,...) y se le ha asignado una unidad, así el sistema operativo reconoce las particiones lógicas o su sistema de archivos. Puede haber un máximo de 23 particiones lógicas en una partición extendida.

Facilidad de reinstalación. Si separamos los archivos Windows de nuestra información personal, será mucho más fácil reinstalar Windows. Esto es porque nos «ata» todo lo que tenemos guardado, evitando formatear o intentando hallar otras soluciones antes que esa. De hecho, podemos clonar la partición de Windows para hacer restauración.
Copias de seguridad. Las copias de seguridad son las que nos salvan de los problemas catastróficos (que me lo digan a mí). Siempre hay que funcionar sobreseguro, lo que se traduce en tener backups de toda la información, o de la más importante. Las particiones nos dan la ventaja de tener un volumen para copias de seguridad.
Más seguridad. Imaginad que nuestra partición de Windows queda infectada por un virus y perdemos toda la información hallada en ella. Tener nuestra información importante en otra partición nos salva de un gran apuro, especialmente si el virus es ransomware. Igualmente, instalad un antivirus y funcionad con él.
Mejor organización. Esto depende de la persona, pero es innegable que podemos organizarnos mucho mejor teniendo varias particiones. Así, podemos clasificar toda nuestra información de mayor a menor importancia, o según el tipo de información, tamaño, etc.
Instalar dos o más sistemas operativos. En mi opinión, es uno de los motivos principales por los que las personas hacen particiones. En el pasado, hice una partición para usar OS X y Windows, creando un arranque dual que me permitiera elegir el sistema operativo que quisiese iniciar. Al fin y al cabo, tenéis un volumen listo para usar.
Máquinas virtuales. Quienes trabajéis con ellas, haréis particiones para instalar una máquina virtual en ella. Es una gran idea para separar nuestro PC de nuestra máquina virtual. Por tanto, podemos tener ambos contenidos separados; de lo contrario, si algo falla, podríamos perder toda la información de nuestro PC y máquina virtual.

Experiencia más lenta. Si tenemos muchas particiones, puede que nos cueste encontrar un archivo en concreto. Aquí hay que ser muy metódico y ordenado para saber qué partición es vital, como cuál es prescindible. Al final, tardamos en encontrar algo por tener demasiadas particiones.
Posibilidad de errores. Existe la posibilidad de que surjan más fallos cuando tenemos muchas particiones. Son meras cuestiones de probabilidad, así que no hay que volverse loco.
Desorden en los volúmenes. Es fácil que esto ocurra; de hecho, me ha pasado muchas veces a mí. Cuando hacemos una partición, formateamos, volvemos a crear un volumen, etc., podemos crear particiones extendidas que no van a ningún sitio. En mi caso, se trataba de una partición de 700 MB en un HDD de 2 TB: el impacto es mínimo. Sin embargo, no tiene gracia que nos pase en un SSD de poca capacidad.
Innecesario para el usuario medio. Al final, las personas que utilizan el PC para «3 cosas», no requieren particiones, ni se quieren liar a aprender cómo funciona esto. Por tanto, es una opción limitada a aquellos que buscan cierta utilidad.

El primer disco duro IDE se conoce como /dev/hda. Si tenemos un segundo disco duro IDE se llamará /dev/hdb, etc.

Los discos duros SCSI y SATA se denominan /dev/sda, /dev/sdb, etc. En cada disco son representadas añadiendo un número decimal al nombre del disco: sda1 y sda2 representan a la primera y segunda partición en la primera unidad de disco SCSI en el sistema.

Si bien el número mínimo absoluto de particiones sería uno (1), una instalación típica de GNU / Linux tendrá al menos dos (2) particiones: la partición raíz (indicada como /) y la partición de intercambio. Puede optar por tener todos los archivos en una sola partición dentro de la mayoría de las distribuciones durante la instalación.

El esquema de particiones estándar para la mayoría de las instalaciones domésticas de Linux es el siguiente: Una partición de 12-20 GB para el sistema operativo, que se monta como / (llamada “raíz” o root) Una partición más pequeña que se utiliza para aumentar su RAM, montada y denominada /swap. Una mampara más grande para uso personal, montada como /home

Para una instalación de GNU/Linux saludable se recomiendan 3 particiones swap, root y home.

Hay 2 tipos de particiones principales en un sistema Linux:

Partición de datos datos normales del sistema Linux, incluida la partición raíz que contiene todos los datos para iniciar y ejecutar el sistema; y.
Partición de intercambio expansión de la memoria física de la computadora, memoria extra en el disco duro.
Tipo de filesystem Sistema de archivos Ext2, ext3 y ext4: Así como Apple y Microsoft tienen sus propios sistemas, estos tres (cada uno evolución del anterior) son los utilizados por las distribuciones GNU/Linux. El principal inconveniente es que sólo puede ser utilizado en esta familia de sistemas operativos.

Tipo de filesystem Sistema de archivos Ext2, ext3 y ext4: Así como Apple y Microsoft tienen sus propios sistemas, estos tres (cada uno evolución del anterior) son los utilizados por las distribuciones GNU/Linux. El principal inconveniente es que sólo puede ser utilizado en esta familia de sistemas operativos.

Integración de nuevas adquisiciones Si forma una empresa nueva. La empresa recién formada no utiliza las mismas aplicaciones para las nóminas, el inventario y la facturación. Tiene previsto consolidar las dos empresas en un solo conjunto de aplicaciones, pero esta consolidación tardará un tiempo. Mientras tanto, debe reducir el coste de los centros de datos con rapidez.

Por tanto, decide crear particiones lógicas para las aplicaciones utilizadas por la empresa recién adquirida. Instala un sistema operativo y las aplicaciones utilizadas por la empresa nueva en la partición lógica. Si las cargas de trabajo combinadas necesitan más recursos.

Creación de varios entornos de cliente El usuario suministra servicios e-commerce de alta disponibilidad a diversos clientes. Proporciona recursos de sistema, aplicaciones y soporte técnico a cada cliente, y cada cliente puede configurar y utilizar independientemente las aplicaciones ejecutadas en los recursos de sistema suministrados. En un entorno de este tipo, es esencial aislar a los clientes para que sólotengan acceso a sus recursos. Sin embargo, dedicar un servidor físico a cada cliente tiene un coste prohibitivo, y no permite aumentar ni disminuir fácilmente la cantidad de recursos de sistema utilizados por cada cliente.

Por tanto, decide crear una partición lógica para cada cliente. Instala un sistema operativo y aplicaciones en cada partición lógica. A continuación, puede utilizar el particionamiento dinámico para añadir recursos a particiones lógicas o eliminar recursos de ellas según sea necesario. Si un cliente deja de utilizar el servicio, puede suprimir la partición lógica de dicho cliente y reasignar los recursos a otras particiones lógicas

Existen 2 tipos:

Destructivos: permiten crear y eliminar particiones (fdisk)
No destructivo: permiten crear, eliminar y modificar particiones

8) Arranque (bootstrap) de un Sistema Operativo:

La BIOS (Sistema Básico de Entrada/Salida) es un software que inicializa y comprueba todos los componentes de hardware durante el arranque de la máquina. También prepara el equipo para que el Sistema Operativo se cargue y se ejecute. Su nombre viene de las siglas en inglés Basic Input Output System.

La Bios es un software de bajo nivel que se encuentra en el Motherboard. Cuando se arranca la computadora el bios se ejecuta, realizando el POST (power – on Self -test) que incluye rutinas que, entre otras actividades, fijan valores de señales internas y ejecutan test internos (ram , teclado etc).

POST POST es un acrónimo de Power-On Self Test (Autocomprobación de encendido) que se ejecuta en tu PC en el momento en que la enciendes. El POST prueba el hardware de tu computadora y se asegura de que no exista ninguna avería ni haya errores presentes en su sistema operativo. El POST comprueba todo, desde el teclado y la unidad de disco, hasta la velocidad de la RAM en una computadora y los puertos integrados. Si todo está en orden, POST continuará como de costumbre y permitirá que tu PC se inicie normalmente. Si se detecta un error, el BIOS emitirá un mensaje de error que puede aparecer en forma de texto en la pantalla o una serie de pitidos indicativos de dicho error. Estos sonidos siempre son señales para mensajes determinados, por lo que, si te sucede esto, deberás verificar lo que ello significa para el hardware de tu computadora.
Configuración del CMOS Tu PC almacena todas las configuraciones de bajo nivel como la hora del sistema y la configuración de hardware dentro del CMOS. Esto significa que cada cambio que realices en la estructura del BIOS se guardará en este chip de memoria especial llamado Semiconductor Complementario de Óxido Metálico, o CMOS (por sus siglas en inglés). La configuración del CMOS es responsable, a su vez, de configurar tu contraseña, hora y fecha.
Cargador de arranque El cargador de arranque, programa que vive dentro de la EPROM o ROM de tu computadora, tiene la tarea de leer el sector de arranque del disco duro de tu PC para moverse a lo largo de todo el proceso de carga del sistema operativo.

UEFI (Unified Extensible Firmware Interface o Interfaz de Firmware Extensible Unificada). Es la Alianza entre varias compañías con el objetivo de modernizar el proceso de arranque, querían reemplazar a la BIOS. Sus funciones son parecidas a los de la BIOS, pero mejoradas. UEFI aporta criptografía, autenticación por red, y una interfaz gráfica.

Usa el sistema GPT (GUID Partition table) para solucionar algunas limitaciones del MBR, tales como la cantidad de particiones y capacidad máxima del dispositivo particionado.

Sector de arranque – MBR

El Master Boot Record es el primer sector del disco físico.

Se ubica en el cilindro 0, cabeza 0, sector 1. En todos los discos existe un MBR, pero el mismo es tenido en cuenta si el disco contiene las particiones del sistema.

El tamaño de MBR coincide con el tamaño estandard de sector del disco, generalmente 512 bytes. Estos bytes contienen lo siguiente:

El MBC es un pequeño código que permite arrancar el sistema operativo. La tarea del MBC consiste en buscar una entrada de la tabla de particiones marcada con el valor 0x80 indicando que esta entrada es booteable lo cual indica que la partición correspondiente a esta entrada es booteable. La última acción del BIOS es leer el MBC. Lo lleva a memoria y lo ejecuta.

Una partición GPT GUID Partition Table es un estándar diseñado para realizar la configuración de las tablas de particiones y su ubicación en medios de almacenamiento como los discos duros físicos.

Puede ser utilizado independientemente de la UEFI.

MBR es la tabla de particiones tradicional que soporta los sistemas operativos más antiguos, mientras que GPT es un nuevo sustituto que no tiene límites en cuanto al tamaño del disco y el número de particiones que se pueden crear

Las ventajas de GPT sobre MBR

Soporta discos duros más grandes que 2TiB.
Permite crear particiones teóricamente ilimitadas.
Contiene una verificación de redundancia cíclica para comprobar la integridad de sus datos.
Contiene la copia de seguridad del encabezado GPT primario y las entradas de la partición que protege mejor los datos del disco.

Un gestor de arranque, es un programa que se encarga del inicio del ordenador, antes del sistema operativo, y que nos permite elegir el sistema operativo que queremos cargar, es decir se encarga del bootstrap (carga) o booteo del sistema.

Es el encargado de carga el sistema operativo (kernel) de un ordenador en la memoria RAM.

Se ejecuta luego del código de la BIOS.

Los datos de un sistema operativo deben cargarse directamente en la memoria RAM al iniciarse el dispositivo. Esto es posible con el bootloader, también conocido como gestor de arranque. El bootloader suele ejecutarse directamente al arrancar un dispositivo usando algún medio que sea booteable, es decir, que sirva como unidad de arranque, como puede ser un disco duro, un CD o DVD, o un stick booteable. El medio de arranque recibe la información acerca de dónde se encuentra el bootloader por parte del firmware del ordenador (BIOS, por ejemplo). Al proceso completo se le denomina inicio, arranque o, en inglés to boot.

En lo que a la ubicación de los bootloaders se refiere, se han consolidado dos opciones:

El bootloader se guarda en el primer bloque del medio booteable o de arranque (MBR): Está estrechamente relacionada con el principio de los Master Boot Records, que no solo contienen la referencia necesaria por parte del firmware hacia el bootloader, sino también el software de inicio en sí. Para el record se reserva siempre el primer bloque o sector de memoria disponible en el medio. Este bloque o sector también es llamado, precisamente por esta función tan importante, boot block o boot sector.
El bootloader se guarda en una partición específica del medio de arranque: El sistema operativo usa como lugar de almacenamiento del bootloader una partición seleccionada, si bien el sistema de archivos de base y la tabla de particiones utilizada no tienen por qué coincidir en absoluto. El firmware siempre es un factor decisivo y, este tipo de ubicación del bootloader, requiere además un formato de archivo específico del gestor de arranque. En dispositivos con UEFI se trata, por ejemplo, del formato PE/COFF (Portable Executable / Common Object File Format).

Algunos gestores de arranque: GRUB

GRUB 2
LILO o SYSLINUX.
NTLDR
GAG
YaST

GRand Unified Bootloader(grub): gestor de arranque múltiple que se usa para iniciar dos o más sistemas operativos instalados en un mismo ordenador.

Cuando aprietas el botón de arranque de un ordenador, lo primero que aparece en la pantalla son los datos acerca del hardware del equipo. El software responsable de esta información es, en primer lugar, el ya mencionado firmware, que los productores de los dispositivos por lo general implementan en una memoria flash en la placa base o mainboard. En la mayoría de los ordenadores de mesa y portátiles se apuesta por el ya veterano BIOS (Basic Input/Output System) o por el más reciente UEFI (Unified Extensible Firmware Interface). Ambos programas reúnen diferentes datos del hardware y para generar, entre otras cosas, una lista completa de todas las unidades de disco disponibles en el dispositivo.

Una vez se ha completado este proceso, el firmware comprueba uno a uno los soportes de datos encontrados en busca del bootloader o, más concretamente, la llamada boot signature o boot record. La búsqueda se inicia siempre en los medios extraíbles conectados (CD/DVD, stick USB, discos duros externos, etc.) y luego pasa a los discos duros internos. En estos últimos, el bootloader (o la boot signature) suele estar en el Master Boot Record (MBR), que también aloja la tabla de particiones del soporte de datos. Cuando se encuentre un bootloader, este se cargará y se iniciará así el sistema. Si la búsqueda, en cambio, no tiene éxito, el firmware mostrará un mensaje de error.

Ell flujo de control durante el arranque es desde el BIOS, al gestor de arranque y al núcleo (kernel)).

Kernel: Este inicia el planificador (para permitir la multitarea) y ejecuta el primer espacio de usuario (fuera del espacio del núcleo) y el programa de inicialización (que establece el entorno de usuario y permite la interacción del usuario y el inicio de sesión), momento en el que el núcleo se inactiva hasta que sea llamado externamente.
La etapa del cargador de arranque no es totalmente necesaria. Determinadas BIOS pueden cargar y pasar el control a Linux sin hacer uso del cargador. Cada proceso de arranque será diferente dependiendo de la arquitectura del procesador y el BIOS.
En el apagado, Init es llamado a cerrar toda las funcionalidades del espacio de usuario de una manera controlada, de nuevo a través de secuencias de comandos, tras lo cual el Init termina y el núcleo ejecuta el apagado.

Se notifica a los usuarios este hecho.
Se bloquea el sistema para que nadie más pueda acceder exceptuando el root.
Se envía la señal SIGTERM (señal de terminación) a todos los procesos no definidos en inittab(contiene un registro para cada proceso que define los niveles de ejecución para ese proceso) para el siguiente run level, provocando que terminen su ejecución de modo ordenado.

Si es posible ya lo vimos anteriormente gracias a las particiones de disco instalar múltiples sistema operativos o a través de maquinas virtuales.

9) Archivos

Un nombre de archivo puede tener entre 1 y 255 caracteres. recomendable emplear los caracteres con significado especial en Linux, que son los siguientes: = \ ^ ~ ' " ` * ; - ? ( )! & ~ < >

VI Es el editor de texto clásico en UNIX. Puede usarse en cualquier tipo de terminal con un mínimo de teclas.

MODOS DE VI: Existen tres modos o estados de vi:

Modo comando: Este es el modo en el que se encuentra el editor cada vez que se inicia. Las teclas ejecutan acciones (comandos) que permiten mover el cursor, ejecutar comandos de edición de texto, salir de vi, guardar cambios, etc.
Modo inserción o texto: Este es el modo que se usa para insertar el texto. Existen varios comandos que se pueden utilizar para ingresar a este modo.
Modo línea o ex: Se escriben comandos en la última línea al final de la pantalla.
MCEDIT

Al igual que Vi funciona como gestor de archivos

cat Es la abreviatura de concatenar. Esto se refiere al hecho de que cat puede ser utilizado para combinar múltiples archivos en un archivo, también se puede utilizar para crear nuevos archivos y para mostrar el contenido de los archivos existentes.
more Es un comando para ver (pero no modificar) el contenido de un archivo o comando y visualizarlo por páginas.

Utilice el siguiente comando para crear un archivo (en este ejemplo, .htaccess). También puede editar un archivo existente con el mismo comando.

nvim fabianmartinezrincon.txt

Pulse la tecla de la letra i para cambiar al modo de entrada.
Inserte el contenido deseado o realice las modificaciones deseadas.
Pulse la tecla ESC para salir del modo de entrada.
Guarde el nuevo archivo o los cambios realizados con el siguiente comando:

:wq

Permite detectar el tipo y formato de un archivo

file [opciones] archivo

b) muestra solo el tipo de archivo sin ninguna información adicional.
i) fuerza el uso de la sintaxis MIME para mostrar el tipo de archivo.
z) trata los archivos como si estuvieran comprimidos.

10) Indique qué comando es necesario utilizar para realizar cada una de las siguientes acciones. Investigue su funcionamiento y parámetros más importantes:

mkdir "ISO 2022" Cree la carpeta ISO2017
cd 'ISO 2022' Acceda a la carpeta (cd)
touch ISO2022-1 ISO2022-2 Cree dos archivos con los nombres iso2017-1 e iso2017-2 (touch)
ls Liste el contenido del directorio actual (ls)
pwd Visualizar la ruta donde estoy situado (pwd)
find ./'ISO 2022' -name "ISO*" Busque todos los archivos en los que su nombre contiene la cadena “iso*” (find)
df Informar la cantidad de espacio libre en disco (df)
who Verifique los usuarios conectado al sistema (who)
vi ISO2022-1 Acceder a el archivo iso2017-1 e ingresar Nombre y Apellido
tail ISO2022-1 Mostrar en pantalla las últimas líneas de un archivo (tail).

shutdown El comando de apagado (Shutdown) te permite apagar, reiniciar y detener tu sistema

sudo shutdown
sudo shutdown now
sudo shutdown [time]
sudo shutdown 11:50
sudo shutdown +5
sudo shutdown +2 "System update"
sudo shutdown -r
sudo shutdown +3 –r "Update System"
sudo shutdown -c

sudo reboot Sirve para reiniciar el equipo
sudo halt El comando halt detiene la CPU del ordenador
locate El comando locate es una alternativa útil, ya que es más rápido que find para realizar búsquedas. Eso se debe a que sólo escanea tu base de datos de Linux en lugar de todo el sistema. Además, la sintaxis es más fácil de escribir sudo apt install locate

uname Se usa para verificar la información del sistema

uname -s
uname -r
uname -v
uname -n
uname -m
uname -p
uname -i
uname -o
uname -a

gmesg (No entiendo porque esta diferente) El comando dmesg es una utilidad de Linux que muestra mensajes relacionados con el kernel recuperados del búfer de anillo del kernel. dmesg
lspci El comando lspci lista todos los componentes tipo pci como son las tarjetas de red, tarjetas de sonido o tarjetas de televisión.
at Ejecuta comandos a la hora especificada.
netstat Los administradores de sistemas utilizan netstat el comando de Linux para ver información sobre las conexiones de red sudo apt install net-tools

mount Se utiliza para montar dispositivos y particiones para su uso por el sistema operativo

sudo apt install nfs-common
sudo mkdir -p /mnt/client_ shareddirectory
sudo mount [nfs_server]:/[nfs_shareddirectory] [client_mountpoint]

umount El comando umount le permite eliminar un sistema de archivos remoto que esté montando en la actualidad umount --all
head Este comando sirve principalmente para mostrar al principio de un archivo (de texto) o para reducir a lo especificado los datos mostrados por un comando de Linux
losetup losetup de comandos de Linux se utiliza para fijar el dispositivo de bucle. parámetros:
- d dispositivo extraíble.
- e Iniciar cifrado codificación.
- o <número de traducción> Establecer el número de conversión de datos.
write sirve para enviar un mensaje a otro usuario del sistema.
- write usuario
- Escribo aquí lo que
- quiera que le llegue y luego cierro.
- Control-D
mkfs Se utiliza para dar formato a un dispositivo de almacenamiento de bloque con un determinado sistema de archivos
fdisk (con cuidado) Permite al usuario crear particiones en el disco duro de la misma manera que su contraparte de MS-DOS

Indique en qué directorios se almacenan los comandos mencionados en el ejercicio anterior.

El directorio /bin es un directorio estático y es donde se almacenan todos los binarios necesarios para garantizar las funciones básicas a nivel de usuario. Solo almacena los ejecutables de usuario, ya que los binarios necesarios para tareas administra/vas gestionadas por el usuario root o súper-usuario del sistema se encuentran en el directorio / sbin.

El objetivo de esta práctica es que el alumno comprenda los aspectos principales acerca de la estructura del sistema Operativo GNU/Linux en lo que respecta a procesos, usuarios, filesystems, permisos, etc

1) Editor de textos:

Vim: Es un editor de texto que rompe las bolas pero aprendes
GNU Emacs: La misma basura que vim pero con calculadora y administrador de archivos
mcedit: Te permite navegar entre los ficheros con una interfaz.

Los comandos cat, more y less permiten mostrar el contenido de ficheros de texto desde la línea de comandos en sistemas Unix.

En su lugar los editores de texto, justamente nos dejan editar texto además de poder visualizarlo.

cat imprimirá por pantalla el contenido del fichero sin ningún tipo de paginación ni posibilidad de modificarlo. Básicamente concatena archivos o la salida estándar en la salida estándar.
more permite visualizar por pantalla el contenido de un fichero de texto, con la diferencia con el anterior de que more página los resultados. Primero mostrará por pantalla todo lo que se pueda visualizar sin hacer scroll y después, pulsando la tecla espacio avanzará de igual modo por el fichero.
less es el más completo de los tres, pues puede hacer todo lo que hace more añadiendo mayor capacidad de navegación por el fichero (avanzar y retroceder) además de que sus comandos están basados en el editor vi, del cual se diferencia en que no tiene que leer todo el contenido del fichero antes de ser abierto.

Comandos basicos

2) Proceso de Arranque SystemV

Paso 1) Se empieza a ejecutar el código del BIOS
Paso 2) El BIOS ejecuta el POST
Paso 3) El BIOS lee el sector de arranque (MBR)
Paso 4) Se carga el gestor de arranque (MBC)
Paso 5) El bootloader carga el kernel y el initrd
Paso 6) Se monta el initrd como sistema de archivos raíz y se inicializan componentes esenciales (ej.: scheduler)
Paso 7) El Kernel ejecuta el proceso init y se desmonta el initrd
Paso 8) Se lee el /etc/inittab
Paso 9) Se ejecutan los scripts apuntados por el runlevel 1
Paso 10) El final del runlevel 1 le indica que vaya al runlevel por defecto
Paso 11) Se ejecutan los scripts apuntados por el runlevel por defecto
Paso 12) El sistema est´a listo para usarse

Su función es cargar todos los subprocesos necesarios para el correcto funcionamiento del SO
El proceso init posee el PID 1 y se encuentra en /sbin/init
En SysV se lo configura a traves del archivo /etc/inittab
No tiene padre y es el padre de todos los procesos (pstree)
Es el encargado de montar los filesystems y de hacer disponible los dem´as dispositivos

El programa pstree facilita información sobre la finalización de una serie de procesos relacionados entre sí, esto es, todos los descendientes de un proceso particular. El programa deja claro desde un principio que proceso es el primario y cuales son los secundarios.

Es el modo en que arranca Linux (3 en Redhat, 2 en Debian)
El proceso de arranque lo dividimos en niveles
Cada uno es responsable de levantar (iniciar) o bajar (parar) una serie de servicios
Un nivel de ejecución es básicamente una configuración de programas y servicios que se ejecutarán orientados a un determinado funcionamiento.

Explicación más detallada

Paso 1) Cuando un sistema GNU/Linux arranca, primero se carga el kernel del sistema, después se inicia el primer proceso, denominado init, que es el responsable de ejecutar y activar el resto del sistema, mediante la gestión de los niveles de ejecución (o runlevels).
Paso 2) En el caso del modelo runlevel de SystemV, cuando el proceso init arranca, utiliza un fichero de configuración llamado /etc/inittab para decidir el modo de ejecución en el que va a entrar.
Paso 3) En este fichero se define el runlevel por defecto (initdefault) en arranque (por instalación en Fedora el 5, en Debian el 2) y una serie de servicios de terminal por activar para atender la entrada del usuario.
Paso 4) Después, el sistema, según el runlevel escogido, consulta los ficheros contenidos en /etc/rcn.d, donde n es el número asociado al runlevel (nivel escogido), en el que se encuentra una lista de servicios por activar o parar en caso de que arranquemos en el runlevel, o lo abandonemos
Paso 5) Dentro del directorio encontraremos una serie de scripts o enlaces a los scripts que controlan el servicio. Cada script posee un nombre relacionado con el servicio, una S o K inicial que indica si es el script para iniciar (S) o matar (K) el servicio, y un número que refleja el orden en que se ejecutarán los servicios.

0 Indica halt o apagado de la máquina.
1 Indica monousuario.
2 Indica modo multiusuario sin soporte de red.
3 Indica modo multiusuario completo con soporte de red.
4 No usado, con esta opción el administrador puede personalizar el inicio para cargar algún servicio.
5 Indica multiusuario completo con inicio gráfico (X11)
6 Indica shutdown y reboot: Se apaga inmediatamente la máquina para reinicio.

Un administrador (root) puede editar el archivo /etc/inittab como mejor convenga al usuario, sin embargo también tiene el poder de establecerlo en 0 o en 6. Si se establece en 6, algo que hice como experimento en mi Mandriva, la próxima vez que la máquina se encienda, se leerá el modo 6, shutdown y reboot, y se hará exactamente eso.

¿Dónde se define qué Runlevel ejecutar al iniciar el sistema operativo?

Se encuentran definidos en /etc/inittab
Los scripts que se ejecutan están en /etc/init.d
En /etc/rcX.d (donde X = 0..6) hay links a los archivos del /etc/init.d
Formato de los links:

    [SjK]<orden><nombreScript>

S) lanza el script con el argument start
K) lanza el script con el argument stop

¿Todas las distribuciones respetan estos estándares?

No todas las distribuciones respetan los estándares.

Es el archivo de configuración de init, que decide el modo de ejecución en el que va a entrar.

Cuando el sistema se arranca, se verifica si existe un runlevel predeterminado en el archivo /etc/inittab, si no, se debe introducir por medio de la consola del sistema. Después se procede a ejecutar todos los scripts relativos al runlevel especificado.

¿Qué tipo de información se almacena en el? ¿Cuál es la estructura de la información que en él se almacena?

/etc/inittab

id:nivelesEjecucion:acción:proceso

Id: identifica la entrada en inittab (1 a 4 caracteres)
Niveles_ejecucion: el/los nivel de ejecución en los que se realiza la acción
Acción: describe la acción a realizar
- wait: Se inicia cuando se entra al runlevel e init espera a que termine
- initdefault
- ctrlaltdel: se ejecutará cuando init reciba la señal SIGINT
- off, repawn, once, boot, bootwait, powerwait, otras…
Proceso: el proceso exacto que será ejecutado

Existen dos formas de modificar los runlevels:

a) Cambiar de runlevel en ejecución: Existe una utilidad para línea de comandos que permite cambiar de un nivel de ejecución a otro. Esta es la herramienta init. Para cambiar de nivel de ejecución sólo hay que ejecutar init seguido del número del runlevel.
Por ejemplo
init 0 Cambia al runlevel 0 (se apaga el sistema, equivalente al comando halt).
init 2 Cambia al runlevel 2.
init 6 Cambia al runlevel 6 (reinicia el sistema, equivalente al comando reboot).

También telinit, nos permite cambiar de nivel de ejecución, sólo tenemos que indicar el número. Por ejemplo, necesitamos hacer una tarea crítica en root; sin usuarios trabajando, podemos hacer un tellinit 1 (también puede usarse S) para pasar a runlevel monousuario, y después de la tarea un tellinit 3 para volver a multiusuario

b) Modificar el runlevel por defecto

Por defecto, el sistema suele arrancar en el nivel de ejecución 5 (modo gráfico). Si se quisiera modificar este comportamiento, habría que editar el fichero /etc/inittab.

Más concretamente, habría que modificar en el fichero /etc/inittab la línea donde el número 5 indica que el nivel de ejecución por defecto es el 5

No es permanente. En el caso de que el runlevel se cambie durante la sección de bash abierta y luego se apague la máquina, cuando se vuelva a prender la maquina se volverá a restablecer al modo que tenga el sistema configurado (por defecto).

En el caso de que se quiera cambiar el modo de arranque del runlevel de manera permanente se tendrá que configurar para que eso suceda.

ls /etc/rc0.d
sudo runlevel
sudo telinit 2

Los scripts RC se encargan de cargar o cerrar los servicios necesarios para que el sistema funcione, de acuerdo con el runlevel que se está iniciando. Por ejemplo: lpd (servicio para imprimir), fetchmail (servicio para leer correo-e), sshd (SecureShell para abrir sesiones remotas de una manera segura), networking (abre las conexiones de red).

¿Dónde se almacenan?

Todos estos servicios se encuentran en /etc/init.d/

Sin embargo, no todos los servicios se cargan en todos los runlevels. ¿Cómo sabe el RC que servicios tiene que cargar? Los servicios a cargar se encuentran en el directorio /etc/rcX.d/, donde X es el runlevel a cargar. En realidad, en estos directorios no hay más que enlaces simbólicos a /etc/init.d/

Cuando un sistema GNU/Linux arranca o se detiene se ejecutan scripts, indique cómo determina qué script ejecutar ante cada acción. ¿Existe un orden para llamarlos? Justifique.

Orden para llamarlos:

Los nombres en estos directorios tienen una sintaxis bastante concreta. Empiezan por una letra (S o K) seguidos de un número y el nombre del servicio. La letra S significa iniciar (S de start). La letra K significa acabar (K de kill). El número es de dos dígitos, de 00 a 99 e indica el orden en el que se arrancará el servicio.

1) Ejecuta, por orden de nombre, todos los scripts que comienzan por K en el directorio correspondiente al nivel, utilizando como argumento para dicho script la opción stop.
2) Ejecuta, por orden de nombre, todos los scripts que comienzan por S en el directorio correspondiente al nivel, utilizando como argumento para dicho script la opción start.

El comando insserv se usa para controlar el orden de inicio y detención de los servicios que se encuentran en un sistema Linux.

¿Para qué se utiliza?

Se utiliza para administrar el orden de los enlaces simbólicos del /etc/rcX.d, resolviendo las dependencias de forma automática

Utiliza cabeceras en los scripts del /etc/init.d que permiten especificar la relación con otros scripts rc -> LSBInit (Linux Standard Based Init)
Es utilizado por update-rc.d para instalar / remover los links simbólicos

¿Qué ventajas provee respecto de un arranque tradicional?

Mejora la performance del arranque en sistemas multiprocesadores.

Upstart fue el primer reemplazo propuesto para SystemV (Ubuntu, Fedora, Debian, etc.).

Permite la ejecución de trabajos en forma asincrónica a través de eventos (event-based) como principal diferencia con sysVinit que es estrictamente sincrónico (dependencybased).
Estos trabajos se denominan Jobs.
El principal objetivo de un job es definir servicios o tareas a ser ejecutadas por init
Son scripts de texto plano que definen las acciones/tareas (unidad de trabajo) a ejecutar ante determinados eventos.
Cada job es definido en el /etc/init (.conf).
Suelen ser de dos tipos:
- Task: ejecución finita (task) -> not respawning -> exit 0 o uso de stop.
- Service: ejecución indeterminada  respawning
Los jobs son ejecutados ante eventos (arranque del equipo, inserción de un dispositivo USB,etc)
- Es posible crear eventos pero existen algunos de manera estándar.
- Definido por start on y stop on.
Es compatible con SystemV ! /etc/init/rc-sysinit.conf, runlevels, scripts en /etc/init.d, objetivo start y stop.
Cada job posee un objetivo (goal start/stop) y un estado (state).
- En base a ellos se ejecuta un proceso específico.
- Al inicio, init emite el evento startup.
Un job puede tener uno o varias tareas ejecutables como parte de su ciclo de vida y siempre debe existir la tarea principal
Las tareas de un job se definen mediante exec o script ... end script
A través de initctl podemos administrar los jobs del demonio de Upstart:
start <job>: cambia el objetivo a start del job especificado
stop <job>: cambia el objetivo a stop del job especificado
emit <event>: event es emitido causando que otros Jobs cambien a objetivo start o stop
No más /etc/inittab

Upstart se creó como reemplazo del modelo SysVinit. A diferencia de SysVinit, que se creó para operar en un entorno estático Upstart se creó para operar en un entorno flexible.

Upstart proporciona beneficios principales sobre el SysVinit. Estos beneficios son: event-based (principal diferencia con SysVinit que es estrictamente sincrónico - dependecy-based -) es la ejecucion de servicios en forma asincrónica y otro beneficio es el reinicio automático de servicios que dejan de responder de la manera inesperada para el sistema.

Upstart en lugar de usar runlevels, usa jobs que cada uno de ellos posee un objetivo (start/stop y un estado state). Cuando ocurre una interrupción, upstart detecta ese interrupción y realiza los cambios necesarios.

Los jobs reemplazan a los scripts de SystemV en Upstart.
Cada job es definido en el /etc/init (.conf)

# MySQL Servise
description "MySQL Server " {Descripcion}
autor "info autor" {Autor}
start on ( net − device − up {Iniciar base de datos}
        and local −filesystems   {}
        and runlevel [2345])
stop on runlevel [016]
[...]
exec / usr / sbin /mysqld
[...]

Este es un archivo de configuración Upstart para el servicio de base de datos MySQL. Cada línea se explica a continuación:

MySQL Service: un comentario que describe el servicio que se va a iniciar.
description "MySQL Server": una descripción del servicio, que aparecerá en los registros del sistema. {Descripcion}
author "info autor": información sobre el autor del archivo de configuración. {Autor}
start on (net-device-up and local-filesystems and runlevel [2345]): indica que el servicio debe iniciarse cuando la red y el sistema de archivos locales estén disponibles y el sistema se esté ejecutando en el nivel de ejecución 2, 3, 4 o 5. {Iniciar base de datos}
stop on runlevel [016]: indica que el servicio debe detenerse cuando el sistema se esté ejecutando en el nivel de ejecución 0, 1 o 6.
exec /usr/sbin/mysqld: la línea que indica al sistema qué comando ejecutar para iniciar el servicio MySQL. El comando /usr/sbin/mysqld es el comando para iniciar el servidor de base de datos MySQL.

Es un sistema que centraliza la administración de demonios y librerias del sistema.
Puede ser controlado por systemctl
Compatible con SysV -> si es llamado como init
El demonio systemd reemplaza al proceso init -> este pasa a terner PID 1
Los runlevels son reemplazados por targets
Al igual que con Upstart el archivo /etc/inittab no existe más.

Las unidades de trabajo son denominadas units de tipo:

Service: controla un servicio particular (.service)

Socket encapsula IPC, un sockect del sistema o file system FIFO (.socket) -> sockect-based activation.
Target agrupa units o establece puntos de sincronización durante el booteo (.target)
dependencia de unidades
Snapshot almacena el estado de un conjunto de unidades que puede ser establecido más tarde (.snapshot) etc.

Las units pueden tener dos estados -> active o inactive

Permite organizar un grupo de procesos en forma jerárquica

Agrupa conjunto de procesos relacionados (por ejemplo, un servidor web Apache con sus dependientes).

Tareas que realiza:

Tracking mediante subsistema cgroups  no se utiliza el PID  doble fork no funciona para escapar de systemd.
Limitar el uso de recursos.

3) Usuarios

En un sistema GNU/Linux, la información de los usuarios se almacena principalmente en los siguientes archivos:

/etc/passwd Este archivo contiene información básica de los usuarios, como sus nombres de usuario, identificación de usuario (UID), identificación de grupo (GID), nombre completo, ruta del directorio de inicio y shell predeterminada.
/etc/shadow Este archivo contiene información confidencial de los usuarios, como sus contraseñas encriptadas, tiempo de última modificación de la contraseña, tiempo de expiración, cuenta bloqueada, etc.
/etc/group Este archivo contiene información de los grupos de usuarios, como el nombre del grupo, identificación de grupo (GID) y una lista de nombres de usuario que pertenecen a ese grupo.
/etc/gshadow Este archivo contiene información confidencial de los grupos de usuarios, como sus contraseñas encriptadas, tiempo de última modificación de la contraseña, tiempo de expiración, cuenta bloqueada, etc.

Es importante destacar que estos archivos son de lectura y escritura solo para el superusuario (root) y que modificarlos sin conocimiento puede comprometer la seguridad del sistema.

Los sistemas operativos Linux y Unix utilizan el UID (User ID o ID de usuario) para identificar al usuario particular. El GID (Group ID o ID de grupo) se utiliza para identificar a un grupo. Supongo que no podrian existir dos iguales ya que no los podrias distinguir.

Puede haber un caso que seria el root en el que podemos tener varios usuarios root con el ID 0

En sistemas operativos del tipo Unix, el superusuario o root es el nombre convencional de la cuenta de usuario que posee todos los derechos en todos los modos (monousuario o multiusuario). Normalmente es la cuenta de administrador.

Su UID (User ID) y GID es 0 (cero).
Es la única cuenta de usuario con privilegios sobre todo el sistema.
Acceso total a todos los archivos y directorios con independencia de propietarios y permisos.
Controla la administración de cuentas de usuarios.
Ejecuta tareas de mantenimiento del sistema.
Puede detener el sistema.
Instala software en el sistema.
Puede modificar o reconfigurar el kernel, controladores, etc.

sudo adduser iso2022 creo un usuario y en home le agrego /home/ (contra = nombre para pruebas)
sudo gropadd catedra creo un grupo
sudo usermod -a -G catedra iso2022
id -nG iso2022 menciona los grupos a los que pertenece mi usuario
sudo login iso2022 entro como el usuario
cd .. para ir a la home personal y crear un archivo (creo)
sudo userdel iso2022 lo elimina pero aun tenemos todos los archivos creados por este

useradd nombre ó adduser nombre Crea un nuevo usuario
usermod nombre nos permite modificar todos los parámetros de la cuenta de un usuario creado con anterioridad.
userdel nombre Elimina un usuario
su entrar al super usuario (tenes los permisos de TODO)
groupadd nombre te deja crear un grupo
who Verifiqua los usuarios conectado al sistema
groupdel nombre elimina un grupo
passwd de deja cambiar la constraseña del usuario actual

4) FileSystem:

Este mecanismo permite que archivos y directorios “pertenezcan” a un usuario en particular. Por ejemplo, como diego creó archivos en su directorio “home”, diego es el propietario de esos archivos y tiene acceso total a ellos.

Unix también permite que los archivos sean compartidos entre usuarios y grupos de usuarios. Si diego lo desea, podría restringir el acceso a sus archivos de forma que ningún otro usuario pueda acceder a ellos.

Los permisos están divididos en tres tipos: lectura, escritura y ejecución. Estos permisos pueden ser fijados para tres clases de usuarios: el propietario del archivo o directorio, los integrantes del grupo al que pertenece y todos los demás usuarios.

lectura permite a un usuario leer el contenido del archivo o en el caso de un directorio, listar el contenido del mismo (usando ls).
escritura permite a un usuario escribir y modificar el archivo (inclusive, eliminarlo). Para directorios, el permiso de escritura permite crear nuevos archivos o borrar archivos ya existentes en el mismo.
ejecución permite a un usuario ejecutar el archivo si es un programa. Para directorios, el permiso de ejecución permite al usuario ingresar al mismo (por ejemplo, con el comando cd).
Interpretando los permisos de archivos Veamos un ejemplo del uso de permisos de archivos. Usando el comando ls con la opción -l se mostrara un listado largo de los archivos, el cual incluye los permisos.
```
fabrizio@debian: /$ ls -l
-rwxr-xr-- 1 fabrizio users 505 May 5 19:05 prueba.exe
```

El primer campo representa los permisos del archivo. El tercer campo es el propietario del mismo (fabrizio), el cuarto es el grupo al cual pertenece el archivo (users) y el último campo es el nombre del archivo (prueba.exe).

La cadena -rwxr-xr-- nos informa, por orden, los permisos para el propietario, los usuarios del grupo y el resto de los usuarios.

El primer carácter de la cadena de permisos (“-”) representa el tipo de archivo. El “-” significa que es un archivo regular, “d” indicaría que se trata de un directorio. Los siguientes tres caracteres (“rwx”) representan los permisos para el propietario del archivo, fabrizio. Éste tiene permisos para leer (r), escribir (w) y ejecutar (x) el archivo prueba.exe.

Los siguientes tres caracteres, “r-x”, representan los permisos para los miembros del grupo al que pertenece el archivo (en este caso, users). Como sólo aparece “r-x” cualquier usuario que pertenezca al grupo users puede leer este archivo, y ejecutarlo, pero no modificarlo.

Los últimos tres caracteres, “r--”, representan los permisos para cualquier otro usuario del sistema (que no sea fabrizio ni pertenezca al grupo users). Como sólo está presente la “r”, los demás usuarios pueden leer el archivo, pero no escribir en él o ejecutarlo

Aquí tenemos otros ejemplos de permisos de grupo

-rw-------
El propietario del archivo puede leer y escribir. Nadie más puede acceder al archivo.
rwxrwxrwx
Todos los usuarios pueden leer, escribir y ejecutar el archivo.
drwxr-xr-x
El propietario del directorio puede leer, escribir y entrar al mismo. Los usuarios pertenecientes al grupo del directorio y todos los demás usuarios pueden leer e ingresar al directorio.

chmod: nos permite gestionar permisos
chown: permite cambiar el propietario de un archivo o directorio en sistemas
chgrp: nos permite cambiar el grupo al que pertenece un archivo

Existen 3 tipos de permisos y se basan en una notacion octal para referenciar a cada uno:

| Permiso | Valor | Octal | | ------------- | ------------- | ------------- | | Lectura | R | 4 | | Escritura | W | 2 | | Ejecución | X | 1 |

Se aplican sobre los usuarios:

Usuarios: permisos del dueño -> U
Usuarios: permisos del grupo -> G
Usuarios: permisos de otro usuario -> O

La notación octal se refiere a ver estos valores en 3 bits , 010 equivale a 2 , por lo tanto si un archivo tendrá solo permisos de escritura, figura de esa manera. Si los valores fueran 110= serian permisos de lectura y escritura, y si fueran 111 el archivo tendría todos los permisos (lectura escritura y ejecución).

En general cuando se le da un permiso a un archivo requiere 3 números (ejemplo chmod 755) cada uno de esos números representa los permisos para diferentes cosas.
El primer número es para indicar los permisos para el dueño del archivo (U).
El segundo número es para indicar los permisos para los usuarios del grupo de un archivo (G)
El tercer número es para indicar los permisos para todo el resto de los usuarios (O).

Por lo tanto, en el ejemplo chmod 755, indica que el dueño (U) tiene permiso para lectura, escritura y ejecución ( 4 + 2 + 1 = 7). Los usuarios del grupo (G) y para el resto de los usuarios (O) tienen permiso para lectura y ejecución (4 + 1= 5). Ver tabla.

Existe la posibilidad, si es que el usuario puede utilizar el comando su, o sudo. Sino, sin poseer los permisos necesarios no puede acceder al archivo. Sólo root.

Full path name es la ruta completa a ese archivo o carpeta desde el directorio / del sistema de archivos. ejemplo /home/your_username/my_script
Relative path name Rastrea la ruta desde el directorio actual a través de su padre o sus subdirectorios y archivos. ..\Documents

Con el comando pwd podemos saber el directorio actual.
Con cdo cd ~ vamos al directorio personal.
Se puede usar este mismo comando para acceder a directorios a partir de la ruta en donde estemos parados

Se podría acceder a diferentes directorios gracias la ubicación relativa o atajos ya prestablecidos como cd .. para volver al directorio anterior sin necesidad de poner ningún atajo

cd Nos permite meternos en un directorio interno
umount permite eliminar un sistema de archivos remoto que esté montando en la actualidad (no usar xd)
mkdir Cree una carpeta
du Para ver el tamaño de ficheros y carpetas
rmdir Borrar directorios
df Informa la cantidad de espacio libre en disco
mount Se utiliza para montar dispositivos y particiones para su uso por el sistema operativo (se instala con sudo apt install nfs-common)
ln crear un enlace simbólico al fichero o directorio (como un acceso directo)
ls Lista el contenido del directorio actual
pwd Visualiza la ruta donde estoy situado
cp sirve para copiar archivos y directorios dentro del sistema de archivos
mv se utiliza para mover o renombrar los archivos y directorios

5) Procesos

Un proceso es un programa en ejecución. Para nosotros serán sinónimos de tarea, job y proceso.

Es dinámico
Tiene program counter.
Su ciclo de vida comprende desde que se lo dispara hasta que termina.

La sigla PID hace referencia al ID del Proceso y la sigla PPID hace referencia al ID del Proceso Padre del proceso.

Todos los procesos tienen estos atributos, además de estos (que son los más importantes pero no todos): Usuario (UID), Grupo (GID), Prioridad, etc. Con ps –ejH

PUEDO VER EL PPID.

pstree que nos muestra los procesos en una estructura de árbol top El comando top te permite ver las tareas del sistema que se ejecutan en tiempo real.
top El comando top te permite ver las tareas del sistema que se ejecutan en tiempo real.Proporciona un buen resumen de tu sistema para verificar rápidamente si algo se destaca que pueda estar causando problemas con tu sitio web o servidor
ps muestra por pantalla un listado de los procesos que están ejecutándose en el sistema.

Las opciones (parámetros) más importantes y utilizadas de este comando son:

a para mostrar los procesos de todos los teminales.
u para mostrar el usuario al que pertenece el proceso y la hora de inicio.
x para mostrar procesos que no estan controlados por ningún terminal.

Suelen usarse combiandas para tener una visión global de los procesos que están en ejecutan.

Proceso ejecutándose en Background significa que el proceso continúa la ejecución mientras que el shell se libera para otras actividades. Proceso en segundo plano.
Proceso ejecutándose en Foreground Es exactamente lo contrario, quiere decir que no se admitirá ningún otro comando hasta que se complete el proceso. Proceso en primer plano.

Para ejecutar un proceso en background en Linux, se puede agregar el símbolo "&" al final del comando en la línea de comandos. Por ejemplo, para ejecutar un proceso llamado "mi_proceso" en background, se puede escribir:

mi_proceso &

Esto permitirá que el proceso se ejecute en segundo plano mientras se sigue usando la terminal para ejecutar otros comandos.

Para pasar un proceso de background a foreground y viceversa, se pueden usar los siguientes comandos:

fg mueve un proceso en background a foreground. Se debe proporcionar el número de trabajo (job number) del proceso como argumento. El número de trabajo se puede obtener con el comando "jobs". Por ejemplo:
```
fg %1
```
Esto mueve el proceso número 1 en background al foreground.
bg mueve un proceso en foreground a background. También se debe proporcionar el número de trabajo del proceso como argumento. Por ejemplo:
```
bg %1
```
Esto mueve el proceso número 1 en foreground a background.

También se puede suspender un proceso en foreground con la combinación de teclas Ctrl + Z. Esto detendrá el proceso y lo moverá a background. Para reanudar el proceso en background, se puede usar el comando bg

El | nos permite comunicar dos procesos por medio de un pipe o tubería desde la shell

El pipe conecta stdout (salida estándar) del primer comando con la stdin (entrada estándar) del segundo.

Por ejemplo:

ls | more

Se ejecuta el comando ls y la salida del mismo, es enviada como entrada del comanda more.
Se pueden anidar tantos pipes como se deseen

¿Cómo haríamos si quisiéramos contar la cantidad de usuarios del sistema que en su nombre de usuario aparece una letra “a"?

cat /etc/passwd | cut -d: -f1 | grep a | wc –l

En Linux, al final todo es tratado como si fuera un fichero y como tal, tenemos descriptores de fichero para aquellos puntos donde queramos acceder.

Hay unos descriptores de fichero por defecto:

0 Entrada estándar (normalmente el teclado).
1 Salida estándar (normalmente la consola).
2 Salida de error.

Para redirigir las salidas utilizaremos el descriptor de fichero seguido del símbolo > o < si redirigimos la entrada hacia un comando. Veamos unos ejemplos

ls -l > fichero Guarda la salida de ls -l en fichero. Si no existe lo crea, y si existe lo sobreescribe.
ls -l >> fichero Añade la salida del comando a fichero. Si no existe lo crea, y si existe, lo añade al final.
ls -l 2 > fichero Si hay algún error, lo guarda en fichero (podría salir un error si no tuviéramos permiso de lectura en el directorio).

Las redirecciones consisten en trasladar información de un tipo a otro

Hay 2 tipos de redirecciones

Al utilizar redirecciones mediante > (destructiva):
- Si el archivo de destino no existe, se lo crea
- Si el archivo existe, se lo trunca y se escribe el nuevo contenido
Al utilizar redirecciones mediante >> (no destructiva):
- Si el archivo de destino no existe, se lo crea
- Si el archivo existe, se agrega la información al final

EJEMPLOS

Redirecciona stdout hacía un archivo. Lo crea si no existe, si existe lo sobreescribe.

ls -l > lista.txt

(La salida del comando se envía a un archivo en vez de la terminal.)

Redirecciona stdout hacía un archivo. Lo crea si no existe, si existe concatena la salida al final de este.

ps -ef >> processos.txt

(Concatena al archivo procesos.txt la salida del comando.)

Es importante ver que si no se especifica el descriptor de fichero se asume que se redirige la salida estándar. En el caso del operador < se redirige la entrada estándar, es decir, el contenido del fichero que especificáramos, se pasaría como parámetro al comando.

Si quisiéramos redirigir todas las salidas a la vez hacia un mismo fichero, podríamos utilizar >&.

Además, con el carácter & podemos redirigir salidas de un tipo hacia otras, por ejemplo, si quisiéramos redirigir la salida de error hacia la salida estándar podríamos indicarlo con: 2>&1. Es importante tener en cuenta que el orden de las redirecciones es significativo: se ejecutarán de izquierda a derecha.

El comando kill en Linux (ubicado en / bin / kill), es un comando incorporado que se usa para terminar los procesos manualmente. El comando kill envía una señal a un proceso que termina el proceso. Si el usuario no especifica ninguna señal que se enviará junto con el comando kill, se envía la señal TERM predeterminada que finaliza el proceso.

kill -l Para mostrar todas las señales disponibles, puede usar la siguiente opción de comando.
kill pid Para mostrar cómo usar un PID con el comando kill.
kill -s Para mostrar cómo enviar señales a los procesos.
kill -L este comando se usa para listar las señales disponibles en un formato de tabla.

ps: Muestra información de los procesos activos.
kill: Usa el PID para matar el proceso. Permite interactuar con cualquier proceso mandando señales. Kill <pid> termina un proceso y Kill -9 <pid> fuerza a terminar un proceso en caso de que la anterior opción falle.
pstree: muestra un árbol de procesos.
killall: nos permite matar un proceso escribiendo su nombre
top: Sirve para ver los procesos de ejecución del sistema (y más cosas) en tiempo real
nice: Ejecuta un comando con una prioridad determinada, o modifica la prioridad a de un proceso. nice -10 named Esto bajaría la prioridad de named en 10 unidades(Si estaba en -10, pasará a - 20) MENOS GENTIL = MAS PRIORIDAD

6) Otros comandos de Linux (Indique funcionalidad y parámetros)

Los archivos TAR no son archivos comprimidos sino empaquetados. TAR es un empaquetador, es algo más parecido a un compresor como arj ó zip pero sin compresión. Su función es la de incluir todos los ficheros juntos en el mismo archivo, conservando las estructuras de directorios y permisos de los mismos.

crear un archivo .tar

tar –cvf mi_archivo.tar /directorio/a/empaquetar

extraer el contenido de un archivo .tar ya creado
```
tar –xvf mi_archivo.tar
```
actualizar el contenido de un archivo .tar ya existente
```
tar –uvf mi_archivo.tar
```
agregar un directorio a un archivo .tar ya existente
```
tar –rvf archivo. tar  directorio/a/agregar
```

empaquetar y comprimir el archivo .tar

tar –cvzf archivo.tgz /directorio/a/empaquetar/y/comprimir

desempaquetar el archivo .tgz
```
tar –xvzf archivo.tgz
```
Ojo : Observa la extensión ".tgz" para el tar comprimido. Aunque también podemos ponerle como extensión ".tar.gz"

Claro, para sumar el tamaño de cuatro archivos en Linux y crear un archivo empaquetado que los contenga, puede seguir los siguientes pasos:

Abrir una terminal y navegar hasta el directorio que contiene los cuatro archivos usando el comando cd.
Para sumar el tamaño de los cuatro archivos, use el comando
```
du -sh file1 file2 file3 file4
```
Esto le dará la suma total de los tamaños de los cuatro archivos.
Para crear un archivo empaquetado que contenga los cuatro archivos, puede utilizar el comando
```
tar -cvzf archivo_empaquetado.tar.gz file1 file2 file3 file4
```
Esto creará un archivo empaquetado llamado archivo_empaquetado.tar.gz que contiene los cuatro archivos.
Para comparar los tamaños de los cuatro archivos individuales y el archivo empaquetado, use el comando ls -lh. Esto mostrará el tamaño de cada archivo en una lista. Compare el tamaño total de los cuatro archivos individuales con el tamaño del archivo empaquetado para notar la diferencia en el tamaño.

Es importante tener en cuenta que el comando tar utiliza la compresión para reducir el tamaño del archivo empaquetado, por lo que es posible que el tamaño del archivo empaquetado sea menor que la suma total de los tamaños de los cuatro archivos individuales.

Teniendo en cuenta que tenemos 4 archivos en el directorio Descargas/ejercicio6 y nos situamos en Descargas ejecutamos lo siguiente

tar cvfz archivo.tar.gz ejercicio6

Esto nos dejaria un archivo empaquetado de archivos comprimidos en un solo archivo archivo.tar.gz y para acceder a dicha informacion haremos

tar xvfz archivo.tar.gz

Si los archivos están en el mismo directorio utilizamos el comando visto anteriormente

tar Empaqueta/desempaqueta varios archivos en uno solo, puede realizar compresión sin perdida
grep El comando grep nos permite buscar cadenas de texto y palabras dentro de un fichero de texto o de la entrada estándar de la terminal. Una vez encontrado el contenido que estamos buscando: grep mostrará en pantalla la totalidad de la línea/s que contiene/n la cadena de texto o palabra que estamos buscando
gzip Comprime solo archivos utilizando la extensión .gz que se utiliza para truncar el tamaño de un archivo.
zgrep Se usa para buscar expresiones de un archivo dado, incluso si está comprimido
wc Cuenta los caracteres, palabras y líneas del archivo de texto.

7) Ejercicio

Enunciado: Indique qué acción realiza cada uno de los comandos indicados a continuación considerando su orden. Suponga que se ejecutan desde un usuario que no es root ni pertenece al grupo de root. (Asuma que se encuentra posicionado en el directorio de trabajo del usuario con el que se logueó). En caso de no poder ejecutarse el comando, indique la razón

l s −l > prueba {No se puede acceder a pruebas pq no existe el fichero}                         
ps > PRUEBA 
chmod 710 prueba
chown root : root PRUEBA
chmod 777 PRUEBA 
chmod 700 / etc / passwd 
passwd root 
rm PRUEBA 
man / etc / shadow 
find / −name ∗ .conf 
usermod root −d /home/ newroot −L 
cd / root 
rm ∗ 
cd / etc 
cp ∗ /home −R 
shutdown

ls -l > prueba Genera un archivo de nombre prueba que contiene un listado detallado con los contenidos del directorio home del usuario. Se redirige la salida estándar de ls mediante el carácter > hacia el archivo prueba.
ps > PRUEBA Genera un archivo de nombre PRUEBA que contiene un listado de los procesos en ejecución en el directorio home del usuario. AL igual que en el ejemplo anterior, se redirige la salida estándar mediante >.
chmod 710 prueba Cambia los permisos del archivo prueba a 710 para UGO (usuario, Grupo, Otros).
chown root:root PRUEBA Se intenta cambiar el propietario del archivo prueba pero la operación no está permitida.
chmod 777 PRUEBA Cambia los permisos del archivo PRUEBA a 777. Es decir, todos los usuarios pueden leer, escribir y ejecutar el archivo.
chmod 700 /etc/passwd Intenta cambiar los permisos a 700, pero la operación no está permitida para un usuario que no es root, esto por el archivo que está intentando cambiar.
passwd root passwd: No debe ver o cambiar la información de la contraseña para root.
rm PRUEBA Se elimina el archivo PRUEBA.
man /etc/shadow Permiso denegad, porque “man” no debe recibir una ruta, si hago “man shadow” si anda.
find / -name *.conf Lista todos los archivos cuyo nombres terminan con .conf, empezando la búsqueda en el directorio raíz /.
usermod root –d /home/newroot –L
cd /root Se intenta acceder a la carpeta root, pero la operación falla porque el usuario no tiene los permisos.
rm * Borra todos los archivos del directorio donde está posicionado el usuario.
cd /etc Cambia el directorio a /etc, osea “se mueve” a /etc
cp * /home –R Intenta copiar el contenido de /etc a home, pero el usuario no tiene los permisos necesarios para crear archivos en el directorio /home.
shutdown Apaga el equipo

8) Indique qué comando sería necesario ejecutar para realizar cada una de las siguientes acciones:

Todos los procesos tienen un pid (id de proceso) para terminar un proceso se usa el comando:
```
kill -9 23 (kill menos 9 número de id del proceso).
```
ps –aux Para ver los procesos del sistema que corren en el momento comando:

1) Primero buscamos el PID de init con el comando ps –aux
2) Ingresamos como superusuario: su – e ingresamos contraseña
3) Utilizamos el comando kill –9 1
4) Y vamos a ver que no va a suceder nada, porque el proceso init, no puede terminarse, así que ni responde al comando.

Para buscar un archivo se utiliza el comando:

 find / -type f -name NombreDelArchivoABuscar

Búsqueda por tipo

Linux permite a los usuarios listar toda la información basada en sus tipos. Hay varios filtros que puedes usar:

d directorio o carpeta
f archivo normal
l enlace simbólico
c dispositivos de caracteres
b dispositivos de bloque

Si deseamos buscar la palabra “conf” en todo el sistema se utiliza el comando:

find / -name NombreABuscar

ps > /home/user/procesos

cat Procesos Para poder comprobar el contenido que tiene el directorio Procesos
rm –r Procesos Para eliminar dicho directorio

Usuario: Lectura, escritura, ejecución
Grupo: Lectura, ejecución
Otros: ejecución
mkdir xxxx Primero creamos el directorio “xxxx”
ls –l Para ver los permisos que tiene dicho directorio
chmod 751 xxxx Para cambiar sus permisos donde Usuario tenga los permisos de lectura, escritura, ejecución, Grupo los permisos de lectura y ejecución y Otros el permiso
7 = 4(Lectura) + 2(Escritura) + 1(Ejecución) --> Usuario
5 = 4(Lectura) + 1(Ejecución) --> Grupo
1 = 1(Ejecución) --> Otros
ls -l Para chequear si los permisos fueron modificados

Para lograr visualizar los permisos se lee de la siguiente forma:

No ver la primera d!
Los primeros rwx(Lectura, Escritura, Ejecución) pertenecen a Usuario
Luego rx (LecturaEjecución) pertenece a Grupo
Y x (Ejecución) pertenece a Otros

Usuario: Lectura, escritura.
Grupo: Lectura, ejecución
Otros: Ninguno
mkdir yyyy Primero creamos el directorio “yyyy”
ls –l Para ver los permisos que tiene dicho directorio
chmod 650 yyyy Para cambiar sus permisos donde Usuario tenga los permisos de lectura, escritura, ejecución, Grupo los permisos de lectura y ejecución y Otros el permiso de ejecución.

cd /tmp
rm *

chown iso2010 /opt/isodata

pwd >> /home/user/donde

9) Indique qué comando sería necesario ejecutar para realizar cada una de las siguientes acciones

su

sudo adduser il {crear}
passwd il {nueva contra}

se modificaron los archivos /etc/passwd y se creo el directorio personal del perfil en /home/nombrelegido

cd /tmp
mkdir cursada2017

En modo superusuario/root

cp /var/log/* /tmp/cursada2017

chown nombreUsuario:nombreUsuario /tmp/cursada2017

chmod -R 745 /tmp/cursada2017

sudo login user

ps -p 544

ps aux | wc -l

who

sudo shutdown 1 'El sistema se va a apagar'
tmb sin apagar
wall "En un minuto apagaremos el sistema."

sudo shutdown now

10) Indique qué comando sería necesario ejecutar para realizar cada una de las siguientes acciones

mkdir 19508/3 {No se puede dado q confunde / con un desplazamiento de directorio}

Nombre, Apellido, Número de alumno y dirección de correo electrónico. El archivo debe llamarse "LEAME".

cd legajo
vi LEAME

Dueño: ningún permiso
Grupo: permiso de ejecución
Otros: todos los permisos

chmod 017 LEAME

Se puede porque unix es case sensitive y distingue entre mayúsculas y minúsculas.

find / -name "[0-9]*"

find / -name "*.os" > /home/user/legajo/ejerciciof

11) Ejercicio

Indique qué acción realiza cada uno de los comandos indicados a continuación considerando su orden. Suponga que se ejecutan desde un usuario que no es root ni pertenece al grupo de root. (Asuma que se encuentra posicionado en el directorio de trabajo del usuario con el que se logueó). En caso de no poder ejecutarse el comando indique la razón:

mkdir iso Crea el directorio iso
cd . / iso; ps > f0 Me situo en iso y creo el archivo f0 con los procesos en ejecucion
ls > f1 Guardo en F1 la lista de archivos en el directorio iso
cd / Me posiciono en la raiz
echo $HOME muestra en pantalla la direccion del directorio personal del usuario
ls −l $> $HOME/iso/ls No se puede acceder a $ no existe el fichero o directorio
cd $HOME; mkdir f2 Nos situamos en el directorio personal y creamos el directorio f2
ls −ld f2 Se da un listado detallado de f2
chmod 341 f2 Se modifican los permisos de f2;Es,Ej para usuario,L para Grupo, y Ej para otros
touch dir se crea el archivo dir
cd f2 accedemos al directoriio f2
cd ~/ iso accedemos a la carpeta iso
pwd > f3 se guarda en el archivo f3 la direccion de la carpeta iso
ps | grep ' ps ' | wc −l >> ../f2/f3 se obtienen los procesos, se usa de entrada para grep el cual filtra todos los que posean ps,pra luego almacenar la cantidad de lineas obtenidas luegro de dicho filtro y añadirlas al archivo f3
chmod 700 .. / f2 ; cd .. Se modifica el acceso de f2 dando al usuario todos los permisos y a los demas nada, volviendo despues al directorio personal
find . −name etc / passwd Lanza un warning por mal uso del comando
find / −name etc / passwd filtra todos los archivos de passwd por nombre en orden
mkdir ejercicio5 crea el directorio ejercicio5

a) Inicie 2 sesiones utilizando su nombre de usuario y contraseña. En una sesión vaya siguiendo paso a paso las órdenes que se encuentran escritas en el cuadro superior. En la otra sesión, cree utilizando algún editor de textos un archivo que se llame. ejercicio10_explicacion"dentro del directorio creado en el ejercicio 9.a) y, para cada una de las órdenes que ejecute en la otra sesión, realice una breve explicación de los resultados obtenidos. (ARRIBA)

19: Copiar el directorio iso y todo su contenido al directorio creado en el inciso 9.a).
20: Copiar el resto de los archivos y directorios que se crearon en este ejercicio al directorio creado en el ejercicio 9.a).

12) Ejercicio

Enunciado: Cree una estructura desde el directorio /home que incluya varios directorios, subdirectorios y archivos, según el esquema siguiente. Asuma que “usuario” indica cuál es su nombre de usuario. Además deberá tener en cuenta que dirX hace referencia a directorios y fX hace referencia a archivos:

a) Utilizando la estructura de directorios anteriormente creada, indique que comandos son necesarios para realizar las siguientes acciones:

Mueva el archivo "f3.al directorio de trabajo /home/usuario.

mv f3 $HOME

Copie el archivo "f4.en el directorio "dir11".

cp f4 $HOME/dir11

Haga los mismo que en el inciso anterior pero el archivo de destino, se debe llamar "f7".

cp f4 $HOME/dir11/f7

Cree el directorio copia dentro del directorio usuario y copie en él, el contenido de "dir1".

mkdir copia; cp -a dir11 copia

Renombre el archivo "f1"por el nombre archivo y vea los permisos del mismo.

cd iso;mv f0 archivo; ls  -ld archivo

Cambie los permisos del archivo llamado archivo de manera de reflejar lo siguiente:

Usuario Permisos de lectura y escritura
Grupo Permisos de ejecución
Otros Todos los permisos

chmod 617 archivo

Renombre los archivos "f3 2 "f4"de manera que se llamen "f3.exe 2 "f4.exerespectivamente.

mv f3 f3.exe; cd $HOME/dir11 ; mov f4 f4.exe

Utilizando un único comando cambie los permisos de los dos archivos renombrados en el inciso anterior, de manera de reflejar lo siguiente:

Usuario Ningún permiso
Grupo Permisos de escritura
Otros Permisos de escritura y ejecución

chmod 023 f3.exe f4.exe

13) Indique qué comando/s es necesario para realizar cada una de las acciones de la siguiente secuencia de pasos (considerando su orden de aparición):

a) Cree un directorio llamado logs en el directorio /tmp.

cd /tmp; mkdir logs

b) Copie todo el contenido del directorio /var/log en el directorio creado en el punto anterior.

cp -a /var/log/. /tmp/logs

c) Empaquete el directorio creado en 1, el archivo resultante se debe llamar "misLogs.tar".

tar cvf misLogs.tar logs

d) Empaquete y comprima el directorio creado en 1, el archivo resultante se debe llamar "misLogs.tar.gz".

tar cvfz misLogs.tar.gz logs

e) Copie los archivos creados en 3 y 4 al directorio de trabajo de su usuario.

cp misLogs.tar $HOME
cp misLogs.tar.gz $HOME

f) Elimine el directorio creado en 1, logs

rm -r logs

g) Desempaquete los archivos creados en 3 y 4 en do directorios diferentes.

tar xvf misLogs.tar -C 1 
tar xvfz misLogs.tar.gz -C 2

Fecha -> Con el comando Date

Ejercicios de scripting

1) Ejercicio

¿Qué es el Shell Scripting? ¿A qué tipos de tareas están orientados los script? ¿Los scripts deben compilarse? ¿Por qué?

La Shell provee estructuras de control que permiten programar shell scripts.

El Shell Scripting es la técnica (habilidad / destreza) de diseñar y crear Script (archivo de automatización de tareas) mediante un Shell (preferiblemente) de un Sistema Operativo, o un

Editor de Texto (Gráfico o Terminal). Este es un tipo de lenguaje de programación que generalmente es interpretado.

Está orientado a diferentes tareas:

Automatización de tareas
Aplicaciones interactivas
Aplicaciones con interfaz gráfica (con el comando zenity, por ejemplo).

2) Ejercicio

Investigar la funcionalidad de los comandos echo y read

Echo: Es un comando para la impresión de un texto en pantalla. El comando para imprimir el contenido de la variable es:
echo $nombreVar
Read: El comando read lee su entrada estándar y asigna las palabras leídas en la(s) variable(s) cuyo nombre se pasa como argumento. Se trata del input desde teclado.

a) ¿Como se indican los comentarios dentro de un script?

Los comentarios tienen que comenzar con el símbolo #

b) ¿Cómo se declaran y se hace referencia a variables dentro de un script?

No necesita declarar una variable. Se creará sólo con asignarle un valor a su referencia. Luego se referencia con el símbolo $ Ejemplo

Para hacer un script:

Paso 1 en la consola usar el comando: touch script.sh para crear el directorio.
Paso 2 Ver si se creo el directorio con el comando ls
Paso 3 Ingresar al archivo script.sh con el editor de texto vi de la siguiente manera
- vim script.sh
- DENTRO DEL EDITOR VIM:
- Ingresar la letra i para estar en modo insertar y Escribir
```
#!/bin/bash 
CAD="¡Hola Mundo!"
echo $CAD
```
- ESC (para salir del modo editor)
- :wq (para guardar los cambios)
- Salimos del editor vi e ingresamos a la consola
Paso 4: Damos permiso de ejecución con el comando:
- chmod u+x script.sh
- Si ponemos el comando ls vamos a ver que el directorio .sh cambio de color.
Paso 5: Con el comando ./script.sh vamos a ver el contenido de ese script en cosola.
Paso 6: Si queremos borrar ese directorio con script solo es necesario poner en consola el comando rm script.sh

Tambien podes ejecutar el script con el comando bash script.sh

3) Ejercicio

Crear dentro del directorio personal del usuario logueado un directorio llamado practicashell-script y dentro de él un archivo llamado mostrar.sh cuyo contenido sea el siguiente:

#!/bin/bash
# Comentarios acerca de lo que hace el script
# Siempre comento mis scripts, si no hoy lo hago
# y mañana ya no me acuerdo de lo que quise hacer
echo "Introduzca su nombre y apellido:"
read nombre apellido
echo "Fecha y hora actual:"
date
echo "Su apellido y nombre es:"
echo "$apellido $nombre"
echo "Su usuario es: `whoami`"
echo "Su directorio actual es:"

(a) Asignar al archivo creado los permisos necesarios de manera que pueda ejecutarlo

(b) Ejecutar el archivo creado de la siguiente manera: ./mostrar

(c) ¿Qué resultado visualiza?

(d) Las backquotes (`) entre el comando whoami ilustran el uso de la sustitución de comandos. ¿Qué significa esto? Son para poder ejecutar comando cuando se encuentran dentro de un string

(e) Realizar modificaciones al script anteriormente creado de manera de poder mostrar distintos resultados (cuál es su directorio personal, el contenido de un directorio en particular, el espacio libre en disco, etc.). Pida que se introduzcan por teclado (entrada estándar) otros datos.

#!/bin/bash

echo "Nombre y apellido"
read nombre apellido
echo "Fecha y hora actual: `date`"
echo $nombre $apellido
echo "Su usuario es: `whoami`"
echo "su directorio actual es :`pwd`"
echo "su directorio personal es : `$HOME`"
echo "Nombre de un directorio:"
echo contenido
echo "Contenido de $contenido es `ls $contenido`"
echo "Espacio libre en el disco `df`"

4) Ejercicio

Parametrización: ¿Cómo se acceden a los parámetros enviados al script al momento de su invocación? ¿Qué información contienen las variables $#, $*, $? y $HOME dentro de un script?

Los scripts pueden recibir argumentos en su invocación. Para accederlos, se utilizan variables especiales:
$0 contiene la invocación al script. (nombre del script)
$1, $2, $3,... contienen cada uno de los argumentos.
$# contiene la cantidad de argumentos recibidos.
$* contiene la lista de todos los argumentos separados por espacios.
$? contiene en todo momento el valor de retorno del ultimo comando ejecutado.(si el valor es 0 se ejecuto correctamente, en caso de que haya habido algún error dará un valor entre 1 y 255).

#!/bin/bash

echo "$0"
echo "$1 $3"
echo "$#"
echo "$*"
echo "$HOME"

5) Ejercicio

¿Cual es la funcionalidad de comando exit? ¿Qué valores recibe como parámetro y cual es su significado?

El comando exit finaliza un script. Incluso, puede arrojar un valor de terminación, el cual estará disponible para su proceso padre.

Todo comando posee un estado de terminación (exit status). Un comando que se ejecutó satisfactoriamente arrojará un valor de 0, mientras que un comando que no se procesó de manera correcta, finalizará con un número diferente de 0.

Al igual que un comando, un script posee su propio estado de terminación, el cual será determinado por la última instrucción ejecutada por el script.

Dentro de un script, el comando exit puede arrojar un número dentro de un rango de 0 a 255.

Se puede consultar el exit status imprimiendo la variable $? de la siguiente manera:

Ingresamos al editor VIM con el archivo mostrar.sh
Una vez hecho el bin bash, como última línea y dentro de insertar ingresamos el siguiente comando: echo $?
ESC
:exit

En la consola se mostrara un número de 0 a 255.

6) Ejercicio

El comando expr permite la evaluación de expresiones. Su sintaxis es: expr arg1 op arg2, donde arg1 y arg2 representan argumentos y op la operación de la expresión. Investigar que tipo de operaciones se pueden utilizar

Se puede utilizar
- suma
- resta
- multiplicación (/*)
- división (/).
Y devuelve solo la parte entera.:
expr 10 + 10 -> 20, expr 14 % 9 -> 5.

También se puede utilizar para:

Cálculo de la longitud de la cadena:
- expr length “esto es un test” >
- devuelve la cantidad de caracteres: 15
Cadena de rastreo:
- expr substr “esto es un test” 3 5 >
- te devuelve el texto desde la pos 3 y 5 lugares: to es
La cadena numérica primera posición de rastreo personaje que aparece:
- expr index “esto es un test” s
- te devuelve el índice de la letra pasado por parámetro en la cadena (la primera aparición).

#!/bin/bash/

SUMA=`expr 10 + 5`
RESTA=$(expr 10 - 5)
MULTIPLICACION=$(expr 10 \* 5)
DIVISION=$(expr 10 / 5)
MODULO=$(expr 10 % 5)
LONGITUD="Fabian "$(expr length "Fabian")
SUBSTR="Fabian 1 6: "$(expr substr "Fabian" 1 6)
INDICE="Fabian b: "$(expr index "Fabian" b)

echo "var1 = 10, var2 = 5"
echo "SUMA $SUMA"
echo "RESTA $RESTA"
echo "MULTIPLICACION $MULTIPLICACION"
echo "DIVISION $DIVISION"
echo "MODULO $MODULO"
echo "LONGITUD $LONGITUD"
echo "SUBSTR $SUBSTR"
echo "INDICE $INDICE"

7) Ejercicio

El comando “test expresión” permite evaluar expresiones y generar un valor de retorno, true o false. Este comando puede ser reemplazado por el uso de corchetes de la siguiente manera [ expresión ]. Investigar que tipo de expresiones pueden ser usadas con el comando test. Tenga en cuenta operaciones para: evaluación de archivos, evaluación de cadenas de caracteres y evaluaciones numéricas.

Este comando tiene un código de retorno igual a 0 cuando el test es positivo, y diferente de cero en caso contrario

El comando test posee dos sintaxis: test expresión y [ expresión ], donde expresión representa el test que se debe efectuar

#!/bin/bash

var1=10
var2=5

if [ -e 7.sh ]; then echo "existe"; else echo "no existe"; fi

if (( $var1 % $var2 == 0 )); then echo "Es Par"; else echo "Es Impar"; fi

if (( $var1 > $var2 )); then echo "Es Mayor"; else echo "Es Menor"; fi

if [ -r 7.sh -a -w 7.sh -a -x 7.sh ]; then echo "Todos los permisos"
else echo "no tiene todos los permisos"; fi

if [ -r 7.sh -o -w 7.sh -o -x 7.sh ]; then echo "algun permiso"
else echo "no tiene todos los permisos"; fi

8) Ejercicio

Estructuras de control. Investigue la sintaxis de las siguientes estructuras de control incluidas en shell scripting:

#!/bin/bash
if [ 3 -eq 3 ]; then
  echo "Son iguales"
else
  echo "Son distintos"
fi

#!/bin/bash
echo "Ingrese un caracter"
read letra
case $letra in
  [a-z]) echo "Es una minuscula";;
  [A-Z]) echo "Es una mayuscula";;
  [0-9]) echo "Es un nro";;
  *) echo "Ingreso un caracter invalida";;
esac

#!/bin/bash
var1=0
while [ $var1 -le 5 ]
do
  echo "Hola mundo"
  var1=$((var1+1))
done

#!/bin/bash
for var in 1 2 3 4 5
do
  echo $var
done
echo "--------"
for var2 in {1..5}
do
  echo $var2
done
echo "--------"
for ((i=1; i<=5; i++))
do
  echo $i
done

#!/bin/bash
select opcion in opcion1 opcion2
do
  case $opcion in
    opcion1) echo "Opcion1" ;;
    opcion2) echo "Opcion2";;
    *) exit;;
  esac
done

9) Ejercicio

¿Qué acciones realizan las sentencias break y continue dentro de un bucle? ¿Qué parámetros reciben?

break [n] Corta la ejecución de n niveles de loops.
continue [n] salta a la siguiente iteración del enésimo loop que contiene esta instrucción

#!/bin/bash/
contador=0
while true
do
  let contador++
  if [ $contador -eq 10 ]; then
    break
  elif [ $contador -eq 5 ]; then
    continue
  fi
  echo $contador
done

10) Ejercicio

¿Qué tipo de variables existen? ¿Es shell script fuertemente tipado? ¿Se pueden definir arreglos? ¿Cómo?

bash soporta strings y arrays

Los nombres son case sensitive
Para crear una variable:
- NOMBRE="pepe" # SIN espacios alrededor del =
Para accederla se usa $:
- echo $NOMBRE

Para evitar ambigüedades se pueden usar llaves:

Esto no accede a $NOMBRE
echo $NOMBREesto_no_es_parte_de_la_variable
Esto sí
echo ${NOMBRE}esto_no_es_parte_de_la_variable Los nombres de las variables pueden contener mayúsculas, minúsculas, números y el símbolo (underscore), pero no pueden empezar con un número.

No es fuertemente tipado, y no requiere una declaración explícita de tipo variables.

Todo sobre los arreglos

| Bash | Resultado | | --- | --- | | arreglo=() | Definir Arreglo vacio | | arreglo[0]="valor1" | Asignación | | arreglo=("valor1", "valor2") | Definir con valores | | read -a arreglo | leer desde teclado tiene que estar definido arriba | | ${arreglo[0]} | retorna "valor1" | | ${arreglo[*]} | Retorna todos los elementos del array | | ${arreglo[@]} | Retorna todos los elementos del array | | ${#arreglo[@]} | Retorna 2, si contiene valor1 y valor2 |

Codigo de ejemplo

#!/bin/bash
array=()

read -a array
echo "Array pelado" $array
echo "index 3" ${array[3]}
echo "Todos los elementos" ${array[*]}
echo "Cantidad de elementos" ${#array[*]}

11) Ejercicio

¿Pueden definirse funciones dentro de un script? ¿Cómo? ¿Cómo se maneja el pasaje de parámetros de una función a la otra?

Si, se pueden definir funciones dentro de un script.

Las funciones permiten modularizar el comportamiento de los scripts.

Se pueden declarar de 2 formas:

function nombre { block }
nombre() { block }

Con la sentencia return se retorna un valor entre 0 y 255
El valor de retorno se puede evaluar mediante la variable $?
Reciben argumentos en las variables $1, $2, etc

Para definir variables locales podemos usar la palabra clave local var1

#!/bin/bash
sumar(){
  return $(( $1 + $2 ))
}
cadena(){
  echo "Hola $1, como estas"
}

sumar 2 3
echo $?
mensaje=$(cadena "Juan")
echo $mensaje

12) Ejercicio

Evaluación de expresione

(a) Realizar un script que le solicite al usuario 2 números, los lea de la entrada Standard e imprima la multiplicación, suma, resta y cual es el mayor de los números leídos.

#!/bin/bash

echo "Ingrese dos nros"
read nro1 nro2
echo "MULTIPLICACION: $(( $nro1 * $nro2 ))"
echo "SUMA: $(( $nro1 + $nro2 ))"
echo "RESTA: $(( $nro1 - $nro2 ))"

if [ $nro1 -gt $nro2 ]; then
  echo "es mayor el $nro1"
else 
  echo "es mayor el $nro2"
fi

(b) Modificar el script creado en el inciso anterior para que los números sean recibidos como parámetros. El script debe controlar que los dos parámetros sean enviados.

#!/bin/bash

if (( $# != 2 )); then exit 0; fi

echo "MULTIPLICACION: $(( $1 * $2 ))"
echo "SUMA: $(( $1 + $2 ))"
echo "RESTA: $(( $1 - $2 ))"

if [ $1 -gt $2 ]; then
  echo "es mayor el $1"
else 
  echo "es mayor el $2"
fi

(c) Realizar una calculadora que ejecute las 4 operaciones básicas: +, - ,*, %. Esta calculadora debe funcionar recibiendo la operación y los números como parámetros

#!/bin/bash
select operacion in Multiplicacion Suma Resta CualEsMayor Cerrar
do
   case $operacion in
      Multiplicacion) echo "MULTIPLICACION: $(( $1 * $2 ))" ;;
      Suma) echo "SUMA: $(( $1 + $2 ))" ;;
      Resta) echo "RESTA: $(( $1 - $2 ))" ;;
      CualEsMayor) 
         if [ $1 -gt $2 ]; then echo "es mayor el $1";
         else echo "es mayor el $2" ;fi
         ;;
      Cerrar|*) exit ;;
   esac  
done

13) Ejercicio

Uso de las estructuras de control

(a) Realizar un script que visualice por pantalla los números del 1 al 100 así como sus cuadrados.

#!/bin/bash
for i in {1..100}
do
  echo "$i La potencia es: $(($i * $i))"
done

b) Crear un script que muestre 3 opciones al usuario: Listar, DondeEstoy y QuienEsta. Según la opción elegida se le debe mostrar:

Listar: lista el contenido del directoria actual.
DondeEstoy: muestra el directorio donde me encuentro ubicado.
QuienEsta: muestra los usuarios conectados al sistema.

#!/bin/bash
select opcion in Listar DondeEstoy QuienEsta
do
  case $opcion in
    Listar) echo $(ls) ;;
    DondeEstoy) echo $(pwd);;
    QuienEsta) echo $(who);;
    *) exit;;
  esac
done

c) Crear un script que reciba como parámetro el nombre de un archivo e informe si el mismo existe o no, y en caso afirmativo indique si es un directorio o un archivo. En caso de que no exista el archivo/directorio cree un directorio con el nombre recibido como parámetro

#!/bin/bash
if (( $# != 1 )); then exit; fi

fi [ -e $1 ]; then
   echo "El archivo $1 existe"
   fi [ -f $1 ]; then echo "Y es un archivo"; fi
   fi [ -d $1 ]; then echo "Y es un directorio"; fi
   exit
fi
mkdir $1

14) Ejercicio

Renombrando Archivos: haga un script que renombre solo archivos de un directorio pasado como parametro agregandole una CADENA, contemplando las opciones:

“-a CADENA”: renombra el fichero concatenando CADENA al final del nombre del archivo
“-b CADENA”: renombra el fichero concantenado CADENA al principio del nombre del archivo

Ejemplo:

Si tengo los siguientes archivos: /tmp/a /tmp/b
Al ejecutar: ./renombra /tmp/ -a EJ
Obtendré como resultado: /tmp/aEJ /tmp/bEJ
Y si ejecuto: ./renombra /tmp/ -b EJ
El resultado será: /tmp/EJa /tmp/EJb

Comandos ejecutados

bash 14.sh prueba -a Ej
Despues
bash 14.sh prueba -b Ej

#!/bin/bash
if [ $# -ne 3 ]; then 
  echo  -e "
  Parametros: \n
  Path \n
  -a/-b \n
  sufijo/prefijo
"; exit;fi

if ! [ -e $1 ]; then 
  echo "El path ingresado no existe"
  exit
fi
cd $1
archivos="$(ls)"
ls -1
if [ $2 = "-a" ];then
  for i in ${archivos[*]};do mv $i $i$3;done
elif [ $2 = "-b" ];then
  for i in ${archivos[*]};do mv $i $3$i;done
else
  echo "Tiene que ingresar -a o -b"
fi
echo "Despues de todo:"
ls -1

15) Ejercicio

Comando cut. El comando cut nos permite procesar la líneas de la entrada que reciba (archivo, entrada estándar, resultado de otro comando, etc) y cortar columnas o campos, siendo posible indicar cual es el delimitador de las mismas. Investigue los parámetros que puede recibir este comando y cite ejemplos de uso.

Comando cut : Su principal utilidad es la de borrar secciones, campos o caracteres de la salida de un comando o de cada una de las líneas de un fichero de texto.

Ejemplos de uso:

Mostrar los caracteres que nos interesen en una línea de texto o en un conjunto de líneas
Imaginemos que tenemos un fichero de texto con el nombre geekland.txt que tiene el siguiente contenido:
```
la utilidad
es fácil de usar y es útil
```
Si únicamente queremos mostrar el cuarto carácter de cada una de las líneas lo haremos con la opción -c 4
cut -c 4 geekland.txt
```
u
f
```
Si ahora queremos mostrar los caracteres del 2 al 6:
cut -c 2-6 geekland.txt
```
a uti
s fá
```
Si finalmente queremos mostrar los caracteres 1,2,3 y 5,6,7 y 8 de cada una de las líneas de un fichero de texto:
cut -c 1-3,5-8 geekland.txt
```
la tili
es áci
```

Cut también ofrece la posibilidad de seleccionar un carácter inicial y seleccionar el resto de caracteres hasta el final. Por ejemplo para seleccionar el texto a partir del carácter 5 hasta el final usaremos la opción -c 5- del siguiente modo:

cut -c 5- geekland.txt
```
tilidad cut
ácil de usar y es útil
```

O también permite seleccionar un carácter final y seleccionar el resto de caracteres hasta el inicio de la frase o fichero. Por lo tanto para mostrar desde el carácter 4 hasta el inicio de la frase lo haremos del siguiente modo:

cut -c -4 geekland.txt
```
la u
es f
```
Capturar texto a partir de un delimitador y fijando el campo que queremos mostrar
Si únicamente queremos mostrar la tercera palabra:
a) Cada palabra esta separada por un espacio. Por lo tanto tendremos que fijar el espacio como delimitador. Para fijar el espacio como delimitador lo haré con la opción
-d ' '
b) A continuación hay que definir la palabra que queremos mostrar. si queremos mostrar la tercera palabra lo haremos con la opción –f2. La opción –f2 hace que se muestre la palabra que hay entre el segundo y tercer delimitador.
cut -d ' ' –f2
```
utilidad
fácil
```
Ahora imaginemos que la salida del comando cat /etc/passwd es la siguiente:

cat /etc/passwd

root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
...

Si únicamente queremos mostrar los usuarios podemos fijar que el delimitador sea : y a posteriori definir que se muestre el primer campo. Para hacer lo que acabo de mencionar podemos usar el siguiente comando:

cut -d ':' -f1 /etc/passwd

root
daemon
bin
sys
...

16) Ejercicio

Realizar un script que reciba como parámetro una extensión y haga un reporte con 2 columnas, el nombre de usuario y la cantidad de archivos que posee con esa extensión. Se debe guardar el resultado en un archivo llamado reporte.txt

Funciona un toque raro el find

#!/bin/bash

if [ $# -ne 1 ]; then echo "error"; exit 1; fi

cadena=""
for i in $(cat /etc/passwd) 
do
  usuario=$(echo $i | cut -d: -f1)
  path=$(echo $i | cut -d: -f6)  
  cadena+="$usuario $(find $path -name "*$1" | wc -l) \n"
done
echo -e "$cadena" > reporte.txt

17) Ejercicio

Escribir un script que al ejecutarse imprima en pantalla los nombre de los archivos que se encuentran en el directorio actual, intercambiando minúsculas por mayúsculas, además de eliminar la letra a (mayúscula o minúscula). Ejemplo, directorio actual:

IsO
pepE
Maria
Si ejecuto: ./ejercicio17

Obtendré como resultado

iSo
PEPe
mRI

Ayuda: Investigar el comando tr

#!/bin/bash

archivos=$(ls)
for i in $archivos
do
  nuevo=$(echo $i | tr '[:lower:][:upper:]' '[:upper:][:lower:]' | tr -d 'aA')
  echo $nuevo
done

Tambien podemos eliminar de la siguiente manera

nuevo_nombre=${archivo//a}
nuevo_nombre=${archivo^^} Todo a mayuscula
nuevo_nombre=${archivo,,} Todo a minuscula
echo $i | tr [a-zA-Z] [A-Za-z] | tr -d 'aA'

18) Ejercicio

Crear un script que verifique cada 10 segundos si un usuario se ha loqueado en el sistema (el nombre del usuario será pasado por parámetro). Cuando el usuario finalmente se loguee, el programa deberá mostrar el mensaje ”Usuario XXX logueado en el sistema” y salir.

#!/bin/bash

if [ $# -ne 1 ]; then 
  echo "Parametros incorrectos"; exit 1; 
fi

usuarios=$(cat /etc/passwd | cut -d: -f1 | grep -w $1 | wc -l)
if [ $usuarios -eq 0 ]; then
  echo "El usuario pasado no existe"; exit 2;
fi

while true
do
  if [ $(users | grep -w $1 | wc -l) -eq 1 ]; then
    echo "usuario $1 logueado en el sistema"
    exit
  fi  
  sleep 10
done

19) Ejercicio

Escribir un Programa de “Menu de Comandos Amigable con el Usuario” llamado menu, el cual, al ser invocado, mostrará un menú con la selección para cada uno de los scripts creados en esta práctica. Las instrucciones de como proceder deben mostrarse junto con el menú. El menú deberá iniciarse y permanecer activo hasta que se seleccione Salir. Por ejemplo:

MENU DE COMANDOS
03. Ejercicio 3
12. Evaluar Expresiones
13. Probar estructuras de control
...
Ingrese la opción a ejecutar: 03

#!/bin/bash

scripts=$(ls | grep "\.sh")
select opcion in Salir $scripts
do
  case $opcion in
    Salir) exit;;
    *) source $opcion;;
  esac
done

20) Ejercicio

Realice un scrip que simule el comportamiento de una estructura de PILA e implemente las siguientes funciones aplicables sobre una estructura global definida en el script:

push: Recibe un parámetro y lo agrega en la pila
pop: Saca un elemento de la pila
lenght: Devuelve la longitud de la pila
print: Imprime todos elementos de la pila

#!/bin/bash
pila=()

push (){
  pila+=($1)
}
pop (){
  unset pila[${#pila[@]}-1]
}
lenght (){
  echo ${#pila[*]}
}
print(){
  echo ${pila[*]}
}

21) Ejercicio

Agregue 10 elementos a la pila.
Saque 3 de ellos.
Imprima la longitud de la cola.
Luego imprima la totalidad de los elementos que en ella se encuentan.

#!/bin/bash

pila=()
push (){ pila+=($1); }
pop (){ unset pila[${#pila[@]}-1]; }
lenght (){ echo ${#pila[*]}; }
print(){ echo ${pila[*]}; }

push 2
push 4
echo "$(lenght)"
print
pop
print

22) Ejercicio

Dada la siguiente declaración al comienzo de un script: num=(10 3 5 7 9 3 5 4) (la cantidad de elementos del arreglo puede variar). Implemente la función productoria dentro de este script, cuya tarea sea multiplicar todos los números del arreglo

#!/bin/bash

num=(10 3 5 7 9 3 5 4)
productora(){
  let resultado=1
  for i in ${num[*]}
  do
    resultado=$(($i * $resultado))
  done
  echo $resultado
}

productora

23) Ejercicio

Implemente un script que recorra un arreglo compuesto por números e imprima en pantalla sólo los números pares y que cuente sólo los números impares y los informe en pantalla al finalizar el recorrido

#!/bin/bash
nros=(10 3 5 7 9 3 5 4)

imprimir(){
  let nro
  for i in ${nros[*]}
  do
    echo $i
    if (( $i % 2 == 0 )); then
      echo "Par: "$i
    else
      let impares++
    fi
  done
  echo "Nros Impares: "$impares
}

imprimir

24) Ejercicio

Dada la definición de 2 vectores del mismo tamaño y cuyas longitudes no se conocen

vector1=( 1 .. N)
vector2=( 7 .. N)
Por ejemplo:
vector1=( 1 80 65 35 2 )
y
vector2=( 5 98 3 41 8 ).

Complete este script de manera tal de implementar la suma elemento a elemento entre ambos vectores y que la misma sea impresa en pantalla de la siguiente manera:

La suma de los elementos de la posición 0 de los vectores es 6
La suma de los elementos de la posición 1 de los vectores es 178
...
La suma de los elementos de la posición 4 de los vectores es 10

#!/bin/bash
vector1=(1 80 65 35 2 )
vector2=(5 98 3 41 8 )
long=`expr ${#vector1[*]} - 1`

for i in $(seq 0 $long)
do
  resultado=`expr ${vector1[$i]} + ${vector2[$i]}`
  echo "La suma de los elementos de la posicion $i de los vectores es $resultado"
done

25) Ejercicio

Realice un script que agregue en un arreglo todos los nombres de los usuarios del sistema pertenecientes al grupo “users”. Adicionalmente el script puede recibir como parametro:

“-b n”: Retorna el elemento de la posición n del arreglo si el mismo existe. Caso contrario, un mensaje de error.
“-l”: Devuelve la longitud del arreglo
“-i”: Imprime todos los elementos del arreglo en pantalla

#!/bin/bash

# En grupo, me quedo con la columna 4 que tiene
# Los usuarios del grupo
# Uso el grep para filtrar por grupo aunque puede haber un usuario con nombre
# users pero bueno
# Cambiamos el separador de , por un espacio para agregarlo al array

if [ $# -ne 1 ] && [ $# -ne 2 ]; then echo "Parametros Invalidos"; exit 1; fi 
grupo=$(cat /etc/group | grep -w "users" |cut -d: -f4 | tr "," " ")
usuarios=($grupo)

case $1 in
  -b)
    if [ $2 -lt ${#usuarios[*]} ]; then
      echo ${usuarios[$2]}
    else
      echo "Parametro fuera de rango"
      exit 1
    fi;;
  -l) echo "Longitud: ${#usuarios}";;
  -i) echo "Todos: ${usuarios[*]}";;
esac

26) Ejercicio

Escriba un script que reciba una cantidad desconocida de parámetros al momento de su invocación (debe validar que al menos se reciba uno). Cada parámetro representa la ruta absoluta de un archivo o directorio en el sistema. El script deberá iterar por todos los parámetros recibidos, y solo para aquellos parámetros que se encuentren en posiciones impares (el primero, el tercero, el qverificar si el archivo o directorio existen en el sistema, imprimiendo en pantalla que tipo de objeto es (archivo o directorio). Además, deberá informar la cantidad de archivos o directorios inexistentes en el sistema.

#!/bin/bash
if [ $# -le  0 ]; then exit 1;fi

let existen
for ((i=0 ; i<=$cantidad ; i+=2));
do
  actual=${elementos[$i]}
  if [ -d $actual ]; then echo "es un directorio";
  elif [ -f $actual ]; then echo "es un archivo";
  else let existen++;fi
done
echo "La cantidad de archivos que no existen es" $existen

27) Ejercicio

Realice un script que implemente a través de la utilización de funciones las operaciones básicas sobre arreglos:

inicializar: Crea un arreglo llamado array vacío
agregar_elem <parametro1>: Agrega al final del arreglo el parámetro recibido
eliminar_elem <parametro1>: Elimina del arreglo el elemento que se encuentra en la posición recibida como parámetro. Debe validar que se reciba una posición válida
longitud: Imprime la longitud del arreglo en pantalla
imprimir: Imprime todos los elementos del arreglo en pantalla
inicializar_Con_Valores <parametro1><parametro2>: Crea un arreglo con longitud <parametro1>y en todas las posiciones asigna el valor <parametro2>

#!/bin/bash

inicializar(){
  array=()
  echo "vecto pa"
}
agregar_elem(){
  array+=($1)
}
eliminar_elem(){
  unset array[$1]
}
imprimir(){
  echo ${array[*]}
}
longitud(){
  echo ${#array[*]}
}
inicializar_Con_Valores(){
  for ((i=0; i<$1; i++));
  do
    array+=($2)
  done
}

select opcion in  inicializar agregar_elem eliminar_elem longitud imprimir inicializar_Con_Valores
do  
  case $opcion in
    inicializar) inicializar;;
    agregar_elem) agregar_elem 9;;
    eliminar_elem) eliminar_elem 0;;
    longitud) longitud ;;
    inicializar_Con_Valores) inicializar_Con_Valores 10 4 ;;
    imprimir) imprimir;;
  esac
done

28) Ejercicio

Realice un script que reciba como parámetro el nombre de un directorio. Deberá validar que el mismo exista y de no existir causar la terminación del script con código de error 4. Si el directorio existe deberá contar por separado la cantidad de archivos que en él se encuentran para los cuales el usuario que ejecuta el script tiene permiso de lectura y escritura, e informar dichos valores en pantalla. En caso de encontrar subdirectorios, no deberán procesarse, y tampoco deberán ser tenidos en cuenta para la suma a informar.

#!/bin/bash

if [ $# -ne 1 ]; then echo "Ingrese un parametro"; exit 1; fi
if ! [ -e $1 ] && ! [ -d $1 ] ; then exit 4; fi

archivos=($(ls))
let contador=0
for i in ${archivos[*]} 
do
  if [ -f $i ] && [ -w $i ] && [ -r $i ]; then let contador++;fi
done
echo $contador

29) Ejercicio

Implemente un script que agregue a un arreglo todos los archivos del directorio /home cuya terminación sea .doc. Adicionalmente, implemente las siguientes funciones que le permitan acceder a la estructura creada:

verArchivo <nombre_de_archivo>: Imprime el archivo en pantalla si el mismo se encuentra en el arreglo. Caso contrario imprime el mensaje de error “Archivo no encontrado” y devuelve como valor de retorno 5
cantidadArchivos: Imprime la cantidad de archivos del /home con terminación .doc
borrarArchivo <nombre_de_archivo>: Consulta al usuario si quiere eliminar el archivo lógicamente. Si el usuario responde Si, elimina el elemento solo del arreglo. Si el usuario responde No, elimina el archivo del arreglo y también del FileSystem. Debe validar que el archivo exista en el arreglo. En caso de no existir, imprime el mensaje de error “Archivo no encontrado” y devuelve como valor de retorno 10

#!/bin/bash

archivos_doc=$( ls $HOME | grep '\.doc$' )

verArchivo(){
  encontro=false
  for i in ${archivos_doc[*]}
  do
    if [ $1 = $i ]; then 
      echo $(cat "$HOME/$1")
      encontro=true
    fi
  done
  if [ $encontro = false ]; then echo "No se encontro" ;return 5; fi
}

cantidadArchivos(){
  echo ${#archivos_doc[*]}
}

borrarArchivo(){
  echo "Ingrese un archivo"
  if ! [ -e "$HOME/$1" ]; then echo "Archivo no encontrado"; return 10; fi
  echo "Quiere eliminar el archivo logicamente? SI O NO"
  select desicion in SI NO SALIR  
  do
    case $desicion in
      SI) unset "$archivos_doc[$1]"; echo "Elementos ${archivos_doc[*]}" ;;
      NO) rm "$HOME/$1" ;;
      SALIR) break;;
    esac
  done
}

verArchivo "ejercio292.doc"
cantidadArchivos
borrarArchivo "ejercio9.doc"
echo $?

30) Ejercicio

Realice un script que mueva todos los programas del directorio actual (archivos ejecutables) hacia el subdirectorio “bin” del directorio HOME del usuario actualmente logueado. El script debe imprimir en pantalla los nombres de los que mueve, e indicar cuántos ha movido, o que no ha movido ninguno. Si el directorio “bin” no existe,deberá ser creado.

#!/bin/bash

# El -F agrega un indicador al final para saber que permisos tiene
# / para directorios
# * para archivos ejecutables

archivos=$(ls -F | grep "*$")
if [ -n ${archivos[*]} ];then exit 1; fi
echo ${archivos[*]}
bin="$HOME/bin"
if ! [ -e $bin ]; then mkdir $bin; fi

mv ${archivos[*]} $bin