Forem: Nat

How to Set Up a Clean Development Environment with Docker and Alpine Linux

Nat — Tue, 24 Sep 2024 14:45:04 +0000

Introduction

In this tutorial, you will set up a lightweight development environment using Docker and Alpine Linux. Docker works on containers, providing a lightweight and isolated space for running different programming languages and tools without affecting your main computer. Alpine Linux, known for its small footprint, is ideal for this setup.

By following this guide, you'll create a Docker-based environment where you can experiment with Python, Node.js, and other tools without installing them directly on your machine. You'll also set up a shared folder, allowing you to transfer files between your host machine and the Docker container.

By the end of this tutorial, you will have a fully functioning, isolated development environment. You'll be able to install and test different programming languages and tools quickly, keeping your main system clean and organized, which is perfect for coders who like to experiment.

Prerequisites

To follow this tutorial, you'll need:

Docker installed on your machine. Follow the instructions for your system on the Docker Official Website.
Familiarity with Linux commands like cd (change directory), mkdir (create a directory), ls (list directory contents), and nano (text editor) will be helpful for navigating and editing files in the terminal.

Step 1 -- Create a Project Directory

We'll start by setting up a project folder to hold our files.

Create the directory:

mkdir docker-dev-env

Navigate to the directory:

cd docker-dev-env

This will serve as the workspace for your Docker setup.

Step 2 -- Create a Dockerfile

The Dockerfile is a text file where we define the instructions or commands for building our development environment within a container. This file is also conventionally named Dockerfile.

Create the Dockerfile:

nano Dockerfile

Add the following content:

FROM alpine:latest
RUN apk add bash
CMD ["bash"]

FROM alpine:latest: Specifies Alpine Linux as the base image. Alpine is lightweight, making it ideal for development.
RUN apk add bash: Installs Bash in the container.
CMD ["bash"]: Launches Bash when the container starts.

Step 3 -- Build the Docker Image

Now we'll build the Docker image from the Dockerfile. The Docker image acts as a snapshot of everything you want in your container. It will be used to create and run your container.

Run the following command:

docker build -t docker-dev-env .

docker build -t docker-dev-env: Builds the image and tags (names) it as docker-dev-env.
.: Indicates the current directory, where the Dockerfile is located.

Step 4 -- Set Up a Shared Folder

To exchange files between your host machine and the container, we'll create a shared folder and use a feature called bind mount

First, create a folder:

mkdir shared-folder

This folder will be accessible inside the container, allowing easy file transfer between the host and container.

Step 5 -- Run the Container

Now, we'll run the container using the image we built.

Run the container:

docker run --name dev-env-01 -it -v "$(pwd)/shared-folder:/app" docker-dev-env

--name dev-env-01: Assigns a name to the container.
-it: Runs the container in interactive mode with a terminal. Interactive mode allows you to use the terminal inside the container just like you would on a regular computer.
-v "$(pwd)/shared-folder:/app": Mounts the shared-folder directory on the host to the app directory inside the container.

Once the container is running, the terminal will switch to the container's environment (the container ID will differ):

902f3cefc126:/#

Step 6 -- Create a File in the Container

Let's create a file inside the container and check if it appears in the shared folder on the host.

List the contents of the current directory:

ls

You'll see the app directory (declared from the bind mount):

app    bin    dev    etc    home   ...

Navigate to the app directory:

cd app

Create a file:

touch someFile.txt

This file will now appear in the shared-folder on your host machine, showing that the bind mount works.

Step 7 -- Install Programming Languages

Next, we'll install Python and Node.js in the container.

Run the following command:

apk add python3 nodejs

After the installation, confirm Python is installed by running:

python3

You should see:

Python 3.12.6 (main, Sep 24 2024, ...) on linux

Exit Python by typing quit(). Then, try running the Node.js interpreter:

node

You'll see the Node.js prompt:

Welcome to Node.js v20.15.1.
Type ".help" for more information.
>

Press Ctrl+C to exit.

Using the container like this helps you experiment with different languages without cluttering your host machine.

Step 8 -- Stopping and Restarting the Container

Once you're done working in the container, you can stop it without losing any data or configurations.

To stop the container, run:

docker stop dev-env-01

This command gracefully stops the container named dev-env-01.

To restart the container and pick up where you left off, use:

docker start -i dev-env-01

The -i flag opens the container in interactive mode again, allowing you to continue working inside the environment.

Conclusion

You've successfully set up a lightweight development environment using Docker, created a shared folder between the host and container, and installed Python and Node.js. This isolated development setup ensures that your main system remains clean and uncluttered, making Docker a great tool for testing and experimenting.

A Step-by-Step Guide to Building Your Private Cloud with Nextcloud (2023)

Nat — Sat, 15 Jul 2023 10:50:13 +0000

This guide will walk you through the process of setting up your personal Nextcloud instance. In the first section, you will be setting up a Nextcloud Docker container and running it in your local network. Then, you will learn how to access your Nextcloud instance over the internet using Ngrok.

Setting Up a Nextcloud Docker Container

First, ensure you have Docker Desktop installed on your machine. Since we will be writing some configuration files, it would also be helpful to have a code editor like Visual Studio Code installed.

To keep this project organised, create a folder called Nextcloud in a directory of your choice.

In the Nextcloud folder, create a file called docker-compose.yml and another folder called data.

Your folder structure should now look like this

Nextcloud/
├ docker-compose.yml
├ data/

In docker-compose.yml, add the following configuration for your Nextcloud instance

version: '3'

volumes:
  db:
  nextcloud:

services:
  db:
    image: mariadb:10.6
    restart: always
    command: --transaction-isolation=READ-COMMITTED --log-bin=binlog --binlog-format=ROW
    volumes:
      - db:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=nextcloud
      - MYSQL_PASSWORD=nextcloud
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud

  app:
    image: nextcloud
    restart: always
    ports:
      - 8080:80
    depends_on:
      - db
    volumes:
      - nextcloud:/var/www/html
      - ./data:/var/www/html/data
    environment:
      - MYSQL_PASSWORD=nextcloud
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_HOST=db

Save the file and run the following command in a terminal

docker-compose up

In the browser, go to http://localhost:8080 (you may have to refresh the browser before the Nextcloud login page loads). You should see a prompt to create an admin account. Provide a username and secure password, then select 'Install'. Installation takes a few minutes.

Once done, you will be brought to an app installation page. Skip the installation for now.

Finally, you will see the welcome page, meaning you have successfully set up your private Nextcloud instance!

If you would like to "shutdown" your Nextcloud instance, head back to your terminal and run

docker-compose down

If you look at the Nextcloud directory created earlier, it should like this now

Nextcloud/
├ docker-compose.yml
├ data/
  ├ files_external/
  ├ admin/
  ├ .htaccess
  ├ .ocdata
  ├ index.html
  ├ nextcloud.log

The data folder created earlier is where you can find files uploaded to Nextcloud. The admin folder contains the files that were uploaded by the admin user.

Accessing Nextcloud Over The Internet With Ngrok

Ngrok is a service that provides a secure URL which can be used to access the Nextcloud instance created in the previous section. Creating a free account is sufficient for this guide.

Once you have created your Ngrok account, go to your account dashboard and navigate to the "Getting Started" tab and select "Your Authtoken". You will be using this authtoken later on.

Navigate to the "Domains" tab and select "Claim your free static subdomain". Take note of your generated URL.

Now, go to "Edges" and select "Create Edge"

Select "Create HTTPS edge"

You should now see the following dashboard. Take note of your tunnel label, edge=XXXXXX

Go back to your docker-compose.yml file created earlier and add the following entry which contains your Ngrok tunnel label and authtoken.

ngrok:
    image: ngrok/ngrok:latest
    restart: always
    command: tunnel --label edge=<YOUR-NGROK-TUNNEL-LABEL> app:80
    ports:
      - 4040:4040
    environment:
      - NGROK_AUTHTOKEN=<YOUR-NGROK-TOKEN>

The docker-compose.yml file should now look like this

version: '3'

volumes:
  db:
  nextcloud:

services:
  db:
    image: mariadb:10.6
    restart: always
    command: --transaction-isolation=READ-COMMITTED --log-bin=binlog --binlog-format=ROW
    volumes:
      - db:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=nextcloud
      - MYSQL_PASSWORD=nextcloud
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud

  app:
    image: nextcloud
    restart: always
    ports:
      - 8080:80
    depends_on:
      - db
    volumes:
      - nextcloud:/var/www/html
      - ./data:/var/www/html/data
    environment:
      - MYSQL_PASSWORD=nextcloud
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_HOST=db

  ngrok:
    image: ngrok/ngrok:latest
    restart: always
    command: tunnel --label edge=<YOUR-NGROK-TUNNEL-LABEL> app:80
    ports:
      - 4040:4040
    environment:
      - NGROK_AUTHTOKEN=<YOUR-NGROK-TOKEN>

Now, run docker-compose up again, and head to the Ngrok URL created earlier. You should see an error message.

This is not a problem, as the Nextcloud instance simply has to whitelist your Ngrok subdomain. Run the following command in the terminal

docker exec -u 33 -it nextcloud-app-1 php occ config:system:set trusted_domains 1 --value=<YOUR-NGROK-SUBDOMAIN>

The success message looks like this

System config value trusted domains => 1 set to string <YOUR-NGROK-SUBDOMAIN>

Restart the Nextcloud instance by running docker restart nextcloud-app-1. Then go to your Ngrok URL again. Now, you should be able to access Nextcloud.

You might have noticed that Ngrok's free subdomains are pretty random.

For personal use, using the free subdomain would be sufficient. Another way I have tried is redirecting a custom domain to the free subdomain.

However, you would need to get a paid Ngrok plan to to use a custom domain name without the aforementioned workarounds.

Conclusion

Congratulations, you have a private cloud that is accessible from anywhere!

When starting out using Nextcloud, I sourced for information from many different places, was quite confused and had to experiment quite a bit. I hope that this guide helps someone who was in my position.

While this guide has covered a basic set up process of Nextcloud, I hope to cover more security and feature configurations in the future.