bodyshop/_reference/dockerreadme.md

# Setting up External Networking and Static IP for WSL2 using Hyper-V

This guide will walk you through the steps to configure your WSL2 (Windows Subsystem for Linux) instance to use an external Hyper-V virtual switch, enabling it to connect directly to your local network. Additionally, you'll learn how to assign a static IP address to your WSL2 instance.

## Prerequisites

1. **Windows 10/11** with **WSL2** installed.
2. **Hyper-V** enabled on your system. If not, follow these steps to enable it:
  - Open PowerShell as Administrator and run:
    ```powershell
    dism.exe /Online /Enable-Feature /All /FeatureName:Microsoft-Hyper-V
    ```
  - Restart your computer.

3. A basic understanding of networking and WSL2 configuration.

---

## Step 1: Create an External Hyper-V Switch

1. **Open Hyper-V Manager**:
  - Press `Windows Key + X`, select `Hyper-V Manager`.

2. **Create a Virtual Switch**:
  - In the right-hand pane, click `Virtual Switch Manager`.
  - Choose `External` and click `Create Virtual Switch`.
  - Select your external network adapter (this is usually your Ethernet or Wi-Fi adapter).
  - Give the switch a name (e.g., `WSL External Switch`), then click `Apply` and `OK`.

---

## Step 2: Configure WSL2 to Use the External Hyper-V Switch

Now that you've created the external virtual switch, follow these steps to configure your WSL2 instance to use this switch.

1. **Set WSL2 to Use the External Switch**:
  - By default, WSL2 uses NAT to connect to your local network. You need to configure WSL2 to use the external Hyper-V switch instead.

2. **Check WSL2 Networking**:
  - Inside WSL, run:
    ```bash
    ip a
    ```
  - You should see an IP address in the range of your local network (e.g., `192.168.x.x`).

---

## Step 3: Configure a Static IP Address for WSL2

Once WSL2 is connected to the external network, you can assign a static IP address to your WSL2 instance.

1. **Open WSL2** and Edit the Network Configuration:
  - Depending on your Linux distribution, the file paths may vary, but typically for Ubuntu-based systems:
    ```bash
    sudo nano /etc/netplan/01-netcfg.yaml
    ```
  - If this file doesn’t exist, create a new file or use the correct configuration file path.

2. **Configure Static IP**:
  - Add or update the following configuration:
    ```yaml
    network:
      version: 2
      renderer: networkd
      ethernets:
        eth0:
          dhcp4: no
          addresses:
            - 192.168.1.100/24  # Choose an IP address in your network range
          gateway4: 192.168.1.1  # Your router's IP address
          nameservers:
            addresses:
              - 8.8.8.8
              - 8.8.4.4
    ```
  - Adjust the values according to your local network settings:
    - `addresses`: This is the static IP you want to assign.
    - `gateway4`: This should be the IP address of your router.
    - `nameservers`: These are DNS servers, you can use Google's public DNS or any other DNS provider.

3. **Apply the Changes**:
  - Run the following command to apply the network configuration:
    ```bash
    sudo netplan apply
    ```

4. **Verify the Static IP**:
  - Check if the static IP is correctly set by running:
    ```bash
    ip a
    ```
  - You should see the static IP you configured (e.g., `192.168.1.100`) on the appropriate network interface (usually `eth0`).

---

## Step 4: Restart WSL2 to Apply Changes

To ensure the changes are fully applied, restart WSL2:

1. Open PowerShell or Command Prompt and run:
   ```powershell
   wsl --shutdown
2. Then, start your WSL2 instance again.

## Step 5: Verify Connectivity

1. Check Internet and Local Network Connectivity:
   - Run a ping command from within WSL to verify that it can reach the internet: ```ping 8.8.8.8```
2. Test Access from other Devices:
    - If you're running services inside WSL (e.g., a web server), ensure they are accessible from other devices on your local network using the static IP address you configured (e.g., `http://192.168.1.100:4000`).



# Configuring `vm.overcommit_memory` in sysctl for WSL2

To prevent memory overcommitment issues and optimize performance, you can configure the `vm.overcommit_memory` setting in WSL2. This is particularly useful when running Redis or other memory-intensive services inside WSL2, as it helps control how the Linux kernel handles memory allocation.

### 1. **Open the sysctl Configuration File**:
To set the `vm.overcommit_memory` value, you'll need to edit the sysctl configuration file. Inside your WSL2 instance, run the following command to open the `sysctl.conf` file for editing:
```bash
   sudo nano /etc/sysctl.conf
```
### 2. Add the Overcommit Memory Setting:
Add the following line at the end of the file to allow memory overcommitment:
```bash
vm.overcommit_memory = 1
```

This setting tells the Linux kernel to always allow memory allocation, regardless of how much memory is available, which can prevent out-of-memory errors when running certain applications.

### 3. Apply the Changes:
After editing the file, save it and then apply the new sysctl configuration by running:

```bash
sudo sysctl -p
```

# Install Docker and Docker Compose in WSL2
- https://docs.docker.com/desktop/wsl/

# Local Stack 
- LocalStack Front end (Optional) - https://apps.microsoft.com/detail/9ntrnft9zws2?hl=en-us&gl=US
- http://localhost:4566/_aws/ses will allow you to see emails sent

# Docker Commands

##  General `docker-compose` Commands:
1. Bring up the services, force a rebuild of all services, and do not use the cache: `docker-compose up --build --no-cache`
2. Start Containers in Detached Mode: This will run the containers in the background (detached mode): `docker-compose up -d`
3. Stop and Remove Containers: Stops and removes the containers gracefully: `docker-compose down`
4. Stop containers without removing them: `docker-compose stop`
5. Remove Containers, Volumes, and Networks: `docker-compose down --volumes`
6. Force rebuild of containers: `docker-compose build --no-cache`
7. View running Containers:  `docker-compose ps`
8. View a specific containers logs: `docker-compose logs <container-name>`
9. Scale services (multiple instances of a service): `docker-compose up --scale <container-name>=<instances number> -d`
10. Watch a specific containers logs in realtime with timestamps: `docker-compose logs -f --timestamps <container-name>`

## Volume Management Commands
1. List  Docker volumes: `docker volume ls`
2. Remove Unused volumes `docker volume prune`
3. Remove specific volumes `docker volume rm <volume-name>`
4. Inspect a volume: `docker volume inspect <volume-name>`

## Container Image Management Commands:
1. List running containers: `docker ps`
2. List all containers: `docker os -a`
3. Remove Stopped containers: `docker container prune`
4. Remove a specific container: `docker container rm <container-name>`
5. Remove a specific image: `docker rmi <image-name>:<version>`
6. Remove all unused images: `docker image prune -a`

## Network Management Commands:
1. List networks: `docker network ls`
2. Inspect a specific network: `docker network inspect <network-name>`
3. Remove a specific network: `docker network rm <network-name>`
4. Remove unused networks: `docker network prune`

## Debugging and maintenance:
1. Enter a Running container: `docker exec -it <container name> /bin/bash` (could also be `/bin/sh` or for example `redis-cli` on a redis node)
2. View container resource usage: `docker stats`
3. Check Disk space used by Docker: `docker system df`
4. Remove all unused Data (Nuclear option): `docker system prune`

## Specific examples
1. To simulate a Clean state, one should run `docker system prune` followed by `docker volume prune -a`
2. You can run `docker-compose up` without the `-d` option, and you will get what is identical to the experience you were used to, this includes being able to control-c and bring the entire stack down