Esta publicación está coescrita con Justin Miles, Liv d'Aliberti y Joe Kovba de Leidos. 

Leidos es un líder en soluciones de ciencia y tecnología de Fortune 500 que trabaja para abordar algunos de los desafíos más difíciles del mundo en los mercados de defensa, inteligencia, seguridad nacional, civil y de atención médica. En esta publicación, analizamos cómo Leidos trabajó con AWS para desarrollar un enfoque para la inferencia de modelos de lenguaje grande (LLM) que preservan la privacidad utilizando Enclaves Nitro de AWS.

Los LLM están diseñados para comprender y generar un lenguaje similar al humano y se utilizan en muchas industrias, incluidas las gubernamentales, sanitarias, financieras y de propiedad intelectual. Los LLM tienen una amplia aplicabilidad, incluidos chatbots, generación de contenido, traducción de idiomas, análisis de sentimientos, sistemas de respuesta a preguntas, motores de búsqueda y generación de código. La introducción de la inferencia basada en LLM en un sistema también tiene el potencial de introducir amenazas a la privacidad, incluida la exfiltración de modelos, violaciones de la privacidad de datos y manipulación involuntaria de servicios basados ​​en LLM. Es necesario implementar arquitecturas técnicas para garantizar que los LLM no expongan información confidencial durante la inferencia.

Esta publicación analiza cómo Nitro Enclaves puede ayudar a proteger las implementaciones del modelo LLM, específicamente aquellas que utilizan información de identificación personal (PII) o información de salud protegida (PHI). Esta publicación tiene fines educativos únicamente y no debe utilizarse en entornos de producción sin controles adicionales.

Descripción general de los LLM y los enclaves Nitro

Un caso de uso potencial es un chatbot de consultas confidenciales basado en LLM diseñado para llevar a cabo un servicio de preguntas y respuestas que contiene PII y PHI. La mayoría de las soluciones de chatbot LLM actuales informan explícitamente a los usuarios que no deben incluir PII o PHI al ingresar preguntas debido a problemas de seguridad. Para mitigar estas preocupaciones y proteger los datos de los clientes, los propietarios de servicios dependen principalmente de protecciones de usuario como las siguientes:

• Redacción – El proceso de identificar y ocultar información confidencial como PII en documentos, textos u otras formas de contenido. Esto se puede lograr con datos de entrada antes de enviarlos a un modelo o a un LLM capacitado para redactar sus respuestas automáticamente.
• Autenticación de múltiples factores – Un proceso de seguridad que requiere que los usuarios proporcionen múltiples métodos de autenticación para verificar su identidad y obtener acceso al LLM.
• Transport Layer Security (TLS) – Un protocolo criptográfico que proporciona una comunicación segura que mejora la privacidad de los datos en tránsito entre los usuarios y el servicio LLM.

Aunque estas prácticas mejoran la postura de seguridad del servicio, no son suficientes para salvaguardar toda la información confidencial del usuario y otra información confidencial que pueda persistir sin el conocimiento del usuario.

En nuestro caso de uso de ejemplo, un servicio LLM está diseñado para responder preguntas sobre beneficios de atención médica de los empleados o proporcionar un plan de jubilación personal. Analicemos la siguiente arquitectura de ejemplo e identifiquemos áreas de riesgo para la privacidad de los datos.

Figura 1: Diagrama de áreas de riesgo de privacidad de datos

Las áreas de riesgo potenciales son las siguientes:

1. Los usuarios privilegiados tienen acceso a la instancia que alberga el servidor. Los cambios no intencionados o no autorizados en el servicio podrían dar lugar a que datos confidenciales queden expuestos de forma no deseada.
2. Los usuarios deben confiar en que el servicio no expondrá ni retendrá información confidencial en los registros de la aplicación.
3. Los cambios en los paquetes de aplicaciones pueden provocar cambios en el servicio, lo que resulta en la exposición de datos confidenciales.
4. Los usuarios privilegiados con acceso a la instancia tienen acceso sin restricciones al LLM utilizado por el servicio. Los cambios pueden provocar que se devuelva información incorrecta o inexacta a los usuarios.

Nitro Enclaves proporciona aislamiento adicional a su Nube informática elástica de Amazon (Amazon EC2), que protege los datos en uso del acceso no autorizado, incluidos los usuarios de nivel administrador. En la arquitectura anterior, es posible que un cambio involuntario provoque que los datos confidenciales persistan en texto sin formato y se revelen accidentalmente a un usuario que tal vez no necesite acceder a esos datos. Con Nitro Enclaves, crea un entorno aislado de su instancia EC2, lo que le permite asignar recursos de CPU y memoria al enclave. Este enclave es una máquina virtual altamente restrictiva. Al ejecutar código que maneja datos confidenciales dentro del enclave, ninguno de los procesos principales podrá ver los datos del enclave.

Nitro Enclaves ofrece los siguientes beneficios:

• Aislamiento de memoria y CPU – Se basa en Nitro Hypervisor para aislar la CPU y la memoria del enclave de los usuarios, aplicaciones y bibliotecas en la instancia principal. Esta característica ayuda a aislar el enclave y su software, y reduce significativamente la superficie para eventos no deseados.
• Máquina virtual separada – Los enclaves son máquinas virtuales separadas conectadas a una instancia EC2 para proteger aún más y procesar de forma segura datos altamente confidenciales.
• Sin acceso interactivo – Los enclaves solo proporcionan conectividad de socket local segura con su instancia principal. No tienen almacenamiento persistente, acceso interactivo ni redes externas.
• Atestación criptográfica – Ofertas Nitro Enclaves atestación criptográfica, un proceso utilizado para probar la identidad de un enclave y verificar que solo se esté ejecutando código autorizado en su enclave.
• Integración de AWS – Nitro Enclaves está integrado con Servicio de administración de claves de AWS (AWS KMS), lo que le permite descifrar archivos que se han cifrado mediante AWS KMS dentro del enclave. Administrador de certificados de AWS (ACM) para Nitro Enclaves le permite utilizar certificados SSL/TLS públicos y privados con sus aplicaciones web y servidores que se ejecutan en instancias EC2 con Nitro Enclaves.

Puede utilizar estas funciones proporcionadas por Nitro Enclaves para ayudar a mitigar los riesgos asociados con los datos PII y PHI. Recomendamos incluir Nitro Enclaves en un servicio LLM cuando maneje datos confidenciales del usuario.

Resumen de la solución

Examinemos la arquitectura del servicio de ejemplo, que ahora incluye Nitro Enclaves. Al incorporar Nitro Enclaves, como se muestra en la siguiente figura, el LLM se convierte en un chatbot más seguro para manejar datos PHI o PII.

Figura 2: Diagrama de descripción general de la solución

Los datos del usuario, incluida la PII, la PHI y las preguntas, permanecen cifrados durante todo el proceso de solicitud-respuesta cuando la aplicación está alojada dentro de un enclave. Los pasos llevados a cabo durante la inferencia son los siguientes:

1. La aplicación de chatbot genera credenciales temporales de AWS y le pide al usuario que ingrese una pregunta. La pregunta, que puede contener PII o PHI, se cifra a través de AWS KMS. La entrada cifrada del usuario se combina con las credenciales temporales para crear la solicitud cifrada.
2. Los datos cifrados se envían a un servidor HTTP alojado en Flask como una solicitud POST. Antes de aceptar datos confidenciales, este punto final debe configurarse para HTTP.
3. La aplicación cliente recibe la solicitud POST y la reenvía a través de un canal local seguro (por ejemplo, vsock) a la aplicación del servidor que se ejecuta dentro de Nitro Enclaves.
4. La aplicación del servidor Nitro Enclaves utiliza las credenciales temporales para descifrar la solicitud, consulta el LLM y genera la respuesta. La configuración específica del modelo se almacena dentro de los enclaves y está protegida con certificación criptográfica.
5. La aplicación del servidor utiliza las mismas credenciales temporales para cifrar la respuesta.
6. La respuesta cifrada se devuelve a la aplicación de chatbot a través de la aplicación del cliente como respuesta a la solicitud POST.
7. La aplicación de chatbot descifra la respuesta utilizando su clave KMS y muestra el texto sin formato al usuario.

Requisitos previos

Antes de comenzar, necesita los siguientes requisitos previos para implementar la solución:

Configurar una instancia EC2

Complete los siguientes pasos para configurar una instancia EC2:

1. Lanzar un r5.8xgrande Instancia EC2 usando el amzn2-ami-kernel-5.10-hvm-2.0.20230628.0-x86_64-gp2 AMI con Nitro Enclaves habilitado.
2. Instale la CLI de Nitro Enclaves para crear y ejecutar aplicaciones de Nitro Enclaves:
   • sudo amazon-linux-extras install aws-nitro-enclaves-cli -y
   • sudo yum install aws-nitro-enclaves-cli-devel -y
3. Verifique la instalación de la CLI de Nitro Enclaves:
   • nitro-cli –version
   • La versión utilizada en esta publicación es 1.2.2
4. Instale Git y Docker para crear imágenes de Docker y descargue la aplicación desde GitHub. Agregue su usuario de instancia al grupo Docker ( es el usuario de su instancia de IAM):
   • sudo yum install git -y
   • sudo usermod -aG ne <USER>
   • sudo usermod -aG docker <USER>
   • sudo systemctl start docker && sudo systemctl enable docker
5. Inicie y habilite el asignador de Nitro Enclaves y los servicios de proxy vsock:
   • sudo systemctl start nitro-enclaves-allocator.service && sudo systemctl enable nitro-enclaves-allocator.service
   • sudo systemctl start nitro-enclaves-vsock-proxy.service && sudo systemctl enable nitro-enclaves-vsock-proxy.service

Nitro Enclaves utiliza una conexión de socket local llamada vsock para crear un canal seguro entre la instancia principal y el enclave.

Después de iniciar y habilitar todos los servicios, reinicie la instancia para verificar que todos los grupos de usuarios y servicios se estén ejecutando correctamente:

sudo shutdown -r now

Configurar el servicio de asignador de Nitro Enclaves

Nitro Enclaves es un entorno aislado que designa una parte de la CPU y la memoria de la instancia para ejecutar el enclave. Con el servicio de asignación de Nitro Enclaves, puede indicar cuántas CPU y cuánta memoria se tomarán de la instancia principal para ejecutar el enclave.

Modifique los recursos reservados del enclave usando un editor de texto (para nuestra solución, asignamos 8 CPU y 70,000 XNUMX MiB de memoria para proporcionar suficientes recursos):

vi /etc/nitro_enclaves/allocatory.yaml

Figura 3: Configuración del servicio de asignación de AWS Nitro Enclaves

Clonar el proyecto

Después de configurar la instancia EC2, puede descargar el código para ejecutar el chatbot sensible con un LLM dentro de Nitro Enclaves.

Necesita actualizar el server.py archivo con el ID de clave KMS apropiado que creó al principio para cifrar la respuesta LLM.

1. Clona el proyecto GitHub:
   • cd ~/ && git clone https://<THE_REPO.git>
2. Navegue a la carpeta del proyecto para construir el enclave_base Imagen de Docker que contiene el Kit de desarrollo de software Nitro Enclaves (SDK) para documentos de certificación criptográfica del hipervisor Nitro (este paso puede tardar hasta 15 minutos):
   • cd /nitro_llm/enclave_base
   • docker build ./ -t “enclave_base”

Guarde el LLM en la instancia EC2

Estamos utilizando el Bloom 560m LLM de código abierto para el procesamiento del lenguaje natural para generar respuestas. Este modelo no está ajustado a PII y PHI, pero demuestra cómo un LLM puede vivir dentro de un enclave. El modelo también debe guardarse en la instancia principal para poder copiarlo en el enclave a través del Dockerfile.

1. Navegue al proyecto:
   • cd /nitro_llm
2. Instale los requisitos necesarios para guardar el modelo localmente:
   • pip3 install requirements.txt
3. Ejecute el save_model.py aplicación para guardar el modelo dentro del /nitro_llm/enclave/bloom directorio:
   • python3 save_model.py

Construya y ejecute la imagen de Nitro Enclaves

Para ejecutar Nitro Enclaves, debe crear un archivo de imagen de enclave (EIF) a partir de una imagen de Docker de su aplicación. El Dockerfile ubicado en el directorio del enclave contiene los archivos, el código y el LLM que se ejecutarán dentro del enclave.

La construcción y ejecución del enclave tardará varios minutos en completarse.

1. Navegue hasta la raíz del proyecto:
   • cd /nitro_llm
2. Construya el archivo de imagen del enclave como enclave.eif:
   • nitro-cli build-enclave --docker-uri enclave:latest --output-file enclave.eif

Figura 4: Resultado de la compilación de AWS Nitro Enclaves

Cuando se construye el enclave, se creará una serie de hashes únicos y registros de configuración de plataforma (PCR). Los PCR son una medida contigua para demostrar la identidad del hardware y la aplicación. Estas PCR serán necesarias para la certificación criptográfica y se utilizarán durante el paso de actualización de la política de claves KMS.

3. Dirige el enclave con los recursos del allocator.service (agregando el --attach-console El argumento al final ejecutará el enclave en modo de depuración):
   • nitro-cli run-enclave --cpu-count 8 --memory 70000 --enclave-cid 16 --eif-path enclave.eif

Debe asignar al menos cuatro veces el tamaño del archivo EIF. Esto se puede modificar en el allocator.service de los pasos anteriores.

4. Verifique que el enclave se esté ejecutando con el siguiente comando:
   • nitro-cli describe-enclaves

Figura 5: comando de descripción de AWS Nitro Enclave

Actualizar la política de claves KMS

Complete los siguientes pasos para actualizar su política de claves KMS:

1. En la consola de AWS KMS, elija Claves administradas por el cliente en el panel de navegación.
2. Busque la clave que generó como requisito previo.
3. Elige Editar sobre la política clave.
4. Actualice la política de claves con la siguiente información:
   • Su ID de cuenta
   • Su nombre de usuario de IAM
   • El rol de instancia del entorno Cloud9 actualizado
   • Acciones kms:Encrypt y kms:Decrypt
   • Enclave PCR (por ejemplo, PCR0, PCR1, PCR2) en su política clave con una declaración de condición

Consulte el siguiente código de política clave:

{
   "Version":"2012-10-17",
   "Id":"key-default-1",
   "Statement":[
      {
         "Sid":"Enable User permissions",
         "Effect":"Allow",
         "Principal":{
            "AWS":"arn:aws:iam:::user/"
         },
         "Action":[
            "kms:CreateAlias",
            "kms:CreateKey",
            "kms:DeleteAlias",
            "kms:Describe*",
            "kms:GenerateRandom",
            "kms:Get*",
            "kms:List*",
            "kms:TagResource",
            "kms:UntagResource",
            "iam:ListGroups",
            "iam:ListRoles",
            "iam:ListUsers"
         ],
         "Resource":"*"
      },
      {
         "Sid":"Enable Enclave permissions",
         "Effect":"Allow",
         "Principal":{
            "AWS":"arn:aws:iam:::role/"
         },
         "Action":[
            "kms:Encrypt",
            "kms:Decrypt"
         ],
         "Resource":"*",
         "Condition":{
            "StringEqualsIgnoreCase":{
               "kms:RecipientAttestation:PCR0":"",
               "kms:RecipientAttestation:PCR1":"",
               "kms:RecipientAttestation:PCR2":""
            }
         }
      }
   ]
}

Guarde la aplicación de chatbot

Para imitar una aplicación de chatbot de consultas confidenciales que reside fuera de la cuenta de AWS, debe guardar el chatbot.py aplicación y ejecútela dentro del entorno Cloud9. Su entorno Cloud9 utilizará su función de instancia para credenciales temporales para desasociar permisos del EC2 que ejecuta el enclave. Complete los siguientes pasos:

1. En la consola de Cloud9, abra el entorno que creó.
2. Copie el siguiente código en un nuevo archivo como chatbot.py en el directorio principal.
3. Instale los módulos necesarios:
   • pip install boto3
   • Pip install requests
4. En la consola de Amazon EC2, anote la IP asociada con su instancia de Nitro Enclaves.
5. Actualizar la variable URL en http://<ec2instanceIP>:5001.

"""
Modules for a basic chatbot like application and AWS communications
"""
import base64
import requests
import boto3
 
def get_identity_document():
    """
    Get identity document for current EC2 Host
    """
    identity_doc = requests.get(
        "http://169.254.169.254/latest/dynamic/instance-identity/document", timeout=30)
    return identity_doc
 
def get_region(identity):
    """
    Get account of current instance identity
    """
    region = identity.json()["region"]
    return region
 
def get_account(identity):
    """
    Get account of current instance identity
    """
    account = identity.json()["accountId"]
    return account
 
def set_identity():
    """
    Set region and account for KMS
    """
    identity = get_identity_document()
    region = get_region(identity)
    account = get_account(identity)
    return region, account
 
def prepare_server_request(ciphertext):
    """
    Get the AWS credential from EC2 instance metadata
    """
    instance_prof = requests.get(
        "http://169.254.169.254/latest/meta-data/iam/security-credentials/", timeout=30)
    instance_profile_name = instance_prof.text
 
    instance_prof_json = requests.get(
        f"http://169.254.169.254/latest/meta-data/iam/security-credentials/{instance_profile_name}",
        timeout=30)
    response = instance_prof_json.json()
 
    credential = {
        'access_key_id': response['AccessKeyId'],
        'secret_access_key': response['SecretAccessKey'],
        'token': response['Token'],
        'region': REGION,
        'ciphertext': ciphertext
    }
    return credential
 
def get_user_input():
    """
    Start chatbot to collect user input
    """
    print("Chatbot: Hello! How can I assist you?")
    user_input = input('Your Question: ')
    return user_input.lower()
 
def encrypt_string(user_input, alias, kms):
    """
    Encrypt user input using AWS KMS
    """
    file_contents = user_input
    encrypted_file = kms.encrypt(KeyId=f'alias/{alias}', Plaintext=file_contents)
    encrypted_file_contents = encrypted_file[u'CiphertextBlob']
    encrypted_file_contents_base64 = base64.b64encode(encrypted_file_contents)
    return encrypted_file_contents_base64.decode()
 
def decrypt_data(encrypted_data, kms):
    """
    Decrypt the LLM response using AWS KMS
    """
    try:
        ciphertext_blob = base64.b64decode(encrypted_data)
        response = kms.decrypt(CiphertextBlob=ciphertext_blob)
        decrypted_data = response['Plaintext'].decode()
        return decrypted_data
    except ImportError as e_decrypt:
        print("Decryption failed:", e_decrypt)
        return None
 
REGION, ACCOUNT = set_identity()
  
def main():
    """
    Main function to encrypt/decrypt data and send/receive with parent instance
    """
    kms = boto3.client('kms', region_name=REGION)
    alias = "ncsnitro"
    user_input = get_user_input()
    encrypted_input = encrypt_string(user_input, alias, kms)
    server_request = prepare_server_request(encrypted_input)
    url = 'http://<EC2 Instance Private IP>:5001'
    x = requests.post(url, json = server_request)
    response_body = x.json()
    llm_response = decrypt_data(response_body["EncryptedData"], kms)
    print(llm_response)
 
if __name__ == '__main__':
    main()

6. Ejecute la aplicación de chatbot:

• • python3 chat.py

Cuando se esté ejecutando, el terminal solicitará la entrada del usuario y seguirá el diagrama arquitectónico anterior para generar una respuesta segura.

Ejecute el chatbot privado de preguntas y respuestas

Ahora que Nitro Enclaves está en funcionamiento en la instancia EC2, puede hacer preguntas sobre PHI y PII a su chatbot de forma más segura. Veamos un ejemplo.

Dentro del entorno Cloud9, le hacemos una pregunta a nuestro chatbot y le proporcionamos nuestro nombre de usuario.

Figura 6: Hacer una pregunta al Chat Bot

AWS KMS cifra la pregunta, que se parece a la siguiente captura de pantalla.

Figura 7 – Pregunta cifrada

Luego se envía al enclave y se solicita al LLM asegurado. La pregunta y la respuesta del LLM se verán como la siguiente captura de pantalla (el resultado y la respuesta cifrada son visibles dentro del enclave solo en modo de depuración).

Figura 8 – Respuesta del LLM

Luego, el resultado se cifra mediante AWS KMS y se devuelve al entorno de Cloud9 para descifrarlo.

Figura 9 – Respuesta final descifrada

Limpiar

Complete los siguientes pasos para limpiar sus recursos:

1. Detenga la instancia EC2 creada para albergar su enclave.
2. Elimine el entorno Cloud9.
3. Elimine la clave KMS.
4. Elimine la función de instancia EC2 y los permisos de usuario de IAM.

Conclusión

En esta publicación, mostramos cómo usar Nitro Enclaves para implementar un servicio de preguntas y respuestas de LLM que envía y recibe información PII y PHI de manera más segura. Esto se implementó en Amazon EC2 y los enclaves están integrados con AWS KMS, lo que restringe el acceso a una clave KMS, por lo que solo Nitro Enclaves y el usuario final pueden usar la clave y descifrar la pregunta.

Si planea escalar esta arquitectura para admitir cargas de trabajo más grandes, asegúrese de que el proceso de selección del modelo coincida con los requisitos de su modelo con los recursos de EC2. Además, debe considerar el tamaño máximo de solicitud y el impacto que tendrá en el servidor HTTP y el tiempo de inferencia contra el modelo. Muchos de estos parámetros se pueden personalizar a través del modelo y la configuración del servidor HTTP.

La mejor manera de determinar las configuraciones y requisitos específicos para su carga de trabajo es mediante pruebas con un LLM ajustado. Aunque esta publicación solo incluyó el procesamiento de datos confidenciales en lenguaje natural, puede modificar esta arquitectura para admitir LLM alternativos que admitan audio, visión por computadora o multimodalidades. Los mismos principios de seguridad destacados aquí se pueden aplicar a datos en cualquier formato. Los recursos utilizados para crear esta publicación están disponibles en el Repositorio GitHub.

Comparta cómo va a adaptar esta solución a su entorno en la sección de comentarios.

Acerca de los autores

justin millas es ingeniero de nube dentro del Sector de Modernización Digital de Leidos dependiente de la Oficina de Tecnología. En su tiempo libre le gusta jugar al golf y viajar.

Liv d'Aliberti es investigador dentro del Acelerador Leidos AI/ML de la Oficina de Tecnología. Su investigación se centra en el aprendizaje automático para preservar la privacidad.

Chris Renzo es arquitecto senior de soluciones dentro de la organización aeroespacial y de defensa de AWS. Fuera del trabajo, disfruta del equilibrio entre el clima cálido y los viajes.

joe kovba es vicepresidente del sector de modernización digital de Leidos. En su tiempo libre, le gusta arbitrar partidos de fútbol y jugar sóftbol.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/large-language-model-inference-over-confidential-data-using-aws-nitro-enclaves/