Apply updates from containerization.md to all localized documents

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,22 +162,24 @@ 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.
     - Crea `compose.yaml` como el archivo Docker Compose.
     - 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.
 
 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.

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,22 +162,24 @@ 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.
     - Créez `compose.yaml` comme fichier Docker Compose.
     - 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.
 
 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.

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,22 +162,24 @@ DevOpsエンジニアとして、両方のアプリをコンテナ化する必
     ```text
     Docker Composeファイルを作成したいと思います。以下の指示に従ってください。
 
+    - まず実行するすべてのステップを特定してください。
     - 作業ディレクトリはリポジトリルートです。
     - バックエンドアプリとして `Dockerfile.java` を使用してください。
     - フロントエンドアプリとして `Dockerfile.dotnet` を使用してください。
     - Docker Composeファイルとして `compose.yaml` を作成してください。
     - ネットワーク名として `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) ボタンをクリックして変更を適用します。
 
 1. `compose.yaml` ファイルが作成されたら、それを実行して両方のアプリが適切に実行されているかどうかを確認します。
 
     ```text
-    Docker composeファイルを実行して、アプリが適切に実行されているかどうかを確認してください。
+    Docker composeファイルを実行して、すべてのアプリが適切に実行されているかどうかを確認してください。
     ```
 
 1. ウェブブラウザを開いて `http://localhost:3030` に移動し、アプリが適切に起動して実行されているかどうかを確認します。