└── image-text-translator 
    ├── scripts/ - 환경 설정 및 도우미 스크립트 
    |└── setup.sh - 설정 도우미 스크립트 
    ├── app/ - 애플리케이션 
    │ ├── ui_cr/ - 브라우저 UI(Cloud Run) 
    │ │ ├── static/ - 프런트엔드용 정적 콘텐츠 
    | | ├── templates/ - 프런트엔드용 HTML 템플릿 
    | | ├── app.py - Flask 애플리케이션 
    | | ├── requirements.txt - UI Python requirements 
    | | ├── Dockerfile - Flask 컨테이너를 빌드하는 Dockerfile 
    | | └── .dockerignore - Dockerfile에서 무시할 파일 
    | | 
    │ └── backend_gcf/ - 백엔드(클라우드 함수) 
    │ ├── main.py - 백엔드 CF 애플리케이션 
    │ └── requirements.txt - 백엔드 CF Python 요구 사항 
    ├── requirements.txt - 프로젝트 로컬 개발에 대한 Python 요구 사항 
    └── README.md

# Google Cloud에 인증
gcloud auth list 

# 올바른 프로젝트를 선택했는지 확인 
export PROJECT_ID=<프로젝트 ID 입력> 
gcloud config set project $PROJECT_ID 

# Cloud Build API 사용
 gcloud services enable cloudbuild.googleapis.com 

# Cloud Storage API 사용
 gcloud services enable storage-api.googleapis.com 

# Artifact Registry API 사용
 gcloud services enable artifactregistry.googleapis.com 

# Eventarc API 사용
 gcloud services enable eventarc.googleapis.com 

# Cloud Run Admin API 사용
 gcloud services enable run.googleapis.com 

# Cloud Logging API 사용
 gcloud services enable logging.googleapis.com 

# Cloud Pub/Sub API 사용
 gcloud services enable pubsub.googleapis.com # 

Cloud Functions API
 사용 gcloud services enable cloudfunctions.googleapis.com 

# Cloud Translation API 사용
 gcloud services enable translate.googleapis.com 

# Cloud Vision API 사용
 gcloud services enable vision.googleapis.com 

# 서비스 계정 자격 증명 API 사용
 gcloud services enable iamcredentials.googleapis.com

# 이 작업을 하기 전에 PROJECT_ID 변수가 설정되어 있는지 확인하세요! 
export SVC_ACCOUNT=image-text-translator-sa 
export SVC_ACCOUNT_EMAIL= $SVC_ACCOUNT @ $PROJECT_ID .iam.gserviceaccount.com 

# 사용자 관리 서비스 계정을 연결하는 것은 Google Cloud에서 실행되는 프로덕션 코드에 대한 ADC에 자격 증명을 제공하는 가장 좋은 방법입니다.
 gcloud iam service-accounts create $SVC_ACCOUNT

# 서비스 계정에 역할 부여
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL" \
  --role=roles/run.admin

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL" \
  --role=roles/run.invoker

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL" \
  --role=roles/cloudfunctions.admin

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL" \
  --role=roles/cloudfunctions.invoker

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL" \
  --role="roles/cloudtranslate.user"

# 서비스 계정을 다른 리소스에 연결할 주체에게 필요한 역할을 부여합니다.
gcloud iam service-accounts add-iam-policy-binding $SVC_ACCOUNT_EMAIL \
  --member="group:gcp-devops@my-org.com" \
  --role=roles/iam.serviceAccountUser

# 서비스 계정 허용
gcloud iam service-accounts add-iam-policy-binding $SVC_ACCOUNT_EMAIL \
  --member="group:gcp-devops@my-org.com" \
  --role=roles/iam.serviceAccountTokenCreator

# 계정에 Cloud Functions 및 Cloud Run에 배포할 수 있는 액세스 권한이 있는지 확인합니다.
gcloud projects add-iam-policy-binding $PROJECT_ID \
   --member="group:gcp-devops@my-org.com" \
   --role roles/run.admin

# 로컬 Linux 환경에 Google Cloud CLI를 설치합니다. 
# https://cloud.google.com/sdk/docs/install을 참조하세요. # 

Gcloud CLI에서 Python 및 pip를 설정합니다. 
# https://cloud.google.com/python/docs/setup을 참조하세요. 

# 로컬 개발자를 위한 추가 Google Cloud CLI 패키지를 설치합니다.
sudo apt install google-cloud-cli-gke-gcloud-auth-plugin kubectl google-cloud-cli-skaffold google-cloud-cli-minikube

# Google Cloud에 인증합니다.
gcloud auth login

git clone https://github.com/hanhyeonkyu/image-text-translator.git

cd image-text-translator

python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

gcloud auth application-default login

# 아직 설정하지 않은 경우... 
export SVC_ACCOUNT=image-text-translator-sa
export SVC_ACCOUNT_EMAIL=$SVC_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com

# 로컬 개발자를 위한 서비스 계정 키 생성
gcloud iam service-accounts keys create ~/.config/gcloud/$SVC_ACCOUNT.json \
  --iam-account=$SVC_ACCOUNT_EMAIL

# 클라이언트 라이브러리에서 자동으로 감지되는 ADC 환경변수
export GOOGLE_APPLICATION_CREDENTIALS=~/.config/gcloud/$SVC_ACCOUNT.json

export PROJECT_ID=$(gcloud config list --format='value(core.project)')
export REGION=europe-west4
export SVC_ACCOUNT=image-text-translator-sa
export SVC_ACCOUNT_EMAIL=$SVC_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com
export GOOGLE_APPLICATION_CREDENTIALS=~/.config/gcloud/$SVC_ACCOUNT.json

# Functions
export FUNCTIONS_PORT=8081
export BACKEND_GCF=https://$REGION-$PROJECT_ID.cloudfunctions.net/extract-and-translate

# Flask
export FLASK_SECRET_KEY=some-secret-1234
export FLASK_RUN_PORT=8080

echo "Environment variables configured:"
echo PROJECT_ID="$PROJECT_ID"
echo REGION="$REGION"
echo SVC_ACCOUNT_EMAIL="$SVC_ACCOUNT_EMAIL"
echo BACKEND_GCF="$BACKEND_GCF"
echo FUNCTIONS_PORT="$FUNCTIONS_PORT"
echo FLASK_RUN_PORT="$FLASK_RUN_PORT"

@functions_framework.http
def extract_and_translate(request):
    """Extract and translate the text from an image.
    The image can be POSTed in the request, or it can be a GCS object reference.
    
    If a POSTed image, enctype should be multipart/form-data and the file named 'uploaded'.
    If we're passing a GCS object reference, content-type should be 'application/json', 
    with two attributes:
    - bucket: name of GCS bucket in which the file is stored.
    - filename: name of the file to be read.
    """

    # Check if the request method is POST
    if request.method == 'POST':
        # Get the uploaded file from the request
        uploaded = request.files.get('uploaded')  # Assuming the input filename is 'uploaded'
        to_lang = request.form.get('to_lang', "en")
        print(f"{uploaded=}, {to_lang=}")
        if not uploaded:
            return flask.jsonify({"error": "No file uploaded."}), 400

        if uploaded: # Process the uploaded file
            file_contents = uploaded.read()  # Read the file contents
            image = vision.Image(content=file_contents)
        else:
            return flask.jsonify({"error": "Unable to read uploaded file."}), 400
    else:
        # If we haven't created this, then get it from the bucket instead
        content_type = request.headers.get('content-type', 'null')
        if content_type == 'application/json':
            bucket = request.json.get('bucket', None)
            filename = request.json.get('filename', None)
            to_lang = request.json.get('to_lang', "en")

            print(f"Received {bucket=}, {filename=}, {to_lang=}")
        else:
            return flask.jsonify({"error": "Unknown content type."}), 400

        if bucket:
            image = vision.Image(source=vision.ImageSource(gcs_image_uri=f"gs://{bucket}/{filename}"))

    # Use the Vision API to extract text from the image
    detected = detect_text(image)
    if detected:
        translated = translate_text(detected, to_lang)
        if translated["text"] != "":
            # print(translated)
            return translated["text"]

    return "No text found in the image."

def detect_text(image: vision.Image) -> dict | None:
    """Extract the text from the Image object """
    text_detection_response = vision_client.text_detection(image=image)
    annotations = text_detection_response.text_annotations

    if annotations:
        text = annotations[0].description
    else:
        text = ""
    # print(f"Extracted text from image:\n{text}")

    # Returns language identifer in ISO 639-1 format. E.g. en.
    # See https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes
    detect_language_response = translate_client.detect_language(text)
    src_lang = detect_language_response["language"]
    print(f"Detected language: {src_lang}.")

    message = {
        "text": text,
        "src_lang": src_lang,
    }

    return message

def translate_text(message: dict, to_lang: str) -> dict:
    """
    Translates the text in the message from the specified source language
    to the requested target language, then sends a message requesting another
    service save the result.
    """

    text = message["text"]
    src_lang = message["src_lang"]

    translated = { # before translating
        "text": text,
        "src_lang": src_lang,
        "to_lang": to_lang,
    }

    if src_lang != to_lang and src_lang != "und":
        print(f"Translating text into {to_lang}.")
        translated_text = translate_client.translate(
                text, target_language=to_lang, source_language=src_lang)

        translated = {
            "text": unescape(translated_text["translatedText"]),
            "src_lang": src_lang,
            "to_lang": to_lang,
        }
    else:
        print("No translation required.")

    return translated

# Run the function
functions-framework --target extract_and_translate \
  --debug --port $FUNCTIONS_PORT

# You will first need to authenticate and set the environment vars in this terminal
source ./scripts/setup.sh

# now invoke
curl -X POST localhost:$FUNCTIONS_PORT \
   -H "Content-Type: multipart/form-data" \
   -F "uploaded=@./testing/images/kr_meme.jpg" \
   -F "to_lang=en"

# From the backend-gcf folder
gcloud functions deploy extract-and-translate \
  --gen2 --max-instances 1 \
  --region $REGION \
  --runtime=python312 --source=. \
  --trigger-http --entry-point=extract_and_translate \
  --no-allow-unauthenticated

# Allow this function to be called by the service account
gcloud functions add-invoker-policy-binding extract-and-translate \
  --region=$REGION \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL"

curl -X POST https://$REGION-$PROJECT_ID.cloudfunctions.net/extract-and-translate \
    -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
    -H "Content-Type: multipart/form-data" \
    -F "uploaded=@./testing/images/ua_meme.jpg" \
    -F "to_lang=en"

gcloud functions delete extract-and-translate --region=$REGION

export IMAGE_NAME=$REGION-docker.pkg.dev/$PROJECT_ID/image-text-translator-artifacts/image-text-translator-ui

# configure Docker to use the Google Cloud CLI to authenticate requests to Artifact Registry.
gcloud auth configure-docker $REGION-docker.pkg.dev

# Build the image and push it to Artifact Registry
# Run from the ui_cr folder
gcloud builds submit --tag $IMAGE_NAME:v0.1 .

# create a random secret key for our Flask application
export RANDOM_SECRET_KEY=$(openssl rand -base64 32)

gcloud run deploy image-text-translator-ui \
  --image=$IMAGE_NAME:v0.1 \
  --region=$REGION \
  --platform=managed \
  --allow-unauthenticated \
  --max-instances=1 \
  --service-account=$SVC_ACCOUNT \
  --set-env-vars BACKEND_GCF=$BACKEND_GCF,FLASK_SECRET_KEY=$RANDOM_SECRET_KEY

# Check our IMAGE_NAME is set
export IMAGE_NAME=$REGION-docker.pkg.dev/$PROJECT_ID/image-text-translator-artifacts/image-text-translator-ui
# Set our new version number
export VERSION=v0.2

# Rebuild the container image and push to the GAR
gcloud builds submit --tag $IMAGE_NAME:$VERSION .

# create a random secret key for our Flask application
export RANDOM_SECRET_KEY=$(openssl rand -base64 32)

# Redeploy
gcloud run deploy image-text-translator-ui \
  --image=$IMAGE_NAME:$VERSION \
  --region=$REGION \
  --platform=managed \
  --allow-unauthenticated \
  --max-instances=1 \
  --service-account=$SVC_ACCOUNT \
  --set-env-vars BACKEND_GCF=$BACKEND_GCF,FLASK_SECRET_KEY=$RANDOM_SECRET_KEY

# Verify your domain ownership with Google
gcloud domains verify mydomain.com
# Check it
gcloud domains list-user-verified

# Create a mapping to your domain
gcloud beta run domain-mappings create \
  --region $REGION \
  --service image-text-translator-ui \
  --domain image-text-translator.mydomain.com
  
# Obtain the DNS records. We want everything under `resourceRecords`.
gcloud beta run domain-mappings describe \
  --region $REGION \
  --domain image-text-translator.mydomain.com