Patch for dual-mode-worker.mdx (#294)

Author: muhsinking

serverless/development/dual-mode-worker.mdx

@@ -39,7 +39,7 @@ In this tutorial you'll learn how to:
 
 ## Requirements
 
-*   You've [created a RunPod account](/get-started/manage-accounts).
+*   You've [created a Runpod account](/get-started/manage-accounts).
 *   You've installed [Python 3.x](https://www.python.org/downloads/) and [Docker](https://docs.docker.com/get-started/get-docker/) on your local machine and configured them for your command line.
 *   Basic understanding of Docker concepts and shell scripting.
 
@@ -57,7 +57,7 @@ touch handler.py start.sh Dockerfile requirements.txt
 
 This creates:
 
-- `handler.py`: Your Python script with the RunPod handler logic.
+- `handler.py`: Your Python script with the Runpod handler logic.
 - `start.sh`: A shell script that will be the entrypoint for your Docker container.
 - `Dockerfile`: Instructions to build your Docker image.
 - `requirements.txt`: A file to list Python dependencies.
@@ -105,9 +105,9 @@ Key features:
 
 *   `MODE_TO_RUN = os.getenv("MODE_TO_RUN", "pod")`: Reads the mode from an environment variable, defaulting to `pod`.
 *   `async def handler(event)`: Your core logic.
-*   `if __name__ == '__main__':`: This block controls what happens when the script is executed directly.
-    *   In `serverless`" mode, it starts the RunPod Serverless worker.
+*   `if mode_to_run == "pod" ... else`: This conditional controls what happens when the script is executed directly.
     *   In `pod` mode, it runs a sample test call to your `handler` function, allowing for quick iteration.
+    *   In `serverless`" mode, it starts the Runpod Serverless worker.
 
 ## Step 3: Create the `start.sh` script
 
@@ -214,7 +214,7 @@ sleep infinity
 ```
 Key features:
 *   `case $MODE_TO_RUN in ... esac`: This structure directs the startup based on the mode.
-*   `serverless` mode: Executes `handler.py`, which then starts the RunPod Serverless worker. `exec` replaces the shell process with the Python process.
+*   `serverless` mode: Executes `handler.py`, which then starts the Runpod Serverless worker. `exec` replaces the shell process with the Python process.
 *   `pod` mode: Starts up the JupyterLab server for Pod development, then runs `sleep infinity` to keep the container alive so you can connect to it (e.g., via SSH or `docker exec`). You would then manually run `python /app/handler.py` inside the Pod to test your handler logic.
 
 ## Step 4: Create the `Dockerfile`
@@ -224,7 +224,7 @@ This file defines how to build your Docker image.
 Add the following content to `Dockerfile`:
 
 ```dockerfile
-# Use an official RunPod base image
+# Use an official Runpod base image
 FROM runpod/pytorch:2.0.1-py3.10-cuda11.8.0-devel-ubuntu22.04
 
 # Environment variables
@@ -267,7 +267,7 @@ COPY requirements.txt ./requirements.txt
 RUN pip install --no-cache-dir --upgrade pip && \
     pip install --no-cache-dir -r requirements.txt
 
-# Delete's the default start.sh file from RunPod (so we can replace it with our own below)
+# Delete's the default start.sh file from Runpod (so we can replace it with our own below)
 RUN rm ../start.sh
 
 # Copy all of our files into the container
@@ -284,7 +284,7 @@ RUN ls -la $WORKSPACE_DIR/start.sh
 CMD $WORKSPACE_DIR/start.sh
 ```
 Key features:
-*   `FROM runpod/pytorch:2.0.1-py3.10-cuda11.8.0-devel-ubuntu22.04`: Starts with a RunPod base image that comes with nginx, runpodctl, and other helpful base packages.
+*   `FROM runpod/pytorch:2.0.1-py3.10-cuda11.8.0-devel-ubuntu22.04`: Starts with a Runpod base image that comes with nginx, runpodctl, and other helpful base packages.
 *   `ARG WORKSPACE_DIR=/workspace` and `ENV WORKSPACE_DIR=${WORKSPACE_DIR}`: Allows the workspace directory to be set at build time.
 *   `WORKDIR $WORKSPACE_DIR`: Sets the working directory to the value of `WORKSPACE_DIR`.
 *   `COPY requirements.txt ./requirements.txt` and `RUN pip install ...`: Installs Python dependencies.
@@ -309,7 +309,7 @@ Now, build your Docker image and push it to a container registry like Docker Hub
     ```sh
     docker build --platform linux/amd64 --tag [YOUR_USERNAME]/dual-mode-worker .
     ```
-    The `--platform linux/amd64` flag is important for compatibility with RunPod's infrastructure.
+    The `--platform linux/amd64` flag is important for compatibility with Runpod's infrastructure.
   </Step>
 
   <Step title="Push the image to your container registry">
@@ -330,7 +330,7 @@ Now that you've finished building our Docker image, let's explore how you would
 
 Deploy the image to a Pod by following these steps:
 
-1. Go to the [Pods page](https://www.runpod.io/console/pods) in the RunPod console and click **Create Pod**.
+1. Go to the [Pods page](https://www.runpod.io/console/pods) in the Runpod console and click **Create Pod**.
 2. Choose a GPU.
 3. For "Docker Image Name", enter `[YOUR_USERNAME]/dual-mode-worker:latest`.
 4. Under **Pod Template**, select **Edit Template**.
@@ -349,7 +349,7 @@ This will execute the Pod-specific test harness in your `handler.py`, giving you
 
 Once you're confident with your `handler.py` logic tested in Pod mode, you're ready to deploy your dual-mode worker to a Serverless endpoint.
 
-1. Go to the [Serverless section](https://www.runpod.io/console/serverless) of the RunPod console.
+1. Go to the [Serverless section](https://www.runpod.io/console/serverless) of the Runpod console.
 2. Click **New Endpoint**.
 3. Under **Custom Source**, select **Docker Image**, then select **Next**.
 4. In the **Container Image** field, enter your Docker image URL: `docker.io/[YOUR_USERNAME]/dual-mode-worker:latest`.
@@ -363,7 +363,7 @@ The *same* image is used, but `start.sh` will now direct it to run in Serverless
 
 After deploying your endpoint in to Serverless mode, you can test it with the following steps:
 
-1.  Navigate to your endpoint's detail page in the RunPod console.
+1.  Navigate to your endpoint's detail page in the Runpod console.
 2.  Click the **Requests** tab.
 3.  Use the following JSON as test input:
 ```json
@@ -395,7 +395,7 @@ Congratulations! You've successfully built, deployed, and tested a dual-mode Ser
 
 <Steps>
   <Step title="Develop using Pod mode">
-    1. Deploy your initial Docker image to a RunPod Pod, ensuring `MODE_TO_RUN` is set to `pod` (or rely on the Dockerfile default).
+    1. Deploy your initial Docker image to a Runpod Pod, ensuring `MODE_TO_RUN` is set to `pod` (or rely on the Dockerfile default).
     2. [Connect to your Pod](/pods/connect-to-pod) (via SSH or web terminal).
     3. Navigate to the `/app` directory.
     4. As you develop, install any necessary Python packages (`pip install [PACKAGE_NAME]`) or system dependencies (`apt-get install [PACKAGE_NAME]`).
@@ -434,4 +434,4 @@ Now that you've mastered the dual-mode development workflow, you can:
 *   [Explore advanced handler functions.](/serverless/workers/handler-functions)
 *   [Learn about sending requests programmatically via API or SDKs.](/serverless/endpoints/send-requests)
 *   [Understand endpoint configurations for performance and cost optimization.](/serverless/endpoints/endpoint-configurations) 
-*   [Deep dive into local testing and development.](/serverless/development/local-testing)
+*   [Deep dive into local testing and development.](/serverless/development/local-testing)