Fixes after proofreading

Author: kochaika

Deploy/Containerization/backend_dockerfile/task.md

@@ -1,17 +1,17 @@
 Before we write the Dockerfile for the backend, we have made a few changes
-to the project that will simplify our work later on. Please take a look at them.
+to the project to simplify our work later on. Please review them below:
 
 ### Backend changes
-- `database.sqlite` file was moved from the backend root directory to the `backend/data` directory.
-- Updated `storage` path in the [dbConfig.js][dbConfig] file.
-- Added `/health` route in the [index.js][index] file.
-- The `.env` file was moved outside the backend directory.
+- The `database.sqlite` file has been moved from the backend root directory to the `backend/data` directory.
+- The `storage` path has been updated in the [dbConfig.js][dbConfig] file.
+- A `/health` route has been added to the [index.js][index] file.
+- The `.env` file has been moved outside of the backend directory.
 
 ### Dockerfile
 Now it's time to create a Dockerfile in the project directory. 
 A Dockerfile is essentially a set of instructions for building an image, 
-which is a blueprint for our container to run from. 
-Let's go over this line by line of the backend [Dockerfile][Dockerfile]: 
+which is a blueprint for our container to run from.
+Let's go over the backend [Dockerfile][Dockerfile] line by line:
 
 ```Dockerfile
 FROM node:20-alpine
@@ -27,15 +27,15 @@ EXPOSE 8000
 CMD ["npm", "start"]
 ```
 
-- The line `FROM node:20-alpine` uses the Node.js 20 image from [Docker Hub](https://hub.docker.com/_/node/) as our base image. This ensures we have Node.js and all its dependencies in the container.
-- Using `WORKDIR /app` ensures that the next commands will be executed in that directory.
-- We `COPY package*.json ./`, which makes the file available in our Docker image.
+- The line `FROM node:20-alpine` uses the Node.js 20 image from [Docker Hub](https://hub.docker.com/_/node/) as the base image. This ensures that the container includes Node.js and all its dependencies.
+- Using `WORKDIR /app` ensures that subsequent commands execute in that directory.
+- The instruction `COPY package*.json ./` makes the file available in the Docker image.
 - Then, we install dependencies using `RUN npm install`.
-- We then copy the rest of our source code into a subdirectory `COPY . .`.
-- The `EXPOSE 8000` instruction informs Docker that the container listens on port `8000` at runtime. We specified this port in [index.js][index]. The `EXPOSE` instruction doesn't publish the port to your host machine; it simply declares that this port is intended to be published.
-- Finally, we state the command to run the application, which is `CMD ["npm", "start"]`.
+- The `COPY . .` instruction copies the rest of the source code into a subdirectory.
+- The `EXPOSE 8000` instruction informs Docker that the container listens on port `8000` at runtime. We specified this port in [index.js][index]. Note: The `EXPOSE` instruction doesn't publish the port to the host machine; it simply declares that this port is intended to be used.
+- Finally, the `CMD ["npm", "start"]` instruction specifies the command to run the application.
 
-We will run backend container later after frontend updates.
+We will run the backend container later, after making updates to the frontend.
 
 [dbConfig]: course://Deploy/Containerization/backend_dockerfile/backend/src/data/dbConfig.js
 [index]: course://Deploy/Containerization/backend_dockerfile/backend/src/index.js

Deploy/Containerization/docker_compose/task.md

@@ -1,48 +1,48 @@
 So, we are all set to run both containers with our services.
-To make managing them much easier, we will use [Docker Compose](https://docs.docker.com/compose/).
+To simplify their management, we will use [Docker Compose](https://docs.docker.com/compose/).
 
-**Docker Compose** is a tool that allows us to define the deployment of multiple containers
-and has the added benefit of making each container targetable using the service name.
+**Docker Compose** is a tool that allows us to define the deployment of multiple containers.
+It also enables targeting each container by its service name.
 All we need to do is create a [docker-compose.yaml][docker-compose.yaml] file in our main directory.
 
 ### docker-compose.yaml
-This file declares two services. Each service will have its own container built and run.
+This file defines two services, with each service having its own container to be built and run.
 Let’s look at the most important sections used to describe the services.
 
-- `build` specifies the path and name of the Dockerfile used to build the image for the container.
-- `environment` lists the environment variables that should be set inside the container.
-- `env_file` allows environment variables to be loaded from a file without specifying their values here.
+- `build`: Specifies the path and name of the Dockerfile used to build the container's image.
+- `environment`: Lists the environment variables that should be set inside the container.
+- `env_file`: Allows environment variables to be loaded from a file without specifying their values here.
 > **Use this approach for secret keys like `JWT_SECRET`.**
-> **Also, remember to generate unique `JWT_SECRET` using the script `backend/scripts/generateSecret.js`.**
-- `volumes` allows creating persistent storage where data will be saved even if the container restarts.
+> **Also, remember to generate a unique `JWT_SECRET` using the `backend/scripts/generateSecret.js` script.**
+- `volumes`: Allows creating persistent storage where data is retained even if the container restarts.
   For example, the volume `chat-db-data` will store the contents of the `'/app/data'` directory inside the backend container.
-- `healthcheck` defines a command whose successful execution will verify the service's health.
-- `networks` specifies that our containers will be connected via their own private internal network.
-  To access another container within this network, you only need to use the service name.
+- `healthcheck`: Defines a command that verifies the health of the service by checking its successful execution.
+- `networks`: Ensures that our containers are connected via their own private internal network.
+  To access one container from another within this network, you only need to use the service name.
   That’s why we can use a URL like http://backend:8000 inside the frontend container.
-- `ports` allows specifying which port on your machine should be mapped to the container’s port (`Host_Port:Container_Port`).
+- `ports`: Maps a port on your machine to a port inside the container in the format `Host_Port:Container_Port`.
 
-Note that our application is now only accessible through the frontend,
-and the frontend-backend interaction happens via the internal network. 
+Note that our application is now only accessible via the frontend.
+The frontend-backend communication takes place through the internal network. 
 
-You can get more information about the Docker Compose in the [official documentation](https://docs.docker.com/compose/).
+You can find more information about Docker Compose in the [official documentation](https://docs.docker.com/compose/).
 
 ### Launch the application
-To launch both services through the terminal, use the following command:
+To launch both services from the terminal, use the following command:
 ```shell
 docker compose up -d
 ```
-And the following command to stop them:
+To stop the services, run:
 ```shell
 docker compose down
 ```
 
-To launch them in the IDE, click the ![](images/runAll.svg) button
-opposite the `services` in the `docker-compose.yaml` file.
-You can see all information about launched services in the [Services](tool_window://Services) toolwindow:
+To launch the services in your IDE, click the ![](images/runAll.svg) button
+next to `services` in the `docker-compose.yaml` file.
+You can view all relevant information about the launched services in the [Services](tool_window://Services) tool window:
 
 <div style="text-align: center; max-width: 600px; margin: 0 auto;">
-<img src="images/compose_up.png" alt="Services toolwindow">
+<img src="images/compose_up.png" alt="Services tool window">
 </div>
 
 Now you can access the application at http://localhost:3000.

Deploy/Containerization/docker_intro/task.md

@@ -1,31 +1,32 @@
 Docker containers provide code isolation, independence, and portability. Docker is essentially needed
-if one intends to deploy their application into production. Docker containers have fully prescribed
-dependencies with which they can be created. These dependencies, as well as the application code, 
-are stored in the container’s **image**.
+if you intend to deploy your application to production. Docker containers are created with fully prescribed
+dependencies with which they can be created. These dependencies that are stored, along with the application code,
+in the container’s **image**.
 
-A **Dockerfile** is basically a set of instructions for building a container image, which is a blueprint that your container will run from.
+A **Dockerfile** is essentially a set of instructions for building a container image, which serves as a blueprint from which your container runs.
 
 In our project, we will use separate containers for the backend and frontend code.
 
-You can read more about Docker in [Docker docs](https://docs.docker.com/).
+You can read more about Docker in the [Docker documentation](https://docs.docker.com/).
 
 ### Docker support in JetBrains IDEs
-JetBrains IDEs allow you to manage Docker containers using a graphical interface. Only a few simple steps are required to set this up.
+JetBrains IDEs allow you to manage Docker containers using a graphical interface with just a few simple steps to set up.
 
 ### 1. Install and run Docker
-For more information, see the [Docker documentation](https://docs.docker.com/engine/install/) specific to your operating system.
+For detailed instructions, refer to the [Docker installation guide](https://docs.docker.com/engine/install/) for your specific operating system.
 
 ### 2. Configure the Docker daemon connection settings
 
 1. Open the IDE settings (you can use the shortcut &shortcut:ShowSettings;) and select **Build, Execution, Deployment | Docker**.
 2. Click ![](images/add.svg) to add a Docker configuration and specify how to connect to the Docker daemon.  
-   The connection settings depend on your Docker version and operating system. For more information, see [Docker configuration](https://www.jetbrains.com/help/pycharm/settings-docker.html).  
-   The **Connection successful** message should appear at the bottom of the dialog.
+   The connection settings will depend on your Docker version and operating system. For more information, see the [Docker configuration guide](https://www.jetbrains.com/help/pycharm/settings-docker.html).  
+   If everything is set up correctly, you should see the **Connection successful** message at the bottom of the dialog.
 
 ![](images/settings_docker.png)
 
 ### 3. Connect to the Docker daemon
-The configured Docker connection should appear in the Services tool window (**View | Tool Windows | Services** or &shortcut:ActivateServicesToolWindow;). Select the Docker node ![](images/docker.png) and click ![](images/run.svg), or select **Connect** from the context menu. Once connected, it will look like this:
+The configured Docker connection will appear in the Services tool window (**View | Tool Windows | Services** or use the &shortcut:ActivateServicesToolWindow;). 
+Select the Docker node ![](images/docker.png) and click ![](images/run.svg), or select **Connect** from the context menu. Once connected, it should look like this:
 <div style="text-align:center;"><img src="images/services.png" style="width:70%;" alt="Run MyRunConfig"></div>
 
 To edit the Docker connection settings, select the Docker node and click ![](images/edit.svg) on the toolbar, or select **Edit Configuration** from the context menu.

Deploy/Containerization/frontend_dockerfile/task.md

@@ -1,22 +1,22 @@
 Before we write the Dockerfile for the frontend, we have made a few changes
-to the project that will simplify our work later on. Please take a look at them.
+to the project to simplify our work later on. Please review them below.
 
 ### Frontend changes
-- Images (`academy.svg` and `delete.svg`) were moved to the `public/assets` folder. 
-  This is a default folder for resources and built by a Vite project.
-- Paths to the images in [Chat.jsx][Chat] and [index.html][index] files were updated.
-- Added a `build` script to [package.json][package].
-- Made changes in the [vite.config.js][vite.config] to take `backendUrl` from the environmental variables.
-- Created [nginx.conf][nginx]. This is a default configuration file for Nginx where we made few changes like frontend port and backend URLs.
-
-The built-in Vite web server is not intended for use in production.
-However, we can use it to build the project and then host it with
+- Images (`academy.svg` and `delete.svg`) were moved to the `public/assets` folder.
+  This is the default resources folder used by a Vite project.
+- Paths to the images in the [Chat.jsx][Chat] and [index.html][index] files were updated.
+- A `build` script was added to the [package.json][package] file.
+- Updates were made to [vite.config.js][vite.config] to retrieve `backendUrl` from the environment variables.
+- A new [nginx.conf][nginx] file was created. This is the default configuration file for Nginx, where changes were made, such as specifying the frontend port and backend URLs.
+
+The built-in Vite web server is not designed for production use.
+However, it can be used to build the project, which can then be hosted on
 a full-featured web server like [Nginx](https://nginx.org/).
 
 You can read more about Nginx configuration in the [official documentation](https://nginx.org/en/docs/beginners_guide.html#conf_structure). 
 
 ### Dockerfile
-Frontend [Dockerfile][Dockerfile] is a bit more complicated than the backend one. It includes 2 stages:
+The frontend [Dockerfile][Dockerfile] is slightly more complex than the backend one because it includes two stages:
 
 ```dockerfile
 # Build stage
@@ -39,14 +39,14 @@ COPY nginx.conf /etc/nginx/conf.d/default.conf
 EXPOSE 3000
 ```
 
-- A build stage is similar to the backend one. But the build artifacts are used in the next stage.
-- For the production stage, we use a base image with Nginx already installed: `nginx:alpine`.
+- The build stage is similar to the backend process, but its build artifacts are used in the next stage.
+- For the production stage, we use `nginx:alpine`, a base image with Nginx already installed.
 - Then, we copy the built frontend from the build stage into the Nginx directory: `COPY --from=build /app/dist /usr/share/nginx/html`.
 - Next, we copy the configuration file into the image: `COPY nginx.conf /etc/nginx/conf.d/default.conf`.
-- Finally, specify that the container listens on port `3000` at runtime.
+- Finally, we specify that the container will listen on port `3000` at runtime.
 
-You may have noticed that in [nginx.conf][nginx], URLs like `http://backend:8000/api/` are used without explicitly defining what "backend" is.
-In the next step, we’ll explain why this is normal and how to run the backend and frontend together.
+You may have noticed that in [nginx.conf][nginx], URLs such as `http://backend:8000/api/` are used without explicitly defining what "backend" refers to.
+In the next task, we’ll explain why this works and how to run both the backend and frontend together.
 
 [Chat]: course://Deploy/Containerization/frontend_dockerfile/frontend/src/pages/Chat.jsx
 [index]: course://Deploy/Containerization/frontend_dockerfile/frontend/index.html

Deploy/Containerization/introduction/task.md

@@ -1,15 +1,15 @@
-So far, we have been running our project locally, and that was enough for testing.
+So far, we have been running our project locally, which has been sufficient for testing.
 
 In this lesson, we’ll discuss how to adapt our application 
 before deploying it to a server and making it accessible to users.
 
-You could manually copy the application to a server, install all dependencies, 
-and run the application, but this approach is unstable. 
-For example, migrating the application to a different hosting service could take a long time.
+While you could manually copy the application to a server, install all dependencies,
+and run it there, this approach is unreliable.
+For example, migrating the application to a different hosting service might require significant time.
 
 We can avoid these issues by deploying and running the application in a **Docker container**.
 
-From this lesson, you will learn:
-- How to write a Dockerfile.
-- How to create a Docker Compose file for the project.
-- Run your application in a Docker containers in one command.
+From this lesson, you will learn how to:
+- Write a Dockerfile.
+- Create a Docker Compose file for the project.
+- Run your application in Docker containers with a single command.

Deploy/Containerization/summary/task.md

@@ -1,9 +1,9 @@
-Let’s summarize briefly. To deploy our application using Docker, you need:
+Let’s summarize briefly. To deploy your application using Docker, you need:
 
-1. A Dockerfile where we define the environment for our service, install dependencies, and configure the application build process.
-2. A Compose file where we describe how our services should be run, what data should be stored in persistent storage, which ports to expose, and more.
-3. Store secret keys in a `.env` file, avoid committing it to the repository, and do not set sensitive environment variables in the Dockerfile or Compose file.
+1. A Dockerfile where you define the environment for your service, install dependencies, and configure the application build process.
+2. A Compose file where you describe how your services should run, what data should be stored in persistent storage, which ports to expose, and other configurations.
+3. A `.env` file to store secret keys. Avoid committing this file to the repository, and never set sensitive environment variables directly in the Dockerfile or Compose file.
 
-Now you can deploy your application on any server with almost a single command.
+Now you can deploy your application to any server with almost a single command.
 
 Good luck!