Configuring Network Settings for External Access

Before we start, ensure you have completed the first part of this series and have a sample app running and accessible on your Raspberry Pi's localhost.

Introduction

In the previous part, we set up a sample Flask application inside a Docker container and made it accessible on your local network. In this part, we’ll focus on configuring your network settings to allow external access to your Raspberry Pi.

This involves mapping your domain to your router's public IP, configuring your router to forward requests to your Raspberry Pi, and setting up dynamic DNS to handle changes in your public IP address.

Step 1: Configuring a Static IP for Your Raspberry Pi

Ensure your Raspberry Pi has a static IP address on your local network. This was covered in Part 1, but it's crucial for the upcoming steps.

Step 2: Mapping Your Domain to Your Router's Public IP

To make your website accessible via your domain name, you need to update your DNS settings to point your domain to your router's public IP address.

Creating an A Record

1. Log in to your DNS provider’s dashboard (e.g., Cloudflare).
2. Select your domain and navigate to the DNS settings.
3. Create a new A record:
   • Type: A
   • Name: @ (or yourdomain.com)
   • Value: Your router's public IP address
   • TTL: Automatic or 1 hour

Step 3: Allowing Inbound Requests on Your Router

Many routers have inbound HTTP/S requests disabled by default for security reasons. You need to enable this setting to allow external access to your website.

Enabling HTTP/S on Your Router

1. Log in to your router’s admin interface.
2. Navigate to the settings related to security or firewall.
3. Find the option to allow inbound HTTP/S requests on the WAN (public) IP address.
4. Enable the setting for HTTPS, and optionally HTTP (though HTTPS is recommended for security).

Step 4: Configuring Port Forwarding

Next, configure your router to forward requests on specific ports to your Raspberry Pi.

Setting Up Port Forwarding

1. Log in to your router’s admin interface.
2. Navigate to the port forwarding section.
3. Add a new port forwarding rule:
   • Service Name: HTTP
   • External Port: 80
   • Internal IP Address: Your Raspberry Pi’s static IP
   • Internal Port: 80
   • Protocol: TCP
4. Add another rule for HTTPS:
   • Service Name: HTTPS
   • External Port: 443
   • Internal IP Address: Your Raspberry Pi’s static IP
   • Internal Port: 443
   • Protocol: TCP

Step 5: Setting Up Dynamic DNS

Since your router's public IP address can change periodically, it’s essential to keep your DNS records updated. We can automate this process using a dynamic DNS script.

Setting Up a Dynamic DNS Script

Use a script like in this repository to dynamically update your ip address in the dns.

Conclusion

In this part, we've configured your network settings to allow external access to your Raspberry Pi. We've mapped your domain to your router's public IP, enabled inbound requests on your router, set up port forwarding, and configured dynamic DNS to handle IP changes.

In the next part, we'll set up Nginx as a reverse proxy to forward requests from your domain to your Flask app.

If you have any questions or run into any issues, feel free to comment below, and I'll be happy to help.

Happy hosting!

Introduction

Hosting a website from your basement on a Raspberry Pi (Rpi) and making it accessible to the world is an exciting and rewarding project. Whether you're a beginner or a seasoned developer, running your website on a Raspberry Pi introduces you to various aspects of web hosting, including containerization, networking, and security.

In this series, we'll walk you through setting up a sample website on your Raspberry Pi and making it accessible over the internet. We'll focus on using containerized services to ensure consistency across different environments and machines. By the end of this guide, you'll have a fully functional website running on your Raspberry Pi, accessible to the world.

What We'll Cover

1. Setting Up a Sample Flask App Inside a Container: We'll create a simple Flask web application, containerize it using Docker, and expose it on the Raspberry Pi.
2. Configuring Network Settings for External Access: We'll configure your router for port forwarding. We'll also set up dynamic DNS to handle changes in your public IP address.
3. Setup Nginx for Reverse Proxy: We'll set up Nginx to forward requests from your domain to your Flask app.

Prerequisites

Before we start, ensure you have the following:

• A Raspberry Pi with Raspbian OS installed.
• Docker and Docker Compose installed on your Raspberry Pi.
• Python installed on your Raspberry Pi.
• Basic knowledge of Docker and Flask.
• A registered domain and access to a DNS provider like Cloudflare.

If you haven't installed Docker or Python on your Raspberry Pi, there are numerous guides available online to help you get started. We recommend doing some research to complete these installations.

Setting Up a Sample Flask App Inside a Container

Step 1: Creating a Sample Flask Application

Let's start by creating a simple Flask application. Create a directory for your project:

mkdir my_flask_app
cd my_flask_app

Inside this directory, create the following files:

• app.py:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

• requirements.txt:

codeFlask==2.0.1

• Dockerfile:

FROM python:3.8-slim

WORKDIR /app

COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt

COPY . .

CMD ["python", "app.py"]

• docker-compose.yml:

version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"

Step 2: Building and Running the Container

Navigate to your project directory and build and run your container using Docker Compose:

docker-compose up --build -d

This command builds the Docker image and starts the container in detached mode. Your Flask app should now be running and accessible at http://localhost:5000.

Step 3: Accessing the Flask App

You can verify that your Flask app is running by accessing it from your Raspberry Pi's web browser or by making a curl request:

curl http://localhost:5000

Since the Flask app is exposed on all interfaces (0.0.0.0), it will also be accessible on your Raspberry Pi's private IP address. To find your Raspberry Pi's IP address, run:

hostname -I

You can then access your Flask app from any device on your local network by navigating to http://<RPI_PRIVATE_IP>:5000.

Step 4: Configuring a Static IP for Your Raspberry Pi

To ensure your Raspberry Pi always has the same IP address on your local network, you need to configure a static IP. This can be done through your router's admin interface. The steps to set a static IP vary depending on your router model, but generally, you will:

1. Log in to your router's admin interface.
2. Find the DHCP settings or IP reservation settings.
3. Add a new reservation for your Raspberry Pi using its MAC address and the desired IP address.

This ensures that your Raspberry Pi will always receive the same IP address from your router, making it easier to manage and access your services.

Conclusion

In this part, we've set up a simple Flask application inside a Docker container and made it accessible on your local network. We've also configured your Raspberry Pi to have a static IP address. In the next part, we'll set up Nginx as a reverse proxy to forward requests from your domain to your Flask app.

Stay tuned for the next part!

If you have any questions or run into any issues, feel free to comment below, and I'll be happy to help.

Happy hosting!