1. Del módulo interno al servicio independiente
Una función dentro de un proceso comparte memoria, pila y destino con quien la invoca. Al moverla a otro proceso, la invocación necesita un protocolo: argumentos serializados, una respuesta, límites y una forma de reconocer que la conversación no se completó.
Un servicio independiente expone un contrato de comunicación y de fallo. El transporte lleva bytes; el contrato define identidad de solicitudes, versiones, resultados y comportamiento ante incertidumbre.
La separación puede permitir despliegues y escalado independientes, pero agrega estados que no existían en una llamada ordinaria: no se pudo conectar, se envió parte de la solicitud, se perdió la respuesta o el servicio terminó después de ejecutar. Estar en el mismo host reduce algunos costos, pero no elimina esos estados.
Un microservicio no necesita obligatoriamente un protocolo de red entre máquinas. Dos servicios colocados en el mismo host pueden usar sockets Unix y conservar límites de proceso. Tampoco basta usar sockets para que una arquitectura sea adecuada: importan las responsabilidades, el estado y las dependencias que se crean.
El laboratorio implementa una suma de dos enteros sin efectos externos. Esa operación es repetible sin duplicar cambios persistentes. Esta elección permite estudiar comunicación; no convierte en seguros los reintentos de una operación que descuente saldo, reserve inventario o envíe una notificación.
2. Elegir el transporte según la ubicación
| Situación | Opción | Condición que hay que revisar |
|---|---|---|
| Procesos locales con una ruta accesible común. | Socket Unix de flujo. | Permisos, identidad, publicación y retirada del nombre. |
| Procesos relacionados desde el arranque. | socketpair, pipes o recursos heredados. | Cierre de referencias y gestión de procesos. |
| Estado voluminoso compartido en el host. | Memoria compartida con sincronización. | Propiedad, versiones, límites y recuperación. |
| Servicios en máquinas diferentes. | Transporte de red, como TCP, con seguridad y protocolo apropiados. | Direcciones, resolución, identidad remota, fallos de red y cifrado. |
Una ruta de socket Unix no se convierte en un destino remoto al copiar su nombre a otra máquina. Tampoco se puede enviar un descriptor mediante SCM_RIGHTS a un host remoto: esa transferencia representa recursos del mismo núcleo.
TCP ofrece un flujo, no límites de mensaje de aplicación. Cambiar AF_UNIX por TCP no elimina la necesidad de framing, lecturas y escrituras parciales, versión ni tamaños máximos. El protocolo de este tema conserva esas reglas en ambos recorridos.
El puente se ejecuta solo sobre loopback para estudiar el cambio de transporte sin administrar una red externa. El curso de redes desarrolla las direcciones y los protocolos entre equipos; aquí se identifica la frontera y se implementa un puente local verificable.
3. Definir un protocolo antes del puente
Cada conexión lleva una solicitud y una respuesta. La solicitud termina con shutdown de escritura del cliente; ese EOF confirma que no hay otra trama en esa dirección. El servidor responde y cierra. Un EOF antes de completar la trama es truncamiento, no un mensaje vacío válido.
| Bytes de cabecera | Campo | Regla |
|---|---|---|
| 0–3. | Marca IPC7. | Identifica este formato de laboratorio. |
| 4. | Versión. | 1. |
| 5. | Operación. | 1 representa SUMAR. |
| 6. | Estado. | Solicitud: 0. Respuesta: 0 éxito, 1 cuerpo inválido, 2 operación desconocida. |
| 7. | Reservado. | Debe ser cero. |
| 8–11. | Identificador uint32. | Big endian y distinto de cero; se conserva en la respuesta. |
| 12–15. | Longitud uint32. | Big endian; como máximo 64 bytes de cuerpo. |
SUMAR recibe dos uint32 en big endian, ocho bytes en total. Devuelve un uint64 en big endian, también ocho bytes. El máximo resultado es 8589934590, por lo que no se acumula en uint32. No se envían structs nativas ni texto cuya interpretación dependa de la configuración regional.
La cabecera inválida, longitud excesiva, trama truncada o bytes posteriores a la única solicitud hacen que se cierre esa sesión. Para una cabecera válida con operación desconocida se devuelve estado 2; para SUMAR con cuerpo de longitud distinta de ocho, estado 1. Las respuestas de error no llevan cuerpo.
El puente admite únicamente la operación SUMAR válida y valida la respuesta antes de reenviarla. El cliente comprueba operación, identificador, estado, tamaño, valor y EOF. Una coincidencia de tamaño no basta para aceptar una respuesta perteneciente a otra solicitud.
4. Identidad local y autorización
El servicio crea un directorio privado con mkdtemp, publica dentro servicio.sock y restringe el socket a modo 0600. Además, usa SO_PEERCRED para exigir que el UID del interlocutor local coincida con su UID efectivo. Las credenciales y permisos de sockets Unix se documentan en unix(7).
Compartir UID no identifica una aplicación concreta ni garantiza que cualquier operación esté autorizada. El ejemplo ejecuta programas propios con una única operación sin efectos; una instalación con varias identidades necesita una política explícita para cada acción y recurso.
Al atravesar el puente, el servicio Unix ve las credenciales del puente. No ve el UID del cliente TCP original. Reenviar un campo llamado uid dentro del cuerpo no lo convierte en una credencial verificada por el núcleo.
SO_PEERCRED tampoco se traslada automáticamente a TCP. La identidad remota debe establecerse con mecanismos de aplicación y transporte apropiados, por ejemplo autenticación y TLS con validación de certificados. Loopback limita la dirección de escucha, pero no autentica a todos los procesos del host.
El identificador de solicitud sirve para correlacionar una respuesta. No es un secreto, no autentica al cliente y no es por sí solo una clave de deduplicación durable.
5. Presupuestos de tiempo y cancelación
Una operación compuesta puede gastar tiempo en conectar, esperar cola, enviar, procesar y recibir. Si cada etapa recibe un timeout nuevo de dos segundos, el recorrido puede tardar mucho más de dos segundos. Un plazo absoluto local permite calcular el tiempo restante en cada espera.
El cliente Python crea un plazo con time.monotonic y lo reutiliza durante conexión, envío, respuesta y EOF. El puente tiene otro plazo, de 2,5 segundos desde accept, que comparte entre recepción TCP y conversación Unix. El servicio C limita una sesión aceptada a tres segundos con CLOCK_MONOTONIC.
Estos son límites locales de tres participantes. La versión 1 del protocolo no transporta el presupuesto del cliente: el puente no puede deducirlo de una conexión. Si el cliente abandona antes, el puente todavía podría seguir trabajando hasta su límite. No se presenta ese diseño como cancelación distribuida de extremo a extremo.
Una extensión puede propagar un presupuesto restante acotado, descontando el tiempo consumido en cada salto. No debe copiar una fecha monotónica absoluta de una máquina a otra: sus relojes no comparten necesariamente el mismo origen. También deben contarse resolución de nombres, autenticación y establecimiento seguro cuando existan.
Cerrar el socket no revierte una operación ya ejecutada. Este servicio solo calcula una suma, pero una operación con efectos necesita distinguir solicitud de cancelación, cancelación aceptada y resultado ya confirmado. El timeout del cliente describe su espera, no la historia completa del servidor.
6. Topología y responsabilidades del laboratorio
recorrido local:
cliente Python ── socket Unix ──► servicio C SUMAR
recorrido por el puente:
cliente Python ── TCP 127.0.0.1 ──► puente Python ── socket Unix ──► servicio C
misma trama valida y conserva ID calcula
respuesta: operación + ID + estado + uint64, seguida de EOFEl servicio es secuencial: atiende una sesión activa. El puente también procesa una conexión a la vez. Esto hace visibles el orden y los límites; no es una arquitectura diseñada para alto throughput. Las colas de escucha tienen capacidad finita y no sustituyen capacidad de ejecución.
El puente no es un túnel de bytes arbitrarios ni reenvía descriptores. Termina la conexión TCP, valida una solicitud completa, abre una conexión Unix, valida la respuesta y la devuelve. Un cliente malformado no debe hacer reservar memoria a partir de una longitud sin comprobar.
No hay reintentos automáticos, balanceo, resolución DNS ni almacenamiento de resultados. No se modifica la configuración del equipo ni se abre un puerto a otras interfaces. El puerto TCP puede asignarse con cero y se anuncia después de listen.
7. Servicio completo en C por socket Unix
Guarda servicio47.c. Es autónomo y usa extensiones de Linux: signalfd, accept4 y SO_PEERCRED. El servicio atiende señales mientras espera escucha, cabecera, cuerpo, EOF o capacidad de envío. SIGTERM y SIGINT cancelan la sesión actual y retiran sus recursos; no hay efectos externos que deshacer.
#define _GNU_SOURCE
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/signalfd.h>
#include <sys/stat.h>
#include <poll.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define CAB47 16u
#define MAX47 64u
static int cerrar47(int *fd)
{
if (*fd < 0) return 0;
int n = *fd; *fd = -1;
if (close(n) == -1) { perror("close"); return -1; }
return 0;
}
static uint32_t obtener47(const unsigned char *p)
{
return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
((uint32_t)p[2] << 8) | p[3];
}
static void poner32_47(unsigned char *p, uint32_t n)
{
for (unsigned i = 0; i < 4; ++i) p[i] = (unsigned char)(n >> (24u - 8u * i));
}
static void poner64_47(unsigned char *p, uint64_t n)
{
for (unsigned i = 0; i < 8; ++i) p[i] = (unsigned char)(n >> (56u - 8u * i));
}
static int64_t ahora47(void)
{
struct timespec t;
if (clock_gettime(CLOCK_MONOTONIC, &t) == -1) return -1;
return (int64_t)t.tv_sec * 1000 + t.tv_nsec / 1000000;
}
static int control47(int fd, int *parar)
{
for (;;) {
struct signalfd_siginfo s;
ssize_t n = read(fd, &s, sizeof s);
if (n == (ssize_t)sizeof s) {
if (s.ssi_signo == SIGINT || s.ssi_signo == SIGTERM) *parar = 1;
} else if (n == -1 && errno == EINTR) continue;
else if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) return 0;
else { errno = EIO; return -1; }
}
}
/* 1 listo; 0 plazo o cancelacion; -1 fallo interno. fin=-1 para escucha. */
static int esperar47(int fd, short eventos, int control, int *parar, int64_t fin)
{
for (;;) {
if (*parar) return 0;
int ms = -1;
if (fin >= 0) {
int64_t ahora = ahora47();
if (ahora < 0) return -1;
if (ahora >= fin) return 0;
ms = (int)(fin - ahora);
}
struct pollfd p[2] = {
{ .fd = fd, .events = eventos },
{ .fd = control, .events = POLLIN }
};
int r = poll(p, 2, ms);
if (r == -1) { if (errno == EINTR) continue; return -1; }
if (p[1].revents & (POLLERR | POLLHUP | POLLNVAL)) { errno = EIO; return -1; }
if ((p[1].revents & POLLIN) && control47(control, parar) == -1) return -1;
if (*parar) return 0;
if (p[0].revents & POLLNVAL) { errno = EBADF; return -1; }
if (p[0].revents & (eventos | POLLERR | POLLHUP)) return 1;
}
}
/* Un error de transporte es local a la sesion, no derriba al servicio. */
static int transferir47(int fd, unsigned char *p, size_t total, int escribir,
int control, int *parar, int64_t fin)
{
size_t hechos = 0;
while (hechos < total) {
int r = esperar47(fd, escribir ? POLLOUT : POLLIN, control, parar, fin);
if (r <= 0) return r;
ssize_t n = escribir ? send(fd, p + hechos, total - hechos, MSG_NOSIGNAL) :
recv(fd, p + hechos, total - hechos, 0);
if (n > 0) hechos += (size_t)n;
else if (n == 0) return 0;
else if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) return 0;
}
return 1;
}
static int exigir_eof47(int fd, int control, int *parar, int64_t fin)
{
for (;;) {
int r = esperar47(fd, POLLIN, control, parar, fin);
if (r <= 0) return r;
unsigned char extra;
ssize_t n = recv(fd, &extra, 1, 0);
if (n == 0) return 1;
if (n > 0) return 0;
if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) return 0;
}
}
static int atender47(int fd, int control, int *parar)
{
int64_t fin = ahora47();
if (fin < 0) return -1;
fin += 3000;
unsigned char cab[CAB47], cuerpo[MAX47], respuesta[CAB47 + 8];
int r = transferir47(fd, cab, sizeof cab, 0, control, parar, fin);
if (r <= 0) return r;
uint32_t id = obtener47(cab + 8), longitud = obtener47(cab + 12);
if (memcmp(cab, "IPC7", 4) != 0 || cab[4] != 1 || cab[6] != 0 ||
cab[7] != 0 || id == 0 || longitud > MAX47) return 0;
r = transferir47(fd, cuerpo, longitud, 0, control, parar, fin);
if (r <= 0) return r;
r = exigir_eof47(fd, control, parar, fin);
if (r <= 0) return r;
unsigned estado = cab[5] != 1 ? 2u : longitud != 8 ? 1u : 0u;
memcpy(respuesta, cab, sizeof cab); respuesta[6] = (unsigned char)estado;
poner32_47(respuesta + 12, estado == 0 ? 8u : 0u);
if (estado == 0) {
uint64_t suma = (uint64_t)obtener47(cuerpo) + obtener47(cuerpo + 4);
poner64_47(respuesta + CAB47, suma);
}
r = transferir47(fd, respuesta, CAB47 + (estado == 0 ? 8u : 0u),
1, control, parar, fin);
return r < 0 ? -1 : 0;
}
static int retirar47(const char *ruta, const struct stat *identidad)
{
struct stat actual;
if (lstat(ruta, &actual) == -1) return errno == ENOENT ? 0 : -1;
if (!S_ISSOCK(actual.st_mode) || actual.st_dev != identidad->st_dev ||
actual.st_ino != identidad->st_ino) { errno = ESTALE; return -1; }
return unlink(ruta);
}
int main(void)
{
sigset_t mascara;
sigemptyset(&mascara); sigaddset(&mascara, SIGINT); sigaddset(&mascara, SIGTERM);
if (signal(SIGINT, SIG_DFL) == SIG_ERR || signal(SIGTERM, SIG_DFL) == SIG_ERR ||
signal(SIGPIPE, SIG_IGN) == SIG_ERR ||
sigprocmask(SIG_BLOCK, &mascara, NULL) == -1) {
perror("senales"); return EXIT_FAILURE;
}
int escucha = -1, control = -1, propio = 0, directorio = 0;
int salida = EXIT_FAILURE, parar = 0;
char dir[] = "/tmp/svc47.XXXXXX";
struct sockaddr_un direccion = { .sun_family = AF_UNIX };
struct stat identidad;
control = signalfd(-1, &mascara, SFD_NONBLOCK | SFD_CLOEXEC);
if (control == -1 || mkdtemp(dir) == NULL) { perror("preparar"); goto fin; }
directorio = 1;
int largo = snprintf(direccion.sun_path, sizeof direccion.sun_path, "%s/servicio.sock", dir);
if (largo < 0 || (size_t)largo >= sizeof direccion.sun_path) goto fin;
escucha = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
if (escucha == -1 || bind(escucha, (struct sockaddr *)&direccion, sizeof direccion) == -1) {
perror("socket/bind"); goto fin;
}
if (lstat(direccion.sun_path, &identidad) == -1) { perror("lstat"); goto fin; }
propio = 1;
if (chmod(direccion.sun_path, 0600) == -1 || listen(escucha, 16) == -1) {
perror("chmod/listen"); goto fin;
}
printf("SVC47 listo pid=%jd socket=%s\n", (intmax_t)getpid(), direccion.sun_path);
if (fflush(stdout) == EOF) goto fin;
while (!parar) {
int r = esperar47(escucha, POLLIN, control, ¶r, -1);
if (r == -1) { perror("espera"); goto fin; }
if (r == 0) break;
int cliente = accept4(escucha, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (cliente == -1) {
if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ||
errno == ECONNABORTED) continue;
perror("accept4"); goto fin;
}
struct ucred cred;
socklen_t tam = sizeof cred;
if (getsockopt(cliente, SOL_SOCKET, SO_PEERCRED, &cred, &tam) == -1 ||
tam != sizeof cred || cred.uid != geteuid()) {
if (cerrar47(&cliente) == -1) goto fin;
continue;
}
r = atender47(cliente, control, ¶r);
if (cerrar47(&cliente) == -1 || r == -1) goto fin;
}
salida = EXIT_SUCCESS;
fin:
if (cerrar47(&escucha) == -1) salida = EXIT_FAILURE;
if (cerrar47(&control) == -1) salida = EXIT_FAILURE;
if (propio && retirar47(direccion.sun_path, &identidad) == -1) {
perror("retirar socket"); salida = EXIT_FAILURE;
}
if (directorio && rmdir(dir) == -1) { perror("rmdir propio"); salida = EXIT_FAILURE; }
return salida;
}transferir47 conserva el desplazamiento entre llamadas parciales y reintenta EINTR. esperar47 recalcula el plazo sin renovarlo. El cuerpo está limitado a 64 bytes antes de recibirlo. El resultado se calcula en uint64 y se serializa explícitamente.
El supervisor de este ejemplo es el propio proceso de servicio: no crea hijos. La retirada del nombre pertenece a ese proceso, que contrasta tipo, dispositivo e inodo antes de unlink dentro de su directorio privado. La política presupone que otros procesos con el mismo usuario no manipulan ese directorio mientras funciona.
8. Cliente y puente TCP completos en Python
Guarda red47.py. Sus subcomandos permiten consultar el servicio directamente por Unix, levantar el puente local o consultar el puerto TCP. Las funciones de protocolo son compartidas para que ambos caminos tengan las mismas validaciones.
import argparse
import json
import os
from pathlib import Path
import signal
import socket
import struct
import sys
import time
CAB = struct.Struct("!4sBBBBII")
MAXIMO = 64
class Parada(BaseException):
pass
def restante(fin):
r = fin - time.monotonic()
if r <= 0:
raise TimeoutError("plazo agotado")
return r
def recibir_exacto(s, n, fin):
datos = bytearray()
while len(datos) < n:
s.settimeout(restante(fin))
bloque = s.recv(n - len(datos))
if not bloque:
raise EOFError("trama incompleta")
datos.extend(bloque)
return bytes(datos)
def recibir(s, fin):
cab = recibir_exacto(s, CAB.size, fin)
marca, version, op, estado, reservado, ident, largo = CAB.unpack(cab)
if marca != b"IPC7" or version != 1 or reservado != 0 or ident == 0 or largo > MAXIMO:
raise ValueError("cabecera incompatible")
cuerpo = recibir_exacto(s, largo, fin)
return op, estado, ident, cuerpo, cab + cuerpo
def exigir_eof(s, fin):
s.settimeout(restante(fin))
if s.recv(1):
raise ValueError("bytes despues de la unica trama")
def enviar(s, datos, fin):
s.settimeout(restante(fin))
s.sendall(datos)
def conectar(s, destino, fin):
s.settimeout(restante(fin))
s.connect(destino)
def pedido(a, b, ident):
return CAB.pack(b"IPC7", 1, 1, 0, 0, ident, 8) + struct.pack("!II", a, b)
def validar_pedido(f):
op, estado, ident, cuerpo, crudo = f
if op != 1 or estado != 0 or len(cuerpo) != 8:
raise ValueError("solicitud SUMAR incompatible")
def validar_respuesta(f, esperado):
op, estado, ident, cuerpo, crudo = f
if op != 1 or ident != esperado or estado not in (0, 1, 2):
raise ValueError("respuesta incompatible o ID incorrecto")
if len(cuerpo) != (8 if estado == 0 else 0):
raise ValueError("longitud de respuesta incorrecta")
def consultar(familia, destino, a, b, ident=1, ms=2000):
fin = time.monotonic() + ms / 1000
af = socket.AF_UNIX if familia == "unix" else socket.AF_INET
direccion = destino if familia == "unix" else ("127.0.0.1", int(destino))
with socket.socket(af, socket.SOCK_STREAM) as s:
conectar(s, direccion, fin)
enviar(s, pedido(a, b, ident), fin)
s.shutdown(socket.SHUT_WR)
f = recibir(s, fin)
exigir_eof(s, fin)
validar_respuesta(f, ident)
if f[1] != 0:
raise ValueError("servicio respondio estado " + str(f[1]))
valor = struct.unpack("!Q", f[3])[0]
if valor != a + b:
raise ValueError("resultado de suma incorrecto")
return valor
def puente(ruta, puerto):
def parar(signo, frame):
raise Parada()
signal.signal(signal.SIGINT, parar)
signal.signal(signal.SIGTERM, parar)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as escucha:
escucha.bind(("127.0.0.1", puerto))
escucha.listen(16)
escucha.settimeout(0.2)
print("PTE47 listo pid=" + str(os.getpid()) +
" puerto=" + str(escucha.getsockname()[1]), flush=True)
while True:
try:
cliente, direccion = escucha.accept()
except socket.timeout:
continue
with cliente:
ident = None
fin = time.monotonic() + 2.5
try:
solicitud = recibir(cliente, fin)
ident = solicitud[2]
exigir_eof(cliente, fin)
validar_pedido(solicitud)
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as local:
conectar(local, ruta, fin)
enviar(local, solicitud[4], fin)
local.shutdown(socket.SHUT_WR)
respuesta = recibir(local, fin)
exigir_eof(local, fin)
validar_respuesta(respuesta, ident)
enviar(cliente, respuesta[4], fin)
except (OSError, ValueError, EOFError) as error:
print("PTE47 id=" + str(ident) + " error=" + str(error),
file=sys.stderr, flush=True)
def entero(texto, maximo, minimo=0):
try:
n = int(texto)
except ValueError:
raise argparse.ArgumentTypeError("se requiere un entero")
if not minimo <= n <= maximo:
raise argparse.ArgumentTypeError("entero fuera de rango")
return n
def main():
p = argparse.ArgumentParser()
sub = p.add_subparsers(dest="accion", required=True)
b = sub.add_parser("puente")
b.add_argument("ruta", type=Path)
b.add_argument("--puerto", type=lambda x: entero(x, 65535), default=0)
c = sub.add_parser("consulta")
c.add_argument("familia", choices=["unix", "tcp"])
c.add_argument("destino")
c.add_argument("a", type=lambda x: entero(x, 4294967295))
c.add_argument("b", type=lambda x: entero(x, 4294967295))
c.add_argument("--id", type=lambda x: entero(x, 4294967295, 1), default=1)
c.add_argument("--ms", type=lambda x: entero(x, 10000, 1), default=2000)
a = p.parse_args()
if a.accion == "puente":
ruta = str(a.ruta.resolve(strict=True))
try:
puente(ruta, a.puerto)
except Parada:
pass
else:
destino = a.destino if a.familia == "unix" else entero(a.destino, 65535, 1)
suma = consultar(a.familia, destino, a.a, a.b, a.id, a.ms)
print(json.dumps({"id": a.id, "suma": suma, "transporte": a.familia}))
if __name__ == "__main__":
try:
main()
except (OSError, ValueError, EOFError, argparse.ArgumentTypeError) as error:
print(error, file=sys.stderr)
sys.exit(1)Antes de cada operación bloqueante se aplica el tiempo restante del mismo plazo. sendall completa el envío o informa error; no se supone un envío por cada recepción. La interfaz de sockets y sus límites de timeout están documentados en socket de Python.
Un error después de reenviar puede dejar desconocido el resultado del servicio. El puente cierra esa conexión y registra el fallo sin inventar una respuesta de éxito. Un error de aplicación válido se reenvía como tal; no se transforma automáticamente en un reintento.
9. Ejecutar los dos recorridos
gcc -std=c11 -Wall -Wextra -Wpedantic -O2 servicio47.c -o servicio47
./servicio47
# Esperar: SVC47 listo pid=... socket=/tmp/svc47.XXXXXX/servicio.sockCopia la ruta de esta corrida y úsala en la segunda terminal. El ejemplo siguiente usa una ruta ilustrativa que debes reemplazar. La consulta directa permite comprobar el servicio antes de agregar otro participante.
ruta=/tmp/svc47.ABC123/servicio.sock
python3 red47.py consulta unix "$ruta" 40 2 --id 17
python3 red47.py puente "$ruta" --puerto 0
# Esperar: PTE47 listo pid=... puerto=...La consulta devuelve un JSON con suma 42, ID 17 y transporte unix. El puente anuncia el puerto que recibió del sistema; no se supone que siempre sea el mismo. En una tercera terminal consulta ese puerto real.
puerto=45678 # reemplazar por el puerto PTE47 real
python3 red47.py consulta tcp "$puerto" 40 2 --id 18
python3 red47.py consulta tcp "$puerto" 4294967295 4294967295 --id 19
# La segunda suma debe ser 8589934590, sin desbordamiento uint32.Para detener, envía SIGTERM a los PIDs reales del puente y del servicio. El puente cierra su escucha y conectado activo. El servicio cierra sus referencias y retira el socket y directorio propios. Detener el puente no detiene automáticamente al servicio: son procesos independientes.
No cambies la dirección de escucha a 0.0.0.0 para «hacerlo remoto» sin diseñar autenticación, autorización, cifrado y límites de acceso. El código muestra la adaptación de protocolo en loopback; la comunicación remota requiere una arquitectura de seguridad y red adicional.
10. Prueba integrada con arranque confirmado
Guarda probar47.py junto a red47.py. El controlador inicia procesos propios, espera sus anuncios con plazo y verifica ambos caminos. No utiliza una pausa fija para suponer que listen ya ocurrió.
import argparse
import os
from pathlib import Path
import re
import selectors
import signal
import socket
import subprocess
import sys
import time
import red47
def anuncio(proceso):
fin = time.monotonic() + 7
datos = bytearray()
with selectors.DefaultSelector() as sel:
sel.register(proceso.stdout, selectors.EVENT_READ)
while b"\n" not in datos:
resto = fin - time.monotonic()
if resto <= 0 or not sel.select(resto):
raise TimeoutError("sin anuncio de preparacion")
bloque = os.read(proceso.stdout.fileno(), 256)
if not bloque:
raise ValueError("proceso termino antes del anuncio")
datos.extend(bloque)
if len(datos) > 1024:
raise ValueError("anuncio fuera de limite")
return bytes(datos)
def terminar(proceso):
if proceso.poll() is None:
proceso.terminate()
try:
proceso.wait(timeout=4)
except subprocess.TimeoutExpired:
try:
os.killpg(proceso.pid, signal.SIGKILL)
except ProcessLookupError:
pass
proceso.wait()
proceso.stdout.close()
def fragmentado(familia, destino):
fin = time.monotonic() + 2
af = socket.AF_UNIX if familia == "unix" else socket.AF_INET
direccion = destino if familia == "unix" else ("127.0.0.1", destino)
with socket.socket(af, socket.SOCK_STREAM) as s:
red47.conectar(s, direccion, fin)
for byte in red47.pedido(11, 31, 999):
red47.enviar(s, bytes([byte]), fin)
s.shutdown(socket.SHUT_WR)
f = red47.recibir(s, fin)
red47.exigir_eof(s, fin)
red47.validar_respuesta(f, 999)
if f[1] != 0 or f[3] != (42).to_bytes(8, "big"):
raise ValueError("respuesta fragmentada incorrecta")
def main():
p = argparse.ArgumentParser()
p.add_argument("servicio", type=Path)
a = p.parse_args()
procesos = []
try:
servicio = subprocess.Popen([str(a.servicio.resolve(strict=True))],
stdout=subprocess.PIPE, start_new_session=True)
procesos.append(servicio)
m = re.fullmatch(rb"SVC47 listo pid=([0-9]+) socket=(\S+)\n", anuncio(servicio))
if m is None or int(m[1]) != servicio.pid:
raise ValueError("anuncio de servicio incompatible")
ruta = os.fsdecode(m[2])
script = Path(__file__).resolve().with_name("red47.py")
puente = subprocess.Popen([sys.executable, str(script), "puente", ruta],
stdout=subprocess.PIPE, start_new_session=True)
procesos.append(puente)
m = re.fullmatch(rb"PTE47 listo pid=([0-9]+) puerto=([0-9]+)\n", anuncio(puente))
if m is None or int(m[1]) != puente.pid:
raise ValueError("anuncio de puente incompatible")
puerto = int(m[2])
pares = [(0, 0), (40, 2), (4294967295, 0), (4294967295, 4294967295)]
ident = 1
for familia, destino in [("unix", ruta), ("tcp", puerto)]:
for x, y in pares:
valor = red47.consultar(familia, destino, x, y, ident)
if valor != x + y:
raise ValueError("resultado incorrecto")
ident += 1
fragmentado(familia, destino)
for proceso in reversed(procesos):
proceso.terminate()
if proceso.wait(timeout=4) != 0:
raise ValueError("parada no exitosa")
if Path(ruta).exists() or Path(ruta).parent.exists():
raise ValueError("recursos Unix sin retirar")
print("8 consultas y 2 envios fragmentados verificados")
print("Unix y TCP: resultados, ID y EOF correctos; procesos recogidos")
finally:
for proceso in reversed(procesos):
terminar(proceso)
if __name__ == "__main__":
main()python3 probar47.py ./servicio47Los pares incluyen cero, una suma ordinaria y los máximos uint32. Cada respuesta debe corresponder al ID enviado y tener el valor esperado. La igualdad entre recorridos comprueba el resultado de aplicación; no significa igualdad de latencia ni de identidad del interlocutor.
El controlador crea un grupo de procesos separado para cada participante y solo termina esos grupos si la limpieza cooperativa falla. Un SIGKILL de emergencia no ejecuta la retirada del nombre Unix y puede dejar el directorio privado para inspección. La prueba comprueba la retirada en el cierre normal.
La salida estándar contiene únicamente anuncios y resultados de la prueba; los errores del puente van a stderr. El controlador no captura una tubería de errores sin drenarla, lo que evita introducir un bloqueo por registros durante una prueba fallida.
11. Resultados desconocidos, reintentos y disponibilidad
| Fallo | Qué puede saberse | Qué no debe suponerse |
|---|---|---|
| No existe la ruta Unix. | Falló la conexión a ese endpoint en ese momento. | Que ningún servicio equivalente esté disponible por otra ruta. |
| El puente no logra conectar al backend. | No obtuvo una sesión para ese intento. | Que deba mantener infinitamente al cliente esperando. |
| El cliente pierde conexión después de enviar. | No obtuvo una respuesta válida. | Que el servicio no ejecutó la operación. |
| Respuesta con otro ID. | La respuesta no corresponde al intento esperado. | Que un cuerpo con suma correcta la haga aceptable. |
| Vence el plazo durante recepción. | Se agotó el presupuesto de espera de ese participante. | Que se haya cancelado el trabajo remoto. |
La suma del laboratorio no modifica estado, por lo que repetirla tiene el mismo resultado. Una operación con efectos necesita una identidad de operación estable y una política de deduplicación que sobreviva al fallo requerido. El ID de trama que cambia en cada intento no proporciona esa garantía.
Los reintentos también consumen capacidad. Si cada servicio de una cadena reintenta tres veces, los intentos hacia la última dependencia pueden multiplicarse. Debe existir un presupuesto de reintentos, un plazo total y una única capa responsable de la política.
Una política puede separar errores transitorios de incompatibilidades permanentes. Una versión inválida no se corrige conectando diez veces más. Una dependencia saturada puede empeorar si todos los clientes reintentan sin espera ni límite.
El puente no reintenta automáticamente. Una extensión con circuit breaker podría dejar de enviar temporalmente a una dependencia que falla, con reglas de reapertura y pruebas limitadas. Ese mecanismo reduce presión; no recupera respuestas perdidas ni convierte la operación en idempotente.
El tema 43 desarrolla el resultado desconocido y la diferencia entre identificar intentos e identificar operaciones. El tema 46 muestra por qué una confirmación de ejecución tampoco implica durabilidad sin un protocolo de almacenamiento.
12. Contrapresión y límites por dependencia
El puente agrega una cola y una capacidad de ejecución propias. En este programa es secuencial: un cliente que mantiene una solicitud incompleta ocupa su única ranura hasta el plazo o la desconexión. El servicio C también es secuencial y puede tener otras conexiones esperando.
connect exitoso no significa que la aplicación ya haya leído. Una conexión puede estar pendiente en listen. El plazo del puente empieza al aceptar y no cubre el tiempo anterior en backlog; el cliente conserva su propio límite desde antes de conectar.
| Recurso | Límite del ejemplo | Extensión con concurrencia |
|---|---|---|
| Cuerpo de trama. | 64 bytes. | Mantener un máximo por mensaje y un presupuesto global de memoria. |
| Sesión del servicio. | Una activa, tres segundos. | Estado independiente, plazo y buffer por sesión. |
| Sesión del puente. | Una activa, 2,5 segundos. | Límite de solicitudes simultáneas por backend. |
| Conexiones pendientes. | Colas de escucha finitas. | Admisión y rechazo explícitos; no depender solo del backlog. |
| Reintentos. | Ninguno automático. | Presupuesto total y política por clase de fallo. |
Usar un hilo por cliente sin límite trasladaría la saturación a hilos, descriptores y memoria. Un pool acotado o un bucle de eventos permite controlar concurrencia, pero todavía necesita presupuestar clientes activos, conexiones a dependencias y respuestas pendientes.
Un servicio puede reservar cupos separados para dependencias distintas, de modo que una caída no consuma todas las ranuras. Este aislamiento de capacidad requiere límites reales, no solo etiquetas en registros. También puede haber colas distintas para trabajo breve y trabajo costoso.
El modo secuencial del laboratorio permite verificar el contrato; no representa una recomendación universal de implementación. Antes de aumentar concurrencia hay que hacer que cada sesión sea propietaria de sus desplazamientos, buffers, identidad y presupuesto.
13. Evolucionar protocolos y conexiones
La versión no es decorativa: permite rechazar un contrato que no se comprende. Si una versión nueva cambia el significado de un campo, el receptor no debe reinterpretarlo como si fuera la antigua solo porque la cabecera tenga el mismo tamaño.
El campo reservado se exige cero para detectar usos incompatibles. Una extensión necesita definir si negocia capacidades, agrega tipos de mensaje o cambia la versión. También debe conservar límites y reglas de error verificables.
Un ID correlaciona una respuesta con una solicitud dentro del alcance elegido. Si se reutilizan conexiones y hay varias solicitudes en vuelo, se necesita una tabla de pendientes, límites, unicidad entre solicitudes activas y tratamiento de respuestas tardías. El ejemplo evita esa complejidad con una conexión por consulta.
Un pool de conexiones reduce establecimiento, pero incorpora salud, expiración y referencias a instancias antiguas. Que cambie el nombre publicado de un servicio no mueve una conexión ya establecida a la nueva instancia. Hay que definir cómo drenar las antiguas y cuándo renovar el pool.
El descubrimiento puede basarse en una ruta de configuración, un nombre de servicio o un registro. El nombre indica dónde intentar, no garantiza preparación ni compatibilidad. Arranque confirmado, salud y versión siguen siendo observaciones distintas.
Para eventos asíncronos, un productor puede aceptar una confirmación de encolado en lugar de esperar el resultado final. Eso cambia el contrato: es necesario distinguir entrega, procesamiento y efectos confirmados. Sustituir un socket por una cola no elimina la necesidad de esas definiciones.
14. Contenedores, rutas y comunicación remota
Dos procesos sobre el mismo equipo físico no necesariamente ven las mismas rutas ni los mismos recursos de red. Un socket Unix con nombre necesita una ruta accesible para ambos y permisos compatibles; montar una ruta compartida no proporciona automáticamente autorización de aplicación.
Los espacios de nombres de red separan recursos como puertos y pilas de protocolo; en Linux también aíslan el espacio de nombres Unix abstracto. Estas reglas se documentan en network_namespaces(7). Los sockets Unix con ruta también dependen de la vista del sistema de archivos y del control de acceso.
127.0.0.1 significa loopback dentro del ámbito de red del proceso. No debe suponerse que un contenedor alcanza el loopback de otro contenedor o el del host usando esa misma dirección. El endpoint de este ejercicio funciona cuando los participantes comparten el ámbito apropiado.
Las credenciales vistas por un proceso también dependen del contexto de usuarios. Comparar UIDs numéricos exige entender la política de despliegue y los espacios de nombres, no copiar un número de una captura tomada en otro ámbito.
| Al cruzar máquinas | Decisión adicional |
|---|---|
| Endpoint. | Dirección, puerto, descubrimiento y actualización de instancias. |
| Identidad. | Autenticación verificable del servicio y del cliente cuando corresponda. |
| Confidencialidad e integridad. | Protección del transporte, validación de certificados y gestión de secretos. |
| Tiempo. | Presupuesto para resolución, conexión, negociación segura y aplicación. |
| Fallo. | Particiones, respuestas tardías, reintentos y resultados desconocidos. |
El puente del laboratorio no resuelve esas decisiones por escuchar TCP. Su función es mostrar que el protocolo puede conservarse al cambiar el transporte, mientras la identidad y la operación del servicio requieren políticas diferentes.
15. Simular un presupuesto de extremo a extremo
Este modelo descuenta cuatro costos del mismo presupuesto inicial. No reinicia el reloj al cambiar de etapa. Los valores son didácticos, no mediciones. Puedes provocar una pérdida de conexión para ver cuándo el cliente puede quedar sin saber si la operación terminó.
Etapa—
Tiempo consumido / restante—
Conocimiento del cliente—
Estado de la consulta—
—
Las etapas se ejecutan en orden y los valores se congelan al iniciar. En la etapa de envío puede haberse transmitido una solicitud aunque se pierda la conexión antes de terminar el recorrido. El modelo conserva esa incertidumbre; no afirma que un timeout haya deshecho trabajo remoto.
El simulador representa un presupuesto global. El laboratorio tiene plazos locales y no propaga el presupuesto del cliente en su versión 1. Comparar ambos ayuda a identificar qué campo y qué política faltarían para construir esa propagación.
16. Observar el recorrido sin confundir identidades
servicio=12345 # reemplazar
puente=12346 # reemplazar
ps -o pid,ppid,stat,wchan:24,cmd -p "$servicio,$puente"
lsof -nP -a -p "$servicio,$puente" -U
ss -xlnp
ss -tlnpLa escucha TCP pertenece al puente; la escucha Unix, al servicio. Los conectados son recursos distintos. Una consulta TCP genera además una conexión Unix nueva y no comparte el mismo descriptor ni la misma identidad de interlocutor.
ensayo=$(mktemp -d)
strace -ff -tt -T -yy -s 64 -o "$ensayo/traza" -e trace=socket,bind,listen,accept4,getsockopt,poll,signalfd4,recvfrom,sendto,close,unlink,rmdir ./servicio47Consulta la ruta de esa ejecución directamente y después a través del puente. Relaciona los bytes de ID con la trama y el getsockopt de credenciales con el interlocutor inmediato. No deduzcas la identidad del cliente TCP a partir de las credenciales locales del puente.
Un registro útil incorpora servicio, instancia, ID, operación, fase y duración, con un tamaño acotado. No necesita incluir el cuerpo completo ni secretos. El ID ayuda a reconstruir un recorrido; para cadenas con varios servicios puede agregarse un contexto de trazado con una política de propagación explícita.
El ID tampoco debe usarse sin límite como etiqueta de una métrica agregada: una serie distinta por cada solicitud puede hacer crecer enormemente la cardinalidad. Conserva identidad individual en trazas o registros y define dimensiones acotadas para contadores y distribuciones.
Las herramientas muestran el estado de un ámbito y un instante. El tema 44 explica cómo contrastar esas capturas y por qué los tiempos de una ejecución instrumentada no son una medición transparente de rendimiento.
17. Pruebas de protocolo y fallos
| Ensayo | Resultado esperado | Qué comprueba |
|---|---|---|
| Unix y TCP con cero, 40+2 y máximos uint32. | Mismo uint64, ID correcto y EOF. | Contrato y serialización independientes del recorrido. |
| Enviar cabecera y cuerpo byte a byte. | Respuesta íntegra si se completa dentro del plazo. | Framing sin depender de límites de send. |
| recv y send reales de un byte con EINTR. | Las mismas consultas siguen funcionando. | Desplazamientos y reintentos. |
| Marca, versión, reservado, estado de solicitud o ID inválidos. | Sesión cerrada sin éxito. | Validación de cabecera. |
| Longitud declarada superior a 64. | Rechazo sin reservar ni leer ese cuerpo completo. | Límite antes del consumo de memoria. |
| Cuerpo corto seguido de EOF. | Rechazo por truncamiento. | EOF no sustituye los bytes pendientes. |
| Bytes después de la única solicitud. | Rechazo de sesión. | Contrato de una trama por conexión. |
| SUMAR con longitud válida globalmente pero distinta de ocho. | El servicio directo responde estado 1. | Validación semántica del cuerpo. |
| Operación desconocida con cabecera válida. | El servicio directo responde estado 2. | Error de aplicación separado del transporte. |
| Backend de prueba devuelve otro ID, tamaño o suma. | Puente o cliente rechaza la respuesta. | No aceptar solo porque llegaron bytes. |
| Servicio detenido o retirado tras arrancar el puente. | Falla la consulta dentro de su presupuesto; el puente no inventa éxito. | Límites de dependencia. |
| SIGTERM con un cliente que no completa la trama. | El servicio termina y retira sus recursos. | Control observado durante espera de datos. |
Hacer deterministas las pruebas sensibles
El envío de un byte por llamada no garantiza que el receptor lea un byte por llamada. Para probar lecturas y escrituras parciales de forma controlada, limita las operaciones reales del receptor o usa un adaptador de prueba que preserve la semántica. Introducir EINTR significa retornar -1 sin declarar bytes ficticios.
Para una dependencia lenta, un backend de prueba puede aceptar y anunciar ese hecho por un pipe antes de esperar una compuerta. El controlador inicia entonces la comprobación de timeout. Así se diferencia una conexión no aceptada de una operación que ya llegó a una instancia.
Prueba también que un cliente malformado no derriba la escucha: después de cada rechazo, envía otra consulta válida. Mide la finalización con tolerancia para planificación; no exijas un instante exacto de milisegundo en un sistema compartido.
Todos los procesos de prueba deben estar inventariados. Si falla una aserción, termina solo sus grupos y recoge los procesos lanzados. No señales un PID copiado de otra ejecución ni borres sockets por un patrón general.
18. Errores frecuentes y decisiones de arquitectura
| Error | Consecuencia | Regla de diseño |
|---|---|---|
| Suponer que local equivale a infalible. | No se trata caída, truncamiento o saturación. | Contrato de fallo en cada límite de proceso. |
| Enviar structs nativas como protocolo. | Dependencia de padding, tamaños y endianess. | Formato explícito y versionado. |
| Reiniciar timeout en cada fragmento. | Un interlocutor lento prolonga la sesión. | Plazo absoluto por operación local. |
| Confundir UID del puente con el cliente remoto. | Se autoriza con una identidad equivocada. | Autenticación y delegación explícitas. |
| Tratar ID de trama como deduplicación durable. | Se duplican efectos al reintentar. | Identidad de operación y registro bajo el contrato requerido. |
| Reintentar en todas las capas. | Se multiplican intentos hacia la dependencia caída. | Una política con presupuesto y responsable. |
| Aceptar una respuesta solo por tamaño. | Se mezcla identidad, operación o versión. | Validación estructural y semántica. |
| Suponer que loopback cruza contenedores. | Se consulta otro ámbito o no hay escucha. | Identificar espacios de nombres y endpoint real. |
| Crear concurrencia ilimitada en el puente. | Se agotan descriptores y memoria. | Cupos, colas y límites por dependencia. |
| Exponer el ejemplo TCP sin seguridad adicional. | Se amplía acceso sin identidad ni protección suficientes. | Diseñar el despliegue y el transporte seguro. |
Una separación útil mantiene un contrato claro y evita llamadas excesivamente pequeñas entre servicios. Si cada operación simple necesita decenas de viajes, conviene revisar responsabilidades, agregación de solicitudes y localización del estado antes de buscar un transporte más rápido.
El puente agrega un salto, otra instancia y otra posibilidad de saturación. Puede ser útil para adaptar un límite, pero no es gratuito. Las mediciones deben incluir el recorrido completo, respuestas válidas y los recursos de todos los participantes.
19. Resumen, repaso y práctica
Los sockets Unix conectan servicios del mismo host bajo una política de rutas y credenciales. TCP permite construir comunicación de red, pero conserva las necesidades de framing, límites e identidad de solicitud y agrega decisiones de seguridad y despliegue. Un puente debe validar, limitar y preservar el contrato entre ambos lados.
- Contrato: versión, operación, ID, longitud y semántica de error.
- Identidad: el interlocutor inmediato puede ser un puente, no el cliente original.
- Tiempo: consumir un presupuesto no demuestra cancelación remota.
- Capacidad: cada salto necesita límites de concurrencia, cola y memoria.
- Fallo: perder una respuesta puede dejar desconocido un resultado ejecutado.
Preguntas de repaso
1. ¿Por qué un servicio local necesita protocolo de fallo?
Porque el otro proceso puede caer, desconectarse, saturarse o responder parcialmente, aunque comparta el host.
2. ¿Una ruta Unix puede identificar un servicio de otra máquina?
No. Ese endpoint corresponde al ámbito local apropiado. La comunicación remota necesita un transporte de red.
3. ¿TCP conserva límites entre mensajes?
No. Es un flujo; el protocolo debe reconstruir cabecera, longitud y cuerpo.
4. ¿Por qué la suma se devuelve como uint64?
La suma de dos uint32 puede exceder 4294967295 y llegar a 8589934590.
5. ¿Qué identifica el ID de la cabecera?
Permite relacionar respuesta y solicitud. No autentica al cliente ni define deduplicación durable.
6. ¿Para qué se exige EOF tras la solicitud?
Este contrato admite una única trama por conexión; shutdown de escritura confirma que no se enviarán bytes adicionales.
7. ¿A quién identifica SO_PEERCRED tras el puente?
Al interlocutor Unix inmediato: el proceso del puente. No al cliente TCP original.
8. ¿Un timeout nuevo por etapa conserva un presupuesto global?
No. Puede extender la duración total. Hay que descontar tiempo consumido y propagar la política entre saltos.
9. ¿El protocolo del ejemplo propaga el plazo del cliente?
No. Cliente, puente y servicio tienen límites locales. El simulador muestra la política global que requeriría una extensión.
10. ¿Cerrar una conexión revierte efectos?
No. El servicio pudo ejecutar antes de observar el cierre. Este ejemplo calcula una suma sin efectos externos.
11. ¿Por qué no se reintenta automáticamente desde el puente?
Se preserva la incertidumbre y se evita duplicar políticas. Un sistema con reintentos necesita clase de error, presupuesto y semántica de operación.
12. ¿Conectar significa que el servicio ya está procesando?
No necesariamente. Puede haber una conexión pendiente en la cola de escucha.
13. ¿127.0.0.1 representa siempre al host físico?
No. Es loopback en el ámbito de red del proceso; un contenedor puede tener otro ámbito.
14. ¿Qué agrega un pool de conexiones?
Reduce establecimientos, pero necesita salud, límites, expiración, correlación y drenaje de instancias antiguas.
15. ¿El puente TCP ya es un servicio remoto seguro?
No. El laboratorio solo escucha loopback y no implementa autenticación remota ni TLS.
Para practicar y ampliar
- Dibuja recursos e identidades en el recorrido directo y en el recorrido con puente.
- Ejecuta ambos recorridos con los valores límite y conserva resultados verificables.
- Fuerza transferencias reales de un byte y errores EINTR.
- Construye una trama de cada clase inválida y comprueba que la siguiente consulta válida funciona.
- Haz que un backend de prueba devuelva un ID distinto y verifica el rechazo.
- Detén el servicio mientras el puente está activo y comprueba el límite de espera.
- Agrega un presupuesto restante al protocolo con una nueva versión y límites de política.
- Diseña una clave de operación para una acción con efectos, separada del ID de intento.
- Propón cupos por backend y una política de rechazo al agotar capacidad.
- Diseña el drenaje de un pool cuando cambia la instancia publicada.
- Define qué identidad y permisos debería verificar un despliegue entre máquinas.
- Compara latencia directa y por puente conservando validación y alcance de medición.
El tema 48 compara y combina mecanismos según volumen, estructura del dato, aislamiento, portabilidad y sincronización. Reunirá las decisiones de los laboratorios en criterios para elegir una arquitectura.