How to Build Your Own VPN (WireGuard)

 

Free Guide: How to Build Your Own VPN (WireGuard)

This expanded tutorial combines:

✔ Step-by-step VPS provider guides (DigitalOcean, AWS, Linode, Vultr,

 Hostinger)
✔ Multiple client configuration files
✔ Automation scripts
✔ Code samples
✔ Security best practices
✔ Troubleshooting

1. Introduction – What Is a VPN and Why Build Your Own?

A Virtual Private Network (VPN) creates an encrypted tunnel between a device and a remote server. When connected, all internet traffic travels through this tunnel, hiding your real IP address and protecting your data from snooping, surveillance, and insecure networks.

Most users rely on commercial VPN apps, but building your own VPN has several advantages:

• No third-party logging risks — only you control traffic
• Faster speeds because of zero user-sharing congestion
• Fixed static IP for remote development, SSH access, or hosting
• Learning experience in networking, tunneling, encryption, and Linux

This guide will use WireGuard, a modern VPN protocol designed for simplicity and high performance.

2. Why WireGuard?

WireGuard has become popular because:

• It uses state-of-the-art cryptography
• It is extremely lightweight
• The configuration is simple and readable
• It provides better speed and stability than OpenVPN/IPSec

A typical WireGuard configuration consists of:

• A server with a public IP
• One or more clients (Windows, Android, iOS, Linux, macOS)
• A pair of keys (private/public) for each device

3. System Requirements

You need:

• A VPS (any provider) with a public IPv4
• Ubuntu 22.04 or Debian 12 (recommended)
• Root or sudo privileges
• WireGuard client apps for your devices

4. Installing WireGuard on Linux Server

Update packages

sudo apt update && sudo apt upgrade -y

Install WireGuard

sudo apt install -y wireguard 

iptables-persistent

A network interface named wg0 will be created later in configuration.

5. Generating Server & Client Keys

Create a secure folder:

sudo mkdir -p /etc/wireguard/keys
sudo chmod 700 /etc/wireguard/keys
cd /etc/wireguard/keys

Generate server keys

wg genkey | tee server_

private.key | wg pubkey > server_public.key

Generate one client key (client1)

wg genkey | tee client1_private.key 

| wg pubkey > client1_public.key

6. Creating the WireGuard Server Configuration

Create:

sudo nano /etc/wireguard/wg0.conf

Paste:

[Interface]
PrivateKey = SERVER_PRIVATE_KEY
Address = 10.10.0.1/24
ListenPort = 51820
SaveConfig = true

[Peer]
PublicKey = CLIENT1_PUBLIC_KEY
AllowedIPs = 10.10.0.2/32

Replace:

• SERVER_PRIVATE_KEY → content of server_private.key
• CLIENT1_PUBLIC_KEY → content of client1_public.key

Secure:

sudo chmod 600 /etc/wireguard/wg0.conf

7. Enable IP Forwarding & NAT

Temporary forwarding

sudo sysctl -w net.ipv4.ip_forward=1

Permanent forwarding

echo "net.ipv4.ip_forward=1" | 

sudo tee -a /etc/sysctl.conf
sudo sysctl -p

Enable NAT

Assume your public interface is eth0:

sudo iptables -t nat -A POSTROUTING

 -o eth0 -j MASQUERADE
sudo iptables -A FORWARD -i wg0 -j ACCEPT
sudo iptables -A FORWARD -o wg0 -j ACCEPT
sudo netfilter-persistent save

8. Start the VPN Server

sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0

Check status:

sudo wg show

9. Creating the Client Configuration File

Create client1.conf:

[Interface]
PrivateKey = CLIENT1_PRIVATE_KEY
Address = 10.10.0.2/24
DNS = 1.1.1.1

[Peer]
PublicKey = SERVER_PUBLIC_KEY
Endpoint = YOUR.SERVER.IP:51820
AllowedIPs = 0.0.0.0/0, ::/0
PersistentKeepalive = 25

Use the WireGuard app (Windows, macOS, Android, iOS) to import the .conf.

10. Automation Script: Create New Clients Easily

Create:

sudo nano /usr/local/bin/wg-add-client

Paste:

#!/bin/bash

NAME=$1
WG_DIR="/etc/wireguard"
KEY_DIR="$WG_DIR/keys"

wg genkey | tee $KEY_DIR

/${NAME}_private.key 

| wg pubkey > $KEY_DIR

/${NAME}_public.key

SERVER_PUB=$(cat $KEY_DIR

/server_public.key)
CLIENT_PRIV=$(cat $KEY_DIR

/${NAME}_private.key)
CLIENT_PUB=$(cat $KEY_DIR

/${NAME}_public.key)

cat <<EOF > $WG_DIR/${NAME}.conf
[Interface]
PrivateKey = ${CLIENT_PRIV}
Address = 10.10.0.10/24
DNS = 1.1.1.1

[Peer]
PublicKey = ${SERVER_PUB}
Endpoint = YOUR.SERVER.IP:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25
EOF

wg set wg0 peer ${CLIENT_PUB}

 allowed-ips 

10.10.0.10/32
echo "Client $NAME created."

Make executable:

sudo chmod +x /usr/local/bin/wg-add-client

Use:

sudo wg-add-client client2

11. Provider-Specific Setup Guides

DigitalOcean

1. Create a Droplet → Ubuntu 22.04
2. Allow UDP 51820 under firewall
3. Follow this guide normally
4. Use Droplet public IP in Endpoint=

AWS EC2

1. Launch Ubuntu EC2 instance
2. In Security Groups, allow UDP 51820
3. Disable Source/Dest Check (for NAT)
4. Add an Elastic IP (optional)

Linode / Akamai

1. Create Ubuntu Linode
2. Check "Firewall" → allow UDP 51820
3. Configure NAT rules

Vultr

1. Deploy Ubuntu 22.04
2. Under "Firewall" allow UDP 51820
3. Add NAT

Hostinger VPS

1. Create VPS instance
2. Use panel to enable "Open Ports"
3. Install WireGuard normally

12. Client Setup Instructions

Windows

1. Install WireGuard from the official site
2. Click → Add Tunnel → Import From File
3. Select client1.conf

macOS

1. Install WireGuard from App Store
2. Import config

Linux

sudo wg-quick up client1

Android / iOS

1. Install app from Play Store/App Store
2. Tap "+" → Import from file or QR code

13. Testing Your VPN

Ping

ping 10.10.0.1

Check IP

curl ifconfig.me

You should now appear from your server’s IP.

14. Security Best Practices

• Rotate keys every few months
• Disable unused clients
• Limit AllowedIPs for internal devices
• Use strong DNS (Cloudflare / Quad9)
• Keep the OS updated

15. Troubleshooting

No handshake?

• UDP 51820 blocked
• Wrong public/private keys
• NAT rules missing

No internet inside VPN?

• Missing MASQUERADE rule
• Incorrect interface name (eth0 vs ens3)

Mobile clients disconnecting?

Set:

PersistentKeepalive = 25

16. Conclusion

Congratulations — you now have a fully working, secure, self-hosted VPN using WireGuard. You can add unlimited devices, automate client creation, or expand your VPN into a multi-region network with multiple servers.

 

The Definitive Guide to Bootstrap CSS Buttons Reference: Styling, Sizing, and State Management

Buttons drive user actions in web apps. They let people click to submit forms, navigate pages, or trigger events. A poor button design can confuse users and hurt your site's flow. Bootstrap changes that with simple classes that make buttons look sharp and work well across devices.

You know how frustrating it is when buttons clash with your site's style? Bootstrap fixes this fast. Its utility-first system lets you style buttons without writing custom CSS from scratch. This guide covers everything from basic classes to advanced tweaks. By the end, you'll style Bootstrap CSS buttons like a pro, ensuring smooth user interactions and a clean look.

Understanding the Foundation: Basic Bootstrap Button Classes

Bootstrap buttons start simple. You take a plain HTML element like <button> or <a>. Add a few classes, and it transforms into something polished.

The Primary Button Component Class: btn

The .btn class is your starting point. It adds padding, borders, and font tweaks to make elements feel like real buttons. Without it, your button looks flat and boring.

In Bootstrap 4 and 5, .btn works on buttons, links, or inputs. It sets a default border radius for that rounded edge. You can't skip this 

class if you want Bootstrap's magic. For example, <button class="btn">

Click Me</button> gives you a basic gray button right away.

This base lets you layer on more styles. It ensures consistency across your site. Think of .btn as the canvas for your button art.

Contextual Color Classes: Setting the Tone (e.g., btn-primary, btn-success)

Colors tell users what to expect. Bootstrap offers classes like .btn-primary for main actions, blue by default. It draws eyes to key spots, like a "Buy Now" button.

Then there's .btn-success in green. Use it for confirmations, such as "Save Changes." It signals all is good. Red .btn-danger warns of risks, perfect for "Delete Account."

You also get .btn-warning in yellow for cautions, like "Edit Profile." Blue .btn-info shares details, gray .btn-secondary plays support roles. Light .btn-light and dark .btn-dark fit subtle needs.

• Primary: Bold calls to action.
• Success: Positive outcomes.
• Danger: Risky steps.
• Warning: Alerts.
• Info: Helpful info.
• Secondary: Neutral options.
• Light/Dark: Background blends.

These classes tie into user feelings. Green calms, red grabs attention. Pick based on your message to boost UX.

Outline vs. Solid Buttons: Toggle Styling Options

Solid buttons grab focus with full color fills. Outline versions use borders only, keeping things light. Classes like .btn-outline-primary give a blue border on a clear background.

Use outlines when you want less clutter. They shine in crowded forms or sidebars. Solid buttons work for stand-alone spots, like hero sections.

Hover turns outlines solid in Bootstrap, adding life. This subtle shift keeps users engaged. Compare: <button class="btn btn-outline-success">Save</button> vs. the filled one. Outlines save space and feel modern.

When do you choose? Outlines for secondary actions in toolbars. Solids for primary tasks. Mix them for layered designs that guide the eye.

Advanced Button Styling: Sizing and State Modifications

Now let's size up your buttons. Bootstrap makes scaling easy for different screens. States add smarts, like disabling clicks when needed.

Controlling Button Dimensions with Size Modifiers

Big buttons help on touch devices. The .btn-lg class pumps up padding and font size. It creates targets at least 44 pixels wide, ideal for thumbs on phones.

Small .btn-sm shrinks things down. Use it for inline lists or dense menus. It keeps space tight without losing readability.

Pair sizes with contexts. Large primary buttons in mobile CTAs. Small ones in desktop nav bars. Here's a quick setup:

<button class="btn btn-primary btn-lg">

Large Action</button>
<button class="btn btn-secondary btn-sm">

Small Link</button>

Test on devices. Large sizes cut mobile errors by up to 20%, per UX studies. They make your site friendlier.

Button States: Active, Disabled, and Hover Effects

Bootstrap handles hover and focus out of the box. Mouse over a button, and it darkens or glows. This feedback reassures users their click registered.

For active states, add .active. It mimics a pressed look, great for toggles. Disabled buttons need the disabled attribute plus .disabled class. They gray out and block clicks.

Why bother? Clear states prevent mistakes. Imagine a form submit button that stays lit until valid. Use .active for selected tabs. Disabled for loading spinners.

In code: <button class="btn btn-primary disabled">Wait</button>. Focus outlines aid keyboard users. These touches build trust.

Block Level Buttons for Full Width Layouts

Full-width buttons fill their container. The .btn-block class does this in older Bootstrap versions. In v5, use .w-100 utility instead.

They fit mobile forms or drawers. A submit button stretching edge to edge feels natural to tap. Skip them in grids; they can overwhelm.

Picture a login screen. <button class="btn btn-primary w-100">Sign In</button> spans the width. It boosts completion rates on small screens. Use sparingly for impact.

Integrating Buttons with Layouts: Button Groups and Toggles

Buttons don't stand alone. Groups tie them into bars or menus. Toggles turn them into switches.

Creating Cohesive Button Groups with .btn-group

Wrap buttons in <div class="btn-group">. Bootstrap kills gaps between them. They touch for a unified bar.

This setup suits nav or tools. Add .btn classes inside. For example:

<div class="btn-group">
  <button class="btn btn-outline-secondary">

Left</button>
  <button class="btn btn-outline-secondary">

Middle</button>
  <button class="btn btn-outline-secondary">

Right</button>
</div>

Use <nav> for semantic wins. Groups save space and look pro. They mimic app interfaces users know.

Implementing Radio and Checkbox Button Toggles

Toggles act like form inputs. Hide real <input> with .btn-check. Link via labels for clicks.

For radio: One choice from many. Checkboxes allow multiples. Structure like this:

<input type="checkbox" class="btn-check" 

id="toggle1">
<label class="btn btn-outline-primary"

 for="toggle1">Option 1</label>

Active class shows selection. This emulates native controls without extra JS. 

Great for filters or settings.

Users love the visual pick. It cuts confusion in surveys. Test for screen readers; ARIA helps here.

Vertical Stacking Within Groups

Stack buttons with .btn-group-vertical.

 It aligns them top to bottom. Perfect for sidebars or dropdowns.

Gaps form naturally between rows. Add it to your wrapper: <div class="btn-group-vertical">. Inside, buttons stack clean.

Use in narrow spaces. Think mobile menus or tool panels. It keeps options readable without scrolling wide.

Customization and Accessibility Considerations

Tailor buttons to your brand. Bootstrap flexes with utilities and vars. Don't forget access for all users.

Utility Classes for Spacing and Alignment

Space buttons with m-2 for margins or p-3 for padding. Align with text-center or flex classes.

These tweak solo buttons outside groups. <button class="btn btn-primary mt-3 mx-auto">Centered</button> 

floats it middle with top space.

Mix for polish. Bottom margins separate from text. This fine control beats rigid styles. Your layout breathes easy.

Customizing Colors with Sass Variables (Advanced Tip)

Go deep with Sass. Edit $theme-colors map in your build. Swap primary blue for your brand green.

Avoid CSS overrides; they fight Bootstrap updates. Compile fresh for clean code. This keeps buttons unique yet true to the framework.

Tools like Bootstrap's docs guide vars. Test shades for contrast. 

Your site stands out without breaking.

Accessibility (A11Y) Best Practices for Buttons

Stick to <button> for actions, <a> for links. Add role="button" if needed. ARIA labels describe states, like aria-pressed for toggles.

Keyboard focus matters. Skip fancy images; text buttons read better. Colors? Ensure 4.5:1 contrast ratios.

Why care? One in four web users has disabilities. Good A11Y widens your reach. Tools like WAVE check issues fast.

Conclusion: Rapid Prototyping and Consistent Design

Bootstrap CSS buttons reference unlocks quick builds. From basic .btn to groups and toggles, classes speed your work. You control styles, sizes, and states with ease.

Key points: Start with context colors for meaning. Size for devices. Handle states for clarity. Groups unite multiples. Customize smart, access first.

This system cuts dev time by half, per surveys. Your interfaces stay pro and welcoming. Grab Bootstrap, code a button group today, and see the difference. Your users will thank you.

Java program to calculate Profit or Loss based on Cost Price (CP) and Selling Price (SP).

 

Here is a simple and clean Java program to calculate Profit or Loss based on Cost Price (CP) and Selling Price (SP).

You can run it in any Java compiler (online/offline).

✅ Java Program for Profit and Loss

import java.util.Scanner;

public class ProfitLossCalculator {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        // Input cost price and selling price
        System.out.print("Enter Cost Price (CP): ");
        double cp = sc.nextDouble();

        System.out.print("Enter Selling Price (SP): ");
        double sp = sc.nextDouble();

        // Calculate profit or loss
        if (sp > cp) {
            double profit = sp - cp;
            double profitPercent = (profit / cp) * 100;

            System.out.println("Profit: " + profit);
            System.out.println("Profit Percentage: " + profitPercent + "%");

        } else if (cp > sp) {
            double loss = cp - sp;
            double lossPercent = (loss / cp) * 100;

            System.out.println("Loss: " + loss);
            System.out.println("Loss Percentage: " + lossPercent + "%");

        } else {
            System.out.println("No Profit, No Loss.");
        }

        sc.close();
    }
}

✅ How This Works

• If Selling Price > Cost Price → Profit
• If Cost Price > Selling Price → Loss
• If both are equal → No Profit, No Loss

Percentages are calculated by:

Profit % = (Profit / CP) × 100
Loss % = (Loss / CP) × 100

⭐ Sample Output

Enter Cost Price (CP): 500
Enter Selling Price (SP): 650
Profit: 150.0
Profit Percentage: 30.0%

Spring Boot Unit Tests Explanation Guide with full code

 

Spring Boot Unit Tests Explanation Guide with full code

✅ 1. Spring Boot Unit Tests

Create folder:

src/test/java/com/example/profitloss/

Test 1 — Service Logic Test (CalculationServiceTest.java)

package com.example.profitloss;

import com.example.profitloss.model.

Calculation;
import com.example.profitloss.repo.

CalculationRepository;
import com.example.profitloss.service.

CalculationService;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.junit.jupiter.

api.Assertions.*;

public class CalculationServiceTest {

    private final CalculationRepository

 repo = Mockito.mock(CalculationRepository.

class);
    private final CalculationService 

service = new CalculationService(repo);

    @Test
    void testProfit() {
        double cp = 500;
        double sp = 650;

        Calculation saved = new 

Calculation(cp, sp, 150, 30, true);
        Mockito.when(repo.save

(Mockito.any())).thenReturn(saved);

        Calculation calc = service.

calculateAndSave(cp, sp);

        assertEquals(150, calc.getAmount());
        assertEquals(30, calc.getPercent());
        assertTrue(calc.isProfit());
    }

    @Test
    void testLoss() {
        double cp = 500;
        double sp = 300;

        Calculation saved = new 

Calculation(cp, sp, 200, 40, false);
        Mockito.when(repo.save

(Mockito.any())).thenReturn(saved);

        Calculation calc = service.

calculateAndSave(cp, sp);

        assertEquals(200, calc.getAmount());
        assertEquals(40, calc.getPercent());
        assertFalse(calc.isProfit());
    }

    @Test
    void testNoProfitNoLoss() {
        double cp = 500;
        double sp = 500;

        Calculation saved =

 new Calculation(cp, sp, 0, 0, false);
        Mockito.when(repo.save

(Mockito.any())).thenReturn(saved);

        Calculation calc = service.

calculateAndSave(cp, sp);

        assertEquals(0, calc.getAmount());
        assertEquals(0, calc.getPercent());
    }
}

Test 2 — REST API Test Using MockMVC (CalculationControllerTest.java)

package com.example.profitloss;

import com.example.profitloss.

controller.CalculationController;
import com.example.profitloss.

dto.CalculateRequest;
import com.example.profitloss.

model.Calculation;
import com.example.profitloss.

service.CalculationService;

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.springframework.

beans.factory.annotation.Autowired;
import org.springframework.

boot.test.autoconfigure.web.

servlet.WebMvcTest;
import org.springframework.

boot.test.mock.mockito.MockBean;
import org.springframework.

http.MediaType;
import org.springframework.

test.web.servlet.MockMvc;

import static org.springframework.

test.web.servlet.request.

MockMvcRequestBuilders.post;
import static org.springframework.

test.web.servlet.result.

MockMvcResultMatchers.*;

@WebMvcTest(CalculationController.class)
public class CalculationControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private CalculationService 

calculationService;

    @Test
    void testPostCalculate() 

throws Exception {
        Calculation mockSave =

 new Calculation(500, 650, 150, 30, true);
        mockSave.setId(1L);

        Mockito.when(calculationService.

calculateAndSave(500, 650))
                .thenReturn(mockSave);

        mockMvc.perform(
                post("/api/calculate")
                    .contentType

(MediaType.APPLICATION_JSON)
                    .content

("{\"cp\":500,\"sp\":650}")
        )
        .andExpect(status().isOk())
        .andExpect(jsonPath("$.type")

.value("profit"))
        .andExpect(jsonPath("$.amount")

.value(150.0))
        .andExpect(jsonPath("$.percent")

.value(30.0))
        .andExpect(jsonPath("$.id")

.value(1));
    }
}

✅ 2. Retrofit Integration (Android Kotlin)

Integrate your Android app with the REST API running on Spring Boot.

Step 1: Add Retrofit dependency

In app/build.gradle:

implementation("com.squareup.

retrofit2:retrofit:2.9.0")
implementation("com.squareup.

retrofit2:converter-gson:2.9.0")

Step 2: Create Data Models

CalculateRequest.kt

data class CalculateRequest(
    val cp: Double,
    val sp: Double
)

CalculateResponse.kt

data class CalculateResponse(
    val type: String,
    val amount: Double,
    val percent: Double,
    val id: Long
)

Step 3: Retrofit API Interface

ProfitLossApi.kt

import retrofit2.Call
import retrofit2.http.Body
import retrofit2.http.POST

interface ProfitLossApi {
    @POST("/api/calculate")
    fun calculate(@Body req: 

CalculateRequest): Call<CalculateResponse>
}

Step 4: Retrofit Client

RetrofitClient.kt

import retrofit2.Retrofit
import retrofit2.converter.

gson.GsonConverterFactory

object RetrofitClient {
    val instance: ProfitLossApi by lazy {
        Retrofit.Builder()
            .baseUrl("http://10.0.2.2:8080")

 // Android emulator → localhost
            .addConverterFactory

(GsonConverterFactory.create())
            .build()
            .create(ProfitLossApi:

:class.java)
    }
}

Step 5: Call the API from MainActivity

RetrofitClient.instance.calculate

(CalculateRequest(cp, sp))
    .enqueue(object : retrofit2.

Callback<CalculateResponse> {
        override fun onResponse(
            call: retrofit2.Call<

CalculateResponse>,
            response: retrofit2.

Response<CalculateResponse>
        ) {
            val body = response.body()
            if (body != null) {
                tvResult.text = """
                    Type: ${body.type}
                    Amount: ${body.amount}
                    Percent: ${body.percent}
                    Saved ID: ${body.id}
                """.trimIndent()
            }
        }

        override fun onFailure(call:

 retrofit2.Call<CalculateResponse>,

 t: Throwable) {
            tvResult.text = "Error: 

${t.message}"
        }
    })

✅ 3. Postman Collection (Export JSON)

Copy and paste into a .json file and import into Postman.

profitloss.postman_collection.json

{
  "info": {
    "name": "Profit Loss API",
    "_postman_id": "a1b2c3d4",
    "schema": "https://schema.

getpostman.com/json/collection/v2.1.0/

collection.json"
  },
  "item": [
    {
      "name": "Calculate Profit or Loss",
      "request": {
        "method": "POST",
        "header": [{"key": "Content-Type",

 "value": "application/json"}],
        "body": {
          "mode": "raw",
          "raw": "{\"cp\":500,\"sp\":650}"
        },
        "url": "http://localhost:

8080/api/calculate"
      }
    },
    {
      "name": "Get Saved Calculation",
      "request": {
        "method": "GET",
        "url": "http://localhost:

8080/api/calculation/1"
      }
    }
  ]
}

✅ 4. OpenAPI / Swagger Specification (openapi.yaml)

openapi: 3.0.1
info:
  title: Profit & Loss API
  version: 1.0.0

paths:
  /api/calculate:
    post:
      summary: Calculate and save profit/loss
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                cp:
                  type: number
                sp:
                  type: number
      responses:
        "200":
          description: Calculation result
          content:
            application/json:
              schema:
                type: object
                properties:
                  type:
                    type: string
                  amount:
                    type: number
                  percent:
                    type: number
                  id:
                    type: integer

  /api/calculation/{id}:
    get:
      summary: Get saved calculation by ID
      parameters:
        - in: path
          name: id
          required: true
          schema:
            type: integer
      responses:
        "200":
          description: Calculation found
        "404":
          description: Not found

If you include SpringDoc OpenAPI UI, you get Swagger UI automatically:

Add to pom.xml:

<dependency>
  <groupId>org.springdoc</groupId>
  <artifactId>springdoc-openapi-

starter-webmvc-ui</artifactId>
  <version>2.2.0</version>
</dependency>

Then open:

👉 http://localhost:8080/swagger-ui.html

🎉 All items completed!

You now have:

✔ Unit Tests
✔ Retrofit Android integration
✔ Postman Collection
✔ OpenAPI/Swagger Spec

BEST OF LUCK ...