diff --git a/localisation/es-es/docs/05-containerization.md b/localisation/es-es/docs/05-containerization.md
index 3ba2d08..c4ddcb2 100644
--- a/localisation/es-es/docs/05-containerization.md
+++ b/localisation/es-es/docs/05-containerization.md
@@ -70,14 +70,16 @@ Consulta el documento [README](../README.md) para la preparación.
     ```text
     Me gustaría construir una imagen de contenedor de una aplicación Java. Sigue las instrucciones a continuación.
 
-    - La aplicación Java se encuentra en `java`.
-    - Tu directorio de trabajo es la raíz del repositorio.
     - Identifica primero todos los pasos que vas a hacer.
+    - La aplicación Java se encuentra en `java/socialapp`.
+    - Tu directorio de trabajo es la raíz del repositorio.
     - Crea un Dockerfile, `Dockerfile.java`.
     - Usa Microsoft OpenJDK 21.
     - Usa el enfoque de construcción multi-etapa.
     - Extrae JRE del JDK.
     - Usa el número de puerto objetivo `8080` para la imagen del contenedor.
+    - Agrega ambas variables de entorno, `CODESPACE_NAME` y `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` del host a la imagen del contenedor.
+    - Crea un archivo de base de datos SQLite, `sns_api.db`, en la imagen del contenedor. NO copies el archivo del host.
     ```
 
 1. Haz clic en el botón ![imagen del botón keep](https://img.shields.io/badge/keep-blue) de GitHub Copilot para tomar los cambios.
@@ -101,6 +103,7 @@ Consulta el documento [README](../README.md) para la preparación.
     Usa la imagen del contenedor recién construida, ejecuta un contenedor y verifica si la aplicación se está ejecutando correctamente.
     
     - Usa el puerto del host `8080`.
+    - Ambos valores `CODESPACE_NAME` y `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` deben ser los de GitHub Codespaces.
     ```
 
 ### Contenedorizar Aplicación .NET
@@ -111,13 +114,14 @@ Consulta el documento [README](../README.md) para la preparación.
     ```text
     Me gustaría construir una imagen de contenedor de una aplicación .NET. Sigue las instrucciones a continuación.
 
+    - Identifica primero todos los pasos que vas a hacer.
     - La aplicación .NET se encuentra en `dotnet`.
     - Tu directorio de trabajo es la raíz del repositorio.
-    - Identifica primero todos los pasos que vas a hacer.
     - Crea un Dockerfile, `Dockerfile.dotnet`.
     - Usa .NET 9.
     - Usa el enfoque de construcción multi-etapa.
     - Usa el número de puerto objetivo `8080` para la imagen del contenedor.
+    - Agrega la variable de entorno, `ApiSettings__BaseUrl` al contenedor. Debe apuntar a la aplicación Java, `http://localhost:8080/api`.
     ```
 
 1. Haz clic en el botón ![imagen del botón keep](https://img.shields.io/badge/keep-blue) de GitHub Copilot para tomar los cambios.
@@ -141,12 +145,13 @@ Consulta el documento [README](../README.md) para la preparación.
     Usa la imagen del contenedor recién construida, ejecuta un contenedor y verifica si la aplicación se está ejecutando correctamente.
     
     - Usa el puerto del host `3030`.
+    - Pasa la variable de entorno `ApiSettings__BaseUrl` el valor de `http://localhost:8080/api`.
     ```
 
 1. Asegúrate de que tanto las aplicaciones frontend como backend NO se estén comunicando entre sí porque aún no se conocen. Ejecuta el prompt como el siguiente.
 
     ```text
-    Independientemente o no, remueve ambos contenedores que están ejecutándose actualmente.
+    Remueve ambos contenedores Java y .NET y sus respectivas imágenes de contenedor.
     ```
 
 ### Orquestar Contenedores
@@ -157,6 +162,7 @@ Consulta el documento [README](../README.md) para la preparación.
     ```text
     Me gustaría crear un archivo Docker Compose. Sigue las instrucciones a continuación.
     
+    - Identifica primero todos los pasos que vas a hacer.
     - Tu directorio de trabajo es la raíz del repositorio.
     - Usa `Dockerfile.java` como aplicación backend.
     - Usa `Dockerfile.dotnet` como aplicación frontend.
@@ -164,7 +170,8 @@ Consulta el documento [README](../README.md) para la preparación.
     - Usa `contoso` como el nombre de la red.
     - Usa `contoso-backend` como el nombre del contenedor de la aplicación Java. Su puerto objetivo es 8080, y el puerto del host es 8080.
     - Usa `contoso-frontend` como el nombre del contenedor de la aplicación .NET. Su puerto objetivo es 8080, y el puerto del host es 3030.
-    - Monta el volumen para la base de datos que usa la aplicación Java, `java/socialapp/sns_api.db`.
+    - Agrega ambas variables de entorno, `CODESPACE_NAME` y `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` del host al contenedor Java.
+    - Agrega la variable de entorno, `ApiSettings__BaseUrl` al contenedor .NET. Debe apuntar al `/api` de la aplicación Java.
     ```
 
 1. Haz clic en el botón ![imagen del botón keep](https://img.shields.io/badge/keep-blue) de GitHub Copilot para tomar los cambios.
@@ -172,7 +179,7 @@ Consulta el documento [README](../README.md) para la preparación.
 1. Una vez que el archivo `compose.yaml` esté creado, ejecútalo y verifica si ambas aplicaciones se están ejecutando correctamente.
 
     ```text
-    Ahora, ejecuta el archivo Docker compose y verifica si las aplicaciones se están ejecutando correctamente.
+    Ejecuta el archivo Docker compose y verifica si todas las aplicaciones se están ejecutando correctamente.
     ```
 
 1. Abre un navegador web y navega a `http://localhost:3030`, y verifica si las aplicaciones están funcionando correctamente.
diff --git a/localisation/fr-fr/docs/05-containerization.md b/localisation/fr-fr/docs/05-containerization.md
index b8a3a04..f2a21f4 100644
--- a/localisation/fr-fr/docs/05-containerization.md
+++ b/localisation/fr-fr/docs/05-containerization.md
@@ -70,14 +70,16 @@ Consultez le document [README](../README.md) pour la préparation.
     ```text
     J'aimerais construire une image conteneur d'une application Java. Suivez les instructions ci-dessous.
 
-    - L'application Java se trouve dans `java`.
-    - Votre répertoire de travail est la racine du dépôt.
     - Identifiez d'abord toutes les étapes que vous allez effectuer.
+    - L'application Java se trouve dans `java/socialapp`.
+    - Votre répertoire de travail est la racine du dépôt.
     - Créez un Dockerfile, `Dockerfile.java`.
     - Utilisez Microsoft OpenJDK 21.
     - Utilisez l'approche de construction multi-étapes.
     - Extrayez JRE de JDK.
     - Utilisez le numéro de port cible `8080` pour l'image conteneur.
+    - Ajoutez les deux variables d'environnement, `CODESPACE_NAME` et `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` de l'hôte à l'image conteneur.
+    - Créez un fichier de base de données SQLite, `sns_api.db`, dans l'image conteneur. NE copiez PAS le fichier de l'hôte.
     ```
 
 1. Cliquez sur le bouton ![l'image du bouton keep](https://img.shields.io/badge/keep-blue) de GitHub Copilot pour prendre les modifications.
@@ -101,6 +103,7 @@ Consultez le document [README](../README.md) pour la préparation.
     Utilisez l'image conteneur qui vient d'être construite, exécutez un conteneur et vérifiez si l'application fonctionne correctement.
     
     - Utilisez le port hôte `8080`.
+    - Les deux valeurs `CODESPACE_NAME` et `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` doivent être celles de GitHub Codespaces.
     ```
 
 ### Conteneuriser l'Application .NET
@@ -111,13 +114,14 @@ Consultez le document [README](../README.md) pour la préparation.
     ```text
     J'aimerais construire une image conteneur d'une application .NET. Suivez les instructions ci-dessous.
 
+    - Identifiez d'abord toutes les étapes que vous allez effectuer.
     - L'application .NET se trouve dans `dotnet`.
     - Votre répertoire de travail est la racine du dépôt.
-    - Identifiez d'abord toutes les étapes que vous allez effectuer.
     - Créez un Dockerfile, `Dockerfile.dotnet`.
     - Utilisez .NET 9.
     - Utilisez l'approche de construction multi-étapes.
     - Utilisez le numéro de port cible `8080` pour l'image conteneur.
+    - Ajoutez la variable d'environnement, `ApiSettings__BaseUrl` au conteneur. Elle doit pointer vers l'application Java, `http://localhost:8080/api`.
     ```
 
 1. Cliquez sur le bouton ![l'image du bouton keep](https://img.shields.io/badge/keep-blue) de GitHub Copilot pour prendre les modifications.
@@ -141,12 +145,13 @@ Consultez le document [README](../README.md) pour la préparation.
     Utilisez l'image conteneur qui vient d'être construite, exécutez un conteneur et vérifiez si l'application fonctionne correctement.
     
     - Utilisez le port hôte `3030`.
+    - Passez la variable d'environnement `ApiSettings__BaseUrl` la valeur de `http://localhost:8080/api`.
     ```
 
 1. Assurez-vous que les applications frontend et backend ne communiquent PAS entre elles car elles ne se connaissent pas encore. Exécutez l'invite comme ci-dessous.
 
     ```text
-    Peu importe ou non, supprimez les deux conteneurs actuellement en cours d'exécution.
+    Supprimez les deux conteneurs Java et .NET et leurs images conteneur respectives.
     ```
 
 ### Orchestrer les Conteneurs
@@ -157,6 +162,7 @@ Consultez le document [README](../README.md) pour la préparation.
     ```text
     J'aimerais créer un fichier Docker Compose. Suivez les instructions ci-dessous.
     
+    - Identifiez d'abord toutes les étapes que vous allez effectuer.
     - Votre répertoire de travail est la racine du dépôt.
     - Utilisez `Dockerfile.java` comme application backend.
     - Utilisez `Dockerfile.dotnet` comme application frontend.
@@ -164,7 +170,8 @@ Consultez le document [README](../README.md) pour la préparation.
     - Utilisez `contoso` comme nom de réseau.
     - Utilisez `contoso-backend` comme nom de conteneur de l'application Java. Son port cible est 8080, et le port hôte est 8080.
     - Utilisez `contoso-frontend` comme nom de conteneur de l'application .NET. Son port cible est 8080, et le port hôte est 3030.
-    - Montez le volume pour la base de données que l'application Java utilise, `java/socialapp/sns_api.db`.
+    - Ajoutez les deux variables d'environnement, `CODESPACE_NAME` et `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` de l'hôte au conteneur Java.
+    - Ajoutez la variable d'environnement, `ApiSettings__BaseUrl` au conteneur .NET. Elle doit pointer vers le `/api` de l'application Java.
     ```
 
 1. Cliquez sur le bouton ![l'image du bouton keep](https://img.shields.io/badge/keep-blue) de GitHub Copilot pour prendre les modifications.
@@ -172,7 +179,7 @@ Consultez le document [README](../README.md) pour la préparation.
 1. Une fois le fichier `compose.yaml` créé, exécutez-le et vérifiez si les deux applications fonctionnent correctement.
 
     ```text
-    Maintenant, exécutez le fichier Docker compose et vérifiez si les applications fonctionnent correctement.
+    Exécutez le fichier Docker compose et vérifiez si toutes les applications fonctionnent correctement.
     ```
 
 1. Ouvrez un navigateur web et naviguez vers `http://localhost:3030`, et vérifiez si les applications sont en marche et fonctionnent correctement.
diff --git a/localisation/ja-jp/docs/05-containerization.md b/localisation/ja-jp/docs/05-containerization.md
index 260ec9b..139a3c4 100644
--- a/localisation/ja-jp/docs/05-containerization.md
+++ b/localisation/ja-jp/docs/05-containerization.md
@@ -70,14 +70,16 @@ DevOpsエンジニアとして、両方のアプリをコンテナ化する必
     ```text
     Javaアプリのコンテナイメージを構築したいと思います。以下の指示に従ってください。
 
-    - Javaアプリは `java` にあります。
-    - 作業ディレクトリはリポジトリルートです。
     - まず実行するすべてのステップを特定してください。
+    - Javaアプリは `java/socialapp` にあります。
+    - 作業ディレクトリはリポジトリルートです。
     - Dockerfile `Dockerfile.java` を作成してください。
     - Microsoft OpenJDK 21を使用してください。
     - マルチステージビルドアプローチを使用してください。
     - JDKからJREを抽出してください。
     - コンテナイメージのターゲットポート番号として `8080` を使用してください。
+    - ホストからコンテナイメージに環境変数 `CODESPACE_NAME` と `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` の両方を追加してください。
+    - コンテナイメージにSQLiteデータベースファイル `sns_api.db` を作成してください。ホストからファイルをコピーしないでください。
     ```
 
 1. GitHub Copilot の ![keepボタンの画像](https://img.shields.io/badge/keep-blue) ボタンをクリックして変更を適用します。
@@ -101,6 +103,7 @@ DevOpsエンジニアとして、両方のアプリをコンテナ化する必
     構築したばかりのコンテナイメージを使用して、コンテナを実行し、アプリが適切に実行されているかどうかを確認してください。
     
     - ホストポートとして `8080` を使用してください。
+    - `CODESPACE_NAME` と `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` の両方の値は GitHub Codespaces のものである必要があります。
     ```
 
 ### .NET アプリケーションをコンテナ化
@@ -111,13 +114,14 @@ DevOpsエンジニアとして、両方のアプリをコンテナ化する必
     ```text
     .NETアプリのコンテナイメージを構築したいと思います。以下の指示に従ってください。
 
+    - まず実行するすべてのステップを特定してください。
     - .NETアプリは `dotnet` にあります。
     - 作業ディレクトリはリポジトリルートです。
-    - まず実行するすべてのステップを特定してください。
     - Dockerfile `Dockerfile.dotnet` を作成してください。
     - .NET 9を使用してください。
     - マルチステージビルドアプローチを使用してください。
     - コンテナイメージのターゲットポート番号として `8080` を使用してください。
+    - コンテナに環境変数 `ApiSettings__BaseUrl` を追加してください。これはJavaアプリの `http://localhost:8080/api` を指すようにしてください。
     ```
 
 1. GitHub Copilot の ![keepボタンの画像](https://img.shields.io/badge/keep-blue) ボタンをクリックして変更を適用します。
@@ -141,12 +145,13 @@ DevOpsエンジニアとして、両方のアプリをコンテナ化する必
     構築したばかりのコンテナイメージを使用して、コンテナを実行し、アプリが適切に実行されているかどうかを確認してください。
     
     - ホストポートとして `3030` を使用してください。
+    - 環境変数 `ApiSettings__BaseUrl` に `http://localhost:8080/api` の値を渡してください。
     ```
 
 1. フロントエンドとバックエンドの両方のアプリが、まだ互いを知らないため通信していないことを確認します。以下のようなプロンプトを実行します。
 
     ```text
-    いずれにせよ、現在実行中の両方のコンテナを削除してください。
+    JavaとNETの両方のコンテナとそれぞれのコンテナイメージを削除してください。
     ```
 
 ### コンテナをオーケストレート
@@ -157,6 +162,7 @@ DevOpsエンジニアとして、両方のアプリをコンテナ化する必
     ```text
     Docker Composeファイルを作成したいと思います。以下の指示に従ってください。
     
+    - まず実行するすべてのステップを特定してください。
     - 作業ディレクトリはリポジトリルートです。
     - バックエンドアプリとして `Dockerfile.java` を使用してください。
     - フロントエンドアプリとして `Dockerfile.dotnet` を使用してください。
@@ -164,7 +170,8 @@ DevOpsエンジニアとして、両方のアプリをコンテナ化する必
     - ネットワーク名として `contoso` を使用してください。
     - Javaアプリのコンテナ名として `contoso-backend` を使用してください。ターゲットポートは8080、ホストポートは8080です。
     - .NETアプリのコンテナ名として `contoso-frontend` を使用してください。ターゲットポートは8080、ホストポートは3030です。
-    - Javaアプリが使用するデータベース `java/socialapp/sns_api.db` のボリュームをマウントしてください。
+    - ホストからJavaコンテナに環境変数 `CODESPACE_NAME` と `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` の両方を追加してください。
+    - .NETコンテナに環境変数 `ApiSettings__BaseUrl` を追加してください。これはJavaアプリの `/api` を指すようにしてください。
     ```
 
 1. GitHub Copilot の ![keepボタンの画像](https://img.shields.io/badge/keep-blue) ボタンをクリックして変更を適用します。
@@ -172,7 +179,7 @@ DevOpsエンジニアとして、両方のアプリをコンテナ化する必
 1. `compose.yaml` ファイルが作成されたら、それを実行して両方のアプリが適切に実行されているかどうかを確認します。
 
     ```text
-    Docker composeファイルを実行して、アプリが適切に実行されているかどうかを確認してください。
+    Docker composeファイルを実行して、すべてのアプリが適切に実行されているかどうかを確認してください。
     ```
 
 1. ウェブブラウザを開いて `http://localhost:3030` に移動し、アプリが適切に起動して実行されているかどうかを確認します。
diff --git a/localisation/ko-kr/docs/05-containerization.md b/localisation/ko-kr/docs/05-containerization.md
index 14960d3..cd34b9e 100644
--- a/localisation/ko-kr/docs/05-containerization.md
+++ b/localisation/ko-kr/docs/05-containerization.md
@@ -70,14 +70,16 @@ Contoso는 다양한 야외 활동 제품을 판매하는 회사입니다. Conto
     ```text
     Java 앱의 컨테이너 이미지를 빌드하고 싶습니다. 아래 지침을 따르세요.
 
-    - Java 앱은 `java`에 위치합니다.
-    - 작업 디렉토리는 저장소 루트입니다.
     - 먼저 수행할 모든 단계를 식별하세요.
+    - Java 앱은 `java/socialapp`에 위치합니다.
+    - 작업 디렉토리는 저장소 루트입니다.
     - `Dockerfile.java` Dockerfile을 생성하세요.
     - Microsoft OpenJDK 21을 사용하세요.
     - 멀티 스테이지 빌드 방식을 사용하세요.
     - JDK에서 JRE를 추출하세요.
     - 컨테이너 이미지의 대상 포트 번호로 `8080`을 사용하세요.
+    - 호스트에서 컨테이너 이미지로 환경 변수 `CODESPACE_NAME`과 `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` 모두를 추가하세요.
+    - 컨테이너 이미지에 SQLite 데이터베이스 파일 `sns_api.db`를 생성하세요. 호스트에서 파일을 복사하지 마세요.
     ```
 
 1. GitHub Copilot의 ![the keep button image](https://img.shields.io/badge/keep-blue) 버튼을 클릭하여 변경사항을 적용하세요.
@@ -101,6 +103,7 @@ Contoso는 다양한 야외 활동 제품을 판매하는 회사입니다. Conto
     방금 빌드한 컨테이너 이미지를 사용하여 컨테이너를 실행하고 앱이 제대로 실행되는지 확인하세요.
     
     - 호스트 포트로 `8080`을 사용하세요.
+    - `CODESPACE_NAME`과 `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` 값 모두 GitHub Codespaces의 값이어야 합니다.
     ```
 
 ### .NET 애플리케이션 컨테이너화
@@ -111,13 +114,14 @@ Contoso는 다양한 야외 활동 제품을 판매하는 회사입니다. Conto
     ```text
     .NET 앱의 컨테이너 이미지를 빌드하고 싶습니다. 아래 지침을 따르세요.
 
+    - 먼저 수행할 모든 단계를 식별하세요.
     - .NET 앱은 `dotnet`에 위치합니다.
     - 작업 디렉토리는 저장소 루트입니다.
-    - 먼저 수행할 모든 단계를 식별하세요.
     - `Dockerfile.dotnet` Dockerfile을 생성하세요.
     - .NET 9를 사용하세요.
     - 멀티 스테이지 빌드 방식을 사용하세요.
     - 컨테이너 이미지의 대상 포트 번호로 `8080`을 사용하세요.
+    - 컨테이너에 환경 변수 `ApiSettings__BaseUrl`을 추가하세요. 이는 Java 앱 `http://localhost:8080/api`를 가리켜야 합니다.
     ```
 
 1. GitHub Copilot의 ![the keep button image](https://img.shields.io/badge/keep-blue) 버튼을 클릭하여 변경사항을 적용하세요.
@@ -141,12 +145,13 @@ Contoso는 다양한 야외 활동 제품을 판매하는 회사입니다. Conto
     방금 빌드한 컨테이너 이미지를 사용하여 컨테이너를 실행하고 앱이 제대로 실행되는지 확인하세요.
     
     - 호스트 포트로 `3030`을 사용하세요.
+    - 환경 변수 `ApiSettings__BaseUrl`에 `http://localhost:8080/api` 값을 전달하세요.
     ```
 
 1. 프론트엔드와 백엔드 앱이 서로를 알지 못하므로 아직 통신하지 않는지 확인하세요. 아래와 같은 프롬프트를 실행하세요.
 
     ```text
-    상관없이 현재 실행 중인 두 컨테이너를 모두 제거하세요.
+    Java와 .NET 컨테이너 모두와 각각의 컨테이너 이미지를 제거하세요.
     ```
 
 ### 컨테이너 오케스트레이션
@@ -157,6 +162,7 @@ Contoso는 다양한 야외 활동 제품을 판매하는 회사입니다. Conto
     ```text
     Docker Compose 파일을 생성하고 싶습니다. 아래 지침을 따르세요.
     
+    - 먼저 수행할 모든 단계를 식별하세요.
     - 작업 디렉토리는 저장소 루트입니다.
     - 백엔드 앱으로 `Dockerfile.java`를 사용하세요.
     - 프론트엔드 앱으로 `Dockerfile.dotnet`을 사용하세요.
@@ -164,7 +170,8 @@ Contoso는 다양한 야외 활동 제품을 판매하는 회사입니다. Conto
     - 네트워크 이름으로 `contoso`를 사용하세요.
     - Java 앱의 컨테이너 이름으로 `contoso-backend`를 사용하세요. 대상 포트는 8080이고 호스트 포트는 8080입니다.
     - .NET 앱의 컨테이너 이름으로 `contoso-frontend`를 사용하세요. 대상 포트는 8080이고 호스트 포트는 3030입니다.
-    - Java 앱이 사용하는 데이터베이스 `java/socialapp/sns_api.db`의 볼륨을 마운트하세요.
+    - 호스트에서 Java 컨테이너로 환경 변수 `CODESPACE_NAME`과 `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` 모두를 추가하세요.
+    - .NET 컨테이너에 환경 변수 `ApiSettings__BaseUrl`을 추가하세요. 이는 Java 앱의 `/api`를 가리켜야 합니다.
     ```
 
 1. GitHub Copilot의 ![the keep button image](https://img.shields.io/badge/keep-blue) 버튼을 클릭하여 변경사항을 적용하세요.
@@ -172,7 +179,7 @@ Contoso는 다양한 야외 활동 제품을 판매하는 회사입니다. Conto
 1. `compose.yaml` 파일이 생성되면, 실행하고 두 앱이 모두 제대로 실행되는지 확인하세요.
 
     ```text
-    이제 Docker compose 파일을 실행하고 앱들이 제대로 실행되는지 확인하세요.
+    Docker compose 파일을 실행하고 모든 앱들이 제대로 실행되는지 확인하세요.
     ```
 
 1. 웹 브라우저를 열고 `http://localhost:3030`으로 이동하여, 앱이 제대로 실행되고 있는지 확인하세요.
diff --git a/localisation/pt-br/docs/05-containerization.md b/localisation/pt-br/docs/05-containerization.md
index dca32ef..d3747b7 100644
--- a/localisation/pt-br/docs/05-containerization.md
+++ b/localisation/pt-br/docs/05-containerization.md
@@ -70,14 +70,16 @@ Consulte a documentação [README](../README.md) para preparação.
     ```text
     Gostaria de construir uma imagem de contêiner de uma aplicação Java. Siga as instruções abaixo.
 
-    - A aplicação Java está localizada em `java`.
-    - Seu diretório de trabalho é a raiz do repositório.
     - Identifique todos os passos primeiro, que você vai fazer.
+    - A aplicação Java está localizada em `java/socialapp`.
+    - Seu diretório de trabalho é a raiz do repositório.
     - Crie um Dockerfile, `Dockerfile.java`.
     - Use Microsoft OpenJDK 21.
     - Use abordagem de construção multi-estágio.
     - Extraia JRE do JDK.
     - Use o número da porta de destino `8080` para a imagem do contêiner.
+    - Adicione ambas as variáveis de ambiente, `CODESPACE_NAME` e `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` do host para a imagem do contêiner.
+    - Crie um arquivo de banco de dados SQLite, `sns_api.db`, na imagem do contêiner. NÃO copie o arquivo do host.
     ```
 
 1. Clique no botão ![a imagem do botão keep](https://img.shields.io/badge/keep-blue) do GitHub Copilot para aceitar as mudanças.
@@ -101,6 +103,7 @@ Consulte a documentação [README](../README.md) para preparação.
     Use a imagem do contêiner recém-construída, execute um contêiner e verifique se a aplicação está funcionando adequadamente.
     
     - Use a porta do host `8080`.
+    - Ambos os valores `CODESPACE_NAME` e `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` devem ser aqueles do GitHub Codespaces.
     ```
 
 ### Containerizar Aplicação .NET
@@ -111,13 +114,14 @@ Consulte a documentação [README](../README.md) para preparação.
     ```text
     Gostaria de construir uma imagem de contêiner de uma aplicação .NET. Siga as instruções abaixo.
 
+    - Identifique todos os passos primeiro, que você vai fazer.
     - A aplicação .NET está localizada em `dotnet`.
     - Seu diretório de trabalho é a raiz do repositório.
-    - Identifique todos os passos primeiro, que você vai fazer.
     - Crie um Dockerfile, `Dockerfile.dotnet`.
     - Use .NET 9.
     - Use abordagem de construção multi-estágio.
     - Use o número da porta de destino `8080` para a imagem do contêiner.
+    - Adicione a variável de ambiente, `ApiSettings__BaseUrl` ao contêiner. Deve apontar para a aplicação Java, `http://localhost:8080/api`.
     ```
 
 1. Clique no botão ![a imagem do botão keep](https://img.shields.io/badge/keep-blue) do GitHub Copilot para aceitar as mudanças.
@@ -141,12 +145,13 @@ Consulte a documentação [README](../README.md) para preparação.
     Use a imagem do contêiner recém-construída, execute um contêiner e verifique se a aplicação está funcionando adequadamente.
     
     - Use a porta do host `3030`.
+    - Passe a variável de ambiente `ApiSettings__BaseUrl` o valor de `http://localhost:8080/api`.
     ```
 
 1. Certifique-se de que ambas as aplicações frontend e backend NÃO estão se comunicando uma com a outra porque elas ainda não se conhecem. Execute o prompt como abaixo.
 
     ```text
-    Independentemente ou não, remova ambos os contêineres atualmente em execução.
+    Remova ambos os contêineres Java e .NET e suas respectivas imagens de contêiner.
     ```
 
 ### Orquestrar Contêineres
@@ -157,6 +162,7 @@ Consulte a documentação [README](../README.md) para preparação.
     ```text
     Gostaria de criar um arquivo Docker Compose. Siga as instruções abaixo.
     
+    - Identifique todos os passos primeiro, que você vai fazer.
     - Seu diretório de trabalho é a raiz do repositório.
     - Use `Dockerfile.java` como aplicação backend.
     - Use `Dockerfile.dotnet` como aplicação frontend.
@@ -164,7 +170,8 @@ Consulte a documentação [README](../README.md) para preparação.
     - Use `contoso` como nome da rede.
     - Use `contoso-backend` como nome do contêiner da aplicação Java. Sua porta de destino é 8080, e porta do host é 8080.
     - Use `contoso-frontend` como nome do contêiner da aplicação .NET. Sua porta de destino é 8080, e porta do host é 3030.
-    - Monte o volume para o banco de dados que a aplicação Java usa, `java/socialapp/sns_api.db`.
+    - Adicione ambas as variáveis de ambiente, `CODESPACE_NAME` e `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` do host para o contêiner Java.
+    - Adicione a variável de ambiente, `ApiSettings__BaseUrl` ao contêiner .NET. Deve apontar para o `/api` da aplicação Java.
     ```
 
 1. Clique no botão ![a imagem do botão keep](https://img.shields.io/badge/keep-blue) do GitHub Copilot para aceitar as mudanças.
@@ -172,7 +179,7 @@ Consulte a documentação [README](../README.md) para preparação.
 1. Uma vez que o arquivo `compose.yaml` seja criado, execute-o e verifique se ambas as aplicações estão funcionando adequadamente.
 
     ```text
-    Agora, execute o arquivo Docker compose e verifique se as aplicações estão funcionando adequadamente.
+    Execute o arquivo Docker compose e verifique se todas as aplicações estão funcionando adequadamente.
     ```
 
 1. Abra um navegador web e navegue para `http://localhost:3030`, e verifique se as aplicações estão funcionando adequadamente.
diff --git a/localisation/zh-cn/docs/05-containerization.md b/localisation/zh-cn/docs/05-containerization.md
index 9b7fb14..8b94c93 100644
--- a/localisation/zh-cn/docs/05-containerization.md
+++ b/localisation/zh-cn/docs/05-containerization.md
@@ -70,14 +70,16 @@ Contoso 是一家销售各种户外活动产品的公司。Contoso 的市场部
     ```text
     我想为 Java 应用构建容器镜像。请按照以下说明操作。
 
-    - Java 应用位于 `java`。
-    - 您的工作目录是存储库根目录。
     - 首先确定您要执行的所有步骤。
+    - Java 应用位于 `java/socialapp`。
+    - 您的工作目录是存储库根目录。
     - 创建一个 Dockerfile，`Dockerfile.java`。
     - 使用 Microsoft OpenJDK 21。
     - 使用多阶段构建方法。
     - 从 JDK 提取 JRE。
     - 为容器镜像使用目标端口号 `8080`。
+    - 从主机向容器镜像添加环境变量 `CODESPACE_NAME` 和 `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN`。
+    - 在容器镜像中创建 SQLite 数据库文件 `sns_api.db`。不要从主机复制文件。
     ```
 
 1. 点击 GitHub Copilot 的 ![保留按钮图片](https://img.shields.io/badge/keep-blue) 按钮接受更改。
@@ -101,6 +103,7 @@ Contoso 是一家销售各种户外活动产品的公司。Contoso 的市场部
     使用刚刚构建的容器镜像，运行容器并验证应用是否正常运行。
     
     - 使用主机端口 `8080`。
+    - `CODESPACE_NAME` 和 `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN` 的值都应该是来自 GitHub Codespaces 的值。
     ```
 
 ### 容器化 .NET 应用程序
@@ -111,13 +114,14 @@ Contoso 是一家销售各种户外活动产品的公司。Contoso 的市场部
     ```text
     我想为 .NET 应用构建容器镜像。请按照以下说明操作。
 
+    - 首先确定您要执行的所有步骤。
     - .NET 应用位于 `dotnet`。
     - 您的工作目录是存储库根目录。
-    - 首先确定您要执行的所有步骤。
     - 创建一个 Dockerfile，`Dockerfile.dotnet`。
     - 使用 .NET 9。
     - 使用多阶段构建方法。
     - 为容器镜像使用目标端口号 `8080`。
+    - 向容器添加环境变量 `ApiSettings__BaseUrl`。它应该指向 Java 应用程序 `http://localhost:8080/api`。
     ```
 
 1. 点击 GitHub Copilot 的 ![保留按钮图片](https://img.shields.io/badge/keep-blue) 按钮接受更改。
@@ -141,12 +145,13 @@ Contoso 是一家销售各种户外活动产品的公司。Contoso 的市场部
     使用刚刚构建的容器镜像，运行容器并验证应用是否正常运行。
     
     - 使用主机端口 `3030`。
+    - 传递环境变量 `ApiSettings__BaseUrl` 值 `http://localhost:8080/api`。
     ```
 
 1. 确保前端和后端应用暂时无法相互通信，因为它们还不知道彼此。运行如下提示。
 
     ```text
-    无论如何，删除当前运行的两个容器。
+    删除 Java 和 .NET 容器以及它们各自的容器镜像。
     ```
 
 ### 编排容器
@@ -157,6 +162,7 @@ Contoso 是一家销售各种户外活动产品的公司。Contoso 的市场部
     ```text
     我想创建一个 Docker Compose 文件。请按照以下说明操作。
     
+    - 首先确定您要执行的所有步骤。
     - 您的工作目录是存储库根目录。
     - 使用 `Dockerfile.java` 作为后端应用。
     - 使用 `Dockerfile.dotnet` 作为前端应用。
@@ -164,7 +170,8 @@ Contoso 是一家销售各种户外活动产品的公司。Contoso 的市场部
     - 使用 `contoso` 作为网络名称。
     - 使用 `contoso-backend` 作为 Java 应用的容器名称。其目标端口是 8080，主机端口是 8080。
     - 使用 `contoso-frontend` 作为 .NET 应用的容器名称。其目标端口是 8080，主机端口是 3030。
-    - 为 Java 应用使用的数据库挂载卷，`java/socialapp/sns_api.db`。
+    - 从主机向 Java 容器添加环境变量 `CODESPACE_NAME` 和 `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN`。
+    - 向 .NET 容器添加环境变量 `ApiSettings__BaseUrl`。它应该指向 Java 应用的 `/api`。
     ```
 
 1. 点击 GitHub Copilot 的 ![保留按钮图片](https://img.shields.io/badge/keep-blue) 按钮接受更改。
@@ -172,7 +179,7 @@ Contoso 是一家销售各种户外活动产品的公司。Contoso 的市场部
 1. 创建 `compose.yaml` 文件后，运行它并验证两个应用是否正常运行。
 
     ```text
-    现在，运行 Docker compose 文件并验证应用是否正常运行。
+    运行 Docker compose 文件并验证所有应用是否正常运行。
     ```
 
 1. 打开 Web 浏览器并导航到 `http://localhost:3030`，验证应用是否正常运行。