Descubra información sobre costos y uso de AWS con IA generativa impulsada por Amazon Bedrock

Administrar los costos de la nube y comprender el uso de los recursos puede ser una tarea abrumadora, especialmente para organizaciones con implementaciones complejas de AWS. Informes de uso y costos de AWS (AWS CUR) proporciona información valiosa sobre los datos, pero interpretar y consultar los datos sin procesar puede ser un desafío.

En esta publicación, exploramos una solución que utiliza inteligencia artificial generativa (IA) para generar una consulta SQL a partir de la pregunta de un usuario en lenguaje natural. Esta solución puede simplificar el proceso de consulta de datos CUR almacenados en una Amazona Atenea base de datos mediante generación de consultas SQL, ejecución de la consulta en Athena y representación en un portal web para facilitar su comprensión.

La solución utiliza La roca madre del Amazonasun servicio completamente administrado que ofrece una selección de modelos base (FM) de alto rendimiento de empresas de IA líderes como AI21 Labs, Anthropic, Cohere, Meta, Mistral AI, Stability AI y Amazon a través de una única API, junto con un amplio conjunto de capacidades para crear aplicaciones de IA generativas con seguridad, privacidad e IA responsable.

Desafíos abordados

Los siguientes desafíos pueden impedir que las organizaciones analicen eficazmente sus datos de CUR, lo que genera posibles ineficiencias, gastos excesivos y oportunidades perdidas de optimización de costos. Nuestro objetivo es abordarlos y simplificarlos mediante IA generativa con Amazon Bedrock.

• Complejidad de las consultas SQL – Escribir consultas SQL para extraer información de los datos CUR puede ser complejo, especialmente para usuarios no técnicos o aquellos que no están familiarizados con la estructura de datos CUR (a menos que sea un administrador de bases de datos experimentado).
• Accesibilidad de los datos – Para obtener información de los datos estructurados en las bases de datos, los usuarios necesitan acceder a las bases de datos, lo que puede ser una amenaza potencial para la protección general de los datos.
• Facilidad de uso – Los métodos tradicionales de análisis de datos CUR a menudo carecen de una interfaz fácil de usar, lo que dificulta que los usuarios no técnicos aprovechen la valiosa información oculta en los datos.

Descripción general de la solución

La solución que analizamos es una aplicación web (chatbot) que le permite hacer preguntas relacionadas con los costos y el uso de AWS en lenguaje natural. La aplicación genera consultas SQL basadas en la entrada del usuario, las ejecuta en una base de datos de Athena que contiene datos CUR y presenta los resultados en un formato fácil de usar. La solución combina el poder de la IA generativa, la generación de SQL, las consultas a bases de datos y una interfaz web intuitiva para brindar una experiencia perfecta para analizar datos CUR.

La solución utiliza los siguientes servicios de AWS:

El siguiente diagrama ilustra la arquitectura de la solución.

El flujo de datos consta de los siguientes pasos:

1. Los datos CUR se almacenan en Amazon S3.
2. Athena está configurado para acceder y consultar los datos CUR almacenados en Amazon S3.
3. El usuario interactúa con la aplicación web Streamlit y envía una pregunta en lenguaje natural relacionada con los costos y el uso de AWS.

Figura 2. Muestra el Dashboard del Chatbot para hacer preguntas

4. La aplicación Streamlit envía la entrada del usuario a Amazon Bedrock y la aplicación LangChain facilita la orquestación general.
5. El código LangChain utiliza la clase BedrockChat de LangChain para invocar el FM e interactuar con Amazon Bedrock para generar una consulta SQL basada en la entrada del usuario.

Figura 3. Muestra la inicialización de la cadena SQL

6. La consulta SQL generada se ejecuta en la base de datos Athena utilizando FM en Amazon Bedrock, que consulta los datos CUR almacenados en Amazon S3.
7. Los resultados de la consulta se devuelven a la aplicación LangChain.

Figura 4. Muestra la consulta generada en los registros de salida de la aplicación.

8. LangChain envía la consulta SQL y los resultados de la consulta a la aplicación Streamlit.
9. La aplicación Streamlit muestra la consulta SQL y los resultados de la consulta al usuario de una manera formateada y fácil de usar.

Figura 5. Muestra el resultado final presentado en la aplicación web del bot de chat, incluida la consulta SQL y los resultados de la consulta.

Prerrequisitos

Para configurar esta solución, debe tener los siguientes requisitos previos:

Configurar la solución

Complete los siguientes pasos para configurar la solución:

1. Cree una base de datos y una tabla de Athena para almacenar sus datos CURAsegúrese de que los permisos y las configuraciones necesarios estén establecidos para que Athena acceda a los datos CUR almacenados en Amazon S3.
2. Configure su entorno informático para llamar a las API de Amazon Bedrock. Asegúrese de asociar un rol de IAM con este entorno que tenga políticas de IAM que otorguen acceso a Amazon Bedrock.
3. Cuando su instancia esté en funcionamiento, instale las siguientes bibliotecas que se utilizan para trabajar dentro del entorno:

pip install langchain==0.2.0 langchain-experimental==0.0.59 langchain-community==0.2.0 langchain-aws==0.1.4 pyathena==3.8.2 sqlalchemy==2.0.30 streamlit==1.34.0

4. Utilice el siguiente código para establecer una conexión con la base de datos de Athena mediante la biblioteca langchain y la biblioteca pyathena. Configure el modelo de lenguaje para generar consultas SQL basadas en la entrada del usuario mediante Amazon Bedrock. Puede guardar este archivo como cur_lib.py.

from langchain_experimental.sql import SQLDatabaseChain
from langchain_community.utilities import SQLDatabase
from sqlalchemy import create_engine, URL
from langchain_aws import ChatBedrock as BedrockChat
from pyathena.sqlalchemy.rest import AthenaRestDialect

class CustomAthenaRestDialect(AthenaRestDialect):
    def import_dbapi(self):
        import pyathena
        return pyathena

# DB Variables
connathena = "athena.us-west-2.amazonaws.com"
portathena="443"
schemaathena="mycur"
s3stagingathena="s3://cur-data-test01/athena-query-result/"
wkgrpathena="primary"
connection_string = f"awsathena+rest://@{connathena}:{portathena}/{schemaathena}?s3_staging_dir={s3stagingathena}/&work_group={wkgrpathena}"
url = URL.create("awsathena+rest", query={"s3_staging_dir": s3stagingathena, "work_group": wkgrpathena})
engine_athena = create_engine(url, dialect=CustomAthenaRestDialect(), echo=False)
db = SQLDatabase(engine_athena)

# Setup LLM
model_kwargs = {"temperature": 0, "top_k": 250, "top_p": 1, "stop_sequences": ["\n\nHuman:"]}
llm = BedrockChat(model_id="anthropic.claude-3-sonnet-20240229-v1:0", model_kwargs=model_kwargs)

# Create the prompt
QUERY = """
Create a syntactically correct athena query for AWS Cost and Usage report to run on the my_c_u_r table in mycur database based on the question, then look at the results of the query and return the answer as SQLResult like a human
{question}
"""
db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)

def get_response(user_input):
    question = QUERY.format(question=user_input)
    result = db_chain.invoke(question)
    query = result["result"].split("SQLQuery:")[1].strip()
    rows = db.run(query)
    return f"SQLQuery: {query}\nSQLResult: {rows}"

5. Cree una aplicación web Streamlit para proporcionar una interfaz de usuario que permita interactuar con la aplicación LangChain. Incluya los campos de entrada para que los usuarios ingresen sus preguntas en lenguaje natural y muestren las consultas SQL generadas y los resultados de las consultas. Puede nombrar este archivo cur_app.py.

import streamlit as st
from cur_lib import get_response
import os

st.set_page_config(page_title="AWS Cost and Usage Chatbot", page_icon="chart_with_upwards_trend", layout="centered", initial_sidebar_state="auto",
menu_items={
        'Get Help': 'https://docs.aws.amazon.com/cur/latest/userguide/cur-create.html',
        #'Report a bug':,
        'About': "# The purpose of this app is to help you get better understanding of your AWS Cost and Usage report!"
    })#HTML title
st.title("_:orange[Simplify] CUR data_ :sunglasses:")

def format_result(result):
    parts = result.split("\nSQLResult: ")
    if len(parts) > 1:
        sql_query = parts[0].replace("SQLQuery: ", "")
        sql_result = parts[1].strip("[]").split("), (")
        formatted_result = []
        for row in sql_result:
            formatted_result.append(tuple(item.strip("(),'") for item in row.split(", ")))
        return sql_query, formatted_result
    else:
        return result, []

def main():
    # Get the current directory
    current_dir = os.path.dirname(os.path.abspath(__file__))
    st.markdown("<div class="main">", unsafe_allow_html=True)
    st.title("AWS Cost and Usage chatbot")
    st.write("Ask a question about your AWS Cost and Usage Report:")

6. Conecte la aplicación LangChain y la aplicación web Streamlit llamando al formato get_response y muestre la consulta SQL y el resultado en la aplicación web Streamlit. Agregue el siguiente código al código de la aplicación anterior:

# Create a session state variable to store the chat history
    if "chat_history" not in st.session_state:
        st.session_state.chat_history = []

    user_input = st.text_input("You:", key="user_input")

    if user_input:
        try:
            result = get_response(user_input)
            sql_query, sql_result = format_result(result)
            st.code(sql_query, language="sql")
            if sql_result:
                st.write("SQLResult:")
                st.table(sql_result)
            else:
                st.write(result)
            st.session_state.chat_history.append({"user": user_input, "bot": result})
            st.text_area("Conversation:", value="\n".join([f"You: {chat['user']}\nBot: {chat['bot']}" for chat in st.session_state.chat_history]), height=300)
        except Exception as e:
            st.error(str(e))

    st.markdown("</div>", unsafe_allow_html=True)

if __name__ == "__main__":
    main()

7. Implemente la aplicación Streamlit y la aplicación LangChain en su entorno de alojamiento, como Amazon EC2, o una función Lambda.

Limpiar

A menos que invoque Amazon Bedrock con esta solución, no incurrirá en cargos por ello. Para evitar cargos continuos por el almacenamiento de Amazon S3 para guardar los informes CUR, puede eliminar los datos CUR y el depósito S3. Si configura la solución con Amazon EC2, asegúrese de detener o eliminar la instancia cuando haya terminado.

Beneficios

Esta solución ofrece los siguientes beneficios:

• Análisis de datos simplificado – Puede analizar datos CUR utilizando lenguaje natural mediante IA generativa, eliminando la necesidad de conocimientos avanzados de SQL
• Mayor accesibilidad – La interfaz basada en web permite que los usuarios no técnicos accedan y obtengan información de los datos de CUR de manera eficiente sin necesidad de credenciales para la base de datos.
• Ahorro de tiempo – Puede obtener rápidamente respuestas a sus preguntas sobre costos y uso sin tener que escribir manualmente consultas SQL complejas
• Visibilidad mejorada – La solución proporciona visibilidad de los costos y el uso de AWS, lo que permite tomar mejores decisiones de optimización de costos y gestión de recursos.

Resumen

La solución de chatbot de AWS CUR utiliza Anthropic Claude en Amazon Bedrock para generar consultas SQL, consultas de bases de datos y una interfaz web fácil de usar para simplificar el análisis de los datos de CUR. Al permitirle hacer preguntas en lenguaje natural, la solución elimina las barreras y permite que tanto los usuarios técnicos como los no técnicos obtengan información valiosa sobre los costos y el uso de recursos de AWS. Con esta solución, las organizaciones pueden tomar decisiones más informadas, optimizar su gasto en la nube y mejorar la utilización general de los recursos. Le recomendamos que realice la debida diligencia al configurar esto, especialmente para la producción; puede elegir otros lenguajes de programación y marcos para configurarlo según sus preferencias y necesidades.

Amazon Bedrock le permite crear potentes aplicaciones de inteligencia artificial generativa con facilidad. Acelere su proceso siguiendo la guía de inicio rápido en GitHub y usando Bases de conocimiento de Amazon Bedrock para desarrollar rápidamente soluciones de Generación Aumentada de Recuperación (RAG) de vanguardia o permitir que las aplicaciones de IA generativas ejecuten tareas de varios pasos en los sistemas de la empresa y las fuentes de datos utilizando Agentes de Amazon Bedrock.

Acerca del autor

Anutosh es arquitecto de soluciones en AWS India. Le encanta analizar en profundidad los casos de uso de sus clientes para ayudarlos a navegar en su recorrido por AWS. Disfruta creando soluciones en la nube para ayudar a los clientes. Le apasionan la migración y la modernización, el análisis de datos, la resiliencia, la ciberseguridad y el aprendizaje automático.