DEV Community: Tshenolo Mos

Secure Apache with SSL in Docker

Tshenolo Mos — Thu, 06 Nov 2025 21:49:27 +0000

This guide will walk you through setting up an Apache server with PHP support within a Docker container, secured with an SSL certificate for local development purposes. We’ll ensure that the server can be accessed securely via https://localhost using a self-signed SSL certificate. If you’re eager to jump straight into the code, you can locate the complete project on GitHub. Feel free to access it at https://github.com/tshenolo/docker-Secure-Apache.

Introduction
Prerequisites
Step 1: Preparing SSL Certificates
Step 2: Creating the Dockerfile
Step 3: Configuring Apache for SSL
Step 4: Building and Running the Docker Container
Step 5: Accessing Your Secure Apache Server
Conclusion

Introduction

Deploying your web applications in a development environment that closely mirrors your production setup is crucial. This guide focuses on configuring an Apache server with SSL in Docker, providing a secure, isolated environment for development.

Check out my Youtube Channel where I post all kinds of content accompanying my posts, including this video showing everything in this post.

Prerequisites

Docker installed on your machine.
Basic knowledge of Docker, Apache, and SSL certificates.
OpenSSL for generating a self-signed certificate (if not already installed).

Step 1: Preparing SSL Certificates

Before setting up the Docker container, you’ll need to generate a self-signed SSL certificate for localhost. Open a terminal and run:

openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout localhost.key -out localhost.crt -subj "/C=US/ST=YourState/L=YourCity/O=YourOrganization/CN=localhost"

This command generates a new SSL certificate (localhost.crt) and a private key (localhost.key), valid for 365 days.

Step 2: Creating the Dockerfile

Create a Dockerfile in your project directory with the following contents:

# Use an official PHP image with Apache
FROM php:7.4-apache

# Install Vim (optional)
RUN apt-get update && \
    apt-get install -y vim && \
    rm -rf /var/lib/apt/lists/*

# Copy SSL certificate and key
COPY localhost.crt /etc/ssl/certs/localhost.crt
COPY localhost.key /etc/ssl/private/localhost.key

# Copy the custom Apache virtual host config
COPY ./my-httpd-vhosts.conf /etc/apache2/sites-available/my-ssl.conf

# Enable SSL module, configure Apache for PHP support, and enable our SSL site configuration
RUN a2enmod ssl && \
    a2enmod rewrite && \
    a2dissite 000-default default-ssl && \
    a2ensite my-ssl

# Copy your PHP application into the default Apache document root
COPY ./public-html/ /var/www/html/

Step 3: Configuring Apache for SSL

Create a file named my-httpd-vhosts.conf in your project directory with the following Apache virtual host configuration:

<VirtualHost *:443>
    DocumentRoot "/var/www/html"
    ServerName localhost

    SSLEngine on
    SSLCertificateFile "/etc/ssl/certs/localhost.crt"
    SSLCertificateKeyFile "/etc/ssl/private/localhost.key"

    # Other directives here
</VirtualHost>

Step 4: Building and Running the Docker Container

With the Dockerfile and SSL configuration in place, build your Docker image:

docker build -t apache-php-ssl .

Then, run your container:

docker run -d -p 443:443 apache-php-ssl

This command starts a container from your image, mapping port 443 inside the container to port 443 on your host machine.

Step 5: Accessing Your Secure Apache Server

Open a web browser and navigate to https://localhost. You should see your PHP application running securely under HTTPS. Since the certificate is self-signed, your browser may warn you about the site’s security certificate. You can proceed by allowing an exception for this certificate.

Conclusion

You’ve successfully set up an Apache server with SSL inside a Docker container, making your local development environment secure and more aligned with production settings. This setup ensures that your development practices include necessary security measures right from the start.

Thank you for reading this blog post. If you found the post helpful or interesting, here are a few ways you can show your support:

🐦 Follow me on X
📺 Subscribe to my Youtube channel
Your support and engagement means a lot to me as an open-source developer.

Guide to Creating an SFTP Server with Docker (using SSH keys)

Tshenolo Mos — Fri, 31 Oct 2025 02:36:25 +0000

This guide will show you how to make a Docker image step by step that works as an SFTP server. By the time we wrap up, you’ll have a simple but secure SFTP server up and running in a Docker container. If you’re keen on getting your hands dirty or just want to dive right into the code, you can find the full project on GitHub. Go ahead and grab it from tshenolo/docker-sftp-server-with-sshkey

Table of Contents

Introduction
Prerequisites
SSH Key Configuration
Set Up the Docker File
Build Your Docker Image
Running the Docker Container
Verifying the Container’s Status
Connecting to the SFTP Server
Using the SFTP Server
Conclusion

Introduction

An SFTP server provides a secure way to transfer files between computers over an encrypted SSH transport. Docker allows you to package an SFTP server with all its dependencies into a standardized unit for software development, ensuring easy deployment and scalability.

Check out my Youtube Channel where I post all kinds of content accompanying my posts, including this video showing everything in this post.

Prerequisites

Docker installed on your machine.
Basic understanding of Docker and SFTP.
Git is also required to clone the repository.
Basic knowledge of command-line operations is assumed.

SSH Key Configuration

Generate SSH Key

If you do not already have an SSH key pair, you can generate one using the following command:

ssh-keygen -t rsa -b 4096 -C "your_email@example.com" -f $HOME/.ssh/id_rsa

Set Permissions

Ensure your private key (~/.ssh/id_rsa) is kept secure with the appropriate permissions:

chmod 600 ~/.ssh/docker_rsa

Ensure your SSH key is loaded and available

Make sure the SSH key you’ve generated and added to GitHub is loaded into your SSH agent.

eval "$(ssh-agent -s)"

If you haven’t already, you can load your SSH key into the SSH agent by running:

ssh-add ~/.ssh/docker_rsa

Set Up the Docker File

There are two approaches to setting up your Docker environment: either by creating a new Dockerfile from scratch or by cloning an existing GitHub repository.

Option 1: Create the Dockerfile

To create your Dockerfile manually, proceed with the following steps:

Initiate a Dockerfile: In your preferred directory, open a new file named Dockerfile.
Insert the Dockerfile Content: Populate your Dockerfile with the following configuration:

# Use Ubuntu latest as the base image
FROM ubuntu:latest

# Avoid prompts from apt
ENV DEBIAN_FRONTEND=noninteractive

# Update packages and install OpenSSH Server and vim
RUN apt-get update && \
    apt-get install -y openssh-server vim && \
    rm -rf /var/lib/apt/lists/*

# Set up user for SFTP with no shell login
RUN useradd -m -d /home/sftpuser -s /usr/sbin/nologin sftpuser && \
    mkdir -p /home/sftpuser/.ssh && \
    chown sftpuser:sftpuser /home/sftpuser/.ssh && \
    chmod 700 /home/sftpuser/.ssh

# Copy the public key
# Ensure you replace 'docker_rsa.pub' with your actual public key file name
COPY docker_rsa.pub /home/sftpuser/.ssh/authorized_keys

# Set permissions for the public key
RUN chmod 600 /home/sftpuser/.ssh/authorized_keys && \
    chown sftpuser:sftpuser /home/sftpuser/.ssh/authorized_keys

# Create a directory for SFTP that the user will have access to
RUN mkdir -p /home/sftpuser/sftp/upload && \
    chown root:root /home/sftpuser /home/sftpuser/sftp && \
    chmod 755 /home/sftpuser /home/sftpuser/sftp && \
    chown sftpuser:sftpuser /home/sftpuser/sftp/upload && \
    chmod 755 /home/sftpuser/sftp/upload

# Configure SSH for SFTP
RUN mkdir -p /run/sshd && \
    echo "Match User sftpuser" >> /etc/ssh/sshd_config && \
    echo "    ChrootDirectory /home/sftpuser/sftp" >> /etc/ssh/sshd_config && \
    echo "    ForceCommand internal-sftp" >> /etc/ssh/sshd_config && \
    echo "    PasswordAuthentication no" >> /etc/ssh/sshd_config && \
    echo "    PubkeyAuthentication yes" >> /etc/ssh/sshd_config && \
    echo "    PermitTunnel no" >> /etc/ssh/sshd_config && \
    echo "    AllowAgentForwarding no" >> /etc/ssh/sshd_config && \
    echo "    AllowTcpForwarding no" >> /etc/ssh/sshd_config && \
    echo "    X11Forwarding no" >> /etc/ssh/sshd_config

# Expose the SSH port
EXPOSE 22

# Run SSHD on container start
CMD ["/usr/sbin/sshd", "-D", "-e"]

Option 2: Clone the Repository

If you prefer to work with an existing setup clone the GitHub Repository:

git clone https://github.com/tshenolo/docker-sftp-server-with-sshkey.git

Change your current working directory to the newly cloned repository:

cd docker-sftp-server-with-sshkey

To ensure SSH key-based authentication for your SFTP server, place your SSH public key into the working directory:

cp $HOME/.ssh/docker_rsa.pub .

Build Your Docker Image

To build your Docker image, run the following command in the directory containing the Dockerfile:

docker build -t your_sftp_server .

Running the Docker Container

To run your SFTP server container without data persistence, you might use a command like this:

docker run -d --name my_sftp_container -p 2222:22 your_sftp_server

To ensure that uploaded files are not lost when the container stops or is removed, you should persist data by mapping a directory from your host machine to a directory inside the container

docker run -d -v /local/sftp/upload:/home/your_user/sftp/upload --name my_sftp_container -p 22:22 your_sftp_server

Verifying the Container’s Status

Check if the container is running with:

docker ps

View logs with:

docker logs my_sftp_container

Connecting to the SFTP Server

Connect to your SFTP server using:

sftp -oPort=2222 sftpuser@0.0.0.0

Using the SFTP Server

Basic SFTP commands like ls (list files), put (upload files), get (download files), and rm (remove files)

Listing Files with ls

ls /path/to/directory

Uploading Files with put

put example.txt /remote/directory/example.txt

Downloading Files with get

get example.txt /local/directory/example.txt

Removing Files with rm

rm example.txt

Conclusion

You’ve got a simple, safe SFTP server up and running in a Docker container now. This gets you started on the right foot for secure file transfers. But if you’re gearing up for realworld use, you’ll want to tweak and toughen things up more to fit your unique requirements and shield against possible security holes. Docker makes it a breeze to expand your SFTP server and keep it under control when it’s just one piece of a bigger app puzzle.

Thank you for reading this blog post. If you found the project helpful or interesting, here are a few ways you can show your support:

Star the GitHub Repository: If you haven’t already, please consider starring the Docker SFTP Server repository on GitHub. Your stars help us gain visibility and recognition in the open-source community.

🐦 Follow me on X
📺 Subscribe to my Youtube channel

Your support and engagement means a lot to me as an open-source developer.

Detect Linux Server Intrusions

Tshenolo Mos — Fri, 24 Oct 2025 17:56:47 +0000

If someone breached your server right now, would you even know? The faster you detect an intrusion, the faster you can stop it. In this post, we will walk through simple steps you can take to check for signs of unauthorized access and take immediate action - all within 60 seconds.

Check out my Youtube Channel where I post all kinds of content accompanying my posts, including this video showing everything in this post.

Step 1: See Who’s Logged In

Run the following command to check who is currently logged in:

who

You should only see authorized users. If you spot a suspicious login, it might be time to investigate.

Step 2: Check Running Processes

See what’s running and sort by memory usage:

ps aux --sort=-%mem | head

Look for unfamiliar or suspicious processes. Malware often disguises itself with odd names or runs in the background silently.

Step 3: Inspect Network Connections

Identify listening services and active connections:

ss -tulwn

Check for unexpected open ports or connections to unknown IPs.

Step 4: Review Auth Logs

Look at recent authentication attempts:

tail -n 20 /var/log/auth.log

Watch for failed login attempts or unusual root access events. On some systems, you might need to check:

journalctl -xe | grep ssh

Step 5: Check for Recently Banned IPs (if using Fail2Ban)

sudo fail2ban-client status sshd

Review which IPs have been banned and why. This helps track brute force attempts.

Bonus: File Integrity Check

If you’re using tools like AIDE or Tripwire, run an integrity scan to detect any unauthorized file changes:

aide --check

Final Thoughts

Speed matters. While these steps won’t replace a full intrusion detection system, they can help you spot threats early and react quickly.

Want to go further? Set up automated alerts, enable two-factor authentication, and install Fail2Ban to actively block brute-force attacks.

Thank you for reading this blog post. If you found the post helpful or interesting, here are a few ways you can show your support:

🐦 Follow me on X
📺 Subscribe to my Youtube channel

Your support and engagement means a lot to me as an open-source developer.

Stay safe out there!

Keep Calm and Use Docker Volumes

Tshenolo Mos — Thu, 16 Oct 2025 01:00:01 +0000

Docker volumes provide a way to store and share data generated by and used within containers. Unlike a container’s filesystem, which is lost when the container stops, volumes are designed for durability and ease of use.

Check out my Youtube Channel where I post all kinds of content accompanying my posts, including this video showing everything in this post.

Benefits of Docker Volumes:

Data Persistence: Keeps data intact even after the container is removed.
Sharing: Allows multiple containers to access the same data.
Backup-Friendly: Simplifies data management and backups.

Creating a Docker Volume

The first step is to create a Docker volume. Use the following command to do so:

docker volume create myvolume

What Happens Here?

myvolume is the name of the volume you're creating.
Docker handles where and how this volume is stored, using the default driver unless specified otherwise.

Pro Tip: Use descriptive names for your volumes to make them easier to manage later.

Using a Docker Volume

Once the volume is created, you can mount it to a container. Here’s how:

docker run -d \
  -v myvolume:/var/lib/mysql \
  -p 3306:3306 \
  --name mycontainer \
  -e MYSQL_ROOT_PASSWORD=my-secret-pw \
  mysql

Breaking It Down:

This command runs a MySQL database server in a Docker container with the following setup:

Run in the Background: The -d flag ensures the container runs in the background.
Persistent Data: The -v flag maps the MySQL data directory inside the container to a Docker volume (myvolume).
Accessible Ports: The -p flag maps the MySQL port inside the container (3306) to the same port on your host, making the database accessible from outside the container.
Custom Name: The -name flag assigns the container the name mycontainer, so you can easily reference it later.
Set Root Password: The -e flag sets the MySQL root user’s password (my-secret-pw) via an environment variable.
Uses MySQL Image: The command pulls and runs the default MySQL Docker image.

Why Use Volumes? Mounting a volume ensures that any data written to /var/lib/mysql persists, even if the container is removed or recreated. This is crucial for retaining your database data.

Inspecting a Docker Volume

Need to see what’s inside your volume or its configuration details? Use:

docker volume inspect myvolume

Output:

The command displays metadata about the volume, including:

Mount Point: Where the volume is stored on your host machine.
Driver: The software managing the volume.
Usage Details: Information about the containers using the volume.

Removing a Docker Volume

When a volume is no longer needed, you can remove it with:

docker volume rm myvolume

Note:

Ensure no container is using the volume before attempting to remove it.
Removing a volume deletes all its data permanently.

Caution: Double-check before removing a volume to avoid accidental data loss.

Docker volumes are a vital part of containerized workflows, enabling efficient data management and sharing. Whether you’re building a small project or scaling up a large application, understanding and using volumes effectively can save time and simplify your operations.

Thank you for reading this blog post. If you found the post helpful or interesting, here are a few ways you can show your support:

🐦 Follow me on X
📺 Subscribe to my Youtube channel

Your support and engagement means a lot to me as an open-source developer.

From Chaos to Clarity - How I Document My Work Effectively

Tshenolo Mos — Thu, 13 Mar 2025 12:45:31 +0000

I used to struggle with disorganization, which significantly hindered my productivity and led to inefficiencies. However, I found that effective documentation is the key to transforming chaotic workflows into organized, structured, and highly productive processes. Whether I’m working on software development, managing projects, or tackling technical challenges, dedicating time to document my work thoroughly has greatly enhanced my organization, collaboration, and accessibility to vital information. Here are the four fundamental principles I follow to bring clarity to my documentation practices:

Rule #1: Stay Organized

The first step I took in achieving clarity was maintaining a well-structured documentation system. Staying organized has reduced my stress, saved time, and boosted my productivity. Here's how I stay on top of my documentation:

Folder Organization:
- I create dedicated folders for each of my projects.
- I categorize files based on subjects to streamline access.
- I utilize cloud storage solutions to enable access from multiple devices.
Keeping a Calendar:
- I schedule periodic documentation reviews and updates.
- I track deadlines and project milestones effectively.
- I use tools like Google Calendar and Trello to stay organized.

Rule #2: Break Tasks Into Manageable Steps

Whether I am taking a course, working out, or handling a task, I always break down the process into smaller, achievable steps. This approach helps me stay focused, track progress, and avoid feeling overwhelmed. By dividing tasks into bite-sized chunks, I can tackle them more efficiently and systematically.

Define Clear Objectives:
- Set specific goals for each step to maintain focus.
Prioritize Tasks:
- Identify the most critical steps and tackle them first.
Use Checklists:
- Keep track of progress with to-do lists and checkboxes.

Rule #3: Document Everything

I've found that comprehensive documentation acts as a reliable reference for future projects, troubleshooting, and knowledge sharing. To achieve thorough documentation, I use these methods:

Guides:
- I write step-by-step instructions and tutorials to simplify processes.
- You can check out some examples at Medium.
Vlogs:
- I create video documentation to explain complex workflows visually.
- You can view my vlogs at YouTube.
Open Source Contributions:
- I document and share my code contributions on platforms like GitHub.
- Explore my contributions at GitHub.
- I've also created an open-source Chrome plugin, chrome-jira-details, that helps me quickly copy Jira titles, full Jira details, or save them as a file. This has been an invaluable tool in my workflow to capture and document tasks efficiently.

Rule #4: Keep Code Snippets

Reusable code snippets have been a game-changer for me when it comes to efficiency and consistency. Maintaining an organized collection of snippets allows me to quickly access frequently used code. Here’s how I do it effectively:

Digital Note-Taking Apps:
- I use tools like OneNote to categorize and store my snippets.
GitHub Repositories:
- I share and manage my code snippets using GitHub.
Gist for Quick Sharing:
- I store and share snippets effortlessly on GitHub Gist.

Practical Examples of My Documentation Process

Here are some of the tools and strategies I use to stay organized and productive:

Trello for Task Management

I use Trello to manage my content creation workflow by categorizing tasks into backlog, blog, script, video, and posted stages.

Google Calendar for Scheduling

Scheduling my daily activities, such as workouts, meetings, and tasks, helps me stay on track.

Spreadsheet for Website Development Planning

Breaking down website development tasks into stages ensures that I cover all critical aspects efficiently.

Workout Planning

Tracking my workout routines ensures consistency and progress over time.

Training Progress Tracking

I track my training progress to ensure I stay on course with my learning goals.

Using Jira Plugin and Folder Organization

To streamline my workflow, I use my custom Jira Chrome plugin to copy issue details quickly and organize my project files efficiently.

By following these four essential rules: staying organized, breaking tasks into manageable steps, documenting everything, and maintaining code snippets I have turned my chaotic workflow into a well-structured, efficient system. Implement these strategies today and experience the benefits of clear and concise documentation!

Thank you for reading this blog post. If you found the post helpful or interesting, here are a few ways you can show your support:

🐦 Follow me on X
📺 Subscribe to my Youtube channel

Your support and engagement means a lot to me as an open-source developer.

Do you have a favorite organization technique? Share it with us in the comments!

Platforms for Developers and Content Creators to Post Articles

Tshenolo Mos — Mon, 18 Mar 2024 15:24:10 +0000

In the digital age, the demand for platforms to share knowledge, experiences, and ideas has significantly increased. For developers and content creators, this can mean sharing technical know-how, providing insights into the industry, or simply telling stories about their experiences. This blog post will introduce you to platforms where you can post your articles.

Dev.to

URL: https://dev.to

Dev.to is a vibrant community of software developers who write and share articles. It's an open-source platform, making it an excellent space for individuals looking to contribute directly or import from an RSS feed. By posting on Dev.to, you join a community eager to learn, engage, and grow.

Medium

URL: https://medium.com

Medium is a diverse platform that opens its doors to anyone eager to publish articles on any topic. Medium features various publications that you can contribute to, providing a built-in audience that can help your content gain visibility. The platform supports a broad range of topics, making it a great place for interdisciplinary content creators.

GitHub Pages

URL: https://pages.github.com

GitHub isn't just a repository for code; it also offers GitHub Pages, a service that allows you to host webpages directly from a GitHub repository. This feature makes it an ideal place to post articles for developers, enabling you to include code snippets and other technical details in a developer-friendly environment.

LinkedIn Articles

URL: https://www.linkedin.com

LinkedIn allows users to publish articles directly on their profile. It's a fantastic platform for sharing professional insights and engaging with your network. LinkedIn Articles can help you establish your professional brand and connect with peers in your industry.

Hashnode

URL: https://hashnode.com

Hashnode enables you to publish articles on your domain for free. It's a community of software developers who write and share articles on a wide range of topics. Posting on Hashnode, you're not just publishing content; you're becoming a part of a community eager to learn and share.

Blogger

URL: https://www.blogger.com

Blogger is a free blog publishing tool from Google. It's user-friendly, making it easy to start sharing your ideas with the world. As it integrates seamlessly with other Google services, Blogger is an excellent choice for those heavily invested in the Google ecosystem.

WordPress

URL: https://wordpress.com

WordPress is a popular choice for blog publishing, offering two different services. WordPress.com provides a managed service that takes care of all the technical aspects, while WordPress.org allows you to host your own WordPress site, providing more flexibility and control.

Daily.dev

URL: https://daily.dev/

Daily.dev is a unique platform tailored for developers, offering a curated feed of the latest articles, news, and tutorials from across the tech industry. Unlike traditional blogging platforms, daily.dev aggregates content from a wide range of sources, providing developers with a comprehensive and diversified view of the tech landscape. Users can customize their feed to match their interests, ensuring they always stay updated with the trends and technologies relevant to their work.

Each of these platforms has its unique strengths and caters to different needs. It's important to choose a platform that aligns with your goals as a content creator. Whether you're a developer looking to share your expertise or a writer aiming to reach a wider audience, these platforms provide you with the tools you need to share your content with the world.

Thank you for the Support

🐦 Follow me on X
📺 Subscribe to my Youtube channel

Creating a Mixcloud Desktop App in Record Time with Electron.js

Tshenolo Mos — Fri, 30 Jun 2023 15:00:38 +0000

Are you interested in building a desktop application for Mixcloud? Look no further! In this guide, we'll walk you through creating a Mixcloud desktop app using Electron.js. Electron.js is a powerful framework that allows you to develop cross-platform desktop applications using web technologies.

Prerequisites
Getting Started
Conclusion
Contributing
License

Prerequisites

Before we dive into the process, ensure that you have the following prerequisites installed on your system:

Node.js
npm (Node Package Manager)

Getting Started

Let's get started on building our Mixcloud desktop app!

Initialize Your Project
Begin by initializing a new Node.js project. Open your command-line interface, navigate to your desired project directory, and run the following command:
```
npm init -y
```
Install Electron

Next, install Electron.js as a project dependency. Run the following command in your project directory:
```
npm install electron
```

Creating the main.js File

Now, it's time to create the main.js file. This file will serve as the entry point for your Electron application. Add the following code to main.js:

// Import necessary modules
const { app, BrowserWindow } = require('electron');

// Function to create the main window
function createWindow() {
const mainWindow = new BrowserWindow({
    width: 800,
    height: 600,
    webPreferences: {
    nodeIntegration: true
    }
});

// Load the Mixcloud website
mainWindow.loadURL('https://www.mixcloud.com/');

// Uncomment the following line to open DevTools for debugging
// mainWindow.webContents.openDevTools();
}

// Create the window when Electron is ready
app.whenReady().then(createWindow);

// Quit the app when all windows are closed
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') {
    app.quit();
}
});

The code above sets up a basic Electron application with a browser window that loads the Mixcloud website. You can uncomment the openDevTools line if you want to enable the DevTools for debugging purposes.

Modifying package.json

Now, let's modify the package.json file. Update the "main" field to point to main.js:

 {
"name": "mixcloud-desktop-app",
"version": "1.0.0",
"main": "main.js",
"scripts": {
    "start": "electron ."
},
"dependencies": {
    "electron": "^13.0.0"
}
}

Running the Application
To run the Mixcloud desktop application, execute the following command in your project directory:
```
npm start
```
Packaging the Application

If you wish to distribute your Mixcloud desktop app, Electron Packager can help you package it. Install Electron Packager as a development dependency by running:
```
npm install electron-packager --save-dev
```

Next, update the "scripts" section in package.json as follows:

```json
"scripts": {
"start": "electron .",
"package": "electron-packager . --platform=<platform> --arch=<arch> --out=dist --overwrite"
}
```

Replace with your target platform (e.g., win32, darwin, or linux), and with the target architecture (e.g., x64 or arm64). You can specify multiple platforms and architectures separated by commas if needed.

To package the application, run the following command:

```bash
npm run package
```

The packaged application files will be placed in the dist directory.

Thank you for reading this blog post and showing interest in the Mixcloud Desktop App. If you found the project helpful or interesting, here are a few ways you can show your support:

⭐ Star the GitHub Repository

If you haven't already, please consider starring the Mixcloud Desktop App repository on GitHub. Your stars help us gain visibility and recognition in the open-source community. Let's make this project shine together! ✨

🐦 Follow Me on Twitter

Stay updated with the latest news, updates, and announcements about the Mixcloud Desktop App by following me on Twitter @tshenolo. I'll share insights, tips, and other exciting developments related to the project.

📺 Subscribe to My YouTube Channel

Join my YouTube channel and subscribe to receive video tutorials, demos, and other content related to the Mixcloud Desktop App. You can subscribe to my channel here. Don't miss out on valuable content that can help you make the most of the application. Hit that subscribe button and never miss a beat!

Your support and engagement mean a lot to me as an open-source developer. Thank you for being part of the Mixcloud Desktop App journey!

Remember, your support, likes, follows, and shares fuel my motivation and help this project grow. Thank you for being a part of the Mixcloud Desktop App community. Let's keep the music playing and the good vibes flowing! 🎵💻😄

Conclusion

Congratulations! You have successfully created a Mixcloud desktop app using Electron.js. You learned how to set up the project, install Electron, create the main window, run the application, and even package it for distribution.

Feel free to customize your Mixcloud desktop app further and add additional features to enhance the user experience. Happy coding!

Contributing

Contributions to this project are welcome. Feel free to submit issues and pull requests.

License

This project is licensed under the MIT License.