Dokumentübersetzungsdienst mit Streamlit und AWS Translator

Einführung:

DocuTranslator, ein Dokumentübersetzungssystem, das in AWS erstellt und vom Streamlit-Anwendungsframework entwickelt wurde. Mit dieser Anwendung können Endbenutzer die Dokumente, die sie hochladen möchten, in ihre bevorzugte Sprache übersetzen. Es bietet die Möglichkeit, je nach Benutzerwunsch in mehrere Sprachen zu übersetzen, was den Benutzern wirklich hilft, den Inhalt auf ihre bequeme Weise zu verstehen.

Hintergrund:

Ziel dieses Projekts ist es, eine benutzerfreundliche, einfache Anwendungsschnittstelle bereitzustellen, um den Übersetzungsprozess so einfach zu gestalten, wie es die Benutzer erwarten. In diesem System muss niemand Dokumente übersetzen, indem er den AWS Translate-Dienst eingibt, vielmehr kann der Endbenutzer direkt auf den Anwendungsendpunkt zugreifen und die Anforderungen erfüllen.

High-Level-Architekturdiagramm:

Wie funktioniert das:

• Endbenutzer dürfen über einen Anwendungs-Load-Balancer auf eine Anwendung zugreifen.
• Sobald die Anwendungsoberfläche geöffnet ist, lädt der Benutzer die erforderlichen zu übersetzenden Dateien und die zu übersetzende Sprache hoch.
• Nach der Übermittlung dieser Details wird die Datei in den genannten Quell-S3-Bucket hochgeladen, der eine Lambda-Funktion zur Verbindung mit dem AWS Translator-Dienst auslöst.
• Sobald das übersetzte Dokument fertig ist, wird es in den Ziel-S3-Bucket hochgeladen.
• Danach kann der Endbenutzer das übersetzte Dokument vom Streamlit-Anwendungsportal herunterladen.

Technische Architektur:

Die obige Architektur zeigt unten die wichtigsten Punkte -

• Anwendungscode wurde in Containern verpackt und im ECR-Repository gespeichert.
• Gemäß dem obigen Design wurde ein ECS-Cluster eingerichtet, der zwei Aufgaben instanziiert, die Anwendungsbilder aus dem ECR-Repository abrufen.
• Beide Aufgaben werden als Starttyp zusätzlich zu EC2 gestartet. Beide EC2s werden im privaten Subnetz in den Verfügbarkeitszonen us-east-1a und us-east-1b gestartet.
• Ein EFS-Dateisystem wird erstellt, um Anwendungscodes zwischen zwei zugrunde liegenden EC2-Instanzen zu teilen. Es werden zwei Mountpoints in zwei Verfügbarkeitszonen erstellt (us-east-1a und us-east-1b).
• Zwei öffentliche Subnetze werden vor privaten Subnetzen konfiguriert und ein NAT-Gateway wird im öffentlichen Subnetz in der Verfügbarkeitszone us-east-1a eingerichtet.
• Ein Application Load Balancer wurde vor privaten Subnetzen konfiguriert, der den Datenverkehr auf zwei öffentliche Subnetze an Port 80 der Application Load Balancer Security Group (ALB SG) verteilt.
• Zwei EC2-Instanzen sind in zwei unterschiedlichen Zielgruppen mit derselben EC2-Sicherheitsgruppe (Streamlit_SG) konfiguriert, die Datenverkehr am Port 16347 vom Anwendungs-Load-Balancer akzeptiert.
• Es ist eine Portzuordnung zwischen Port 16347 in EC2-Instanzen und Port 8501 im ECS-Container konfiguriert. Sobald der Datenverkehr Port 16347 der EC2-Sicherheitsgruppe erreicht, wird er auf Port 8501 auf ECS-Containerebene umgeleitet.

Wie werden Daten gespeichert?

Hier haben wir den EFS-Freigabepfad verwendet, um dieselben Anwendungsdateien zwischen zwei zugrunde liegenden EC2-Instanzen zu teilen. Wir haben einen Mountpoint /streamlit_appfiles innerhalb der EC2-Instanzen erstellt und mit der EFS-Freigabe gemountet. Dieser Ansatz hilft dabei, denselben Inhalt auf zwei verschiedenen Servern zu teilen. Danach besteht unsere Absicht darin, eine Replikation desselben Anwendungsinhalts im Container-Arbeitsverzeichnis zu erstellen, das /streamlit ist. Dafür haben wir Bind Mounts verwendet, sodass alle Änderungen, die am Anwendungscode auf EC2-Ebene vorgenommen werden, auch im Container repliziert werden. Wir müssen die bidirektionale Replikation einschränken, was besagt, dass, wenn jemand versehentlich Code innerhalb des Containers ändert, dieser nicht auf EC2-Hostebene repliziert werden sollte, daher wurde innerhalb des Containers ein Arbeitsverzeichnis als schreibgeschütztes Dateisystem erstellt.

Konfiguration und Volumen des ECS-Containers:

zugrunde liegende EC2-Konfiguration:
Instanztyp: t2.medium
Netzwerktyp: Privates Subnetz

Containerkonfiguration:
Bild:
Netzwerkmodus: Standard
Host-Port: 16347
Containerhafen: 8501
Aufgaben-CPU: 2 vCPU (2048 Einheiten)
Aufgabenspeicher: 2,5 GB (2560 MiB)

Volumenkonfiguration:
Volume-Name: streamlit-volume
Quellpfad: /streamlit_appfiles
Containerpfad: /streamlit
Schreibgeschütztes Dateisystem: JA

Referenz zur Aufgabendefinition:

{
    "taskDefinitionArn": "arn:aws:ecs:us-east-1:<account-id>:task-definition/Streamlit_TDF-1:5",
    "containerDefinitions": [
        {
            "name": "streamlit",
            "image": "<account-id>.dkr.ecr.us-east-1.amazonaws.com/anirban:latest",
            "cpu": 0,
            "portMappings": [
                {
                    "name": "streamlit-8501-tcp",
                    "containerPort": 8501,
                    "hostPort": 16347,
                    "protocol": "tcp",
                    "appProtocol": "http"
                }
            ],
            "essential": true,
            "environment": [],
            "environmentFiles": [],
            "mountPoints": [
                {
                    "sourceVolume": "streamlit-volume",
                    "containerPath": "/streamlit",
                    "readOnly": true
                }
            ],
            "volumesFrom": [],
            "ulimits": [],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-group": "/ecs/Streamlit_TDF-1",
                    "mode": "non-blocking",
                    "awslogs-create-group": "true",
                    "max-buffer-size": "25m",
                    "awslogs-region": "us-east-1",
                    "awslogs-stream-prefix": "ecs"
                },
                "secretOptions": []
            },
            "systemControls": []
        }
    ],
    "family": "Streamlit_TDF-1",
    "taskRoleArn": "arn:aws:iam::<account-id>:role/ecsTaskExecutionRole",
    "executionRoleArn": "arn:aws:iam::<account-id>:role/ecsTaskExecutionRole",
    "revision": 5,
    "volumes": [
        {
            "name": "streamlit-volume",
            "host": {
                "sourcePath": "/streamlit_appfiles"
            }
        }
    ],
    "status": "ACTIVE",
    "requiresAttributes": [
        {
            "name": "com.amazonaws.ecs.capability.logging-driver.awslogs"
        },
        {
            "name": "ecs.capability.execution-role-awslogs"
        },
        {
            "name": "com.amazonaws.ecs.capability.ecr-auth"
        },
        {
            "name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
        },
        {
            "name": "com.amazonaws.ecs.capability.docker-remote-api.1.28"
        },
        {
            "name": "com.amazonaws.ecs.capability.task-iam-role"
        },
        {
            "name": "ecs.capability.execution-role-ecr-pull"
        },
        {
            "name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
        },
        {
            "name": "com.amazonaws.ecs.capability.docker-remote-api.1.29"
        }
    ],
    "placementConstraints": [],
    "compatibilities": [
        "EC2"
    ],
    "requiresCompatibilities": [
        "EC2"
    ],
    "cpu": "2048",
    "memory": "2560",
    "runtimePlatform": {
        "cpuArchitecture": "X86_64",
        "operatingSystemFamily": "LINUX"
    },
    "registeredAt": "2024-11-09T05:59:47.534Z",
    "registeredBy": "arn:aws:iam::<account-id>:root",
    "tags": []
}

Anwendungscode entwickeln und Docker-Image erstellen:

app.py

import streamlit as st
import boto3
import os
import time
from pathlib import Path

s3 = boto3.client('s3', region_name='us-east-1')
tran = boto3.client('translate', region_name='us-east-1')
lam = boto3.client('lambda', region_name='us-east-1')


# Function to list S3 buckets
def listbuckets():
    list_bucket = s3.list_buckets()
    bucket_name = tuple([it["Name"] for it in list_bucket["Buckets"]])
    return bucket_name

# Upload object to S3 bucket
def upload_to_s3bucket(file_path, selected_bucket, file_name):
    s3.upload_file(file_path, selected_bucket, file_name)

def list_language():
    response = tran.list_languages()
    list_of_langs = [i["LanguageName"] for i in response["Languages"]]
    return list_of_langs

def wait_for_s3obj(dest_selected_bucket, file_name):
    while True:
        try:
            get_obj = s3.get_object(Bucket=dest_selected_bucket, Key=f'Translated-{file_name}.txt')
            obj_exist = 'true' if get_obj['Body'] else 'false'
            return obj_exist
        except s3.exceptions.ClientError as e:
            if e.response['Error']['Code'] == "404":
                print(f"File '{file_name}' not found. Checking again in 3 seconds...")
                time.sleep(3)

def download(dest_selected_bucket, file_name, file_path):
     s3.download_file(dest_selected_bucket,f'Translated-{file_name}.txt', f'{file_path}/download/Translated-{file_name}.txt')
     with open(f"{file_path}/download/Translated-{file_name}.txt", "r") as file:
       st.download_button(
             label="Download",
             data=file,
             file_name=f"{file_name}.txt"
       )

def streamlit_application():
    # Give a header
    st.header("Document Translator", divider=True)
    # Widgets to upload a file
    uploaded_files = st.file_uploader("Choose a PDF file", accept_multiple_files=True, type="pdf")
    # # upload a file
    file_name = uploaded_files[0].name.replace(' ', '_') if uploaded_files else None
    # Folder path
    file_path = '/tmp'
    # Select the bucket from drop down
    selected_bucket = st.selectbox("Choose the S3 Bucket to upload file :", listbuckets())
    dest_selected_bucket = st.selectbox("Choose the S3 Bucket to download file :", listbuckets())
    selected_language = st.selectbox("Choose the Language :", list_language())
    # Create a button
    click = st.button("Upload", type="primary")
    if click == True:
        if file_name:
            with open(f'{file_path}/{file_name}', mode='wb') as w:
                w.write(uploaded_files[0].getvalue())
        # Set the selected language to the environment variable of lambda function
        lambda_env1 = lam.update_function_configuration(FunctionName='TriggerFunctionFromS3', Environment={'Variables': {'UserInputLanguage': selected_language, 'DestinationBucket': dest_selected_bucket, 'TranslatedFileName': file_name}})
        # Upload the file to S3 bucket:
        upload_to_s3bucket(f'{file_path}/{file_name}', selected_bucket, file_name)
        if s3.get_object(Bucket=selected_bucket, Key=file_name):
            st.success("File uploaded successfully", icon="✅")
            output = wait_for_s3obj(dest_selected_bucket, file_name)
            if output:
              download(dest_selected_bucket, file_name, file_path)
        else:
            st.error("File upload failed", icon="?")


streamlit_application()

about.py

import streamlit as st

## Write the description of application
st.header("About")
about = '''
Welcome to the File Uploader Application!

This application is designed to make uploading PDF documents simple and efficient. With just a few clicks, users can upload their documents securely to an Amazon S3 bucket for storage. Here’s a quick overview
of what this app does:

**Key Features:**
- **Easy Upload:** Users can quickly upload PDF documents by selecting the file and clicking the 'Upload' button.
- **Seamless Integration with AWS S3:** Once the document is uploaded, it is stored securely in a designated S3 bucket, ensuring reliable and scalable cloud storage.
- **User-Friendly Interface:** Built using Streamlit, the interface is clean, intuitive, and accessible to all users, making the uploading process straightforward.

**How it Works:**
1. **Select a PDF Document:** Users can browse and select any PDF document from their local system.
2. **Upload the Document:** Clicking the ‘Upload’ button triggers the process of securely uploading the selected document to an AWS S3 bucket.
3. **Success Notification:** After a successful upload, users will receive a confirmation message that their document has been stored in the cloud.
This application offers a streamlined way to store documents on the cloud, reducing the hassle of manual file management. Whether you're an individual or a business, this tool helps you organize and store your
 files with ease and security.
You can further customize this page by adding technical details, usage guidelines, or security measures as per your application's specifications.'''

st.markdown(about)

navigation.py

import streamlit as st

pg = st.navigation([
    st.Page("app.py", title="DocuTranslator", icon="?"),
    st.Page("about.py", title="About", icon="?")
], position="sidebar")

pg.run()

Docker-Datei:

FROM python:3.9-slim
WORKDIR /streamlit
COPY requirements.txt /streamlit/requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
RUN mkdir /tmp/download
COPY . /streamlit
EXPOSE 8501
CMD ["streamlit", "run", "navigation.py", "--server.port=8501", "--server.headless=true"]

Die Docker-Datei erstellt ein Image, indem alle oben genannten Anwendungskonfigurationsdateien gepackt und dann in das ECR-Repository übertragen werden. Docker Hub kann auch zum Speichern des Images verwendet werden.

Lastausgleich

In der Architektur sollen Anwendungsinstanzen in einem privaten Subnetz erstellt werden und ein Lastausgleichsmodul soll erstellt werden, um die eingehende Verkehrslast für private EC2-Instanzen zu reduzieren.
Da zwei zugrunde liegende EC2-Hosts zum Hosten von Containern verfügbar sind, wird der Lastausgleich auf zwei EC2-Hosts konfiguriert, um den eingehenden Datenverkehr zu verteilen. Es werden zwei verschiedene Zielgruppen erstellt, um jeweils zwei EC2-Instanzen mit einer Gewichtung von 50 % zu platzieren.

Load Balancer akzeptiert eingehenden Datenverkehr an Port 80 und leitet ihn dann an Backend-EC2-Instanzen an Port 16347 weiter, der auch an den entsprechenden ECS-Container weitergeleitet wird.

Lambda-Funktion:

Es gibt eine Lambda-Funktion, die so konfiguriert ist, dass sie den Quell-Bucket als Eingabe verwendet, um eine PDF-Datei von dort herunterzuladen und den Inhalt zu extrahieren. Anschließend übersetzt sie den Inhalt aus der aktuellen Sprache in die vom Benutzer angegebene Zielsprache und erstellt eine Textdatei zum Hochladen auf den Ziel-S3 Eimer.

{
    "taskDefinitionArn": "arn:aws:ecs:us-east-1:<account-id>:task-definition/Streamlit_TDF-1:5",
    "containerDefinitions": [
        {
            "name": "streamlit",
            "image": "<account-id>.dkr.ecr.us-east-1.amazonaws.com/anirban:latest",
            "cpu": 0,
            "portMappings": [
                {
                    "name": "streamlit-8501-tcp",
                    "containerPort": 8501,
                    "hostPort": 16347,
                    "protocol": "tcp",
                    "appProtocol": "http"
                }
            ],
            "essential": true,
            "environment": [],
            "environmentFiles": [],
            "mountPoints": [
                {
                    "sourceVolume": "streamlit-volume",
                    "containerPath": "/streamlit",
                    "readOnly": true
                }
            ],
            "volumesFrom": [],
            "ulimits": [],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-group": "/ecs/Streamlit_TDF-1",
                    "mode": "non-blocking",
                    "awslogs-create-group": "true",
                    "max-buffer-size": "25m",
                    "awslogs-region": "us-east-1",
                    "awslogs-stream-prefix": "ecs"
                },
                "secretOptions": []
            },
            "systemControls": []
        }
    ],
    "family": "Streamlit_TDF-1",
    "taskRoleArn": "arn:aws:iam::<account-id>:role/ecsTaskExecutionRole",
    "executionRoleArn": "arn:aws:iam::<account-id>:role/ecsTaskExecutionRole",
    "revision": 5,
    "volumes": [
        {
            "name": "streamlit-volume",
            "host": {
                "sourcePath": "/streamlit_appfiles"
            }
        }
    ],
    "status": "ACTIVE",
    "requiresAttributes": [
        {
            "name": "com.amazonaws.ecs.capability.logging-driver.awslogs"
        },
        {
            "name": "ecs.capability.execution-role-awslogs"
        },
        {
            "name": "com.amazonaws.ecs.capability.ecr-auth"
        },
        {
            "name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
        },
        {
            "name": "com.amazonaws.ecs.capability.docker-remote-api.1.28"
        },
        {
            "name": "com.amazonaws.ecs.capability.task-iam-role"
        },
        {
            "name": "ecs.capability.execution-role-ecr-pull"
        },
        {
            "name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
        },
        {
            "name": "com.amazonaws.ecs.capability.docker-remote-api.1.29"
        }
    ],
    "placementConstraints": [],
    "compatibilities": [
        "EC2"
    ],
    "requiresCompatibilities": [
        "EC2"
    ],
    "cpu": "2048",
    "memory": "2560",
    "runtimePlatform": {
        "cpuArchitecture": "X86_64",
        "operatingSystemFamily": "LINUX"
    },
    "registeredAt": "2024-11-09T05:59:47.534Z",
    "registeredBy": "arn:aws:iam::<account-id>:root",
    "tags": []
}

Anwendungstests:

Öffnen Sie die Anwendungs-Load-Balancer-URL „ALB-747339710.us-east-1.elb.amazonaws.com“, um die Webanwendung zu öffnen. Durchsuchen Sie eine beliebige PDF-Datei und behalten Sie sowohl den Quell-"fileuploadbucket-hwirio984092jjs" als auch den Ziel-Bucket "translatedfileuploadbucket-kh939809kjkfjsekfl" unverändert bei, da im Lambda-Code das Ziel fest codiert wurde Eimer ist wie oben erwähnt. Wählen Sie die Sprache aus, in die das Dokument übersetzt werden soll, und klicken Sie auf Hochladen. Sobald darauf geklickt wird, beginnt das Anwendungsprogramm mit der Abfrage des Ziel-S3-Buckets, um herauszufinden, ob die übersetzte Datei hochgeladen wurde. Wenn die genaue Datei gefunden wird, wird eine neue Option „Herunterladen“ angezeigt, mit der Sie die Datei aus dem Ziel-S3-Bucket herunterladen können.

Bewerbungslink: http://alb-747339710.us-east-1.elb.amazonaws.com/

Eigentlicher Inhalt:

import streamlit as st
import boto3
import os
import time
from pathlib import Path

s3 = boto3.client('s3', region_name='us-east-1')
tran = boto3.client('translate', region_name='us-east-1')
lam = boto3.client('lambda', region_name='us-east-1')


# Function to list S3 buckets
def listbuckets():
    list_bucket = s3.list_buckets()
    bucket_name = tuple([it["Name"] for it in list_bucket["Buckets"]])
    return bucket_name

# Upload object to S3 bucket
def upload_to_s3bucket(file_path, selected_bucket, file_name):
    s3.upload_file(file_path, selected_bucket, file_name)

def list_language():
    response = tran.list_languages()
    list_of_langs = [i["LanguageName"] for i in response["Languages"]]
    return list_of_langs

def wait_for_s3obj(dest_selected_bucket, file_name):
    while True:
        try:
            get_obj = s3.get_object(Bucket=dest_selected_bucket, Key=f'Translated-{file_name}.txt')
            obj_exist = 'true' if get_obj['Body'] else 'false'
            return obj_exist
        except s3.exceptions.ClientError as e:
            if e.response['Error']['Code'] == "404":
                print(f"File '{file_name}' not found. Checking again in 3 seconds...")
                time.sleep(3)

def download(dest_selected_bucket, file_name, file_path):
     s3.download_file(dest_selected_bucket,f'Translated-{file_name}.txt', f'{file_path}/download/Translated-{file_name}.txt')
     with open(f"{file_path}/download/Translated-{file_name}.txt", "r") as file:
       st.download_button(
             label="Download",
             data=file,
             file_name=f"{file_name}.txt"
       )

def streamlit_application():
    # Give a header
    st.header("Document Translator", divider=True)
    # Widgets to upload a file
    uploaded_files = st.file_uploader("Choose a PDF file", accept_multiple_files=True, type="pdf")
    # # upload a file
    file_name = uploaded_files[0].name.replace(' ', '_') if uploaded_files else None
    # Folder path
    file_path = '/tmp'
    # Select the bucket from drop down
    selected_bucket = st.selectbox("Choose the S3 Bucket to upload file :", listbuckets())
    dest_selected_bucket = st.selectbox("Choose the S3 Bucket to download file :", listbuckets())
    selected_language = st.selectbox("Choose the Language :", list_language())
    # Create a button
    click = st.button("Upload", type="primary")
    if click == True:
        if file_name:
            with open(f'{file_path}/{file_name}', mode='wb') as w:
                w.write(uploaded_files[0].getvalue())
        # Set the selected language to the environment variable of lambda function
        lambda_env1 = lam.update_function_configuration(FunctionName='TriggerFunctionFromS3', Environment={'Variables': {'UserInputLanguage': selected_language, 'DestinationBucket': dest_selected_bucket, 'TranslatedFileName': file_name}})
        # Upload the file to S3 bucket:
        upload_to_s3bucket(f'{file_path}/{file_name}', selected_bucket, file_name)
        if s3.get_object(Bucket=selected_bucket, Key=file_name):
            st.success("File uploaded successfully", icon="✅")
            output = wait_for_s3obj(dest_selected_bucket, file_name)
            if output:
              download(dest_selected_bucket, file_name, file_path)
        else:
            st.error("File upload failed", icon="?")


streamlit_application()

Übersetzter Inhalt (in kanadischem Französisch)

import streamlit as st

## Write the description of application
st.header("About")
about = '''
Welcome to the File Uploader Application!

This application is designed to make uploading PDF documents simple and efficient. With just a few clicks, users can upload their documents securely to an Amazon S3 bucket for storage. Here’s a quick overview
of what this app does:

**Key Features:**
- **Easy Upload:** Users can quickly upload PDF documents by selecting the file and clicking the 'Upload' button.
- **Seamless Integration with AWS S3:** Once the document is uploaded, it is stored securely in a designated S3 bucket, ensuring reliable and scalable cloud storage.
- **User-Friendly Interface:** Built using Streamlit, the interface is clean, intuitive, and accessible to all users, making the uploading process straightforward.

**How it Works:**
1. **Select a PDF Document:** Users can browse and select any PDF document from their local system.
2. **Upload the Document:** Clicking the ‘Upload’ button triggers the process of securely uploading the selected document to an AWS S3 bucket.
3. **Success Notification:** After a successful upload, users will receive a confirmation message that their document has been stored in the cloud.
This application offers a streamlined way to store documents on the cloud, reducing the hassle of manual file management. Whether you're an individual or a business, this tool helps you organize and store your
 files with ease and security.
You can further customize this page by adding technical details, usage guidelines, or security measures as per your application's specifications.'''

st.markdown(about)

Abschluss:

Dieser Artikel hat uns gezeigt, wie einfach der Dokumentübersetzungsprozess sein kann, wie wir es uns vorstellen, wenn ein Endbenutzer auf einige Optionen klicken muss, um die erforderlichen Informationen auszuwählen und innerhalb weniger Sekunden die gewünschte Ausgabe zu erhalten, ohne über die Konfiguration nachzudenken. Im Moment haben wir eine einzelne Funktion zum Übersetzen eines PDF-Dokuments integriert, aber später werden wir mehr darüber untersuchen, um mehrere Funktionen in einer einzigen Anwendung mit einigen interessanten Funktionen zu haben.

Das obige ist der detaillierte Inhalt vonDokumentübersetzungsdienst mit Streamlit und AWS Translator. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!