Dette innlegget er skrevet sammen med Justin Miles, Liv d'Aliberti og Joe Kovba fra Leidos. 

Leidos er en Fortune 500-leder for vitenskapelige og teknologiske løsninger som jobber for å møte noen av verdens tøffeste utfordringer innen forsvars-, etterretnings-, hjemlandssikkerhet, sivile og helsetjenester. I dette innlegget diskuterer vi hvordan Leidos jobbet med AWS for å utvikle en tilnærming til personvernbevarende stor språkmodell (LLM) inferens ved hjelp av AWS Nitro-enklaver.

LLM-er er designet for å forstå og generere menneskelignende språk, og brukes i mange bransjer, inkludert myndigheter, helsevesen, finansiell og intellektuell eiendom. LLM-er har bred anvendelighet, inkludert chatbots, innholdsgenerering, språkoversettelse, sentimentanalyse, spørsmålssvarssystemer, søkemotorer og kodegenerering. Å introdusere LLM-basert slutning i et system har også potensial til å introdusere personverntrusler, inkludert modelleksfiltrering, brudd på datapersonvernet og utilsiktet LLM-basert tjenestemanipulasjon. Tekniske arkitekturer må implementeres for å sikre at LLM-er ikke eksponerer sensitiv informasjon under inferens.

Dette innlegget diskuterer hvordan Nitro Enclaves kan bidra til å beskytte LLM-modellimplementeringer, spesielt de som bruker personlig identifiserbar informasjon (PII) eller beskyttet helseinformasjon (PHI). Dette innlegget er kun for pedagogiske formål og bør ikke brukes i produksjonsmiljøer uten ekstra kontroller.

Oversikt over LLM-er og Nitro-enklaver

Et potensielt brukstilfelle er en LLM-basert sensitiv spørring chatbot designet for å utføre en spørsmåls- og svartjeneste som inneholder PII og PHI. De fleste nåværende LLM chatbot-løsninger informerer brukerne eksplisitt om at de ikke bør inkludere PII eller PHI når de legger inn spørsmål på grunn av sikkerhetshensyn. For å dempe disse bekymringene og beskytte kundedata, stoler tjenesteeiere primært på brukerbeskyttelse som følgende:

• redaksjonen – Prosessen med å identifisere og skjule sensitiv informasjon som PII i dokumenter, tekster eller andre former for innhold. Dette kan oppnås med inndata før de sendes til en modell eller en LLM som er opplært til å redigere svarene deres automatisk.
• Flerfaktorautentisering – En sikkerhetsprosess som krever at brukere oppgir flere autentiseringsmetoder for å bekrefte identiteten deres for å få tilgang til LLM.
• Transport Layer Security (TLS) – En kryptografisk protokoll som gir sikker kommunikasjon som forbedrer datavernet under overføring mellom brukere og LLM-tjenesten.

Selv om disse fremgangsmåtene forbedrer sikkerheten til tjenesten, er de ikke tilstrekkelige til å beskytte all sensitiv brukerinformasjon og annen sensitiv informasjon som kan vedvare uten brukerens viten.

I vårt eksempelbruk er en LLM-tjeneste utformet for å svare på spørsmål om ansattes helsehjelp eller gi en personlig pensjonsordning. La oss analysere følgende eksempelarkitektur og identifisere risikoområder for personvern.

Figur 1 – Diagram for risikoområder for personvern

De potensielle risikoområdene er som følger:

1. Privilegerte brukere har tilgang til forekomsten som huser serveren. Utilsiktede eller uautoriserte endringer i tjenesten kan føre til at sensitive data blir eksponert på utilsiktede måter.
2. Brukere må stole på at tjenesten ikke vil eksponere eller beholde sensitiv informasjon i applikasjonslogger.
3. Endringer i applikasjonspakker kan føre til endringer i tjenesten, noe som resulterer i eksponering av sensitive data.
4. Privilegerte brukere med tilgang til forekomsten har ubegrenset tilgang til LLM som brukes av tjenesten. Endringer kan føre til at feil eller unøyaktig informasjon blir returnert til brukerne.

Nitro Enclaves gir ekstra isolasjon til din Amazon Elastic Compute Cloud (Amazon EC2), som beskytter data i bruk mot uautorisert tilgang, inkludert brukere på administratornivå. I den foregående arkitekturen er det mulig at en utilsiktet endring resulterer i at sensitive data vedvarer i klartekst og ved et uhell blir avslørt for en bruker som kanskje ikke trenger å få tilgang til disse dataene. Med Nitro Enclaves oppretter du et isolert miljø fra EC2-forekomsten din, slik at du kan allokere CPU- og minneressurser til enklaven. Denne enklaven er en svært restriktiv virtuell maskin. Ved å kjøre kode som håndterer sensitive data i enklaven, vil ingen av foreldrenes prosesser kunne se enklavedata.

Nitro Enclaves tilbyr følgende fordeler:

• Minne og CPU-isolasjon – Den er avhengig av Nitro Hypervisor for å isolere CPU-en og minnet til enklaven fra brukere, applikasjoner og biblioteker på den overordnede forekomsten. Denne funksjonen hjelper til med å isolere enklaven og programvaren din, og reduserer overflatearealet betydelig for utilsiktede hendelser.
• Separat virtuell maskin – Enklaver er adskilte virtuelle maskiner koblet til en EC2-instans for ytterligere å beskytte og behandle svært sensitive data på en sikker måte.
• Ingen interaktiv tilgang – Enklaver gir kun sikker lokal socket-tilkobling med sin overordnede instans. De har ingen vedvarende lagring, interaktiv tilgang eller eksternt nettverk.
• Kryptografisk attestasjon – Nitro Enclaves tilbyr kryptografisk attestasjon, en prosess som brukes til å bevise identiteten til en enklave og bekrefte at kun autorisert kode kjører i enklaven din.
• AWS-integrasjon – Nitro Enclaves er integrert med AWS nøkkelstyringstjeneste (AWS KMS), slik at du kan dekryptere filer som er kryptert med AWS KMS inne i enklaven. AWS Certificate Manager (ACM) for Nitro Enclaves lar deg bruke offentlige og private SSL/TLS-sertifikater med dine nettapplikasjoner og servere som kjører på EC2-instanser med Nitro Enclaves.

Du kan bruke disse funksjonene levert av Nitro Enclaves for å redusere risikoen forbundet med PII- og PHI-data. Vi anbefaler å inkludere Nitro Enclaves i en LLM-tjeneste når du håndterer sensitive brukerdata.

Løsningsoversikt

La oss undersøke arkitekturen til eksempeltjenesten, nå inkludert Nitro Enclaves. Ved å inkludere Nitro Enclaves, som vist i følgende figur, blir LLM en sikrere chatbot for håndtering av PHI- eller PII-data.

Figur 2 – Løsningsoversiktsdiagram

Brukerdata, inkludert PII, PHI og spørsmål, forblir kryptert gjennom hele forespørsel-svar-prosessen når applikasjonen er vert i en enklave. Trinnene som ble utført under slutningen er som følger:

1. Chatbot-appen genererer midlertidig AWS-legitimasjon og ber brukeren legge inn et spørsmål. Spørsmålet, som kan inneholde PII eller PHI, blir deretter kryptert via AWS KMS. Den krypterte brukerinngangen kombineres med den midlertidige legitimasjonen for å lage den krypterte forespørselen.
2. De krypterte dataene sendes til en HTTP-server hostet av Flask som en POST-forespørsel. Før du godtar sensitive data, bør dette endepunktet konfigureres for HTTPs.
3. Klientappen mottar POST-forespørselen og videresender den gjennom en sikker lokal kanal (for eksempel vsock) til serverappen som kjører inne i Nitro Enclaves.
4. Nitro Enclaves-serverappen bruker den midlertidige legitimasjonen til å dekryptere forespørselen, spørre LLM og genererer svaret. De modellspesifikke innstillingene lagres i enklavene og er beskyttet med kryptografisk attestering.
5. Serverappen bruker den samme midlertidige legitimasjonen for å kryptere svaret.
6. Det krypterte svaret returneres tilbake til chatbot-appen gjennom klientappen som et svar fra POST-forespørselen.
7. Chatbot-appen dekrypterer svaret ved å bruke deres KMS-nøkkel og viser klarteksten til brukeren.

Forutsetninger

Før vi begynner, trenger du følgende forutsetninger for å distribuere løsningen:

Konfigurer en EC2-forekomst

Fullfør følgende trinn for å konfigurere en EC2-forekomst:

1. Start en r5.8xlarge EC2-forekomst som bruker amzn2-ami-kernel-5.10-hvm-2.0.20230628.0-x86_64-gp2 AMI med Nitro Enclaves aktivert.
2. Installer Nitro Enclaves CLI for å bygge og kjøre Nitro Enclaves-applikasjoner:
   • sudo amazon-linux-extras install aws-nitro-enclaves-cli -y
   • sudo yum install aws-nitro-enclaves-cli-devel -y
3. Bekreft installasjonen av Nitro Enclaves CLI:
   • nitro-cli –version
   • Versjonen som brukes i dette innlegget er 1.2.2
4. Installer Git og Docker for å bygge Docker-bilder og last ned applikasjonen fra GitHub. Legg til instansbrukeren din i Docker-gruppen ( er din IAM-forekomstbruker):
   • sudo yum install git -y
   • sudo usermod -aG ne <USER>
   • sudo usermod -aG docker <USER>
   • sudo systemctl start docker && sudo systemctl enable docker
5. Start og aktiver Nitro Enclaves allocator og vsock proxy-tjenester:
   • 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 bruker en lokal socket-tilkobling kalt vsock for å lage en sikker kanal mellom den overordnede forekomsten og enklaven.

Etter at alle tjenestene er startet og aktivert, start forekomsten på nytt for å bekrefte at alle brukergruppene og tjenestene kjører riktig:

sudo shutdown -r now

Konfigurer Nitro Enclaves-allokatortjenesten

Nitro Enclaves er et isolert miljø som angir en del av forekomstens CPU og minne for å kjøre enklaven. Med Nitro Enclaves-allokatortjenesten kan du angi hvor mange CPUer og hvor mye minne som skal tas fra den overordnede forekomsten for å kjøre enklaven.

Endre enklavens reserverte ressurser ved å bruke et tekstredigeringsprogram (for løsningen vår tildeler vi 8 CPU og 70,000 XNUMX MiB minne for å gi nok ressurser):

vi /etc/nitro_enclaves/allocatory.yaml

Figur 3 – AWS Nitro Enclaves Allocator-tjenestekonfigurasjon

Klon prosjektet

Etter at du har konfigurert EC2-forekomsten, kan du laste ned koden for å kjøre den sensitive chatboten med en LLM inne i Nitro Enclaves.

Du må oppdatere server.py fil med riktig KMS-nøkkel-ID som du opprettet i begynnelsen for å kryptere LLM-svaret.

1. Klone GitHub-prosjektet:
   • cd ~/ && git clone https://<THE_REPO.git>
2. Naviger til prosjektmappen for å bygge enclave_base Docker-bilde som inneholder Nitro Enclaves programvareutviklingssett (SDK) for kryptografiske attesteringsdokumenter fra Nitro Hypervisor (dette trinnet kan ta opptil 15 minutter):
   • cd /nitro_llm/enclave_base
   • docker build ./ -t “enclave_base”

Lagre LLM i EC2-forekomsten

Vi bruker åpen kildekode Bloom 560m LLM for naturlig språkbehandling for å generere svar. Denne modellen er ikke finjustert til PII og PHI, men demonstrerer hvordan en LLM kan leve inne i en enklave. Modellen må også lagres på den overordnede forekomsten slik at den kan kopieres inn i enklaven via Dockerfilen.

1. Naviger til prosjektet:
   • cd /nitro_llm
2. Installer de nødvendige kravene for å lagre modellen lokalt:
   • pip3 install requirements.txt
3. Kjør save_model.py app for å lagre modellen i /nitro_llm/enclave/bloom katalogen:
   • python3 save_model.py

Bygg og kjør Nitro Enclaves-bildet

For å kjøre Nitro Enclaves, må du opprette en enklavebildefil (EIF) fra et Docker-bilde av applikasjonen din. Dockerfilen som ligger i enklavekatalogen inneholder filene, koden og LLM som skal kjøres inne i enklaven.

Å bygge og drive enklaven vil ta flere minutter å fullføre.

1. Naviger til roten til prosjektet:
   • cd /nitro_llm
2. Bygg enklavebildefilen som enclave.eif:
   • nitro-cli build-enclave --docker-uri enclave:latest --output-file enclave.eif

Figur 4 – AWS Nitro Enclaves Byggeresultat

Når enklaven er bygget, vil en serie unike hasher og plattformkonfigurasjonsregistre (PCR) bli opprettet. PCR-ene er en sammenhengende måling for å bevise identiteten til maskinvaren og applikasjonen. Disse PCR-ene vil være nødvendige for kryptografisk attestering og brukes under trinnet for oppdatering av KMS-nøkkelpolicy.

3. Kjør enklaven med ressursene fra allocator.service (legger til --attach-console argumentet på slutten vil kjøre enklaven i feilsøkingsmodus):
   • nitro-cli run-enclave --cpu-count 8 --memory 70000 --enclave-cid 16 --eif-path enclave.eif

Du må tildele minst fire ganger EIF-filstørrelsen. Dette kan endres i allocator.service fra tidligere trinn.

4. Bekreft at enklaven kjører med følgende kommando:
   • nitro-cli describe-enclaves

Figur 5 – AWS Nitro Enclave Beskriv kommando

Oppdater KMS-nøkkelpolicyen

Fullfør følgende trinn for å oppdatere KMS-nøkkelpolicyen:

1. På AWS KMS-konsollen velger du Kundeadministrerte nøkler i navigasjonsruten.
2. Søk etter nøkkelen du genererte som en forutsetning.
3. Velg Rediger på nøkkelpolitikken.
4. Oppdater nøkkelpolicyen med følgende informasjon:
   • Din konto-ID
   • Ditt IAM-brukernavn
   • Den oppdaterte Cloud9-miljøforekomstrollen
   • handlinger kms:Encrypt og kms:Decrypt
   • Enklaver PCR-er (for eksempel PCR0, PCR1, PCR2) til nøkkelpolicyen din med en betingelseserklæring

Se følgende nøkkelkode:

{
   "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":""
            }
         }
      }
   ]
}

Lagre chatbot-appen

For å etterligne en sensitiv spørring chatbot-applikasjon som lever utenfor AWS-kontoen, må du lagre chatbot.py app og kjøre den i Cloud9-miljøet. Cloud9-miljøet ditt vil bruke sin instansrolle for midlertidig legitimasjon for å fjerne tillatelser fra EC2 som kjører enklaven. Fullfør følgende trinn:

1. På Cloud9-konsollen åpner du miljøet du opprettet.
2. Kopier følgende kode inn i en ny fil som chatbot.py inn i hovedkatalogen.
3. Installer de nødvendige modulene:
   • pip install boto3
   • Pip install requests
4. På Amazon EC2-konsollen, legg merke til IP-en som er knyttet til Nitro Enclaves-forekomsten.
5. Oppdater URL-variabelen i 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. Kjør chatbot-applikasjonen:

• • python3 chat.py

Når den kjører, vil terminalen be om brukerinndata og følge det arkitektoniske diagrammet fra tidligere for å generere et sikkert svar.

Kjør den private chatboten for spørsmål og svar

Nå som Nitro Enclaves er oppe og kjører på EC2-forekomsten, kan du på en tryggere måte stille spørsmål til chatbot PHI og PII. La oss se på et eksempel.

Innenfor Cloud9-miljøet stiller vi chatboten vår et spørsmål og oppgir brukernavnet vårt.

Figur 6 – Stille Chat Bot et spørsmål

AWS KMS krypterer spørsmålet, som ser ut som følgende skjermbilde.

Figur 7 – Kryptert spørsmål

Den blir deretter sendt til enklaven og spurt om den sikrede LLM. Spørsmålet og svaret til LLM vil se ut som følgende skjermbilde (resultatet og kryptert respons er kun synlig inne i enklaven i feilsøkingsmodus).

Figur 8 – Svar fra LLM

Resultatet blir deretter kryptert med AWS KMS og returnert til Cloud9-miljøet for å bli dekryptert.

Figur 9 – Endelig dekryptert respons

Rydd opp

Fullfør følgende trinn for å rydde opp i ressursene dine:

1. Stopp EC2-forekomsten som er opprettet for å huse enklaven din.
2. Slett Cloud9-miljøet.
3. Slett KMS-nøkkelen.
4. Fjern EC2-forekomstrollen og IAM-brukertillatelser.

konklusjonen

I dette innlegget viste vi frem hvordan du bruker Nitro Enclaves til å distribuere en LLM-spørsmåls- og svartjeneste som sikrere sender og mottar PII- og PHI-informasjon. Dette ble distribuert på Amazon EC2, og enklavene er integrert med AWS KMS som begrenser tilgangen til en KMS-nøkkel, så bare Nitro Enclaves og sluttbrukeren har lov til å bruke nøkkelen og dekryptere spørsmålet.

Hvis du planlegger å skalere denne arkitekturen for å støtte større arbeidsbelastninger, sørg for at modellvalgprosessen samsvarer med modellkravene dine med EC2-ressurser. I tillegg må du vurdere den maksimale forespørselsstørrelsen og hvilken innvirkning det vil ha på HTTP-serveren og slutningstid mot modellen. Mange av disse parameterne kan tilpasses gjennom modellen og HTTP-serverinnstillingene.

Den beste måten å bestemme de spesifikke innstillingene og kravene for arbeidsmengden din på er gjennom testing med en finjustert LLM. Selv om dette innlegget bare inkluderte naturlig språkbehandling av sensitive data, kan du endre denne arkitekturen for å støtte alternative LLM-er som støtter lyd, datasyn eller multimodaliteter. De samme sikkerhetsprinsippene som er fremhevet her kan brukes på data i alle formater. Ressursene som brukes til å bygge dette innlegget er tilgjengelige på GitHub repo.

Del hvordan du skal tilpasse denne løsningen til ditt miljø i kommentarfeltet.

Om forfatterne

Justin Miles er skyingeniør innen Leidos Digital Modernization Sector under Office of Technology. På fritiden liker han å spille golf og reise.

Liv d'Aliberti er forsker innen Leidos AI/ML Accelerator under Office of Technology. Forskningen deres fokuserer på personvernbevarende maskinlæring.

Chris Renzo er en senior løsningsarkitekt i AWS Defence and Aerospace-organisasjonen. Utenom jobben liker han en balanse mellom varmt vær og reiser.

Joe Kovba er visepresident i Leidos Digital Modernization Sector. På fritiden liker han å dømme fotballkamper og spille softball.

• SEO-drevet innhold og PR-distribusjon. Bli forsterket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk deg selv. Tilgang her.
• PlatoAiStream. Web3 Intelligence. Kunnskap forsterket. Tilgang her.
• PlatoESG. Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
• PlatoHelse. Bioteknologisk og klinisk etterretning. Tilgang her.
• kilde: https://aws.amazon.com/blogs/machine-learning/large-language-model-inference-over-confidential-data-using-aws-nitro-enclaves/