<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Gonzalo López</title>
    <description>The latest articles on DEV Community by Gonzalo López (@gonzalo_lpez_18346c27391).</description>
    <link>https://dev.to/gonzalo_lpez_18346c27391</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4184891%2F7a220047-8518-486c-ac20-0bf80d7c5480.jpg</url>
      <title>DEV Community: Gonzalo López</title>
      <link>https://dev.to/gonzalo_lpez_18346c27391</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/gonzalo_lpez_18346c27391"/>
    <language>en</language>
    <item>
      <title>laravel 13 y el fin del boilerplate en las transferencias de archivos</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Mon, 16 Nov 2026 15:31:42 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/laravel-13-y-el-fin-del-boilerplate-en-las-transferencias-de-archivos-1i4i</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/laravel-13-y-el-fin-del-boilerplate-en-las-transferencias-de-archivos-1i4i</guid>
      <description>&lt;h1&gt;
  
  
  laravel 13 y el fin del boilerplate en las transferencias de archivos
&lt;/h1&gt;

&lt;p&gt;Uno de los cambios más elegantes que trae Laravel 13 en el sistema de archivos es la simplificación radical de las transferencias de archivos entre discos. Lo que antes requería varias líneas de código y un manejo manual de streams, ahora se resuelve con una sola llamada limpia y expresiva. ¿Qué es el “boilerplate”? El término boilerplate se refiere al código repetitivo, mecánico y de bajo valor que resulta necesario escribir de forma reiterada para realizar operaciones relativamente simples. Este tipo de código no aporta lógica de negocio, sino que actúa como soporte técnico indispensable para el funcionamiento de determinadas tareas. Ejemplos habituales de boilerplate Apertura y el cierre de archivos o streams. Verificaciones de existencia de recursos. Manejo genérico de excepciones. Conversiones o preparaciones de datos de carácter rutinario. Cuanto mayor sea la cantidad de boilerplate presente en un framework, mayor será el tiempo dedicado a detalles de bajo nivel en lugar de a la lógica principal de la aplicación. Versiones anteriores de Laravel En las versiones anteriores de Laravel 13, la copia de un archivo desde el disco local hacia AWS S3, u otro disco configurado, se realizaba de la siguiente manera:$stream = Storage::disk('local')-&amp;gt;readStream('report.csv'); Storage::disk('s3')-&amp;gt;writeStream('report.csv', $stream); fclose($stream); El proceso exigía Leer el archivo como stream. Escribirlo en el disco de destino. Cerrar manualmente el stream. Estas tres operaciones constituían un ejemplo claro de boilerplate: código necesario, propenso a errores si se omitía el cierre del recurso. Nuevo método en Laravel 13 A partir de Laravel 13, la misma operación se expresa de forma considerablemente más concisa:Storage::disk('local')-&amp;gt;copyToDisk('s3', 'report.csv'); Laravel se encarga internamente de la gestión del stream, de su cierre correcto y del manejo de posibles incidencias. Ventajas La incorporación del método "copyToDisk()! aporta varias mejoras relevantes: Reducción de la cantidad de código necesario, lo que disminuye la probabilidad de errores. Mayor legibilidad, al expresar de forma directa la intención de la operación. Facilidad de mantenimiento, ya que los detalles de implementación quedan centralizados en el framework. Incremento de la productividad al eliminar tareas repetitivas. Este tipo de refinamientos refuerza la filosofía de Laravel de reducir la fricción en el desarrollo y priorizar la claridad del código.&lt;/p&gt;

</description>
      <category>laravel</category>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>vulnerabilidades comunes en php</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Sat, 14 Nov 2026 16:56:23 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/vulnerabilidades-comunes-en-php-1hcf</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/vulnerabilidades-comunes-en-php-1hcf</guid>
      <description>&lt;h1&gt;
  
  
  vulnerabilidades comunes en php
&lt;/h1&gt;

&lt;p&gt;Las aplicaciones web construidas con PHP presentan una serie de vulnerabilidades recurrentes cuando no se aplican controles de seguridad adecuados. Estas fallas suelen originarse en el manejo incorrecto de datos de entrada, el uso de funciones peligrosas o configuraciones inseguras del entorno. A continuación se detallan las principales vulnerabilidades observadas en este tipo de desarrollos. Inyección SQL La inyección SQL se produce cuando se incorporan datos no validados directamente en consultas a la base de datos. Un ejemplo típico consiste en concatenar valores recibidos a través de parámetros de la URL o formularios dentro de una sentencia SQL. El uso de consultas preparadas mediante PDO o MySQLi constituye la principal medida de protección. Además, resulta conveniente limitar los privilegios de la cuenta de base de datos empleada por la aplicación. Cross-Site Scripting (XSS) Esta vulnerabilidad aparece cuando se genera salida HTML que incluye contenido controlado por el usuario sin el escape correspondiente. Puede manifestarse de forma reflejada, almacenada o basada en el DOM. La función "htmlspecialchars()" con los parámetros adecuados (ENT_QUOTES y charset UTF-8) permite neutralizar la mayoría de los casos. El empleo de políticas de Content Security Policy refuerza la protección. Cross-Site Request Forgery (CSRF) Los ataques CSRF explotan la confianza que el navegador deposita en las cookies de sesión de un usuario autenticado. De esta forma se pueden ejecutar acciones no autorizadas en nombre de la víctima. La generación de tokens únicos asociados a cada sesión y formulario, junto con la verificación de los encabezados Origin o Referer, reduce significativamente el riesgo. La configuración del atributo SameSite en las cookies de sesión aporta una capa adicional de defensa. Inclusión de archivos locales y remotos (LFI/RFI) Cuando se utilizan valores externos en funciones como "include", "require" o "file_get_contents()", existe la posibilidad de cargar archivos no previstos del sistema o de ubicaciones remotas. La práctica recomendada consiste en evitar por completo la inclusión dinámica basada en datos de entrada. En caso de resultar imprescindible, se deben aplicar listas blancas estrictas y validaciones con "realpath()" para confirmar que la ruta permanece dentro del directorio permitido. La directiva allow_url_include debe permanecer desactivada. Ejecución de código e inyección de comandos Funciones como "eval()", "system()", "exec()", "passthru()" o "shell_exec()" permiten la ejecución de código o comandos del sistema operativo cuando reciben datos no controlados. La eliminación de estas funciones del código y su deshabilitación mediante la directiva disable_functions en php.ini constituyen medidas prioritarias. Cuando su uso resulta inevitable, se requiere el empleo de "escapeshellarg()" y "escapeshellcmd()" junto con listas blancas. Subida de archivos insegura La ausencia de validaciones rigurosas en los mecanismos de carga de archivos puede permitir la subida de scripts PHP maliciosos que posteriormente se ejecutan en el servidor. Resulta necesario comprobar la extensión, el tipo MIME real y el contenido del archivo, almacenarlo fuera del document root con nombres aleatorios y evitar cualquier posibilidad de ejecución directa. Gestión insegura de sesiones y autenticación Problemas habituales incluyen identificadores de sesión predecibles, ausencia de regeneración del identificador tras el inicio de sesión y almacenamiento de contraseñas con algoritmos débiles. El uso de "password_hash()" y "password_verify()" (con bcrypt o Argon2), la llamada a "session_regenerate_id(true)" después de la autenticación y la correcta configuración de los flags HttpOnly, Secure y SameSite en las cookies de sesión mitigan estos riesgos. Deserialización insegura La función "unserialize()" aplicada a datos controlados por el usuario puede derivar en la ejecución de código arbitrario, especialmente cuando existen clases con métodos mágicos peligrosos. Se recomienda sustituir este mecanismo por "json_encode()" y "json_decode()". En caso de mantener el uso de "unserialize()", deben restringirse las clases permitidas. Exposición de información sensible y software desactualizado La visualización de errores detallados en entornos de producción, la accesibilidad de archivos de configuración o la presencia de versiones antiguas de PHP y dependencias constituyen vectores frecuentes de ataque. La configuración display_errors = Off, la protección de directorios sensibles y la actualización periódica del intérprete y las librerías reducen la superficie de exposición. Consideraciones generales La seguridad en aplicaciones PHP se basa en el principio de no confiar en ninguna entrada externa y en la aplicación de controles en múltiples capas. El mantenimiento actualizado del entorno, el uso de frameworks modernos que incorporan protecciones por defecto y la realización de revisiones periódicas de código contribuyen a minimizar la aparición de estas vulnerabilidades. &lt;/p&gt;

</description>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>aws s3: almacén de la nube</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Fri, 13 Nov 2026 15:28:30 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/aws-s3-almacen-de-la-nube-27gl</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/aws-s3-almacen-de-la-nube-27gl</guid>
      <description>&lt;h1&gt;
  
  
  aws s3: almacén de la nube
&lt;/h1&gt;

&lt;p&gt;S3 significa Simple Storage Service. Es el servicio de almacenamiento de objetos de Amazon Web Services, o AWS. A diferencia de un disco duro tradicional, donde organizas archivos en carpetas, S3 guarda todo como objetos dentro de buckets. Un bucket es como una gran caja con nombre único en todo el mundo. Un objeto es cualquier archivo que se suba, como una foto, un PDF, un video, un respaldo. Por qué S3 tiene tanto impacto La mayoría de las empresas grandes del mundo usan S3. Netflix almacena ahí gran parte de su contenido, Airbnb guarda fotos de alojamientos, bancos hacen respaldos críticos y miles de startups arrancan su infraestructura con él. ¿Por qué? Escalabilidad infinita: No hay que preocuparte por el espacio. S3 crece automáticamente según se necesite. Durabilidad: Amazon garantiza una durabilidad del 99.999999999%. Disponibilidad mundial: Los datos pueden estar en diferentes regiones del planeta. Si una zona falla, otra sigue funcionando. Se pagas solo por el uso: No hay costos fijos altos. Únicamente se paga por el almacenamiento y las transferencias que se realice. Seguridad de nivel empresarial: Se puede cifrar los datos, controlar quién accede y registrar cada movimiento. Es una de las plataformas más seguras del mercado. Cómo se usa Sitios web estáticos: Se puede alojar una página web completa, HTML, CSS, imágenes directamente en S3 a muy bajo coste. Respaldos y recuperación de desastres: Empresas guardan copias de seguridad diarias. Si algo se rompe, se recupera todo en minutos. Almacenamiento de medios: Fotos, videos, podcasts, PDF. Data lakes: Grandes volúmenes de datos sin procesar se acumulan ahí para luego analizarlos con herramientas de inteligencia artificial o big data. Entrega de contenido: Combinado con CloudFront, CDN de AWS, S3 sirve archivos a usuarios de todo el mundo con muy baja latencia. Las clases de almacenamiento No todos los datos se usan igual. Por eso S3 tiene diferentes “clases”: S3 Standard: Para archivos que se consultan frecuentemente. S3 Intelligent-Tiering: Mueve automáticamente los datos según su uso, ahorra dinero sin tener que hacer nada. S3 Glacier: Para archivos que no se usa casi nunca, como archivos históricos. Siendo mucho más barato. Ejemplo S3 con PHP&lt;/p&gt;

</description>
      <category>general</category>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>aws rds: la base de datos relacional gestionada en la nube</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Thu, 12 Nov 2026 16:12:13 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/aws-rds-la-base-de-datos-relacional-gestionada-en-la-nube-50ko</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/aws-rds-la-base-de-datos-relacional-gestionada-en-la-nube-50ko</guid>
      <description>&lt;h1&gt;
  
  
  aws rds: la base de datos relacional gestionada en la nube
&lt;/h1&gt;

&lt;p&gt;Amazon Relational Database Service, Amazon RDS, se ha consolidado como uno de los servicios más utilizados dentro del ecosistema de AWS. Su propuesta es clara y directa: facilitar el despliegue, la operación y el escalado de bases de datos relacionales en la nube, eliminando gran parte de las tareas administrativas tradicionales que consumen tiempo y recursos. Qué es Amazon RDS Amazon RDS es un servicio gestionado de bases de datos relacionales. En lugar de instalar, configurar y mantener un servidor de base de datos de forma manual, el servicio se encarga de gran parte de esas labores. El resultado es una capacidad de base de datos redimensionable, con costes predecibles y un alto nivel de automatización.El servicio ofrece acceso a motores de base de datos ampliamente conocidos y utilizados en la industria. Entre ellos se encuentran MySQL, PostgreSQL, MariaDB, Oracle Database, Microsoft SQL Server, IBM Db2 y Amazon Aurora, compatible con MySQL y PostgreSQL. Esta compatibilidad permite que aplicaciones y herramientas existentes funcionen con mínimos o ningún cambio de código. Ventajas La principal fortaleza de Amazon RDS reside en la automatización de tareas operativas. El servicio gestiona de forma automática el aprovisionamiento de infraestructura, la aplicación de parches de software, las copias de seguridad y la detección y recuperación ante fallos. Esta reducción de trabajo manual libera a los equipos técnicos para concentrarse en el desarrollo de aplicaciones y en la generación de valor para el negocio.Otro aspecto relevante es la flexibilidad de capacidad. Es posible ajustar los recursos de cómputo y almacenamiento según la demanda, sin interrupciones prolongadas. El modelo de precios se basa en el consumo real: no existen inversiones iniciales obligatorias y solo se paga por los recursos utilizados. Alta disponibilidad y escalabilidad Para cargas de producción, Amazon RDS incorpora despliegues Multi-AZ. En esta configuración se mantiene una réplica secundaria síncrona en una zona de disponibilidad distinta. Ante un fallo, el servicio realiza un basculamiento automático hacia la réplica, minimizando el tiempo de inactividad y evitando la pérdida de datos.Además, las réplicas de lectura permiten distribuir la carga de consultas de solo lectura. Esta capacidad resulta especialmente útil en aplicaciones con un volumen elevado de lecturas, ya que reduce la presión sobre la instancia principal y mejora el rendimiento global.El almacenamiento también escala de forma sencilla. Existen opciones de almacenamiento de propósito general y de IOPS provisionadas, diseñadas para adaptarse tanto a entornos de desarrollo como a cargas de producción con requisitos exigentes de rendimiento. Seguridad y control Amazon RDS integra controles de seguridad robustos. Las instancias se despliegan dentro de una VPC, lo que permite aislar el tráfico de red. El cifrado de datos en reposo y en tránsito, junto con la integración con AWS IAM y AWS KMS, refuerza la protección de la información. Las copias de seguridad automáticas y los snapshots manuales facilitan la recuperación ante incidentes. El impacto en las organizaciones La adopción de Amazon RDS suele traducirse en una reducción significativa del tiempo dedicado a tareas de administración de bases de datos. Estudios y casos de uso muestran mejoras en el coste total de propiedad, mayor agilidad en el despliegue de nuevos entornos y una mayor capacidad de respuesta ante picos de demanda.Al eliminar la complejidad operativa, las organizaciones pueden acelerar el ciclo de desarrollo, mejorar la fiabilidad de sus sistemas y destinar recursos humanos a iniciativas de mayor valor estratégico. En un entorno donde la velocidad y la resiliencia son diferenciadores competitivos, este cambio de enfoque resulta decisivo.&lt;/p&gt;

</description>
      <category>general</category>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>aws iam: el control central de identidades y permisos en la nube</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Wed, 11 Nov 2026 16:47:21 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/aws-iam-el-control-central-de-identidades-y-permisos-en-la-nube-7a0</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/aws-iam-el-control-central-de-identidades-y-permisos-en-la-nube-7a0</guid>
      <description>&lt;h1&gt;
  
  
  aws iam: el control central de identidades y permisos en la nube
&lt;/h1&gt;

&lt;p&gt;AWS Identity and Access Management, o IAM, es el servicio que gestiona quién puede hacer qué dentro de una cuenta de AWS. Actúa como el sistema de control de acceso de toda la plataforma: define identidades, establece permisos y determina bajo qué condiciones se pueden realizar acciones sobre los recursos.Sin un control adecuado de identidades y permisos, cualquier persona o servicio con acceso a la cuenta podría crear, modificar o eliminar recursos de forma no autorizada. IAM resuelve este problema al separar la autenticación de la autorización. Componentes principales de IAM IAM se organiza en torno a cuatro elementos básicos: Usuarios: identidades permanentes asociadas generalmente a personas. Grupos: conjuntos de usuarios que comparten los mismos permisos. Roles: identidades temporales que pueden ser asumidas por usuarios, aplicaciones o servicios de AWS. Políticas: documentos que definen los permisos concretos. Las políticas son el corazón del sistema. Se escriben en formato JSON y especifican las acciones permitidas o denegadas sobre determinados recursos. Una política puede adjuntarse directamente a un usuario, a un grupo o a un rol. Cómo funcionan las políticas Cada política contiene una o varias declaraciones. Cada declaración indica: El efecto (Allow o Deny). Las acciones permitidas o denegadas. Los recursos sobre los que se aplica. Condiciones opcionales, por ejemplo, restricción por dirección IP o por etiquetas. Ejemplos Política que permite solo la lectura de información de instancias EC2: { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "ec2:DescribeInstances", "ec2:DescribeTags" ], "Resource": "*" } ] } Esta política otorga visibilidad sin posibilidad de realizar cambios. En entornos reales se suele restringir aún más el alcance mediante ARNs específicos o condiciones adicionales. Ejemplo de una política que permite a un rol asumir permisos temporales: { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::123456789012:role/NombreDelRol" } ] } Principio de mínimo privilegio La práctica más importante en IAM consiste en conceder únicamente los permisos estrictamente necesarios para realizar una tarea. Otorgar permisos amplios, por ejemplo, acceso de administrador, aumenta el riesgo en caso de compromiso de credenciales. Los roles temporales, las políticas con condiciones y la revisión periódica de permisos ayudan a mantener este principio. Buenas prácticas generales Preferir roles frente a usuarios con claves de acceso de larga duración. Utilizar la autenticación multifactor, o MFA, en cuentas privilegiadas. Revisar de forma periódica las políticas y los accesos no utilizados. Aplicar el principio de mínimo privilegio desde el diseño inicial. Separar entornos (desarrollo, pruebas y producción) mediante cuentas distintas o unidades organizativas cuando sea posible. Roles en IAM Los roles en IAM son identidades temporales que permiten a personas, aplicaciones o servicios de AWS obtener permisos de forma segura durante un tiempo limitado. Diferencia clave con los usuariosz Un usuario IAM es una identidad permanente (normalmente asociada a una persona) que suele tener credenciales de larga duración, como usuario/contraseña o claves de acceso. Un rol IAM no tiene credenciales permanentes. En su lugar, se “asume” (se toma prestado) durante un periodo de tiempo y recibe credenciales temporales. &lt;/p&gt;

</description>
      <category>general</category>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>tutorial de políticas de aws iam</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Tue, 10 Nov 2026 18:42:06 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/tutorial-de-politicas-de-aws-iam-2an1</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/tutorial-de-politicas-de-aws-iam-2an1</guid>
      <description>&lt;h1&gt;
  
  
  tutorial de políticas de aws iam
&lt;/h1&gt;

&lt;p&gt;¿Qué es una política de IAM? Una política de IAM es un documento en formato JSON que define permisos. Cuando se asocia a una identidad, usuario, grupo o rol, o a un recurso, AWS la evalúa cada vez que se hace una solicitud y decide si se permite o se deniega la acción.Por defecto, todo está denegado. Solo se permite lo que explícitamente se autoriza. Tipos principales de políticas Tipo Se adjunta a ¿Otorga permisos? Notas importantes Identity-based Usuarios, grupos, roles Sí Las más comunes Resource-based Recursos (S3, SQS, KMS, Lambda, trust policy de roles…) Sí Incluye el elemento Principal Permissions boundary Usuario o rol No (solo limita) Define el máximo de permisos SCP (Service Control Policy) Cuentas/OUs de Organizations No (solo limita) Aplica a toda la organización RCP (Resource Control Policy) Recursos de Organizations No (solo limita) Control centralizado de recursos Session policies Sesión de AssumeRole / federación No (solo limita) Se pasan al asumir el rol VPC Endpoint policies VPC Endpoints No (filtran) Límite adicional de tráfico Las dos políticas que realmente otorgan permisos son: "Identity-based" y "Resource-based". Estructura de una política JSON { "Version": "2012-10-17", "Id": "PolicyOpcional", "Statement": [ { "Sid": "NombreDescriptivo", "Effect": "Allow", "Principal": { ... }, // Solo en resource-based "Action": [ "servicio:accion" ], "Resource": [ "arn:aws:..." ], "Condition": { ... } // Opcional } ] } Elementos principales Elemento Obligatorio Descripción Version Recomendado Siempre usa "2012-10-17" Statement Sí Array de uno o más statements Sid No Identificador legible del statement Effect Sí "Allow" o "Deny" Action Sí* Acciones permitidas/denegadas (s3:GetObject, ec2:&lt;em&gt;, etc.) NotAction Alternativa Todo excepto las acciones listadas Resource Sí&lt;/em&gt; ARNs de los recursos afectados NotResource Alternativa Todo excepto los recursos listados Principal Solo resource-based Quién puede realizar la acción Condition No Condiciones adicionales (IP, fecha, tags, MFA, etc.) Managed Policies vs Inline Policies Tipo Quién la gestiona Reutilizable Recomendado AWS managed AWS Sí Para empezar Customer managed Tú Sí Recomendado en producción Inline Tú No (1:1) Solo casos muy específicos La mejor práctica es usar siempre Customer Managed Policies. Lógica de evaluación Explicit Deny siempre gana (aunque haya un Allow). Si no hay Deny: Se evalúan identity-based + resource-based (unión en same-account). Luego se aplican los “techos”: Permissions Boundary, SCPs, RCPs y Session Policies (intersección). Si no hay ningún Allow → Implicit Deny. Cómo crear políticas Desde la consola, la web IAM → Policies → Create policy. Usar el Visual editor o pega JSON directamente. Validar con IAM Access Analyzer. Nombrar y crear. Adjuntar a usuarios/grupos/roles. Con AWS CLI aws iam create-policy \ --policy-name MiPoliticaS3 \ --policy-document file://politica.json Ejemplo de política (Customer Managed) { "Version": "2012-10-17", "Statement": [ { "Sid": "AllowListAndReadSpecificBucket", "Effect": "Allow", "Action": [ "s3:ListBucket", "s3:GetObject" ], "Resource": [ "arn:aws:s3:::mi-bucket-privado", "arn:aws:s3:::mi-bucket-privado/&lt;em&gt;" ], "Condition": { "IpAddress": { "aws:SourceIp": "203.0.113.0/24" } } } ] } Mejores prácticas Empiezat con permisosmínimos e ir añadiendo solo lo necesario. Evitar "&lt;/em&gt;" en Action y Resource siempre que sea posible. Usar condiciones, IP, MFA, tags, fecha, VPC, etc.. Usar variables de política, "${aws:username}", "${aws:PrincipalTag/Department}". Revisar regularmente con IAM Access Analyzer y Last Accessed information. Usar Permissions Boundaries para roles que crean otros roles. Preferir roles a usuarios de larga duración. No usar nunca la cuenta "root" para operaciones diarias. Herramientas imprescindibles IAM Policy Simulator: Prueba políticas antes de aplicarlas. IAM Access Analyzer: Detecta permisos excesivos y genera políticas desde CloudTrail. Access Advisor / Last Accessed: Ve qué permisos realmente se están usando. Policy Validator: Detecta errores de sintaxis y malas prácticas. . Ejemplo completo recomendado (rol de aplicación) { "Version": "2012-10-17", "Statement": [ { "Sid": "ReadWriteSpecificS3Prefix", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:PutObject", "s3:DeleteObject" ], "Resource": "arn:aws:s3:::mi-app-datos/prod/${aws:PrincipalTag/Environment}/&lt;em&gt;" }, { "Sid": "ListOnlyOwnPrefix", "Effect": "Allow", "Action": "s3:ListBucket", "Resource": "arn:aws:s3:::mi-app-datos", "Condition": { "StringLike": { "s3:prefix": ["prod/${aws:PrincipalTag/Environment}/&lt;/em&gt;"] } } }, { "Sid": "DenyAllOutsideRegion", "Effect": "Deny", "Action": "&lt;em&gt;", "Resource": "&lt;/em&gt;", "Condition": { "StringNotEquals": { "aws:RequestedRegion": "eu-west-1" } } } ] } &lt;/p&gt;

</description>
      <category>general</category>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>tutorial completo: aws lambda con bref y php</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Mon, 09 Nov 2026 17:48:10 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/tutorial-completo-aws-lambda-con-bref-y-php-em2</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/tutorial-completo-aws-lambda-con-bref-y-php-em2</guid>
      <description>&lt;h1&gt;
  
  
  tutorial completo: aws lambda con bref y php
&lt;/h1&gt;

&lt;p&gt;AWS Lambda es un servicio de serverless proporcionado por Amazon Web Services, AWS. que permite ejecutar código sin necesidad de aprovisionar, configurar ni administrar servidores. Requisitos previos Se necesitas tener instalado PHP 8.2+. Composer. Node.js, para Serverless Framework. Cuenta de AWS configurada. Instalar las herramientas globales: npm install -g serverless composer global require bref/bref # opcional Crear el proyecto base mkdir proyecto-lambda cd proyecto-lambda composer require bref/bref Crear el archivo "serverless.yml". Ejemplos Ejemplo 1: Un solo fichero PHP Estructura proyecto-lambda/ ├── index.php └── serverless.yml index.php &amp;lt;?php echo "¡Hola desde AWS Lambda! - " . date('Y-m-d H:i:s'); serverless.yml service: mi-proyecto-lambda provider: name: aws region: us-east-1 stage: dev plugins: - ./vendor/bref/bref functions: web: handler: index.php runtime: php-84-fpm events: - httpApi: '&lt;em&gt;' Desplegar serverless deploy Al terminar se mostrará dará una URL. Abrirla en el navegador y se mostrará en el navegador Ejemplo con dos funciones Ahora se quieren dos endpoints distintos: /fecha: muestra la fecha. /mensaje: muestra un mensaje. Estructura: ├── fecha.php ├── mensaje.php └── serverless.yml fecha.php header('Content-Type: application/json'); echo json_encode([ 'fecha' =&amp;gt; date('Y-m-d H:i:s'), 'timestamp' =&amp;gt; time() ]); mensaje.php header('Content-Type: application/json'); echo json_encode([ 'mensaje' =&amp;gt; '¡Hola desde la segunda función Lambda!', 'php_version' =&amp;gt; PHP_VERSION ]); serverless.yml service: proyecto-lambda provider: name: aws region: us-east-1 plugins: - ./vendor/bref/bref functions: fecha: handler: fecha.php runtime: php-84-fpm events: - httpApi: 'GET /fecha' mensaje: handler: mensaje.php runtime: php-84-fpm events: - httpApi: 'GET /mensaje' Desplegar y acceder serverless deploy Las urls serán: &lt;a href="https://xxxxx.execute-api.us-east-1.amazonaws.com/fecha" rel="noopener noreferrer"&gt;https://xxxxx.execute-api.us-east-1.amazonaws.com/fecha&lt;/a&gt; &lt;a href="https://xxxxx.execute-api.us-east-1.amazonaws.com/mensaje" rel="noopener noreferrer"&gt;https://xxxxx.execute-api.us-east-1.amazonaws.com/mensaje&lt;/a&gt; Proyecto completo Estructura mi-api/ ├── public/ │ └── index.php ← punto de entrada ├── src/ │ ├── Controllers/ │ │ ├── FechaController.php │ │ └── MensajeController.php │ └── Router.php ├── composer.json └── serverless.yml public/index.php require &lt;strong&gt;DIR&lt;/strong&gt; . '/../vendor/autoload.php'; use App\Router; $router = new Router(); $router-&amp;gt;dispatch($_SERVER['REQUEST_URI']); src/Router.phpphp &amp;lt;?php namespace App; class Router { public function dispatch(string $uri) { $path = parse_url($uri, PHP_URL_PATH); match ($path) { '/fecha' =&amp;gt; (new Controllers\FechaController())-&amp;gt;handle(), '/mensaje' =&amp;gt; (new Controllers\MensajeController())-&amp;gt;handle(), default =&amp;gt; $this-&amp;gt;notFound() }; } private function notFound() { http_response_code(404); echo json_encode(['error' =&amp;gt; 'Ruta no encontrada']); } } src/Controllers/FechaController.php namespace App\Controllers; class FechaController { public function handle() { header('Content-Type: application/json'); echo json_encode([ 'fecha' =&amp;gt; date('Y-m-d H:i:s'), 'timezone' =&amp;gt; date_default_timezone_get() ]); } } src/Controllers/MensajeController.phpphp namespace App\Controllers; class MensajeController { public function handle() { header('Content-Type: application/json'); echo json_encode([ 'mensaje' =&amp;gt; 'Bienvenido a mi API en Lambda', 'autor' =&amp;gt; 'Tu Nombre' ]); } } serverless.yml service: mi-api provider: name: aws region: us-east-1 environment: APP_ENV: production plugins: - ./vendor/bref/bref functions: api: handler: public/index.php runtime: php-84-fpm timeout: 28 events: - httpApi: '&lt;/em&gt;' package: patterns: - '!tests/&lt;strong&gt;' - '!.git/&lt;/strong&gt;' - '!node_modules/**' Ejemplo con parámetros saludo.php // Obtenemos los parámetros de la URL $nombre = $_GET['nombre'] ?? 'Invitado'; $edad = $_GET['edad'] ?? null; // Respuesta header('Content-Type: application/json'); echo json_encode([ 'mensaje' =&amp;gt; "¡Hola $nombre!", 'edad' =&amp;gt; $edad, 'fecha' =&amp;gt; date('Y-m-d H:i:s') ], JSON_UNESCAPED_UNICODE); serverless.yml service: LambdaService provider: name: aws region: us-east-1 plugins: - ./vendor/bref/bref functions: saludo: handler: saludo.php runtime: php-84-fpm events: - httpApi: 'GET /saludo' Deplegar serverless deploy Abrir la siguiente url en el navegador: &lt;a href="https://xxxxx.execute-api.us-east-1.amazonaws.com/saludo?nombre=Carlos&amp;amp;edad=28" rel="noopener noreferrer"&gt;https://xxxxx.execute-api.us-east-1.amazonaws.com/saludo?nombre=Carlos&amp;amp;edad=28&lt;/a&gt;&lt;/p&gt;

</description>
      <category>general</category>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>comandos más usados de NPM</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Sat, 07 Nov 2026 18:32:08 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/comandos-mas-usados-de-npm-23jk</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/comandos-mas-usados-de-npm-23jk</guid>
      <description>&lt;h1&gt;
  
  
  comandos más usados de NPM
&lt;/h1&gt;

&lt;p&gt;Configuración "npm init": Crea el archivo "package.json" del proyecto. "npm init -y": Genera el "package.json" con los valores predeterminados. "npm --version": Muestra la versión instalada de npm. "node --version": Muestra la versión instalada de NodeJS. Instalar paquetes "npm install": Instala las dependencias del proyecto. "npm install ": Añade una dependencia al proyecto. "npm install -D ": Añade una dependencia de desarrollo. "npm install -g ": Instala un paquete de forma global. "npm uninstall ": Elimina un paquete del proyecto. Ejecutar scripts "npm run": Lista los scripts disponibles en el "package.json". "npm run dev": Ejecuta el script denominado «dev». "npm start": Ejecuta el script denominado «start». "npm test": Ejecuta el script denominado «test». Actualizar e inspeccionar "npm outdated": Comprueba si existen paquetes desactualizados. "npm update": Actualiza los paquetes respetando los rangos de versión definidos. "npm ls": Lista los paquetes instalados en el proyecto. "npm explain ": Explica el motivo por el que se encuentra instalado un paquete. Seguridad e instalación limpia "npm audit": Busca vulnerabilidades conocidas en las dependencias. "npm audit fix": Aplica las correcciones de seguridad compatibles. "npm ci": Realiza una instalación limpia a partir del archivo de bloqueo. Ejecutar paquetes "npx ": Ejecuta el ejecutable de un paquete. "npm exec -- ": Ejecuta un comando perteneciente a un paquete. &lt;/p&gt;

</description>
      <category>node</category>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>roadrunner: el servidor php de alto rendimiento</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Fri, 06 Nov 2026 16:35:28 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/roadrunner-el-servidor-php-de-alto-rendimiento-4c8g</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/roadrunner-el-servidor-php-de-alto-rendimiento-4c8g</guid>
      <description>&lt;h1&gt;
  
  
  roadrunner: el servidor php de alto rendimiento
&lt;/h1&gt;

&lt;p&gt;RoadRunner es un servidor de aplicaciones PHP de alto rendimiento, escrito en Go y potenciado por plugins. Actúa como process manager y load balancer, manteniendo un pool de workers PHP persistentes en memoria.En lugar de arrancar PHP desde cero en cada request, como hace FPM, los workers se inician una sola vez y reutilizan el estado de la aplicación entre peticiones. El resultado es un salto enorme en rendimiento, menor latencia y un uso más eficiente de recursos. Características principales Servidor HTTP/1.1, HTTP/2, HTTP/3 y FastCGI compatible con PSR-7/PSR-17 Sistema de colas con drivers para RabbitMQ, Kafka, SQS, Beanstalk, NATS… Soporte nativo para gRPC, workflows y WebSockets Supervisión automática de workers Métricas Prometheus, OpenTelemetry y hot-reload Arquitectura de plugins extremadamente flexible Instalación rápida La forma más sencilla de empezar es usando Composer: # Dependencias PHP composer require spiral/roadrunner-http nyholm/psr7 # CLI para descargar el binario de RoadRunner composer require spiral/roadrunner-cli --dev # Descargar el binario compatible con tu sistema vendor/bin/rr get También se puede descargar el binario precompilado desde GitHub Releases o usar la imagen oficial de Docker "ghcr.io/roadrunner-server/roadrunner". La extensión sockets de PHP debe estar activada. Configuración básica Es necesario crear un archivo llamado ".rr.yaml" en la raíz del proyecto: version: "3" server: command: "php psr-worker.php" # Opcional: límites de supervisión # relay: pipes # relay_timeout: 60s http: address: 0.0.0.0:8080 # middleware: ["gzip", "headers"] # max_request_size: 256 logs: level: error # en desarrollo puedes poner debug mode: production Worker simple en PHP Crear el archivo "psr-worker.php": require &lt;strong&gt;DIR&lt;/strong&gt; . '/vendor/autoload.php'; use Nyholm\Psr7\Response; use Nyholm\Psr7\Factory\Psr17Factory; use Spiral\RoadRunner\Worker; use Spiral\RoadRunner\Http\PSR7Worker; $worker = Worker::create(); $factory = new Psr17Factory(); $psr7 = new PSR7Worker($worker, $factory, $factory, $factory); while (true) { try { $request = $psr7-&amp;gt;waitRequest(); if ($request === null) { break; // RoadRunner se está apagando } } catch (\Throwable $e) { $psr7-&amp;gt;respond(new Response(400)); continue; } try { // Aquí va tu aplicación (Laravel, Symfony, Slim, PHP puro…) $psr7-&amp;gt;respond(new Response(200, [], '¡Hola desde RoadRunner!')); } catch (\Throwable $e) { $psr7-&amp;gt;respond(new Response(500, [], 'Error interno')); // Opcional: notificar error al supervisor // $psr7-&amp;gt;getWorker()-&amp;gt;error((string) $e); } } Arrancar el servidor: ./rr serve Con esto el servidor PHP de alto rendimiento escuchando en el puerto 8080 ya está listo. RoadRunner vs FrankenPHP vs Swoole Aspecto RoadRunner FrankenPHP Swoole / OpenSwoole Lenguaje base Go C (basado en Caddy) C (extensión PHP) Modelo Workers persistentes aislados Workers + modo clásico Coroutines + event loop Estabilidad Muy alta (aislamiento fuerte) Alta Media-alta (cuidado con estado) Colas y plugins Excelente (Jobs, Temporal…) Más limitado Bueno pero menos maduro Facilidad de despliegue Binario + YAML Un solo binario Extensión PECL Mejor para Apps empresariales, migraciones, estabilidad Contenedores, simplicidad Real-time, I/O intensivo RoadRunner destaca especialmente por su estabilidad y por el modelo de aislamiento de procesos: si un worker se corrompe o tiene un memory leak, el resto sigue funcionando y RoadRunner lo reinicia de forma controlada. Ventajas reales Eliminación casi total del tiempo de bootstrap Mucho mejor rendimiento en aplicaciones con frameworks pesados Supervisión profesional de workers Sistema de colas integrado muy potente Ideal para microservicios, APIs de alto tráfico y aplicaciones empresariales Configuración clara y versionable en YAML &lt;/p&gt;

</description>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>ejemplo práctico de orquestación en IA con php</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Sun, 01 Nov 2026 16:00:34 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/ejemplo-practico-de-orquestacion-en-ia-con-php-4cno</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/ejemplo-practico-de-orquestacion-en-ia-con-php-4cno</guid>
      <description>&lt;h1&gt;
  
  
  ejemplo práctico de orquestación en IA con php
&lt;/h1&gt;

&lt;p&gt;Objetivo del ejemplo El siguiente código muestra un flujo de orquestación básico en PHP. Recibe una consulta de un usuario, la clasifica, recupera información relevante, genera una respuesta y realiza una validación final antes de devolver el resultado. Cada paso se ejecuta de forma secuencial y controlada. Estructura del flujo Clasificación de la intención: determina el tipo de consulta. Recuperación de contexto: obtiene datos relacionados según la intención. Generación de respuesta: elabora la respuesta utilizando el contexto. Validación: comprueba que la respuesta cumple unos criterios mínimos. Código completo class AIOrchestrator { private array $contextStore = [ 'factura' =&amp;gt; 'Las facturas se emiten el día 5 de cada mes y están disponibles en el área de cliente.', 'soporte_tecnico' =&amp;gt; 'Para problemas de acceso, reinicia la contraseña desde el enlace de recuperación.', 'pedido' =&amp;gt; 'Los pedidos se procesan en 24-48 horas laborables. El seguimiento está disponible en la cuenta.', 'general' =&amp;gt; 'Puedes contactar con soporte en horario de 9:00 a 18:00 de lunes a viernes.' ]; /** * Punto de entrada de la orquestación &lt;em&gt;/ public function process(string $userQuery): array { // Paso 1: Clasificar la intención $intent = $this-&amp;gt;classifyIntent($userQuery); // Paso 2: Recuperar contexto según la intención $context = $this-&amp;gt;retrieveContext($intent); // Paso 3: Generar respuesta $response = $this-&amp;gt;generateResponse($userQuery, $context, $intent); // Paso 4: Validar la respuesta $validated = $this-&amp;gt;validateResponse($response); return [ 'intent' =&amp;gt; $intent, 'context_used' =&amp;gt; $context, 'response' =&amp;gt; $validated['response'], 'is_valid' =&amp;gt; $validated['is_valid'], 'status' =&amp;gt; $validated['is_valid'] ? 'success' : 'needs_review' ]; } /&lt;/em&gt;* * Paso 1: Clasificación simple de la intención &lt;em&gt;/ private function classifyIntent(string $query): string { $query = strtolower($query); if (str_contains($query, 'factura') || str_contains($query, 'pago')) { return 'factura'; } if (str_contains($query, 'acceso') || str_contains($query, 'contraseña') || str_contains($query, 'login')) { return 'soporte_tecnico'; } if (str_contains($query, 'pedido') || str_contains($query, 'envio') || str_contains($query, 'seguimiento')) { return 'pedido'; } return 'general'; } /&lt;/em&gt;* * Paso 2: Recuperación de contexto &lt;em&gt;/ private function retrieveContext(string $intent): string { return $this-&amp;gt;contextStore[$intent] ?? $this-&amp;gt;contextStore['general']; } /&lt;/em&gt;* * Paso 3: Generación de respuesta * (En un caso real aquí se llamaría a un modelo de lenguaje) &lt;em&gt;/ private function generateResponse(string $query, string $context, string $intent): string { $templates = [ 'factura' =&amp;gt; "Sobre tu consulta de facturación: {$context}", 'soporte_tecnico' =&amp;gt; "Respecto al problema de acceso: {$context}", 'pedido' =&amp;gt; "Sobre el estado de tu pedido: {$context}", 'general' =&amp;gt; "Gracias por contactar. {$context}" ]; return $templates[$intent] ?? $templates['general']; } /&lt;/em&gt;* * Paso 4: Validación básica de la respuesta */ private function validateResponse(string $response): array { $isValid = strlen($response) &amp;gt; 20 &amp;amp;&amp;amp; !str_contains(strtolower($response), 'error'); return [ 'response' =&amp;gt; $response, 'is_valid' =&amp;gt; $isValid ]; } } // Ejemplo de uso $orchestrator = new AIOrchestrator(); $queries = [ "No puedo ver mi factura del mes pasado", "He olvidado la contraseña de acceso", "¿Dónde está mi pedido número 45892?" ]; foreach ($queries as $query) { echo "Consulta: {$query}" . PHP_EOL; $result = $orchestrator-&amp;gt;process($query); echo "Intención detectada: {$result['intent']}" . PHP_EOL; echo "Respuesta: {$result['response']}" . PHP_EOL; echo "Estado: {$result['status']}" . PHP_EOL; echo str_repeat('-', 50) . PHP_EOL; } Explicación del código La clase AIOrchestrator actúa como coordinador central. El método público process() define el orden de ejecución de los pasos y garantiza que cada etapa reciba la información generada por la anterior. Paso 1 – Clasificación de la intención El método classifyIntent() analiza el texto de la consulta mediante reglas sencillas. En un entorno real este paso suele delegarse a un modelo de lenguaje o a un clasificador entrenado. Paso 2 – Recuperación de contexto Según la intención detectada se recupera información relevante desde un almacén de contexto (en este ejemplo un array estático). En producción este paso consultaría una base de datos, un sistema de recuperación aumentada (RAG) o una API interna. Paso 3 – Generación de respuesta Con la consulta original y el contexto recuperado se construye la respuesta. Aquí se utilizan plantillas para mantener el ejemplo autocontenido. En un caso real se realizaría una llamada a un modelo de lenguaje (OpenAI, Claude, modelo local, etc.). Paso 4 – Validación Antes de devolver el resultado se aplica una validación mínima. Si la respuesta no cumple los criterios, el flujo puede marcarse para revisión humana o activar un camino alternativo. Resultado de ejemplo Al ejecutar el script con las consultas de prueba se obtiene una salida similar a la siguiente: Consulta: No puedo ver mi factura del mes pasado Intención detectada: factura Respuesta: Sobre tu consulta de facturación: Las facturas se emiten el día 5 de cada mes y están disponibles en el área de cliente. Estado: success -------------------------------------------------- Consulta: He olvidado la contraseña de acceso Intención detectada: soporte_tecnico Respuesta: Respecto al problema de acceso: Para problemas de acceso, reinicia la contraseña desde el enlace de recuperación. Estado: success -------------------------------------------------- Consulta: ¿Dónde está mi pedido número 45892? Intención detectada: pedido Respuesta: Sobre el estado de tu pedido: Los pedidos se procesan en 24-48 horas laborables. El seguimiento está disponible en la cuenta. Estado: success -------------------------------------------------- Posibles mejoras Sustituir la clasificación por reglas por una llamada a un modelo de lenguaje. Integrar un sistema de recuperación de información (RAG) en el paso de contexto. Añadir gestión de errores y reintentos en cada etapa. Persistir el estado del flujo para permitir pausas y reanudaciones. Registrar cada paso para facilitar la observabilidad y la depuración. &lt;/p&gt;

</description>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>sistema multiagente en php</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Mon, 26 Oct 2026 16:31:42 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/sistema-multiagente-en-php-3n8g</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/sistema-multiagente-en-php-3n8g</guid>
      <description>&lt;h1&gt;
  
  
  sistema multiagente en php
&lt;/h1&gt;

&lt;p&gt;En la inteligencia artificial, los sistemas multiagente están ganando cada vez más protagonismo. En lugar de depender de un único modelo o script monolítico, un sistema multiagente distribuye las responsabilidades entre varios componentes especializados, los agentes, que colaboran para resolver una tarea compleja.Cada agente tiene una función concreta y aporta su conocimiento o capacidad al conjunto. Esta arquitectura ofrece varias ventajas: Modularidad: es más fácil mantener y mejorar cada parte por separado. Especialización: cada agente puede centrarse en hacer bien una sola cosa. Escalabilidad: se pueden añadir nuevos agentes sin reescribir todo el sistema. Claridad: el flujo de trabajo resulta más fácil de entender y depurar. Escenario EL siguiente ejemplo es pequeño asistente de viajes. El usuario hace una pregunta, por ejemplo: “¿Qué tiempo hará en Barcelona y cuánto cuestan los vuelos?”, y varios agentes trabajan juntos para generar la respuesta: ClassifierAgent: analiza la pregunta y detecta qué información se necesita. WeatherAgent: se encarga de obtener el clima. FlightAgent: obtiene información sobre vuelos. RecommenderAgent: combina toda la información y genera la respuesta final. Todos los agentes comparten el mismo array de contexto. Cada uno lee la información disponible, decide si debe actuar y escribe sus resultados en ese mismo contexto.Este enfoque es muy didáctico y permite entender claramente cómo se puede construir colaboración entre agentes sin necesidad de una capa de orquestación compleja.A continuación se puede ver el código completo y comentado. Código del ejemplo /** * Sistema Multiagente simple en PHP (sin orquestador) * Ejemplo educativo para blog */ // ============================================ // Clase base de Agente // ============================================ abstract class Agent { protected string $name; public function __construct(string $name) { $this-&amp;gt;name = $name; } abstract public function run(array &amp;amp;$context): void; public function getName(): string { return $this-&amp;gt;name; } } // ============================================ // Agentes especializados // ============================================ class ClassifierAgent extends Agent { public function run(array &amp;amp;$context): void { $question = strtolower($context['question']); $context['needs_weather'] = str_contains($question, 'clima') || str_contains($question, 'tiempo') || str_contains($question, 'temperatura'); $context['needs_flight'] = str_contains($question, 'vuelo') || str_contains($question, 'avion') || str_contains($question, 'precio'); $context['logs'][] = "[{$this-&amp;gt;name}] Análisis completado"; } } class WeatherAgent extends Agent { public function run(array &amp;amp;$context): void { if (empty($context['needs_weather'])) { return; } // Simulación (aquí iría una API real o llamada a un LLM) $city = $context['city'] ?? 'Madrid'; $data = [ 'Madrid' =&amp;gt; '12°C, lluvia ligera', 'Barcelona' =&amp;gt; '18°C, soleado', 'Valencia' =&amp;gt; '16°C, nublado' ]; $context['weather'] = $data[$city] ?? 'Información no disponible'; $context['logs'][] = "[{$this-&amp;gt;name}] Clima obtenido para $city"; } } class FlightAgent extends Agent { public function run(array &amp;amp;$context): void { if (empty($context['needs_flight'])) { return; } // Simulación $city = $context['city'] ?? 'Madrid'; $context['flight'] = "Vuelos a $city desde 89€ (ida y vuelta)"; $context['logs'][] = "[{$this-&amp;gt;name}] Información de vuelos obtenida"; } } class RecommenderAgent extends Agent { public function run(array &amp;amp;$context): void { $parts = []; if (!empty($context['weather'])) { $parts[] = "Clima: " . $context['weather']; } if (!empty($context['flight'])) { $parts[] = "Vuelos: " . $context['flight']; } if (empty($parts)) { $context['final_answer'] = "No he podido encontrar información relevante."; } else { $context['final_answer'] = "Aquí tienes la información solicitada:\n\n" . implode("\n", $parts); } $context['logs'][] = "[{$this-&amp;gt;name}] Respuesta final generada"; } } // ============================================ // Ejecución del sistema multiagente // ============================================ function runMultiAgentSystem(string $question, string $city = 'Madrid'): array { // Contexto compartido entre todos los agentes $context = [ 'question' =&amp;gt; $question, 'city' =&amp;gt; $city, 'logs' =&amp;gt; [] ]; // Creamos los agentes $agents = [ new ClassifierAgent('Clasificador'), new WeatherAgent('AgenteClima'), new FlightAgent('AgenteVuelos'), new RecommenderAgent('Recomendador') ]; // Cada agente aporta su parte al contexto compartido foreach ($agents as $agent) { $agent-&amp;gt;run($context); } return $context; } // ============================================ // Ejemplo de uso // ============================================ $pregunta = "¿Qué tiempo hará en Barcelona y cuánto cuestan los vuelos?"; $resultado = runMultiAgentSystem($pregunta, 'Barcelona'); echo "Pregunta: $pregunta\n\n"; echo "Respuesta final:\n"; echo $resultado['final_answer'] . "\n\n"; echo "--- Logs de los agentes ---\n"; foreach ($resultado['logs'] as $log) { echo $log . "\n"; } En el ejemplo se muestra cómo se puede implementar un sistema multiagente de forma sencilla y legible en PHP. Las respuestas son simuladas, el mismo esquema se puede conectar fácilmente a modelos de lenguaje, como OpenAI, Claude, Grok, Ollama, etc. o a APIs externas sustituyendo la lógica interna de cada agente.La clave está en el contexto compartido: todos los agentes leen y escriben en el mismo lugar, lo que permite una colaboración natural sin necesidad de una capa de orquestación compleja.Este tipo de arquitectura es especialmente útil cuando se quieren construir aplicaciones más mantenibles, escalables y fáciles de evolucionar.&lt;/p&gt;

</description>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
    <item>
      <title>cómo crear un modelo de ia con php</title>
      <dc:creator>Gonzalo López</dc:creator>
      <pubDate>Sun, 25 Oct 2026 13:59:30 +0000</pubDate>
      <link>https://dev.to/gonzalo_lpez_18346c27391/como-crear-un-modelo-de-ia-con-php-3mgp</link>
      <guid>https://dev.to/gonzalo_lpez_18346c27391/como-crear-un-modelo-de-ia-con-php-3mgp</guid>
      <description>&lt;h1&gt;
  
  
  cómo crear un modelo de ia con php
&lt;/h1&gt;

&lt;p&gt;¿Es posible crear un modelo de IA con PHP? Durante años se repitió el mito de que la inteligencia artificial solo se desarrolla con Python. Esa idea ya no es cierta. En 2026 PHP cuenta con librerías maduras, herramientas de inferencia de alto rendimiento y SDKs oficiales que permiten crear modelos de machine learning, ejecutar redes neuronales y consumir modelos de lenguaje grandes (LLM) de forma profesional. Es posible entrenar clasificadores, regressores y redes neuronales simples directamente en PHP, ejecutar modelos pre-entrenados con ONNX y Transformers, o integrar potentes modelos de OpenAI, Anthropic o Gemini. Todo desde código PHP estándar. Tres caminos para crear modelos de IA con PHP Machine Learning nativo: Entrenamiento de modelos clásicos, como KNN, árboles de decisión, redes neuronales, con librerías como Rubix ML o PHP-ML. Inferencia de modelos pre-entrenados: Carga de modelos ONNX o Transformers y ejecución local sin Python. Integración con LLMs: Uso de APIs de modelos de lenguaje grandes para crear agentes inteligentes, chatbots y sistemas RAG. Este artículo se centra en el primer camino: la creación y el entrenamiento de un modelo de inteligencia artificial real con PHP. Librerías recomendadas para Machine Learning en PHP Rubix ML: La librería más completa y mantenida. Más de 40 algoritmos, pipelines de producción, serialización de modelos y soporte para deep learning básico. PHP-ML: Ligera y sencilla. Ideal para aprendizaje y prototipos rápidos. TransformersPHP: Permite ejecutar modelos de Hugging Face (clasificación de texto, generación, embeddings) directamente en PHP mediante ONNX Runtime. Paso a paso: Creación y entrenamiento de un modelo de IA con Rubix ML A continuación se construye un clasificador que predice si un cliente comprará o no un producto según su edad e ingresos. Se trata de un caso de uso real de machine learning supervisado. Instalación composer require rubix/ml reparación de los datos de entrenamiento require 'vendor/autoload.php'; use Rubix\ML\Datasets\Labeled; use Rubix\ML\Classifiers\KNearestNeighbors; use Rubix\ML\CrossValidation\Metrics\Accuracy; use Rubix\ML\Persisters\Filesystem; use Rubix\ML\PersistentModel; $samples = [ [25, 30000], [35, 45000], [45, 60000], [22, 28000], [50, 80000], [28, 32000], [40, 55000], [33, 42000], [55, 90000], [29, 35000] ]; $labels = [ 'no', 'si', 'si', 'no', 'si', 'no', 'si', 'si', 'si', 'no' ]; $dataset = new Labeled($samples, $labels); Entrenamiento del modelo $estimator = new KNearestNeighbors(3); $estimator-&amp;gt;train($dataset); echo "Modelo entrenado correctamente\n"; Evaluación del modelo $predictions = $estimator-&amp;gt;predict($dataset); $metric = new Accuracy(); $score = $metric-&amp;gt;score($predictions, $labels); echo "Precisión del modelo: " . round($score * 100, 2) . "%\n"; 5. Realización de predicciones $nuevoCliente = [[38, 52000]]; $prediccion = $estimator-&amp;gt;predict($nuevoCliente); echo "¿Comprará el cliente? " . $prediccion[0] . "\n"; Guardado del modelo para producción $persister = new Filesystem('modelo_compra.rbx'); $modeloPersistente = new PersistentModel($estimator, $persister); $modeloPersistente-&amp;gt;save(); echo "Modelo guardado en modelo_compra.rbx\n"; Carga y uso del modelo guardado $modeloCargado = PersistentModel::load(new Filesystem('modelo_compra.rbx')); $resultado = $modeloCargado-&amp;gt;predict([[41, 58000]]); echo "Predicción: " . $resultado[0] . "\n"; Creación de una red neuronal simple con PHP-ML Para experimentar con redes neuronales artificiales, PHP-ML incluye un Multilayer Perceptron Classifier. require 'vendor/autoload.php'; use Phpml\Classification\MLPClassifier; $samples = [ [1, 0], [0, 1], [1, 1], [0, 0] ]; $targets = [1, 1, 0, 0]; // problema XOR $classifier = new MLPClassifier(2, [2], [0, 1], 10000); $classifier-&amp;gt;train($samples, $targets); echo $classifier-&amp;gt;predict([1, 0]); // debería devolver 1 echo $classifier-&amp;gt;predict([0, 0]); // debería devolver 0 Este ejemplo demuestra cómo una red neuronal aprende la función lógica XOR, un clásico de la inteligencia artificial. Mejores prácticas para modelos de IA en producción con PHP Separación del entrenamiento de la inferencia. El entrenamiento se realiza offline y el modelo serializado se carga en producción. Uso de pipelines de preprocesamiento (normalización, escalado) para mejorar la precisión. Validación siempre con datos de prueba que el modelo no haya visto durante el entrenamiento. Monitorización de la deriva de datos (data drift) cuando el comportamiento de los usuarios cambia. Para modelos grandes (transformers, LLMs) se recomienda inferencia con ONNX Runtime o APIs externas. Alternativa moderna: Inferencia de modelos Transformers en PHP Para clasificación de sentimientos, generación de texto o embeddings es posible utilizar TransformersPHP: composer require codewithkyrian/transformers require 'vendor/autoload.php'; use function Codewithkyrian\Transformers\Pipelines\pipeline; $pipe = pipeline('sentiment-analysis'); $resultado = $pipe('Este producto es increíble, lo recomiendo mucho'); print_r($resultado); Conclusión: PHP como lenguaje viable para inteligencia artificial La creación de un modelo de inteligencia artificial con PHP es totalmente posible y, en muchos casos, la opción más práctica. Con Rubix ML se pueden entrenar modelos de machine learning de nivel profesional. Con TransformersPHP se ejecutan modelos modernos de forma local. Y con los SDKs de OpenAI, Anthropic o Laravel AI se construyen agentes inteligentes completos. El límite ya no es el lenguaje. El límite es la calidad de los datos y el diseño del sistema.La instalación de Rubix ML, la preparación de un conjunto de datos real y el entrenamiento de un primer modelo permiten disponer de inteligencia artificial funcionando dentro de una aplicación PHP en poco tiempo. &lt;/p&gt;

</description>
      <category>php</category>
      <category>spanish</category>
      <category>programacion</category>
    </item>
  </channel>
</rss>
