DEV Community: Fernando Silva T

Crea tu asistente personal en los Meta Glasses.

Fernando Silva T — Fri, 27 Feb 2026 22:56:03 +0000

Fernando Silva TFollow

AWS Community Builder | Estudiante de Ingeniería Informática en Duoc UC. Apasionado por AWS, desarrollo Full-Stack y proyectos open source. Siempre buscando aprender y colaborar.

Implementación de un asistente de IA con entrada de voz y visión para lentes inteligentes usando Android, Amazon Bedrock y Claude Sonnet 4.5, sin dependencia de la IA nativa de Meta ni restricciones geográficas.

Este proyecto aborda cuatro problemas técnicos concretos:

Wake word detection sin librerías externas
Conversión de frames del SDK de Meta a formatos compatibles con Bedrock
Uso de la Converse API con input multimodal (imagen + texto)
Coordinación de flujos asíncronos en Jetpack Compose

Stack: Kotlin · Jetpack Compose · Meta Wearables DAT SDK · Amazon Bedrock

Nivel: Intermedio

Repositorio: https://github.com/fernandosilvot/aws-bedrock-meta-glasses

Introducción

Todo comenzó con una conversación casual. Elizabeth Fuentes me comentó sobre el Meta Wearables DAT SDK — una API que Meta había liberado para desarrolladores que permitía integrar funcionalidades personalizadas a los Meta Smart Glasses, más allá de la IA nativa de Meta.

La idea me fascinó de inmediato: ¿Y si pudiera conectar estos lentes con Amazon Bedrock y usar Claude Sonnet 4.5 en lugar de la IA de Meta? ¿Podría crear un asistente que no solo escuchara, sino que también viera lo que yo veo?

El resultado es Meta-Rock, un asistente activado por voz que captura el frame actual de la cámara, lo envía junto al texto de la consulta y reproduce la respuesta mediante TTS.

El problema y la visión

Los Meta Ray-Ban Smart Glasses vienen con IA integrada de Meta, pero tienen una limitación importante: solo está disponible en ciertos países. En Chile, donde vivo, no puedo acceder a esa funcionalidad nativa.

Además, incluso si estuviera disponible, quería explorar las posibilidades de integrar modelos de IA más avanzados y personalizables. ¿Qué podría lograr si conectara estos lentes directamente con Amazon Bedrock y Claude Sonnet 4.5?

Objetivo:

Construir un asistente hands-free que combine audio y visión, delegando toda la inferencia a Bedrock.

Arquitectura

Flujo de datos

Pipeline resumido:

Wake word → SpeechRecognizer
Captura de frame desde los lentes
Conversión I420 → JPEG
Request multimodal a Bedrock
Respuesta → Text-to-Speech

Stack tecnológico

Capa	Tecnología	Justificación
UI	Jetpack Compose	Estado reactivo
Voz	Android SpeechRecognizer	API nativa
Video	Meta Wearables DAT SDK	Acceso directo a cámara
IA	Amazon Bedrock	Inferencia multimodal
Modelo	Claude Sonnet 4.5	Razonamiento visual sólido

Demostración en video

Meta-Rock en ejecución

El video muestra el flujo completo:

Activación por wake word
Captura del frame desde los lentes
Envío multimodal a Bedrock
Respuesta hablada

📽️ Video de demostración:

Desafíos técnicos y decisiones de diseño

1. Wake word detection sin librerías externas

Decisión: usar SpeechRecognizer en escucha pasiva.

Motivación: evitar dependencias comerciales y mantener el stack 100% nativo.

Trade-offs:

Falsos positivos en ambientes ruidosos
Mayor consumo de batería
Latencia aproximada de 500 ms

class SpeechManager(
    private val context: Context,
    private val onWakeWord: () -> Unit,
    private val onTranscript: (String) -> Unit
) {
    private val speechRecognizer = SpeechRecognizer.createSpeechRecognizer(context)

    fun startPassiveListening() {
        val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
            putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, 
                    RecognizerIntent.LANGUAGE_MODEL_FREE_FORM)
            putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true)
        }
        speechRecognizer.startListening(intent)
    }

    private fun checkForWakeWord(text: String) {
        val normalized = text.lowercase().trim()
        if (normalized.contains("hey friday") || normalized.contains("oye viernes")) {
            onWakeWord()
        }
    }
}

Aceptable para prototipo funcional y pruebas reales.

2. Envío constante de contexto visual

Decisión clave: enviar siempre el frame de la cámara junto al texto.

Motivación técnica:

Clasificadores por palabras clave son frágiles
Consultas ambiguas requieren visión (“¿y esto?”)
El modelo puede ignorar la imagen si no es relevante

private fun onTranscriptReady(transcript: String) {
    Log.d(TAG, "Transcript: $transcript")
    val frame = currentFrameProvider?.invoke() // Siempre captura el frame

    _uiState.update { 
        it.copy(
            state = NovaState.PROCESSING, 
            transcript = transcript, 
            sentWithImage = frame != null
        ) 
    }

    processingJob = viewModelScope.launch(Dispatchers.IO) {
        val systemPrompt = Prompts.system(language.locale.language)
        val response = if (frame != null) {
            bedrockClient.askWithImage(transcript, frame, systemPrompt)
        } else {
            bedrockClient.askTextOnly(transcript, systemPrompt)
        }
        // ...
    }
}

Costo: mayor consumo de tokens y ancho de banda

Beneficio: lógica simple y UX consistente

3. Conversión de formatos de video

El SDK de Meta entrega frames en formato I420 (YUV).

Bedrock requiere imágenes codificadas (JPEG).

Pipeline implementado:

I420 → NV21 → Bitmap → JPEG (85%)

private fun i420ToNV21(i420: ByteArray, width: Int, height: Int): ByteArray {
    val frameSize = width * height
    val nv21 = ByteArray(frameSize * 3 / 2)

    // Copiar Y
    System.arraycopy(i420, 0, nv21, 0, frameSize)

    // Intercalar U y V para NV21
    var uvIndex = frameSize
    var uIndex = frameSize
    var vIndex = frameSize + frameSize / 4

    for (i in 0 until frameSize / 4) {
        nv21[uvIndex++] = i420[vIndex++]
        nv21[uvIndex++] = i420[uIndex++]
    }

    return nv21
}

private fun bitmapToBytes(bitmap: Bitmap): ByteArray {
    val stream = ByteArrayOutputStream()
    bitmap.compress(Bitmap.CompressFormat.JPEG, 85, stream)
    return stream.toByteArray()
}

El 85% de compresión mantiene legibilidad de texto con menor latencia.

4. Integración con Bedrock (Converse API)

Se utiliza una única llamada con input multimodal:

Texto del usuario
Imagen capturada
System prompt dependiente del idioma

class BedrockClient {
    private val client = BedrockRuntimeClient {
        region = "us-east-1"
        credentialsProvider = StaticCredentialsProvider(
            accessKeyId,
            secretAccessKey
        )
    }

    suspend fun askWithImage(prompt: String, frame: Bitmap, systemPrompt: String): String {
        val imageBytes = bitmapToBytes(frame)
        val request = ConverseRequest {
            modelId = "us.anthropic.claude-sonnet-4-5-20250929-v1:0"
            system = listOf(SystemContentBlock.Text(systemPrompt))
            messages = listOf(
                Message {
                    role = ConversationRole.User
                    content = listOf(
                        ContentBlock.Image(
                            ImageBlock {
                                format = ImageFormat.Jpeg
                                source = ImageSource.Bytes(imageBytes)
                            }
                        ),
                        ContentBlock.Text(prompt)
                    )
                }
            )
            inferenceConfig {
                maxTokens = 300
                temperature = 0.7F
            }
        }
        return client.converse(request).output!!.asMessage().content.first().asText()
    }
}

La inferencia se realiza directamente desde Android usando el SDK oficial de AWS para Kotlin.

5. Gestión de estado en la UI

Se definen estados explícitos para coordinar audio, video e inferencia:

enum class NovaState {
    IDLE,           // Esperando "Hey Viernes"
    LISTENING,      // Escuchando pregunta
    PROCESSING,     // Enviando a Bedrock
    RESPONDING      // Mostrando/leyendo respuesta
}

data class NovaUiState(
    val state: NovaState = NovaState.IDLE,
    val transcript: String? = null,
    val response: String? = null,
    val sentWithImage: Boolean = false
)

Esto reduce errores visuales y facilita el debugging.

Casos de uso validados

Identificación visual (objetos, colores, texto)
Lectura de pantallas
Consultas generales con o sin contexto visual

El modelo decide dinámicamente si usar la imagen.

Resultados

Latencia end-to-end: 2–3 segundos
Precisión wake word: ~95% en ambientes silenciosos
Consumo de batería: ~15% por hora
Tamaño del APK: 12.4 MB

Lecciones técnicas

Optimizar demasiado temprano complica la arquitectura
JPEG al 85% es un buen punto de equilibrio
Wake word sin SDK dedicado tiene límites claros
Claude maneja bien inputs multimodales ruidosos

Próximos pasos

Clasificador local ligero para decidir envío de imagen
Optimización de consumo energético
Nuevos flujos de análisis visual continuo

Conclusión

Construir Meta-Rock fue un desafío técnico fascinante que surgió de una necesidad real: acceder a funcionalidades de IA en los Meta Ray-Ban que no están disponibles en mi región.

Pero más allá de resolver esa limitación, este proyecto me permitió explorar las posibilidades de integrar wearables con modelos de IA de última generación. ¿Qué más se puede lograr cuando tienes acceso directo a la cámara de unos lentes inteligentes y a modelos como Claude Sonnet 4.5?

Lo más emocionante es que esto es solo el comienzo. Planeo seguir mejorando Meta-Rock, explorando nuevas funcionalidades y documentando cada avance en futuros blogs. Desde análisis de escenas en tiempo real hasta traducción visual instantánea, las posibilidades son infinitas.

Este proyecto me enseñó que las limitaciones geográficas o de plataforma no tienen por qué detenerte. Con las herramientas adecuadas (AWS, SDKs abiertos, creatividad), puedes construir soluciones que no solo resuelven tus necesidades, sino que abren puertas a experiencias completamente nuevas.

Recursos

Repositorio GitHub: aws-bedrock-meta-glasses
Repo original de Meta: CameraAccess Sample
Meta Wearables SDK: Documentación oficial
Amazon Bedrock: Converse API
Claude Sonnet 4.5: Modelo en Bedrock

Agradecimientos

Este proyecto no hubiera sido posible sin:

Elizabeth Fuentes por compartir el descubrimiento del Meta Wearables DAT SDK y motivarme a explorar esta tecnología
El equipo de Meta por abrir el SDK de los Ray-Ban a la comunidad de desarrolladores
AWS por hacer Bedrock accesible y proporcionar modelos de IA de clase mundial
La comunidad de AWS Community Builders por el apoyo constante y el intercambio de conocimientos

¿Tienes preguntas o ideas para mejorar Meta-Rock? Déjalas en los comentarios o contáctame en fernandosilvot.cl

Made with ❤️ in Chile 🇨🇱

[Boost]

Fernando Silva T — Sat, 20 Dec 2025 04:05:32 +0000

Elizabeth Fuentes L for AWS

Dec 20 '25

Build Agentic Video Analysis with TwelveLabs Pegasus in minutes

#ai #aws #python #tutorial

Comments

7 min read

Diseño e Implementación de Arquitectura CTF LLaitun: de la Primera Experiencia al Liderazgo Técnico

Fernando Silva T — Sun, 10 Aug 2025 23:36:16 +0000

En este artículo quiero llevarte conmigo en un recorrido que empezó en 2024, cuando era un estudiante curioso que se unió al equipo del Ciberlab, y terminó (por ahora) en 2025, liderando toda la arquitectura AWS del CTF Llaitun. Fueron 195 participantes, 70 equipos, 8 horas continuas y un uptime de 99.9%, con una arquitectura híbrida que unió la nube y la infraestructura física como si fueran uno solo.

No es solo tecnología. Es la historia de cómo la mentoría, la perseverancia y el trabajo en equipo pueden cambiar el rumbo de una carrera.

¿Qué es el CTF Llaitun y en qué se diferencia de otros CTF?

Un Capture The Flag (CTF) es una competencia de ciberseguridad donde los participantes resuelven retos técnicos para obtener “banderas” digitales y sumar puntos.
El CTF Llaitun, organizado por el Centro de Innovación UC, Ejercito de Chile y Duoc Uc en Chile, lleva esta experiencia a otro nivel: combina entornos virtuales en la nube con infraestructura física real para simular ataques y defensas en escenarios de infraestructura crítica como plantas industriales, sistemas SCADA y entornos operativos.

Mientras que en un CTF tradicional todo sucede en un laboratorio aislado, el Llaitun exige una arquitectura híbrida robusta, capaz de conectar la nube con sistemas On-premise bajo condiciones reales, resistiendo picos de tráfico, ataques constantes y cambios en tiempo real durante la competencia.

🎯 De Colaborador a Líder Técnico

CTF Llaitun 2024: Primeros pasos en un mundo real

Recuerdo entrar al proyecto en 2024 con nervios y emoción. Era mi primer gran evento de ciberseguridad: aproximante 200 profesionales, 80 equipos, simuladores, sistemas críticos, y yo, estudiante de segundo año de Analista Programador Computacional, tratando de absorber cada detalle.

Mi rol fue claro: colaborar en el diseño de la arquitectura junto a Martin Tourneboeuf. Pero nada fue sencillo. Nos enfrentamos al reto de conectar AWS con la infraestructura On-premise del Ejército y del Duoc Uc, y la solución terminó siendo dos VPNs que trabajaban en paralelo. Funcionaba, sí, pero con complejidad y riesgos.

Ese año aprendí que:

La nube no es solo "Desplegar"; es pensar en escalabilidad, resiliencia, en el todo del proyecto y la mejora continua.
La buena comunicación en el equipo es tan importante como la configuración del entorno.
La presión real de saber que no debían fallar las conexiones ya que era mi responsabilidad.

CTF Llaitun 2025: El salto al liderazgo

Un año después, las cosas eran distintas. Ya en mi tercer año de Ingeniería en Informática, el reto era mío: diseñar y mantener yo solo toda la arquitectura híbrida que daría vida al evento.

No quise repetir la historia de las dos VPNs. Aposté por algo más arriesgado: una gateway híbrida única. Menos conexiones, menos puntos de falla, más simplicidad. Esto implicó semanas de pruebas, consultas con mentores como Ysabel Troconis, Elizabeth Fuentes y María Isabel, y noches de diagramas y simulaciones.

Fue un proceso muy tenso, volví a sentir la presión del año pasado "No debía fallar", cada cambio que se realizaban en los desafíos o en los sistemas SCADA los probe para adecuar toda la arquitectura, estaba muy nervioso.

El día del evento, vi cómo todo funcionaba sin caídas, con tráfico constante de cientos de participantes. Fue una mezcla de alivio y orgullo que es difícil de describir.

uno de los comentarios que recibí posteriormente me marco de grata manera:

💬 "Increíble trabajo, puedo dar fe de lo robusta y eficiente que fue toda la infraestructura..." – Fernando Gómez.

🏛️ Evolución Arquitectónica

2024: limitaciones y aprendizajes

Conexiones redundantes y complejas.
Configuraciones duplicadas.
Latencia innecesaria.

2025: simplicidad elegante

Una sola conexión para todo el tráfico.
Menos puntos de fallo.
Mejor rendimiento.
Gestión centralizada.

🔧 Desafíos Técnicos Superados

Antes: dos VPNs para dos flujos distintos de comunicación.
Después: una arquitectura unificada con failover automático y rutas optimizadas.

El proceso incluyó analizar el tráfico del año anterior, optimizar el routing, y hacer pruebas exhaustivas para garantizar que nada fallara bajo presión.

👥 El Ecosistema de Apoyo

Nada de esto fue un trabajo en solitario. Detrás hubo personas que creyeron en mí y me guiaron:

Mentores: Martin Tourneboeuf (Dreamlab), Ysabel Troconis, Elizabeth Fuentes Leone, María Isabel Florez.
Compañeros: Bruno Urrea, Sebastián Porma, Marcos Sepúlveda, Joshua Zavala, Pedro Carrasco.
Duoc Uc: Viviana Soto, Cristian Barra Abascal.
Centro de Innovación UC y Ejército de Chile.

📌 Lecciones Clave

Planifica antes de ejecutar: una buena arquitectura nace en la hoja de papel antes que en la consola.
Menos, es Más: reducir la complejidad aumenta la resiliencia.
Escucha a las personas que quieren aportar: sus experiencias te ahorran errores costosos.
La presión real es un maestro implacable.

🚀 Conclusión

El CTF Llaitun fue mucho más que un reto técnico: fue un laboratorio de crecimiento personal. Aprendí que la confianza se gana a base de resultados, que liderar es también saber escuchar, y que las soluciones más elegantes son las que parecen obvias... después de meses de trabajo.

Seguimos adelante, construyendo y aprendiendo en cada desafío.

Integrando Podcasts a Kiu: Cómo Construí un Agente Virtual Serverless con AWS Bedrock y Pinecone

Fernando Silva T — Fri, 06 Jun 2025 20:53:40 +0000

Introducción

Tuve la oportunidad de unirme al equipo de Kiu, un proyecto innovador que permite conocer charlas, meetups y eventos de la comunidad AWS. Descubrí Kiu en el AWS Community Day Chile 2024 y me fascinó desde el primer momento.

En febrero, Hazel Saenz me invitó a participar en el equipo. Mi primera tarea fue integrar contenido de podcasts dentro de Kiu, creando un subagente virtual capaz de consultar y procesar esta información para responder preguntas de forma precisa y eficiente.

En este blog compartiré cómo diseñé y desplegué una infraestructura serverless robusta usando AWS CDK en Python, integrando Pinecone para búsquedas vectoriales y Amazon Bedrock para inteligencia artificial. Además, te contaré los desafíos técnicos que enfrenté y cómo los superé para entregar una solución segura, escalable y automatizada.

El problema y el objetivo

Kiu es un agente virtual que responde consultas utilizando inteligencia artificial apoyada en bases de conocimiento actualizadas. Nuestro objetivo era incorporar el mundo de los podcasts para enriquecer la base y mejorar la experiencia del usuario.

Para esto, necesitábamos:

Extraer datos de podcasts desde una API externa y limpiarlos.
Almacenar esta información estructurada en un bucket S3, que funciona como base de conocimiento.
Usar Pinecone para búsquedas semánticas rápidas y eficientes.
Que el agente Bedrock acceda a esta base para responder consultas.
Automatizar la actualización periódica de los datos.

La solución técnica

Arquitectura Serverless con AWS CDK y Python

Me recomendaron implementar toda la infraestructura como código usando AWS CDK en Python, lo que facilitó mantener la solución versionada, segura y reproducible.

Los componentes clave fueron:

Amazon S3: Bucket cifrado y versionado para almacenar archivos JSON con la información procesada de los podcasts.
AWS Lambda: Función que consulta la API externa, procesa los datos limpiando y normalizando el texto, y actualiza el bucket S3.
Lambda Layers: Capas que contienen las librerías comunes (requests, unidecode) para optimizar despliegues.
AWS Secrets Manager: Almacena de forma segura las credenciales de la API externa, como URL y cookies.
AWS Scheduler: Programa la ejecución semanal automática de la función Lambda para mantener la base actualizada.
Amazon Bedrock: Configura el agente virtual Kiu para consultar la base de conocimiento.
Pinecone: Base de datos vectorial para búsquedas semánticas con un índice de dimensión 1024.

Flujo de datos

El Scheduler activa semanalmente la función Lambda.
Lambda obtiene las credenciales desde Secrets Manager.
Lambda consulta y procesa los datos de la API externa.
La información limpia y estructurada se almacena en S3.
El agente Bedrock utiliza esta base para responder consultas.
Pinecone facilita búsquedas semánticas rápidas y precisas.

Desafíos y aprendizajes

El proyecto implicó una curva de aprendizaje significativa y varios retos técnicos, que me ayudaron a crecer profesionalmente.

1. Aprender AWS CDK en Python

Aunque conocía CDK, tuve que aprender a usarlo correctamente en Python para alinearme con el equipo. Aquí un fragmento donde se define el bucket S3 y el secreto para las credenciales:

class PodcastKiuStack(Stack):
    def __init__(self, scope: Construct, construct_id: str, 
                 pinecone_api_key: str, pinecone_connection_url: str,
                 api_url: str, cookie: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        kb_bucket = s3.Bucket(
            self, "PodcastKnowledgeBase",
            versioned=True,
            encryption=s3.BucketEncryption.S3_MANAGED,
            removal_policy=RemovalPolicy.RETAIN
        )

        api_secret = secretsmanager.Secret(
            self, "PodcastApiSecret",
            secret_name="podcast-api-credentials",
            description="Credenciales para acceder a la API de podcasts",
            generate_secret_string=secretsmanager.SecretStringGenerator(
                secret_string_template=json.dumps({
                    "API_URL": api_url,
                    "COOKIE": cookie
                }),
                generate_string_key="dummy"
            )
        )

2. Integrar Pinecone con Amazon Bedrock

Fue un reto configurar la knowledge base para usar Pinecone como base vectorial para búsquedas semánticas y configurar los roles necesarios para Bedrock:

bedrock_agent_role = iam.Role(
    self, "BedrockAgentRole",
    assumed_by=iam.ServicePrincipal("bedrock.amazonaws.com")
)

kb_bucket.grant_read(bedrock_agent_role)

knowledge_base = bedrock.CfnKnowledgeBase(
            self, "MyKnowledgeBaseKiuPodcast",
            name="KnowledgeBasePineconeKiuPodcast",
            description="Knowledge base for the podcast content with pinecone",
            role_arn=bedrock_role.role_arn,
            knowledge_base_configuration=bedrock.CfnKnowledgeBase.KnowledgeBaseConfigurationProperty(
                type="VECTOR",
                vector_knowledge_base_configuration=bedrock.CfnKnowledgeBase.VectorKnowledgeBaseConfigurationProperty(
                    embedding_model_arn="arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-text-v2:0"
                )
            ),
            storage_configuration=bedrock.CfnKnowledgeBase.StorageConfigurationProperty(
                type="PINECONE",
                pinecone_configuration=bedrock.CfnKnowledgeBase.PineconeConfigurationProperty(
                    connection_string=pinecone_connection_url,
                    credentials_secret_arn=pinecone_url_secret.secret_arn,
                    field_mapping=bedrock.CfnKnowledgeBase.PineconeFieldMappingProperty(
                        text_field="text",
                        metadata_field="metafield"
                    ),
                )
            )
        )

3. Función Lambda para Procesamiento de Datos

Diseñé una función Lambda que consulta la API, procesa los datos limpiando texto con expresiones regulares y unidecode, y almacena la información en S3:

def lambda_handler(event, context):
    secrets_client = boto3.client('secretsmanager')
    secret_response = secrets_client.get_secret_value(SecretId=os.environ['API_SECRET_ARN'])
    secret = json.loads(secret_response['SecretString'])

    api_url = secret['API_URL']
    cookie = secret['COOKIE']

    response = requests.get(api_url, headers={'Cookie': cookie})
    podcasts = response.json()
    processed_data = []

    for podcast in podcasts:
        title = clean_text(podcast.get('title', ''))
        description = clean_text(podcast.get('description', ''))
        processed_data.append({
            'id': podcast.get('id'),
            'title': title,
            'description': description,
            'url': podcast.get('url'),
            'published_date': podcast.get('published_date'),
            'processed_timestamp': context.invoked_function_arn
        })

    s3_client = boto3.client('s3')
    s3_client.put_object(
        Bucket=os.environ['KB_BUCKET_NAME'],
        Key='processed_podcasts.json',
        Body=json.dumps(processed_data),
        ContentType='application/json'
    )

4. Seguridad: Roles IAM y Políticas granulares

Configuré roles con permisos mínimos necesarios para Lambda y Bedrock, garantizando la seguridad del sistema:

lambda_role = iam.Role(
    self, "PodcastProcessorRole",
    assumed_by=iam.ServicePrincipal("lambda.amazonaws.com")
)

lambda_role.add_managed_policy(
    iam.ManagedPolicy.from_aws_managed_policy_name("service-role/AWSLambdaBasicExecutionRole")
)

lambda_role.add_to_policy(
    iam.PolicyStatement(
        actions=["s3:PutObject", "s3:GetObject", "s3:ListBucket"],
        resources=[kb_bucket.bucket_arn, f"{kb_bucket.bucket_arn}/*"]
    )
)

lambda_role.add_to_policy(
    iam.PolicyStatement(
        actions=["secretsmanager:GetSecretValue"],
        resources=[api_secret.secret_arn]
    )
)

5. Pruebas Unitarias para asegurar calidad

Implementé pruebas unitarias que simulan la interacción con Secrets Manager, S3 y la API externa para validar el procesamiento de datos:

class TestLambdaFunction(unittest.TestCase):
    @patch('lambda_function.boto3.client')
    @patch('lambda_function.requests.get')
    def test_successful_processing(self, mock_get, mock_boto3_client):
        mock_context = MagicMock()
        mock_context.invoked_function_arn = 'test-arn'
        # mocks configurados...

        result = lambda_function.lambda_handler({}, mock_context)
        self.assertEqual(result['statusCode'], 200)
        self.assertIn('Procesados 1 podcasts', result['body'])
        mock_s3.put_object.assert_called_once()

6. Emojis en los títulos de los episodios

Durante las pruebas unitarias descubrí un problema curioso: si el título de un pódcast incluía un emoji, los metadatos no se almacenaban correctamente y fallaba el envío a S3. Este detalle, aunque pequeño, tenía un impacto directo en la integridad del flujo de datos. Con la ayuda de Chris Gonzalez, logramos identificar el origen del error y validamos el manejo de emojis usando la tabla oficial de Unicode. Esta corrección fue clave para asegurar que todos los títulos —emoji incluidos— se procesaran de forma segura y consistente.

Conclusión

Este proyecto ha sido para mí una gran curva de aprendizaje, no solo en términos técnicos, sino también en el trabajo colaborativo. Integrar tecnologías como AWS CDK en Python, Pinecone y Amazon Bedrock me llevó a salir de mi zona de confort y a descubrir nuevas formas de construir soluciones serverless escalables y seguras.

Además, trabajar en equipo ha sido fundamental. Cada compañero aporta desde distintos frentes, y esa sinergia nos está permitiendo avanzar con velocidad y calidad. Un agradecimiento muy especial a Hazel Saenz, quien ha sido una guía constante, enseñándome mucho, apoyándome en cada error y alentándome a seguir mejorando. Su paciencia y conocimiento han sido claves para mi crecimiento dentro del proyecto y para la entrega exitosa de esta funcionalidad.

Estoy emocionado por lo que viene y orgulloso de ser parte de este equipo que está construyendo el futuro de Kiu con tecnologías punteras.

Recursos

AWS CDK Python
Amazon Bedrock CDK
Pinecone
Repositorio GitHub: Próximamente disponible

Integración IoT y Generative AI: Cómo Crear una App que Cuenta Chistes Basados en la Temperatura

Fernando Silva T — Mon, 27 Jan 2025 19:01:04 +0000

Introducción

En la era de la tecnología inteligente, combinar el Internet de las Cosas (IoT) con la Inteligencia Artificial Generativa abre un mundo de oportunidades. Imagina una App que, al detectar un aumento en la temperatura, responde presentando un chiste en una pantalla OLED.

En este tutorial, te guiaremos a través de cada paso para desarrollar esta innovadora App, explorando cómo la integración de sensores de temperatura con algoritmos de IA puede crear interacciones más humanas y entretenidas.

Requisitos Previos:

Costo para completar:

¿Cómo funciona esta aplicación?

El flujo comienza con el NodeMCU ESP8266, que está equipado con el sensor de temperatura AM2302 DHT22 para medir la temperatura ambiente. Estos datos se envían a AWS IoT mediante el protocolo MQTT, publicándose en el tópico esp8266/pub. AWS IoT Core evalúa si la temperatura supera el umbral establecido de 30°C. Si es así, se activa una función Lambda que genera un chiste utilizando Amazon Bedrock. Este chiste se envía de vuelta al ESP8266 a través de MQTT, publicándose en el tópico esp8266/joke. Finalmente, el ESP8266 recibe el chiste y lo muestra en la pantalla OLED conectada.

Este flujo permite que la aplicación responda de manera dinámica a los cambios en la temperatura, ofreciendo contenido entretenido y personalizado para ti.

Muestra los pasos para llegar a la solución

Diagrama de conexión

Para que la App funcione correctamente, es fundamental seguir el diagrama de conexión entre el NodeMCU ESP8266, el sensor de temperatura AM2302 DHT22 y la pantalla OLED I2C. Asegúrate de que cada componente esté conectado a los pines adecuados. Es importante destacar que el código está específicamente adaptado para estas conexiones; cualquier modificación en la configuración podría afectar el rendimiento de la App o su funcionamiento.

Paso 1: Acceder a la Consola de AWS

Inicie sesión en la consola de administración de AWS utilizando sus credenciales.

Paso 2: Navegar a AWS IoT Core

En la barra de búsqueda de la consola, escriba AWS IoT Core y seleccione el servicio correspondiente.

Paso 3: Acceder a la Sección de Objetos

En el panel de navegación izquierdo, haga clic en Administrar.
Luego, seleccione Todos los dispositivos y, posteriormente, Objetos.

Paso 4: Crear un Nuevo Objeto

Haga clic en el botón Crear objeto.
Elija la opción Crear un único objeto.
Asigne un nombre único a su objeto que lo identifique claramente.

Paso 5: Configurar Certificados

Seleccione Crear certificados para generar automáticamente un nuevo certificado que permitirá una comunicación segura entre su dispositivo y AWS IoT.

Paso 6: Crear una Política de IoT

Para otorgar los permisos necesarios, cree una política con la siguiente configuración JSON:

  {
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Action": "iot:Connect",
        "Resource": "*"
      },
      {
        "Effect": "Allow",
        "Action": "iot:Publish",
        "Resource": "*"
      },
      {
        "Effect": "Allow",
        "Action": "iot:Receive",
        "Resource": "*"
      },
      {
        "Effect": "Allow",
        "Action": "iot:Subscribe",
        "Resource": "*"
      }
    ]
  }

Paso 7: Finalizar la Creación del Objeto

Revise todas las configuraciones y haga clic en Crear objeto para completar el proceso.

Paso 8: Guardar Archivos Importantes

Descargue y almacene de forma segura los siguientes archivos proporcionados:
- Punto de enlace de Amazon Trust Services: Necesario para que su dispositivo se conecte al punto de enlace correcto.
- Certificado del dispositivo: Identifica de manera única a su dispositivo en AWS IoT.
- Clave privada: Utilizada para autenticar su dispositivo durante la comunicación.

Paso 9: Verificar la Conectividad

Para asegurarse de que su dispositivo puede comunicarse con AWS IoT, realice una prueba de conectividad.
En la consola de AWS IoT, navegue a Conectar y luego seleccione Conectar un dispositivo.
Siga las instrucciones proporcionadas para su tipo de dispositivo específico.
Por ejemplo, puede utilizar el comando ping para verificar la conectividad con el punto de enlace de AWS IoT:

  ping your-endpoint.iot.us-east-1.amazonaws.com

Reemplace your-endpoint con el punto de enlace específico de su cuenta, que puede encontrar en la sección de detalles del objeto creado.

Paso 10: Crear un Rol de AWS IAM

Para que nuestra función Lambda interactúe correctamente con otros servicios de AWS, necesitamos crear un rol de IAM con los permisos adecuados.

Acceder al servicio IAM: Inicia sesión en la consola de administración de AWS y, en la barra de búsqueda, escribe IAM y selecciona el servicio correspondiente.
Crear un nuevo rol:
- En el panel de navegación izquierdo, haz clic en "Roles" y luego en "Crear rol".
- Selecciona "AWS service" como tipo de entidad de confianza y elige "Lambda" como servicio que usará este rol.
- Haz clic en "Siguiente: Permisos".
Asignar permisos al rol:
- En la lista de políticas, busca y selecciona las siguientes:
  - AmazonBedrockFullAccess
  - AWSIoTFullAccess
  - CloudWatchLogsFullAccess
- Tras seleccionar las políticas, haz clic en "Siguiente: Etiquetas" y luego en "Siguiente: Revisar".
Nombrar y crear el rol:
- Asigna un nombre descriptivo al rol, como AWSLambdaBedrockRole.
- Revisa la configuración y haz clic en "Crear rol".

Paso 11: Crear una Función Lambda

Ahora, crearemos una función Lambda que procesará los datos de temperatura y generará chistes cuando se superen ciertos umbrales.

Acceder al servicio Lambda: En la consola de AWS, busca "Lambda" en la barra de búsqueda y selecciona el servicio.
Crear una nueva función:
- Haz clic en "Crear función".
- Elige "Crear desde cero".
- Configura los siguientes detalles:
  - Nombre de la función: Bedrock-IotLambda
  - Tiempo de ejecución: Selecciona Python 3.12
  - Arquitectura: Selecciona arm64
  - Permisos: Selecciona "Usar un rol existente" y elige AWSLambdaBedrockRole creado anteriormente.
- Haz clic en "Crear función".

Paso 12: Configurar la Función Lambda

Para que la función Lambda se active cuando se detecten temperaturas superiores a 30°C, configuraremos un desencadenador de AWS IoT.

Añadir un desencadenador:
- En la página de detalles de la función Lambda, desplázate hasta la sección "Desencadenadores" y haz clic en "Añadir desencadenador".
- Selecciona "AWS IoT" de la lista.
Crear una regla de IoT personalizada:
- Elige "Crear una regla nueva".
- Proporciona un nombre y una descripción para la regla, por ejemplo:
  - Nombre de la regla: High_Temperature_Trigger
  - Descripción: Activa la función Lambda cuando la temperatura supera los 30°C
- En "Instrucción de consulta de regla", ingresa la siguiente consulta:
```
 SELECT temperature
 FROM 'esp8266/pub'
 WHERE temperature > 30.0
```

Haz clic en "Crear regla".

Paso 13: Clonar Repositorio

✅ Clonar el repositorio

git clone https://github.com/fernandosilvot/App-IoT_GenAI

Repositorio

✅ Ir a:

cd App-IoT_GenAI

Paso 14: Integrar Código

Copia el código llamado lambda.py. Este código, como puedes intuir, es para la función Lambda. Debes subir el código y luego realizar el despliegue.

A continuación, el código para el ESP8266 en Arduino IDE comienza con Main.ino. Completa los campos con la red Wi-Fi y su contraseña, así como el nombre del dispositivo en AWS y el broker de AWS.

En el código env.h, debes integrar los siguientes certificados en este orden:

Punto de enlace de Amazon Trust Services (Amazon trust services endpoint)
Certificado del dispositivo (Device certificate)
Clave privada (Private key file)

Conclusión

La integración del Internet de las Cosas (IoT) con la Inteligencia Artificial Generativa abre nuevas posibilidades. Este proyecto combina hardware accesible y servicios de AWS para crear una aplicación que responde dinámicamente al detectar un aumento en la temperatura, generando contenido entretenido y personalizado.

A lo largo del desarrollo, enfrenté desafíos significativos debido a mi inexperiencia con Arduino IDE y el funcionamiento de la ESP8266. Afortunadamente, conté con el valioso apoyo de Marcos Sepúlveda, quien me guió en temas como MQTT y los detalles técnicos de este módulo, y de Elizabeth Fuentes, quien proporcionó algunos de los materiales necesarios y me ayudó a tener una visión más clara del proyecto.

Uno de los principales retos fue que la ESP8266 solo acepta peticiones HTTP y no HTTPS. Inicialmente, consideré crear una API Gateway, pero solo permite peticiones HTTPS. Sin embargo, otra opción era usar una instancia EC2 para mantener una API; lamentablemente, esta opción incrementaría los costos de manera significativa. Con el apoyo de Elizabeth, exploré otras alternativas y decidí implementar una función Lambda que enviara las respuestas por MQTT directamente al ESP8266. Anteriormente, Marcos me explicó que la ESP8266 podía no solamente enviar datos, si no también recibir datos a través de MQTT, lo que facilitó esta solución.

Este proyecto me permitió aprender sobre las limitaciones técnicas de la ESP8266 y sobre cómo superar problemas complejos con creatividad y colaboración. Agradezco el apoyo recibido y estoy satisfecho de haber completado este desafío.

AWS CLI: Instalación en Windows y Linux, y Uso Básico

Fernando Silva T — Sat, 21 Dec 2024 18:55:14 +0000

¿Qué es la AWS CLI?

La AWS Command Line Interface (CLI) es una herramienta que permite interactuar con los servicios de AWS desde la línea de comandos, simplificando tareas como la gestión de recursos, la automatización de procesos y la integración con scripts personalizados. En este artículo, aprenderás a instalar la AWS CLI en Windows y Linux, y a realizar operaciones básicas.

Instalación en Windows

Descargar el instalador: Ve al siguiente enlace y descarga el archivo .msi: Descargar AWS CLI para Windows.
Ejecutar el instalador: Haz doble clic en el archivo descargado y sigue las instrucciones del asistente.
Verificar la instalación: Abre una ventana de comandos (cmd o PowerShell) y ejecuta:

   aws --version

Si la instalación fue exitosa, deberías ver algo similar a:

   aws-cli/2.x.x Python/3.x.x Windows/x86_64

Instalación en Linux

1- Descargar el paquete:

   curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"

2- Extraer el contenido:

   unzip awscliv2.zip

3- Instalar AWS CLI:

   sudo ./aws/install

4- Verificar la instalación:

   aws --version

Verifica que la salida sea similar a:

   aws-cli/2.x.x Python/3.x.x Linux/x86_64

Nota: Si no tienes unzip instalado, puedes instalarlo ejecutando sudo apt install unzip (Debian/Ubuntu) o sudo yum install unzip (CentOS/RedHat).

Configuración de AWS CLI

Tras la instalación, necesitas configurar tus credenciales:

Ejecuta el comando de configuración:

   aws configure

Proporciona la siguiente información:
- AWS Access Key ID: Tu clave de acceso.
- AWS Secret Access Key: Tu clave secreta.
- Default region name: La región por defecto (ejemplo: us-east-1).
- Default output format: El formato de salida (json, yaml, text o table).

Nota: Si no sabes donde conseguir tu AWS Access Key ID, AWS Secret Access Key recomiendo ir a mi anterior blog Potenciando Aplicaciones de IA con AWS Bedrock y Streamlit.

Esto creará los archivos de configuración en ~/.aws/config y ~/.aws/credentials.

Uso Básico de AWS CLI

Con la AWS CLI configurada, puedes comenzar a interactuar con los servicios de AWS. A continuación, algunos comandos básicos:

S3: Almacenamiento en la nube

Listar buckets:

  aws s3 ls

Crear un bucket:

  aws s3 mb s3://mi-nuevo-bucket

Subir un archivo:

  aws s3 cp archivo.txt s3://mi-nuevo-bucket/

Descargar un archivo:

  aws s3 cp s3://mi-nuevo-bucket/archivo.txt .

EC2: Servidores virtuales

Listar instancias en ejecución:

  aws ec2 describe-instances --filters "Name=instance-state-name,Values=running"

Iniciar una instancia:

  aws ec2 start-instances --instance-ids Id-instancia

Detener una instancia:

  aws ec2 stop-instances --instance-ids Id-instancia

IAM: Gestión de usuarios

Listar usuarios:

  aws iam list-users

Crear un nuevo usuario:

  aws iam create-user --user-name nuevo-usuario

Consejos Finales

Automatización: Crea scripts bash o PowerShell para automatizar tareas repetitivas.
Documentación: Consulta siempre la documentación oficial de AWS CLI para explorar más funcionalidades.
Seguridad: Nunca compartas tus claves de acceso y utiliza IAM para asignar permisos de forma granular.

¡Y eso es todo! Ahora tienes una guía básica para comenzar a usar la AWS CLI en tus proyectos. 🚀

Potenciando Aplicaciones de IA con AWS Bedrock y Streamlit

Fernando Silva T — Tue, 17 Dec 2024 18:40:41 +0000

Este blog detalla cómo construir una aplicación de inteligencia artificial utilizando AWS Bedrock y Streamlit, en la que puedes realizar tareas como el procesamiento de lenguaje natural y la generación de imágenes. Este proyecto se basa en AWS Bedrock para interactuar con modelos de IA avanzados como Claude 3 y modelos de generación de imágenes como Stability AI.

1. Configuración de AWS Credentials

Para que tu aplicación de Streamlit se conecte a los servicios de AWS, necesitas configurar correctamente las credenciales de AWS. A continuación te explico cómo obtener y configurar las claves de acceso necesarias: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, y AWS_DEFAULT_REGION.

Paso a Paso para Obtener las Credenciales de AWS:

Inicia sesión en la Consola de Administración de AWS.

En el menú superior derecho, haz clic en tu nombre de usuario y selecciona "My Security Credentials".

En la sección "Access keys (access key ID and secret access key)", haz clic en "Create New Access Key".

Se generará una nueva clave de acceso. Descarga el archivo de claves, ya que solo podrás ver la AWS_ACCESS_KEY_ID y AWS_SECRET_ACCESS_KEY una vez.

Asegúrate de guardar esta información en un lugar seguro.

Para completar la configuración de las credenciales, deberás colocar las variables obtenidas en un archivo .env, de manera que tu aplicación de Python pueda acceder a ellas sin exponer las claves directamente en el código.

Ejemplo de archivo .env:

AWS_ACCESS_KEY_ID=tu_aws_access_key_id
AWS_SECRET_ACCESS_KEY=tu_aws_secret_access_key
AWS_DEFAULT_REGION=us-west-2

2. Explicación del Código

El código de esta aplicación utiliza varios servicios y librerías importantes para interactuar con AWS Bedrock y generar imágenes utilizando IA. A continuación explicamos las partes más esenciales del código:

2.1 Cargar las Variables de Entorno

from dotenv import load_dotenv

# Cargar las variables de entorno desde un archivo .env
load_dotenv()

La librería dotenv permite cargar las credenciales desde un archivo .env, protegiendo las claves de acceso.

2.2 Conexión a AWS Bedrock

import boto3

# Crear un cliente para el servicio Bedrock de AWS
aws_bedrock = boto3.client('bedrock-runtime', 
    aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
    aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
    region_name=os.getenv("AWS_DEFAULT_REGION")
)

Con boto3, la biblioteca oficial de AWS para Python, nos conectamos al servicio de Bedrock de AWS, que proporciona acceso a modelos como Claude 3 para procesamiento de texto y Stable Diffusion XL para generación de imágenes.

2.3 Generación de Imágenes

def generate_image(prompt, style):
    request_payload = json.dumps({
        "text_prompts": [{"text": f"{style} {prompt}"}],
        "cfg_scale": 9,
        "steps": 50,
    })
    model_response = aws_bedrock.invoke_model(body=request_payload, modelId=image_model_id)
    return decode_image_from_response(model_response)

Esta función envía un prompt al modelo de generación de imágenes de AWS Bedrock y obtiene una imagen como respuesta, la cual luego se decodifica y se muestra al usuario.

2.4 Análisis de Imágenes

def analizar_imagen(ruta_imagen, texto=""):
    """Invoca Claude 3 para el análisis de imágenes y devuelve un texto normal."""
    tipo_archivo, imagen_base64 = codificador_base64_imagen(ruta_imagen)
    prompt_sistema = "Describe cada detalle que puedas sobre esta imagen, sé extremadamente minucioso."

    prompt = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 1000,
        "temperature": 0.5,
        "system": prompt_sistema,
        "messages": [
            {
                "role": "user",
                "content": [
                    {"type": "image", "source": {"type": "base64", "media_type": tipo_archivo, "data": imagen_base64}},
                    {"type": "text", "text": texto or "Usa el prompt del sistema"}
                ]
            }
        ]
    }

    respuesta = aws_bedrock.invoke_model(
        body=json.dumps(prompt), 
        modelId="anthropic.claude-3-sonnet-20240229-v1:0",
        accept="application/json", 
        contentType="application/json"
    )

    salida_llm = json.loads(respuesta.get('body').read())['content'][0]['text']
    return salida_llm  # Devuelve el texto normal

En este bloque de código, la función analizar_imagen utiliza Claude 3 (un modelo de lenguaje de AWS) para analizar una imagen y devolver una descripción detallada de su contenido.

3. Configuración de Streamlit

Streamlit facilita la creación de interfaces web interactivas con Python. En este caso, hemos configurado un panel lateral para elegir entre diferentes tareas de IA. Dependiendo de la opción seleccionada, el usuario puede generar imágenes, realizar análisis de texto o más.

import streamlit as st

st.set_page_config(page_title="Potenciando Aplicaciones de IA con AWS Bedrock y Streamlit", page_icon=icon, layout="wide")
st.sidebar.title("Menú de Opciones")
option = st.sidebar.selectbox("Selecciona la tarea de IA", ["Inicio","Procesamiento de Lenguaje", "Generación de imágenes", "Descripción de Imágenes"])

if option == "Inicio":
    st.image(icon, width=50, output_format="SVG")
    st.title("Potenciando Aplicaciones de IA con AWS Bedrock y Streamlit")
    st.markdown(
        """
        Esta aplicación web permite interactuar con modelos de inteligencia artificial para realizar tareas de procesamiento de lenguaje natural y generación de imágenes.
        """
    )

Este fragmento configura el título y las opciones de la interfaz, permitiendo al usuario interactuar con las distintas funcionalidades de la aplicación.

Mi Proyecto

He trabajado en este proyecto como una forma de integrar poderosos servicios de AWS con Streamlit para crear aplicaciones de inteligencia artificial accesibles y fáciles de usar. Si deseas ver el código fuente o probar la aplicación en vivo, puedes hacerlo a través del siguiente enlace:

Ver el proyecto en GitHub

¿Qué puedes encontrar en el proyecto?

Generación de imágenes utilizando AWS Bedrock
Análisis de imágenes usando el modelo Claude 3 de AWS.
Ejemplo de cómo integrar Streamlit con los servicios de AWS.
Instrucciones detalladas sobre cómo configurar el entorno de desarrollo.

No dudes en explorar el código y hacer preguntas o sugerencias sobre cómo mejorar la aplicación. ¡Estaré encantado de recibir tu feedback!

Conclusión

Este proyecto demuestra cómo utilizar los servicios de AWS Bedrock para potenciar aplicaciones de inteligencia artificial con Streamlit. La configuración correcta de las credenciales de AWS es crucial para garantizar el acceso a los servicios de AWS, y con las herramientas de Python como boto3 y langchain_aws, puedes integrar fácilmente modelos avanzados de procesamiento de lenguaje y generación de imágenes.

Guía Completa para Crear una Web Estática con AWS S3 y AWS CLI

Fernando Silva T — Mon, 15 Jul 2024 02:27:56 +0000

En esta guía, aprenderemos cómo crear y alojar una web estática utilizando Amazon S3 y AWS CLI.

Introducción

Amazon S3 (Simple Storage Service) es un servicio de almacenamiento de objetos ofrecido por Amazon Web Services (AWS). Es ideal para alojar sitios web estáticos, ya que proporciona una forma sencilla y escalable de almacenar archivos. Utilizando AWS CLI, podemos gestionar nuestras credenciales de forma segura y automatizar el proceso de despliegue de nuestro sitio web.

Requisitos Previos

Antes de comenzar, asegúrate de tener:

Una cuenta de AWS activa. # Guía Completa para Crear una Web Estática con AWS S3 y AWS CLI

En esta guía, aprenderás cómo crear y alojar una web estática utilizando Amazon S3 y AWS CLI. Sigue estos pasos para configurar y desplegar tu sitio web de manera eficiente.

Requisitos Previos

Antes de comenzar, asegúrate de tener:

Una cuenta de AWS activa.
AWS CLI instalado en tu máquina.
Credenciales de AWS configuradas en tu máquina.
Un sitio web estático (archivos HTML, CSS y JavaScript listos).

Paso 1: Crear un Bucket en Amazon S3

Primero, necesitamos crear un bucket en Amazon S3 para almacenar los archivos de nuestro sitio web.

Abre la consola de administración de AWS y navega a S3.

Haz clic en "Crear bucket".

Proporciona un nombre único para tu bucket (por ejemplo, mi-sitio-web-estatico).

Selecciona una región.
Deshabilita "Bloquear todo el acceso público" y marca la casilla de consentimiento.

Haz clic en "Create bucket".

Paso 2: Configurar el Bucket para Alojar una Web Estática

Una vez creado el bucket, necesitamos configurarlo para alojar nuestro sitio web estático.

En la consola de S3, selecciona tu bucket.
Ve a la pestaña "Propiedades".

En la sección "Alojamiento de sitios web estáticos", haz clic en "Editar".

Selecciona "Habilitar" y elige "Alojar un sitio web estático".

Especifica los nombres de los archivos de índice y error (por ejemplo, index.html y error.html).

Guarda los cambios.

Paso 3: Subir Archivos al Bucket de S3

Utilizando AWS CLI, subiremos los archivos de nuestro sitio web al bucket de S3.

Abre una terminal y navega al directorio donde están los archivos de tu sitio web.
Ejecuta el siguiente comando para copiar todos los archivos al bucket de S3:

aws s3 sync ./ s3://mi-sitio-web-estatico/

Este comando copiará todos los archivos en el directorio actual al bucket de S3.

Este comando lo uso cada vez que estoy a punto de hacer un git push a mi rama principal, cuando logre poder automatizarlo lo subiré

Guarda los cambios.

Paso 4: Acceder a tu Sitio Web

Ahora, tu sitio web estático debería estar disponible públicamente. Puedes acceder a él utilizando la URL proporcionada en la sección "Static website hosting" de las propiedades de tu bucket de S3.

Conclusión

En esta guía, hemos aprendido cómo crear y alojar una web estática utilizando Amazon S3 y AWS CLI. Este es un método efectivo y económico para alojar sitios web estáticos, aprovechando la escalabilidad y fiabilidad de AWS. Si tienes alguna pregunta o necesitas más ayuda, no dudes en dejar un comentario. ¡Buena suerte con tu sitio web!

Cualquier mejora que tengas no dudes en decirme y lo podré actualizar. Muchas gracias por venir a mi primer blog.

DEV Community: Fernando Silva T

Crea tu asistente personal en los Meta Glasses.

Fernando Silva TFollow

Introducción

El problema y la visión

Arquitectura

Flujo de datos

Stack tecnológico

Demostración en video

Meta-Rock en ejecución

Desafíos técnicos y decisiones de diseño

1. Wake word detection sin librerías externas

2. Envío constante de contexto visual

3. Conversión de formatos de video

4. Integración con Bedrock (Converse API)

5. Gestión de estado en la UI

Casos de uso validados

Resultados

Lecciones técnicas

Próximos pasos

Conclusión

Recursos

Agradecimientos

[Boost]

Build Agentic Video Analysis with TwelveLabs Pegasus in minutes

Diseño e Implementación de Arquitectura CTF LLaitun: de la Primera Experiencia al Liderazgo Técnico

¿Qué es el CTF Llaitun y en qué se diferencia de otros CTF?

🎯 De Colaborador a Líder Técnico

CTF Llaitun 2024: Primeros pasos en un mundo real

CTF Llaitun 2025: El salto al liderazgo

🏛️ Evolución Arquitectónica

2024: limitaciones y aprendizajes

2025: simplicidad elegante

🔧 Desafíos Técnicos Superados

👥 El Ecosistema de Apoyo

📌 Lecciones Clave

🚀 Conclusión

Links:

Integrando Podcasts a Kiu: Cómo Construí un Agente Virtual Serverless con AWS Bedrock y Pinecone

Introducción

El problema y el objetivo

La solución técnica

Arquitectura Serverless con AWS CDK y Python

Flujo de datos

Desafíos y aprendizajes

1. Aprender AWS CDK en Python

2. Integrar Pinecone con Amazon Bedrock

3. Función Lambda para Procesamiento de Datos

4. Seguridad: Roles IAM y Políticas granulares

5. Pruebas Unitarias para asegurar calidad

6. Emojis en los títulos de los episodios

Conclusión

Recursos

Integración IoT y Generative AI: Cómo Crear una App que Cuenta Chistes Basados en la Temperatura

Introducción

Requisitos Previos:

Costo para completar:

¿Cómo funciona esta aplicación?

Muestra los pasos para llegar a la solución

Diagrama de conexión

Conclusión

AWS CLI: Instalación en Windows y Linux, y Uso Básico

¿Qué es la AWS CLI?

Instalación en Windows

Instalación en Linux

Configuración de AWS CLI

Uso Básico de AWS CLI

S3: Almacenamiento en la nube

EC2: Servidores virtuales

IAM: Gestión de usuarios

Consejos Finales

Potenciando Aplicaciones de IA con AWS Bedrock y Streamlit

1. Configuración de AWS Credentials

Paso a Paso para Obtener las Credenciales de AWS:

2. Explicación del Código

2.1 Cargar las Variables de Entorno

2.2 Conexión a AWS Bedrock

2.3 Generación de Imágenes

2.4 Análisis de Imágenes

3. Configuración de Streamlit