DEV Community: Carlos Cortez 🇵🇪 [AWS Hero]

Building Your First RAG System with Amazon Bedrock Agents and FAISS: A Developer's Journey

Carlos Cortez 🇵🇪 [AWS Hero] — Wed, 03 Sep 2025 03:14:15 +0000

Building Your First RAG System with Amazon Bedrock Agents and FAISS: A Developer's Journey

Discover how AI is transforming the way we build intelligent applications in the cloud. Let's explore how to create your first Retrieval-Augmented Generation (RAG) system using Amazon Bedrock Agents (managed AI agents service) with FAISS (Facebook AI Similarity Search) as our local vector database, perfect for those first steps into GenAI territory.

Why FAISS for Your First RAG Adventure?

The idea here is simple: when you're starting with RAG (Retrieval-Augmented Generation, a technique to enrich LLMs with external data), you want to focus on understanding the core concepts without getting lost in database configurations. FAISS runs locally, it's fast, and gives you complete control over your vector operations. Plus, it's free and doesn't require any AWS infrastructure setup for the vector storage part.

In practice, this means FAISS is your local playground where you can experiment, learn, and prototype before moving to production-ready solutions like Amazon OpenSearch Serverless or Amazon MemoryDB.

The Architecture We're Building

Our setup combines the best of both worlds:

Amazon Bedrock Agents: Handles the orchestration, reasoning, and LLM (Large Language Model) interactions
FAISS: Manages vector storage and similarity search locally
Custom Action Group: Bridges the agent with our FAISS operations

User Query → Bedrock Agent → Action Group → FAISS Search → Context → LLM Response

Setting Up Your Local FAISS Environment

Let's explore the initial configuration. What's interesting is that we can have everything running with just a few key components:

import boto3
import faiss
import numpy as np
from sentence_transformers import SentenceTransformer
import json
import uuid
from typing import List, Dict, Any

# Initialize the embedding model
embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
embedding_dimension = 384

# Create FAISS index
index = faiss.IndexFlatIP(embedding_dimension)  # Inner Product for cosine similarity
document_store = {}  # Store original documents with metadata

Creating Your Document Ingestion Pipeline

The idea here is to create a simple but effective ingestion system. My recommendation is to start with this class that encapsulates all the functionality:

class FAISSDocumentStore:
    def __init__(self, embedding_model_name='all-MiniLM-L6-v2'):
        self.embedding_model = SentenceTransformer(embedding_model_name)
        self.dimension = self.embedding_model.get_sentence_embedding_dimension()
        self.index = faiss.IndexFlatIP(self.dimension)
        self.documents = {}

    def add_documents(self, texts: List[str], metadata: List[Dict] = None):
        """Add documents to the FAISS index"""
        if metadata is None:
            metadata = [{}] * len(texts)

        # Generate embeddings
        embeddings = self.embedding_model.encode(texts, normalize_embeddings=True)

        # Add to FAISS index
        start_id = len(self.documents)
        self.index.add(embeddings.astype('float32'))

        # Store documents with metadata
        for i, (text, meta) in enumerate(zip(texts, metadata)):
            doc_id = start_id + i
            self.documents[doc_id] = {
                'text': text,
                'metadata': meta,
                'id': doc_id
            }

    def search(self, query: str, k: int = 5) -> List[Dict]:
        """Search for similar documents"""
        query_embedding = self.embedding_model.encode([query], normalize_embeddings=True)
        scores, indices = self.index.search(query_embedding.astype('float32'), k)

        results = []
        for score, idx in zip(scores[0], indices[0]):
            if idx != -1:  # Valid result
                doc = self.documents[idx].copy()
                doc['similarity_score'] = float(score)
                results.append(doc)

        return results

# Initialize your document store
doc_store = FAISSDocumentStore()

Building the Bedrock Agent Action Group

Let's explore how to create the action group that will handle RAG operations. In practice, this means creating a Lambda function that acts as a bridge:

def lambda_handler(event, context):
    """
    Lambda function to handle Bedrock Agent action group calls
    """

    # Parse the incoming request
    action_group = event.get('actionGroup', '')
    api_path = event.get('apiPath', '')
    http_method = event.get('httpMethod', '')
    parameters = event.get('parameters', [])

    # Extract query parameter
    query = None
    for param in parameters:
        if param.get('name') == 'query':
            query = param.get('value')
            break

    if not query:
        return {
            'messageVersion': '1.0',
            'response': {
                'actionGroup': action_group,
                'apiPath': api_path,
                'httpMethod': http_method,
                'httpStatusCode': 400,
                'responseBody': {
                    'application/json': {
                        'body': json.dumps({'error': 'Query parameter is required'})
                    }
                }
            }
        }

    try:
        # Perform FAISS search
        results = doc_store.search(query, k=3)

        # Format results for the agent
        context_documents = []
        for result in results:
            context_documents.append({
                'content': result['text'],
                'score': result['similarity_score'],
                'metadata': result.get('metadata', {})
            })

        response_body = {
            'query': query,
            'documents': context_documents,
            'total_results': len(context_documents)
        }

        return {
            'messageVersion': '1.0',
            'response': {
                'actionGroup': action_group,
                'apiPath': api_path,
                'httpMethod': http_method,
                'httpStatusCode': 200,
                'responseBody': {
                    'application/json': {
                        'body': json.dumps(response_body)
                    }
                }
            }
        }

    except Exception as e:
        return {
            'messageVersion': '1.0',
            'response': {
                'actionGroup': action_group,
                'apiPath': api_path,
                'httpMethod': http_method,
                'httpStatusCode': 500,
                'responseBody': {
                    'application/json': {
                        'body': json.dumps({'error': str(e)})
                    }
                }
            }
        }

Configuring Your Bedrock Agent

What's interesting is that we can use AWS CLI to create the entire setup. My recommendation is to use this approach:

# Create the agent
aws bedrock-agent create-agent \
    --agent-name "faiss-rag-agent" \
    --description "RAG agent using FAISS for vector search" \
    --foundation-model "anthropic.claude-3-sonnet-20240229-v1:0" \
    --instruction "You are a helpful assistant that can search through documents to answer questions. When a user asks a question, use the search_documents function to find relevant information, then provide a comprehensive answer based on the retrieved context." \
    --region us-east-1

# Create action group (after deploying your Lambda function)
aws bedrock-agent create-agent-action-group \
    --agent-id "YOUR_AGENT_ID" \
    --agent-version "DRAFT" \
    --action-group-name "document-search" \
    --description "Search documents using FAISS vector database" \
    --action-group-executor lambda="arn:aws:lambda:us-east-1:YOUR_ACCOUNT:function:faiss-rag-function" \
    --api-schema '{
        "openapi": "3.0.0",
        "info": {
            "title": "Document Search API",
            "version": "1.0.0"
        },
        "paths": {
            "/search": {
                "post": {
                    "description": "Search for relevant documents",
                    "parameters": [
                        {
                            "name": "query",
                            "in": "query",
                            "required": true,
                            "schema": {
                                "type": "string"
                            },
                            "description": "The search query"
                        }
                    ]
                }
            }
        }
    }' \
    --region us-east-1

Loading Your First Documents

Let's explore how to populate our FAISS index with sample documents:

# Sample documents about AWS services
sample_docs = [
    "Amazon S3 is a highly scalable object storage service that offers industry-leading durability, availability, and performance.",
    "AWS Lambda lets you run code without provisioning or managing servers. You pay only for the compute time you consume.",
    "Amazon EC2 provides secure, resizable compute capacity in the cloud. It's designed to make web-scale cloud computing easier.",
    "Amazon RDS makes it easy to set up, operate, and scale a relational database in the cloud.",
    "Amazon DynamoDB is a key-value and document database that delivers single-digit millisecond performance at any scale."
]

metadata = [
    {"service": "S3", "category": "Storage"},
    {"service": "Lambda", "category": "Compute"},
    {"service": "EC2", "category": "Compute"},
    {"service": "RDS", "category": "Database"},
    {"service": "DynamoDB", "category": "Database"}
]

# Add documents to FAISS
doc_store.add_documents(sample_docs, metadata)
print(f"Added {len(sample_docs)} documents to FAISS index")

Testing Your RAG System

The idea here is to validate that everything works before connecting the components. In practice, this means:

# Test the search functionality
test_query = "What database services does AWS offer?"
results = doc_store.search(test_query, k=2)

print(f"Query: {test_query}")
print("Results:")
for i, result in enumerate(results, 1):
    print(f"{i}. Score: {result['similarity_score']:.3f}")
    print(f"   Text: {result['text']}")
    print(f"   Service: {result['metadata'].get('service', 'N/A')}")
    print()

Connecting Everything with Bedrock Agents SDK

What's interesting is that we can interact with our agent programmatically:

import boto3

def chat_with_rag_agent(query: str, agent_id: str, agent_alias_id: str):
    """
    Chat with the Bedrock agent that uses FAISS for RAG
    """
    bedrock_agent_runtime = boto3.client('bedrock-agent-runtime', region_name='us-east-1')

    try:
        response = bedrock_agent_runtime.invoke_agent(
            agentId=agent_id,
            agentAliasId=agent_alias_id,
            sessionId=str(uuid.uuid4()),
            inputText=query
        )

        # Process the streaming response
        full_response = ""
        for event in response['completion']:
            if 'chunk' in event:
                chunk = event['chunk']
                if 'bytes' in chunk:
                    full_response += chunk['bytes'].decode('utf-8')

        return full_response

    except Exception as e:
        print(f"Error invoking agent: {str(e)}")
        return None

# Example usage
agent_response = chat_with_rag_agent(
    query="What are the benefits of using AWS Lambda?",
    agent_id="YOUR_AGENT_ID",
    agent_alias_id="YOUR_ALIAS_ID"
)

print("Agent Response:", agent_response)

Optimizing Your FAISS Performance

In practice, this means that when you scale up, consider these optimizations:

# For larger datasets, use IndexIVFFlat for faster search
def create_optimized_index(dimension: int, nlist: int = 100):
    """
    Create an optimized FAISS index for larger datasets
    """
    quantizer = faiss.IndexFlatIP(dimension)
    index = faiss.IndexIVFFlat(quantizer, dimension, nlist)
    return index

# Add GPU support if available
def create_gpu_index(dimension: int):
    """
    Create GPU-accelerated FAISS index
    """
    if faiss.get_num_gpus() > 0:
        res = faiss.StandardGpuResources()
        index = faiss.IndexFlatIP(dimension)
        gpu_index = faiss.index_cpu_to_gpu(res, 0, index)
        return gpu_index
    else:
        return faiss.IndexFlatIP(dimension)

Common Pitfalls and How to Avoid Them

1. Embedding Model Consistency
Always use the same embedding model for indexing and querying. Mixing models will give you poor results.

2. Normalization Matters

# Always normalize embeddings for cosine similarity
embeddings = model.encode(texts, normalize_embeddings=True)

3. Batch Processing
For large document sets, process in batches to avoid memory issues:

def add_documents_in_batches(doc_store, texts, batch_size=100):
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i+batch_size]
        doc_store.add_documents(batch)
        print(f"Processed batch {i//batch_size + 1}")

Next Steps and Production Considerations

This setup is perfect for learning and prototyping, but for production, my recommendation is:

Persistence: Save your FAISS index to disk

faiss.write_index(index, "my_index.faiss")

Scalability: Consider Amazon OpenSearch Serverless for production workloads
Monitoring: Add logging and metrics to your Lambda function
Security: Implement proper IAM roles and VPC configurations

El Takeaway Principal

The main takeaway is that starting with FAISS locally allows you to understand RAG fundamentals without additional complexities. Once you feel comfortable, you can explore Amazon Bedrock Knowledge Bases for a fully managed solution, or Amazon OpenSearch Serverless for more advanced vector search capabilities.

Lo interesante es que this approach allows you to iterate quickly, understand each component, and gradually move to more sophisticated setups as your needs grow.

Quick Actions for You

[ ] Set up your local Python environment with the required dependencies
[ ] Create a simple FAISS index with your own documents
[ ] Deploy the Lambda function for the action group
[ ] Configure your Bedrock Agent with the action group
[ ] Test the end-to-end RAG pipeline
[ ] Experiment with different embedding models
[ ] Try optimizing FAISS for your specific use case

My Final Recommendation

Start small with this local FAISS approach to understand RAG fundamentals. Once you're comfortable, explore Amazon Bedrock Knowledge Bases for a fully managed solution, or Amazon OpenSearch Serverless for more advanced vector search capabilities.

The beauty of this approach is that you can iterate quickly, understand every component, and gradually move to more sophisticated setups as your needs grow.

Thanks for reading, now it's your turn to try it out! Let's connect and share our experiences building with GenAI:

🔗 LinkedIn: https://www.linkedin.com/in/carloscortezcloud

🐦 X: https://x.com/ccortezb

💻 GitHub: https://github.com/ccortezb

📝 Dev.to: https://dev.to/ccortezb

🏆 AWS Heroes: https://builder.aws.com/community/@breakinthecloud

📖 Medium: https://ccortezb.medium.com

Stay curious, keep experimenting — and I'll catch you in the next one!

Starting with NLP on AWS from scratch — NLP Series part 1 | by Carlos Cortez | Breaking the Cloud

Carlos Cortez 🇵🇪 [AWS Hero] — Tue, 13 Apr 2021 01:17:56 +0000

Listen this article in our new mode: AudioBlog

It would be great to start segmenting our texts as well as the cover image, which is an Open Source software called Coreference created by Hugging Face, right? Let's go in parts ...

In case you are interested in hearing about Hugging Face and SageMaker, I spoke in depth a few days ago about this topic and its recent alliance with AWS here:

The learning curve

The learning curve is long and can get complex if we want to. For that there are flows and frameworks that will help us know where we are right now.

Natural Language Processing (NLP) flow *

Many times we skip key steps before we really understand each of these procedures. For example, data ingestion, web scraping, text analytics, EDA (exploratory analysis, and much more)

Remember CRISP-DM?

It is a framework for data mining, which is now known more as Machine Learning, Deep Learning, Data Science, etc.

Essentials to get started on AWS

Always to each place we go, we keep this pair in our pocket:

Python 3.x + boto3 *

** Boto3 *, is the AWS python library that will give us access to run and manage any resource within the cloud, as simple as * import boto3, ** and have your private keys configured or your roles correctly created .

Pre-trained models

Pre-trained models help us to shorten research, training and analysis time, and not start inventing what already exists. and for this we can use cloud services.

** Amazon Comprehend (Applied NLP) **, It is a SaaS type service, which means that it is ready to consume an API with the AWS boto3 library and begin to obtain insights from the data. It contains models already trained by Amazon Web Services, which we can reuse to start our own, and we will start knowing this great service and start building interesting applications using other AWS services.

** Hugging Face (advanced) **, later we will play with transformers, tokenizers, and more with these Deep Learning models of Hugging Face.

Build your own models:

Once we have a good understanding of NLP's self-managed cloud services, we can move to the next level with Amazon Sagemaker.

Or, with your own containers, which we will also learn, or locally

NLP Open Source Libraries

I will mention these for now and we will surely know more than 2 of this list in the coming months:

NLTK
Spark NLP
CoreNLP
SpaCy
Pytorch
Tensorflow
etc..

Tools and IDEs

From now on we will begin to know and learn step by step, what it is like to work in the cloud with an IDE for Data Science, and learn about AI services on AWS.

I recommend taking a look at the following, some paid and some free.

Sagemaker Studio / Sagemaker Notebooks
Jupyter Notebooks / Jupyter Lab
Databricks
Google Colab
among others ...

To start for free, I suggest ** Databricks and Colab **, the first one, has a community platform that allows you to create free clusters and they are eliminated if you do not use it for limited times, and Google's Colab, you can run it directly on your Google Drive, at no cost.

Deployment of my models in the cloud

It is not yet time to think about deploying, and yes, we will find many, many ways to do it, from the oldest to the most modern.

Traditional servers (VMs, Bare Metal)
Containers (such as AWS ECS, EKS, Fargate)
Without Servers (Functions as a Service)

This is a very good way to start, putting together serverless and Sagemaker.

Think Serverless First

Now we can start working without having to run servers using AWS Lambda, AWS Step Functions, Sagemaker Pipelines, AWS CodePipeline, which are services already deployed in the cloud that we can use to speed up our development and start-up.

In the following posts we learn how to deploy with AWS Lambda and Amazon Comprehend.

Amazon Comprehend and its superpowers

Can you imagine something as simple as writing a few lines of code to create a word detector and phrase extraction in just a few minutes instead of many hours of research? It is possible if you start to take advantage of Amazon Comprehend, a little Python and a couple of drops of Serverless

Phrase extraction:

We are using Python 3.6 here with boto3, the library

response **=** client**.**detect_key_phrases(

Text=’string’,

LanguageCode=’en’|’es’

)

Extraction of Entities, sentiment, language, syntax, topics, and document classification, are some of the additional things that we are going to do with Comprehend, as well as a specific version for Medicine, called ** Amazon Comprehend Medical **

What do we continue with?

Data ingestion and text Analytics is part of the important bases to understand NLP, so in the next post, we will start to build our first data ingestion of a web, to be able to obtain data, texts, titles, in a data frame to play.

** Next post: (on air on April 02) **

(Post Original: Medium and
Dev.cortez.cloud )

If you liked this post, give it a like, share and comment.

Learn by breaking things.

Subscribe to my channel, Breaking the Cloud and be Up to date with AWS at https://cortez.cloud

⭐Subscribe to my channel : http://bit.ly/aldiaconaws

videos, AWS news, analytics, reviews, demos, workshops

🔥🔥 Sígueme en mis redes 🔥🔥

follow me:

🦜 My Twitter: https://twitter.com/ccortezb

📺 Youtube Channel: http://bit.ly/aldiaconaws

📺 AWSUGPerú: https://www.youtube.com/awsusergroupperuoficial

📟 My Facebook: https://www.facebook.com/ccortezb/

🤳 My Instagram: ccortezbazan

📜My AWS Courses: https://cennticloud.thinkific.com

🕮 My blog — cortez.cloud

Thank you very much, I hope we see each other again

🔥🔥 About me 🔥🔥

Cortez.Cloud/whoami

Let me present to you, my little personal website https://www.Cortez.Cloud called “Breaking the Cloud”.

I will continue to create content each week from AWS on Al / ML, Serverless, Security and how to break the rules!

Also my next initiatives, workshops, courses, free videos, awsugperu and more.

Empezando con NLP en AWS desde cero - NLP Series 1

Carlos Cortez 🇵🇪 [AWS Hero] — Wed, 31 Mar 2021 04:15:22 +0000

Sería genial ya empezar a segmentar nuestros textos así como la imagen de portada que es un software Open Source llamado Coreference creado por Hugging Face, no? Vamos por partes…

Por si te interesa escuchar Sobre Hugging Face y SageMaker, hablé hace unos días profundamente sobre este tema y su reciente alianza con AWS aquí:

Al día con AWS - Ep 4 La semana de ML con algunas ROSAs en AWS (Marzo 21 al 29)

La curva de Aprendizaje

La curva de aprendizaje es larga y puede volverse compleja si quisiéramos. Para eso existen los flujos y los frameworks que nos van a ayudar a saber en qué parte estamos ahora mismo.

Flujo de Procesamiento de lenguaje natural (NLP)

Muchas veces saltamos pasos claves antes de entender realmente cada uno de estos procedimientos. Por ejemplo, la ingesta de datos, web scraping, text analytics, EDA (exploratory analysis, y mucho más)

¿Recuerdan CRISP-DM?

Es un framework para realizar minería de datos, lo que ahora se conoce más como Machine Learning, Deep Learning, Data Science, etc..

Lo indispensable para empezar en AWS
Siempre a cada lugar que vayamos, guardemos en el bolsillo esta dupla:

Python 3.x + boto3

Boto3, es la librería de python de AWS que nos dará acceso a ejecutar y administrar cualquier recurso dentro de la nube, tan sencillo como un import boto3, y tener tus llaves privadas configuradas o tus roles correctamente creados.

Modelos pre-entrenados

Los modelos pre entrenados nos ayudan a acortar tiempo de investigación, de entrenamiento y de análisis, y no empezar a inventar lo que ya existe.

Amazon Comprehend (NLP Aplicado), Es un servicio de tipo SaaS, que quiere decir que está listo para poder consumir un API con la librería de AWS boto3 y empezar a obtener insights de los datos. Contiene modelos ya entrenados por Amazon Web Services, que podemos re utilizar para empezar los nuestros, e iniciaremos conociendo este gran servicio y empezar a construir aplicaciones interesantes usando otros servicios de AWS.

Hugging Face (avanzado), más adelante jugaremos con transformers, tokenizers, y más con estos modelos de Deep Learning de Hugging Face.

Construir tus propios modelos:

Una vez entendamos muy bien los servicios auto administrados en la nube de NLP, podemos pasar al siguiente nivel ya se con Amazon Sagemaker
o con tus propios Containers, que también lo aprenderemos, o en modo local

Librerías NLP Open Source

Mencionaré estos por ahora y seguro conoceremos más de 2 de esta lista durante los próximos meses:

NLTK
Spark NLP
CoreNLP
SpaCy
Pytorch
Tensorflow etc..

Tools e IDEs

Desde ahora empezaremos a conocer y aprender paso a paso, cómo es trabajar en la nube con una IDE para Ciencia de Datos, y conocer los servicios de AI en AWS.

Recomiendo echar un vistazo a las siguientes, algunas de pago y otras gratuitas.

Sagemaker Studio / Sagemaker Notebooks
Jupyter Notebooks / Jupyter Lab
Databricks
Colab de Google entre otros...

Para empezar de manera gratuita, sugiero Databricks y Colab, el primero, tiene una plataforma de comunidad que te permite crear cluster gratuitos y se eliminan si no lo usas durante tiempos limitados, y Colab de Google, puedes ejecutarlo directo en tu Google Drive, sin costo alguno.

Despliegue de mis modelos en la nube

Aún no es momento de pensar en desplegar, y sí, encontraremos muchísimas maneras de hacerlo, desde la más antigua, a la más moderna.

Servidores tradicionales (VMs, Bare Metal)
Contenedores (como AWS ECS, EKS, Fargate)
Sin Servers (Funciones como Servicio)

Esta es una muy buena manera de empezar, juntando serverless y Sagemaker.

Think Serverless First

Ahora podemos empezar a trabajar sin tener que correr servidores usando AWS Lambda, AWS Step Functions, Sagemaker Pipelines, AWS CodePipeline, que son servicios ya desplegados en la nube que podemos utilizar para agilizar nuestro desarrollo y puesta en marcha.

En los siguientes posts aprendemos a desplegar con AWS Lambda y Amazon Comprehend.

Amazon Comprehend y sus superpoderes

Imaginas algo tan sencillo como escribir algunas líneas de código para crear un detector de palabras y extracción de frases en tan solo unos minutos en vez de muchas horas de investigación? Es posible si empiezas a sacarle provecho a Amazon Comprehend, un poco de Python y un par de gotitas de Serverless

Extracción de frases:

Estamos usando aquí Python 3.6 con boto3, la librería

response = client.detect_key_phrases(
    Text='string',
    LanguageCode='en'|'es'
)

Extracción de Entidades, sentimiento, lenguaje, sintaxis, tópicos, y clasificación de documentos, son algunas de las cosas adicionales que vamos a realizar con Comprehend, así como una versión específica para Medicina, llamada Amazon Comprehend Medical

¿Con qué continuamos?

La ingesta de datos y el text Analytics, es parte de las bases importantes para comprender NLP, así que en el siguiente post, empezaremos a construir nuestra primera ingesta de datos de una web, para poder obtener datos, textos, títulos, en un data frame para jugar.

Siguiente post: (Al Aire el 02 de Abril)

Si te gustó este post, dale un like, comparte y comenta.

Rompiendo se aprende

Suscríbete a mi canal, Breaking the Cloud y Al día con AWS en https://cortez.cloud

⭐Suscríbete a mi canal : http://bit.ly/aldiaconaws

videos, noticas de AWS, análisis, demos, workshops

🔥🔥 Sígueme en mis redes 🔥🔥

follow <- me()

🦜 Mi Twitter: https://twitter.com/ccortezb

📺 Youtube Channel: http://bit.ly/aldiaconaws

📺 AWSUGPerú: https://www.youtube.com/awsusergroupperuoficial

📟 Mi Facebook: https://www.facebook.com/ccortezb/

🤳 Mi Instagram: ccortezbazan

📜 Mis cursos de AWS: https://cennticloud.thinkific.com

🕮 Mi blog — cortez.cloud

Muchas gracias, espero nos volvamos a ver

🔥🔥 Acerca de mí 🔥🔥

Cortez.Cloud/whoami

Les presento mi pequeña web personal https://www.Cortez.Cloud llamado “Breaking the Cloud”.

Seguiré creando contenido cada semana de AWS sobre Al/ML, Serverless, Security y como romper las reglas!

También mis próximas iniciativas, talleres, cursos, videos gratuitos, awsugperu y más.

Trabajando con Amazon DocumentDB desde mi local

Carlos Cortez 🇵🇪 [AWS Hero] — Tue, 30 Mar 2021 17:46:02 +0000

Hoy vamos a continuar con la 2da parte de las series de Aprendiendo DocumentDB en AWS, Si aún no has visto la 1ra parte, ve aquí: https://www.cortez.cloud/blog/primeros-pasos-con-amazon-documentdb-y-aws-cli

Siempre es importante trabajar localmente, y casi siempre se cometen errores y descuidos que hacen que nuestros ambientes de desarrollo estén expuestos a conexiones locales inseguras. Para ello vamos a asegurar nuestra conexión poco a poco, y en este post aprenderemos a usar las herramientas que nos permitirán una mejor administración de nuestra instancia.

En el anterior post, explicamos cómo crear un cluster e instancias de DocumentDB con AWS CLI, así que partamos desde allí y veamos cómo trabajar localmente con ello.

Usando Robo3T (Ex Robomongo)

Primero que todo veamos la arquitectura esencial y más eficiente para trabajar con DocumentDB:

Me conecto desde mi escritorio y voy instalando Robo3T y mongodb client 3.6 (funciona para mac, windows, linux)

https://robomongo.org/download

Bonita arquitectura, pero ¿Qué es un Bastion Host?

Es un servidor puente, en el cual usaremos recursos para poder saltar a otras partes de la red. En este caso, lo usaremos para saltar de una red pública a una privada que es dónde estará docdb.

Ejemplo:
un EC2, una máquina virtual, una droplet, etc

Veamos paso a paso, cómo configurar desde cero mi conexión hacia mi cluster

Crear un ec2 como bastion Host:

Ya hemos visto cómo usar la CLI, así que hagamos lo siguiente y creemos un EC2, Security groups y agreguemos permisos para poder acceder desde la IP que tengas en casa:

$ aws ec2 create-security-group --group-name docdb --description "docdb" --vpc-id  vpc-81a06de4
{
    "GroupId": "sg-031f86d07f253eacf"
}

Ahora, verifica tu IP Pública, también por cli, somos unos fanáticos de la cli ahora!

curl https://checkip.amazonaws.com
190.236.xxx.xxx

*(usa tu propio resultado para las siguientes líneas..)

Agreguemos estas reglas en nuestro nuevo SG para luego poder usarlo en el bastion host EC2:

Abrir puerto 22

aws ec2 authorize-security-group-ingress --group-id sg-031f86d07f253eacf --protocol tcp --port 22 --cidr 190.236.xxx.xxx

Abrir puerto 27017 y 27018 (mongodb y adicional para el bastion host)

aws ec2 authorize-security-group-ingress --group-id sg-031f86d07f253eacf --protocol tcp --port 27017 --cidr 190.236.xxx.xxx

aws ec2 authorize-security-group-ingress --group-id sg-031f86d07f253eacf --protocol tcp --port 27018 --cidr 190.236.xxx.xxx

habilitar acceso de mongodb hacia sí mismo:

aws ec2 authorize-security-group-ingress --group-id sg-031f86d07f253eacf --protocol tcp --port 27017 --source-group
 sg-031f86d07f253eacf

Creamos ahora la instancia:

$ aws ec2 run-instances --image-id ami-067f5c3d5a99edc80 --count 1 --instance-type t2.micro --key-name ~/llaves/docdb-ccortez.pem --security-group-ids sg-031f86d07f253eacf --subnet-id subnet-6d558c08

Configuramos SSH tunnel para poder habilitar o deshabilitar cuando queramos:

sudo vim .ssh/config

Host tunnel
HostName 52.89.199.68
User ec2-user
IdentitiesOnly yes
IdentityFile ~/llaves/docdb-ccortez.pem
LocalForward 27018 docdb-001.cluster-cgyttffk8nhp.us-west-2.docdb.amazonaws.com:27017:27017

También es posible crear un bashero ejecutable aparte para no sobreescribir el archivo ~/.ssh/config

OJO: puedes refrescar, borrar caché o abrir una terminal nueva para renovar la conexión del túnel en caso tengas problemas para abrirlo, o te aparezca algún error.

Iniciamos nuestra conexión con Robo3T, así, en la 1ra pestaña,

Config inicial:

Autenticación

Opcional:
Database: admin (no vamos a poder ver la base de datos admin pero si todas las demás)

SSH tunnel:

SSL Certificate (en caso sea):

(Advanced Options)
Invalid Hostnames: Allowed

Test final de conexión:

En caso sea un cluster creado sin SSL: (opcional, en este ejemplo usé otro cluster que creé sin SSH llamado docdb2)

Conclusiones:

Conectarse a Docdb es fácil, y seguro.
Nos incentiva a crear arquitecturas más seguras, a usar más la capa privada para las bases de datos.
Con estos tutoriales, irás aprendiendo a usar una base de datos NoSQL desde cero.

Próximos pasos

En el próximo post, empezaremos con las migraciones hacia Amazon DocumentDB con AWS DMS.

Aún necesitamos ahondar más en la seguridad y los accesos, así como seguir aprendiendo más de AWS CLI.

Suscríbete a mi canal, Breaking the Cloud y Al día con AWS en https://cortez.cloud
Si te gustó este post, dale un like, comparte y comenta.
⭐Suscríbete a mi canal : http://bit.ly/aldiaconaws

🔥🔥 Sígueme en mis redes 🔥🔥

🦜 Mi Twitter: https://twitter.com/ccortezb

📺 Youtube Channel: Al día con AWS / Breaking The Cloud: http://bit.ly/aldiaconaws

📺 AWS Perú Community AWS UG Perú Oficial: https://www.youtube.com/awsusergroupperuoficial

📟 Mi Facebook: https://www.facebook.com/ccortezb/

🤳 Mi Instagram: ccortezbazan

📜 Mis cursos de AWS: https://cennticloud.thinkific.com

🕮 Mi blog — https://cortez.cloud

🔥🔥 Acerca de mí 🔥🔥

https://www.cortez.cloud/whoami

Les presento mi pequeña web personal https://www.Cortez.Cloud llamado “Breaking the Cloud”.

Seguiré creando contenido cada semana de AWS sobre Al/ML, Serverless, Security y como romper las reglas!

También mis próximas iniciativas, talleres, cursos, videos gratuitos, awsugperu y más.

aws #breakingthecloud

Análisis en caliente de la Keynote de Andy Jassy Parte 1 - reinvent 2020

Carlos Cortez 🇵🇪 [AWS Hero] — Wed, 02 Dec 2020 01:40:08 +0000

Hola a todos, bienvenido a #BreakingtheCloud, yo soy Carlos Cortez @ccortezb y esto es cobertura del re:invent 2020 día tras día.

¡Vayamos directo al grano!

Nuevas instancias y más nombres que aprenderse

Alguna de ellas que soportan Arm Graviton2
Amazon EC2 C6gn! Con 100 gbps

Durante la mañana también fue lanzado:
*D3dn (Dense Storage)
*R5b (EBS Performance)
*M5zn (ntel Xeon Scalable CPU)
*G4ad (AMD GPUs)

Nuevas características:

Nueva EC2 D3 y D3dn hace referencia a instancias con bajo costo en discos magnéticos. Son perfectos para procesamiento big data y montar los datos en HDFS, procesamiento de logs, etc.

Cabe resaltar que el costo de Terabytes es 80% menor que cuando usábamos D2.

Nueva EC2 R5b, nueva en la familia, con AWS Nitro System, con 60 gbps de ancho de banda en el EBS y con 260 mil de IOPS ya se nos desborda de las manos! OMG! La R5 norma solo llega hasta 19 gbps

Cuando pensábamos que ya habíamos tocado el cielo, viene la nueva EC2 M5zn! La evolución de la z1d, también con AWS Nitro System y EFA (Elastic Fabric Adapter) especialmente diseñada para HPC.

Pero, ¿para qué se necesitaría este tipo de instancia? Lo vimos en la Keynote, un buen ejemplo es BOOM, Supersonic Passenger Airplanes.

*Industria Aeroespacial
*Automoviles
*Aplicaciones financieras
*Simulación de modelamiento de aplicaciones
*Energía, etc..

Habana Gaudi-based Amazon EC2 instances

La verdadera competencia de NVIDIA

AWS, nunca escapa poder presentar nueva tecnología para machine learning, pero que cosa realmente es Habana Gaudi?
Habana Labs es una start-up israelí, adquirida luego por Intel que tienen los Procesadores para AI, llamados Gaudi AI processors.

Excelentes para correr modelos de deep learning, en todas sus gamas: NLP, Computer vision, motor de recomendaciones, etc.
Por qué Habana Gaudi?

40% más económicas que las anteriores EC2 con procesamiento de GPU para ML. Y Lo más impactante es que tendremos hasta 8 tarjetas Gaudi:

An 8-card Gaudi EC2 instance can process about 12,000 images->per-second training the ResNet-50 model on TensorFlow. Each >Gaudi processor integrates 32GB of HBM2 memory and features >RoCE on-chip integration used for inter-processor >connectivity inside the server. Scaling across servers will >be enabled using the AWS Elastic Fabric Adapter (EFA) >technology, allowing AWS and its customers to seamlessly >expand use of multiple Gaudi based systems for efficient and >scalable distributed training.

Fuente: Hanaba: https://habana.ai/habana-gaudi-ai-processors-to-bring-lower-cost-to-train-to-amazon-ec2-customers/

El hermano menor de Inferencia: AWS Trainium

Un Billón de cálculos por segundo? La mayor cantidad de TFLOPS, chip de entrenamiento? ¿Qué son estas cosas y cómo lo entendemos más fácil?

Primero que todo, volvamos a Inferentia, que fue lanzado en el 2019. Palabras claves?

Chip de inferencia para modelos de ML
Neuron SDK, ¿qué es? Un compilador.
Instancias Inf1 EC2, que corren con el chip de Inferencia.

Aprendamos los términos:

El término FLOPS (Floating point operations per second) >significa “operaciones de coma flotante por segundo”, es una >unidad que se utiliza para medir cálculos matemáticos que >puede hacer por segundo una CPU o en una GPU.
De allí viene GigaFlops, es decir millones de cálculos por >segundo y TeraFlops, Billones de cálculos por segundo.

AWS Trainium sale a cubrir todo lo que Inferentia no hace, es decir la parte del entrenamiento. También funcionará con Neuron SDK y en instancias Inf1

Ya puedo usarlo?

No, aún estará disponible en los primeros meses del 2021. Así que atento a las noticias.

Nos alineamos con las nubes. ECS y EKS desde cualquier lado.

Ahora podremos correr cargas de trabajo literalmente desde donde se nos plazca,

Como funcionará?

Seguiremos usando el Clásico ECS Control Plane dentro de la región
Se instalará el agente de AWS Systems Manager
Se agrega y veremos un nuevo tipo de opción para lanzar ECS, aparte de los ya conocidos “EC2” y “FARGATE” se tendrá uno nuevo llamado “EXTERNAL”.

Revisen el blog oficial donde encontrarán una demo y un diagrama de cómo se verá realmente:

EKS Distro de código abierto!

ECS no es el único que recibe una actualización, sino que EKS también podrá “desplegarse en cualquier lado” de una manera distinta. La distribución de Kubernetes que usa EKS será puesta a disposición de la comunidad.

Veamos qué podemos construir con esta nueva característica en la que recién tendremos acceso a mediados del 2021.

Github Repo:

https://github.com/aws/eks-distro

Lambda ahora nos cobra por cada 1 ms. Debo preocuparme?

Serverless Lovers, acaso no es genial que ahora Lambda nos cobre por cada milisegundo procesado de cómputo?

Solo si tienen cargas de trabajo de millones y millones de transacciones verás la diferencia sustancial.
Tengo que resaltar que también va a ser soportado por Provisioned Concurrency para realizar pruebas de carga. Esto sí está espectacular!

Ejemplo:

50 millones de transacciones de 100 ms vs 50 ms tiene una mejora de 25% en costos.

Desarrollando microservicios ahora con AWS Proton!, es en serio? Más vendor lock-in? más simplicidad?

Después de leerme parte de la documentación, tengo que decirles que aprovechen este post, porque les explicaré algo que me tomó varios minutos entenderlo. Vamos AWS, sí que hiciste algo complicado al inicio con todos esos componentes nuevos, templates, environments, services, services templates y más! Ufff, ahora sí vayamos a AWS Proton:

Qué realmente es?

Automatiza:

aprovisionamiento y
despliegue: Sólo para infraestructura relacionada con Serverless y Contenedores. Con 2 caminos: Equipo de infra aprovisiona y Equipo de desarrollo consume.
Infra estandarizada: CloudFormation
CI/CD Integrado para que sea consumido por los desarrolladores.

Cómo va funcionar?

Antes de nada según la documentación nos piden algunos pre-requisitos!!!!!
Permisos de Admin, IAM Roles, Saber CloudFormation y Jinja y pues un repositorio Github

Proton desde cero:

Creamos la plantilla de ambientes (environment template)
Creamos un ambiente (Proton Environment)
Crear una plantilla de servicio
Crear un Proton Service y desplegar una aplicación

Proton simplifica la entrega de infraestructura como también define un estándar. Es cierto que seguimos usando CloudFormation, posiblemente veamos integraciones internas con SAM y luego con third-party apps como Terraform que puedan ir agregándole a esta gran herramienta.

Genera vendor lock-in de alguna manera, seguimos usando CloudFormation, tal vez en el roadmap de desarrollo estén pensando integrar herramientas de testing para plantillas así como pruebas de seguridad,

Beneficios?

*Rapidez en la entrega de Infraestructura para los que ya *tenemos todo corriendo con CloudFormation.
*Simplicidad para el desarrollador elegir y desplegar en ambientes aislados
*Pruebas rápidas de aplicaciones

Estemos atentos a lo que se viene con AWS Proton!

¡Actualizados al fin! ¡Llegó la nueva generación de EBS! gp3 e io2

¿Qué hay de nuevo con gp3? 20% más económico y 4x mejor performance

Simplemente una muy buena opción, ahora tendremos 3,000 IOPS de base para todo el volumen, mientras que en gp2 tenemos 3 IOPS por GB.

Habrá que afinar más la calculadora para ver cuál conviene y en qué momento.

Acciones inmediatas: Migremos todo a gp3 right now!

Pueden revisar más en el blog oficial de AWS:
https://aws.amazon.com/es/blogs/aws/new-amazon-ebs-gp3-volume-lets-you-provision-performance-separate-from-capacity-and-offers-20-lower-price/

Y por último, tenemos a:

Nuevo EBS io2 Block Express al mismo precio que io1?

La nueva generación de los discos EBS especializados para IOPS, tienen un gran aumento en el ratio de IOPS por GB, subiendo a 500 IOPS por GB.

Lo interesante y raro al mismo tiempo es que está al mismo precio que su generación anterior y sport muchisimo más IOPS, de manera que es mandatorio que migremos todo lo que actualmente esté en io1 hacia io2

Algo tan simple como esto:

aws ec2 modify-volume --volume-id vol-0b3c663aeca5aabb7 --volume-type io2

Pueden revisar más en el blog oficial de AWS:

https://aws.amazon.com/es/blogs/aws/new-ebs-volume-type-io2-more-iops-gib-higher-durability/

Definitivamente fue un día muy largo y lleno de emociones. Lo vivimos tal cual fuese presencial, como un partido de Fútbol, cómo cuándo Perú volvió al mundial después de 36 años. Gritando cada nuevo servicio lanzado, especialmente los de Sagemaker que son mis favoritos y haré un post especial para cada uno de ellos!

Por ahora terminamos con esta parte 1 del Keynote, realmente espectacular y esperando probar estos servicios en estos días, espero les haya servido y por favor comenten y compartan.

En la siguiente parte:

Parte 1: EC2 y microservicios
Parte 2: Bases de datos y ML
Parte 3: Contact Center e Industrial IoT

Unanse al Slack de AWS UG Perú para recibir noticias en vivo del re:invent 2020,

Estén atentos para cuando lancemos los After Party de los anuncios en las noches, y puedas unirte a discutir con nosotros. Vive las reacciones en vivo, repasemos los nuevos servicios y más sorpresas y sorteos!

Slack: https://join.slack.com/t/aws-peru/shared_invite/zt-jt2324io-3VBHUQ8iH5rEkqGchKicEw

Carlos Cortez - AWS UG Perú Leader / AWS ML Community Builder
ccortez@aws.pe
@ccortezb
Podcast: imperiocloud.com @imperiocloud
twitch.tv/awsugperu
cennticloud.thinkific.com

Primeros pasos con Amazon DocumentDB y AWS CLI

Carlos Cortez 🇵🇪 [AWS Hero] — Tue, 20 Oct 2020 06:22:26 +0000

Hola a todos, bienvenido a #BreakingtheCloud, yo soy Carlos Cortez @ccortezb
Y estas serán unas series donde hablaremos de una de las bases de datos más interesantes en AWS: Amazon DocumentDB

Primero que todo debemos de saber de qué tipo de base de datos estamos hablando. DocumentDB, pertenece al grupo de bases de datos NoSQL orientadas a documentos.

NoSQL, significa Not Only SQL, donde los modelos de datos pueden ser esquemas flexibles que se adaptan a los requisitos de las aplicaciones más modernas.

Les recomiendo leer a Martin Fowler,

https://martinfowler.com/tags/noSQL.html

Pero, porqué deberíamos usar una base de datos orientada a documentos? Cuál es la verdadera ventaja? Qué tipos de aplicaciones son las que usualmente se desarrollan usando una base de datos orientada a documentos?

Vayamos paso a paso, no nos desesperemos, hay mucho por describir en el mundo de Nosql y más aún en Amazon Web Services

Lo primero que debemos saber, es que una de las bases de datos más conocidas y comerciales orientadas a documentos es MongoDB

Ahora, DocumentDB, según la documentación de AWS, DocumentDB tiene compatibilidad con MongoDB 3.6 exactamente en el momento que estoy escribiendo este post, pero qué significa que sea “compatible” realmente? La verdad detrás de este espectacular motor de base de datos es que no replica nada de MongoDB 3.6, sino que emula el comportamiento del motor, y de sus componentes.

Muchas de sus funcionalidades que empezaremos a conocer se pueden realizar en DocumentDB, la manera cómo hacemos las consultas, creación de índices también son compatibles y cómo usamos los comandos, se mantiene:

https://docs.aws.amazon.com/documentdb/latest/developerguide/what-is.html

Ahora que sabemos, revisemos los componentes y funcionalidades que tiene DocumentDB. Este servicio se compone por una capa de cluster, instancia y almacenamiento. Así como en Mongodb al crear múltiples instancias introducimos el término de replica set o ReplSet, en dónde existe un nodo máster y nodos réplicas. En DocumentDB las réplicas se conocen como nodos de lectura y el máster como nodo de escritura.

Manos a la obra ahora, empezamos a jugar con la línea de comandos de AWS, la famosa CLI, y lo haremos dentro de una instancia de Cloud9 con un InstanceRole

Primero creemos una instancia de Cloud9

Vamos a crear un instance Role, vamos al servicio IAM y le damos a create role y también agregamos documentDB Full Access al rol.

Elegimos las políticas de IAM necesarias, en este caso accesos Full para DocumentDB, esto nos permitirá acceder por líneas de comandos a todas la API de DocumentDB

Seleccionamos EC2 para que asuma el rol

Creamos un Instance Role en IAM y cambiamos en EC2 del Cloud9, al nuevo rol.

Luego solo reemplazamos el rol por defecto de Cloud9 por el nuevo creado. Otra opción es también solo editar el rol por defecto y agregarle las políticas que creas necesario.

Ahora toca desactivar las credenciales temporales en cloud9 para poder trabajar con Roles
Ir a configuracion
AWS Settings
Desactivar Temporary Credentials

SI quieres saber más de el principio de “Least privilege” dale un vistazo a IAM Keeper:
https://medium.com/@iamkeeper/achieving-least-privilege-permissions-in-aws-97ab8378fb2#:~:text=One%20of%20the%20basic%20principles,required%20to%20get%20job%20done.

Ahora que ya podemos ejecutar CLI en cloud9, vayamos a crear recursos de DocumentDB,

Ejemplo:

aws docdb create-db-cluster \
      --db-cluster-identifier docdb-cluster \
      --engine docdb \
      --deletion-protection \
      --master-username ccortez \
      --master-user-password cortez,,123 \
      --region us-west-2

Puedes ir verificando lo que creas con describe-db-clusters así:

Describe clusters:

aws docdb describe-db-clusters --filter Name=engine,Values=docdb --region us-west-2

Otra manera de buscar con filtros con la CLI es la siguiente:

Describe Clusters con filtros:

aws docdb describe-db-clusters \
   --filter Name=engine,Values=docdb \
   --db-cluster-identifier docdb-cluster \
   --region us-west-2

Ahora que el cluster está creado, vamos a crear instancias dentro del cluster:

Crear instancia de documentDB en el Cluster creado

aws docdb create-db-instance \
    --db-cluster-identifier docdb-cluster \
    --db-instance-class db.t3.medium \
    --db-instance-identifier docdb-cluster-instance01 \
    --engine docdb

(Opcional) Otra manera de lanzar clusters e instancias de DocumentDB es usar CloudFormation, la herramienta de

Infraestructura como código de AWS:

https://s3.amazonaws.com/amazon-documentdb-samples/v1/cloudformation-templates/documentdb_full_stack.yaml

Finalmente, necesitamos instalar el cliente de Mongodb 3.6 en nuestra consola de Cloud9,
Eso lo podemos hacer directamente con esta documentación oficial:

https://docs.mongodb.com/v3.6/tutorial/install-mongodb-on-amazon/

E intentemos conectarnos desde nuestra instancia Cloud9,

mongo --host docdb-cluster.cluster-cgyttffk8nhp.us-west-2.docdb.amazonaws.com:27017 --username ccortez --password ccortez,,123

Por ahora terminamos con este primer tutorial, espero les haya servido y por favor comenten y compartan.

Estas series de DocumentDB cuentan con los siguientes post:

Primeros pasos con Amazon DocumentDB y AWS CLI
Trabajando con Amazon DocumentDB desde mi local
Migrando hacia Amazon DocumentDB con AWS DMS
Migrando hacia Amazon DocumentDB de la manera tradicional
Configurando SSL en Amazon DocumentDB
Backup de Indices con Amazon DocumentDB Index Tool
Creación de perfiles de consultas de ejecución lenta en
Amazon DocumentDB (slow queries profiling)

Muchas gracias,

Carlos Cortez
ccortez@aws.pe
@ccortezb
Podcast: imperiocloud.com @imperiocloud
twitch.tv/breakingthecloud
cennticloud.thinkific.com