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

Cuidar los costos de la cirro y comprender el uso de los bienes 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 decisión que utiliza inteligencia fabricado generativa (IA) para suscitar una consulta SQL a partir de la pregunta de un usufructuario en lengua natural. Esta decisión puede simplificar el proceso de consulta de datos CUR almacenados en una Amazona Atenea colchoneta de datos mediante reproducción de consultas SQL, ejecución de la consulta en Athena y representación en un portal web para proporcionar su comprensión.

La decisión utiliza La roca matriz del Amazonasun servicio completamente administrado que ofrece una selección de modelos colchoneta (FM) de detención 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, unido 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 confuso, 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 alcanzar a las bases de datos, lo que puede ser una amenaza potencial para la protección común de los datos.
Facilidad de uso – Los métodos tradicionales de disección de datos CUR a menudo carecen de una interfaz tratable de usar, lo que dificulta que los usuarios no técnicos aprovechen la valiosa información oculta en los datos.

Descripción común de la decisión

La decisión que analizamos es una aplicación web (chatbot) que le permite hacer preguntas relacionadas con los costos y el uso de AWS en lengua natural. La aplicación genera consultas SQL basadas en la entrada del usufructuario, las ejecuta en una colchoneta de datos de Athena que contiene datos CUR y presenta los resultados en un formato tratable de usar. La decisión combina el poder de la IA generativa, la reproducción de SQL, las consultas a bases de datos y una interfaz web intuitiva para elogiar una experiencia perfecta para analizar datos CUR.

La decisión utiliza los siguientes servicios de AWS:

El sucesivo diagrama ilustra la construcción de la decisión.

Figura 1. Bloque de la decisión

El flujo de datos consta de los siguientes pasos:

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

Figura 2. Muestra el Dashboard del Chatbot para hacer preguntas

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

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

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

La consulta SQL generada se ejecuta en la colchoneta de datos Athena utilizando FM en Amazon Bedrock, que consulta los datos CUR almacenados en Amazon S3.
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.

LangChain envía la consulta SQL y los resultados de la consulta a la aplicación Streamlit.
La aplicación Streamlit muestra la consulta SQL y los resultados de la consulta al usufructuario de una guisa formateada y tratable 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 decisión, debe tener los siguientes requisitos previos:

Configurar la decisión

Complete los siguientes pasos para configurar la decisión:

Cree una colchoneta de datos y una tabla de Athena para acumular 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.
Configure su entorno informático para convocar 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 camino a Amazon Bedrock.
Cuando su instancia esté en funcionamiento, instale las siguientes bibliotecas que se utilizan para trabajar en el interior 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

Utilice el sucesivo código para establecer una conexión con la colchoneta de datos de Athena mediante la biblioteca langchain y la biblioteca pyathena. Configure el maniquí de lengua para suscitar consultas SQL basadas en la entrada del usufructuario mediante Amazon Bedrock. Puede ahorrar 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": ("nnHuman:")}
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}"

Cree una aplicación web Streamlit para proporcionar una interfaz de usufructuario que permita interactuar con la aplicación LangChain. Incluya los campos de entrada para que los usuarios ingresen sus preguntas en lengua 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="coche",
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("", unsafe_allow_html=True)
    st.title("AWS Cost and Usage chatbot")
    st.write("Ask a question about your AWS Cost and Usage Report:") 
        
        
        Connect the LangChain application and Streamlit web application by calling the get_response Format and display the SQL query and result in the Streamlit web application. Append the following code with the preceding application code: 
        
        
        # 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("

", unsafe_allow_html=Real) si __name__ == "__main__": main()

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

Enjuagar

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

Beneficios

Esta decisión ofrece los siguientes beneficios:

Prospección de datos simplificado – Puede analizar datos CUR utilizando lengua natural mediante IA generativa, eliminando la condición de conocimientos avanzados de SQL
Decano accesibilidad – La interfaz basada en web permite que los usuarios no técnicos accedan y obtengan información de los datos de CUR de guisa capaz sin condición de credenciales para la colchoneta de datos.
Economía 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 decisión proporciona visibilidad de los costos y el uso de AWS, lo que permite tomar mejores decisiones de optimización de costos y trámite de bienes.

Recapitulación

La decisión de chatbot de AWS CUR utiliza Anthropic Claude en Amazon Bedrock para suscitar consultas SQL, consultas de bases de datos y una interfaz web tratable de usar para simplificar el disección de los datos de CUR. Al permitirle hacer preguntas en lengua natural, la decisió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 bienes de AWS. Con esta decisión, las organizaciones pueden tomar decisiones más informadas, optimizar su pago en la cirro y mejorar la utilización común de los bienes. Le recomendamos que realice la debida diligencia al configurar esto, especialmente para la producción; puede nominar otros lenguajes de programación y marcos para configurarlo según sus preferencias y deyección.

Amazon Bedrock le permite crear potentes aplicaciones de inteligencia fabricado generativa con facilidad. Acelere su proceso siguiendo la práctico de inicio rápido en GitHub y usando Bases de conocimiento de Amazon Bedrock para desarrollar rápidamente soluciones de Gestació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 represión por AWS. Disfruta creando soluciones en la cirro para ayudar a los clientes. Le apasionan la migración y la modernización, el disección de datos, la resiliencia, la ciberseguridad y el enseñanza forzoso.

Etiquetado Amazon, Artificial, AWS, Bedrock, con, costos, Descubra, generativa, impulsada, información, inteligencia, por, sobre, uso