DEV Community: Klemens

Ditch Your VPN Subscription: Create Your Own Pay-As-You-Go VPN on GCP in Minutes!

Klemens — Tue, 31 Oct 2023 21:21:36 +0000

Introduction

This guide walks you through the process of setting up a Virtual Private Server (VPS) with OpenVPN on Google Cloud Platform (GCP) using Terraform. Unlike traditional VPN services like NordVPN that require a monthly subscription, this setup allows you to pay only for the minutes you actually use. Plus, you can easily tear down and spin up your VPN server as needed, offering unparalleled flexibility.

Why Choose This Approach?

No Monthly Subscription: Only pay for what you use, down to the minute.
Quick Setup and Teardown: Easily spin up or tear down your VPN server whenever you need it.
Full Control: You have complete control over the server, its security settings, and its location.

Pre-requisites

Terraform installed on your machine.
A Google Cloud Platform (GCP) account with necessary permissions to create resources.
Git (Optional, for cloning the repository)

Step 1: Clone the Repository

First, clone the repository containing the Terraform scripts.

git clone https://github.com/kwisser/create-cloud-compute-engine-ovpn-server
cd create-cloud-compute-engine-ovpn-server/infrastructure

Step 2: Choose a Zone for Your VPN Location

Select a suitable zone for deploying the VM instance. The choice of zone can affect the latency and speed of your VPN. You can find a list of available regions and zones on GCP here.

Step 3: Execute Terraform Scripts

Navigate to the infrastructure directory and initialize Terraform. This will download the necessary provider plugins.

cd infrastructure
terraform init

Now, plan and apply the Terraform configuration. This will show the resources that will be created and apply the changes, respectively. You will have to enter the following variables:

project_id: Your GCP project ID
name: Name of your VM instance
machine_type: Machine type (e.g., f1-micro)
zone: Zone (e.g., us-central1-a)
vm_username: Your username

terraform plan
terraform apply

Upon successful execution, a client.ovpn file will be generated in the user directory. This file can be used to connect to the VPN server from a client machine.

Credits

The OpenVPN installation script is sourced from angristan/openvpn-install.

Support & Contributions

For issues or contributions, feel free to open a pull request or create an issue in the repository.

Enjoy the flexibility and cost-effectiveness of your own pay-as-you-go VPN server on GCP!

You can find the full code in the GitHub repository

kwisser / create-cloud-compute-engine-ovpn-server

Terraform script which creates a compute engine in gcp which hosts a openvpn server.

Setting up a VPS Server with OpenVPN on GCP using Terraform

This guide walks through the process of setting up a Virtual Private Server (VPS) with OpenVPN on Google Cloud Platform (GCP) using Terraform. The provided Terraform script will automate the provisioning of a Google Compute Engine instance, and the installation of OpenVPN server on it. Upon successful execution, a client.ovpn configuration file will be generated in the user directory, which can be used to connect to the VPN server from a client machine.

Pre-requisites

Ensure you have Terraform installed on your machine.
A Google Cloud Platform (GCP) account with necessary permissions to create resources.
Git (Optional, for cloning the repository)

Step 1: Clone the Repository

Clone the repository containing the Terraform scripts.

git clone https://github.com/kwisser/create-cloud-compute-engine-ovpn-server
cd create-cloud-compute-engine-ovpn-server/infrastructure

Step 2: Choose a Zone for Your VPN Location

Select a suitable zone for deploying the VM instance. The choice of zone…

View on GitHub

Developing a YouTube Subscription Analysis Application with Python

Klemens — Tue, 08 Aug 2023 06:06:43 +0000

YouTube has grown into a vast platform where users follow various channels, each representing different topics and interests. Managing these subscriptions and understanding what content you are mostly engaged with can be overwhelming. In this article, we'll walk through the creation of a Python application that analyzes a user's subscriptions and visualizes the distribution of topics.

Step 1: Authenticate with the YouTube API

First, we need to authenticate with the YouTube Data API v3 to access information about a user's subscriptions.

Install the Google Client Library

pip install --upgrade google-auth-oauthlib google-auth-httplib2 google-api-python-client

Authenticate and Save Credentials

import os
import pickle
import google_auth_oauthlib.flow
import googleapiclient.discovery

scopes = ["https://www.googleapis.com/auth/youtube.force-ssl"]

def get_authenticated_service():
    credentials_path = "credentials.pickle"
    if os.path.exists(credentials_path):
        with open(credentials_path, "rb") as f:
            credentials = pickle.load(f)
    else:
        flow = google_auth_oauthlib.flow.InstalledAppFlow.from_client_secrets_file(
            "client_secret.json", scopes)
        credentials = flow.run_console()
        with open(credentials_path, "wb") as f:
            pickle.dump(credentials, f)

    youtube = googleapiclient.discovery.build("youtube", "v3", credentials=credentials)
    return youtube

Make sure to download the client_secret.json file from your Google Cloud Console.

Step 2: Retrieve Subscriptions and Analyze Topics

After authentication, we can retrieve subscriptions and count the topics using a defaultdict.

Getting Subscriptions and Topics

from collections import defaultdict

def get_subscriptions(youtube):
    subscriptions = []
    next_page_token = None
    topic_count = defaultdict(int)

    while True:
        response = youtube.subscriptions().list(
            part="snippet",
            mine=True,
            maxResults=50,
            pageToken=next_page_token
        ).execute()

        subscriptions += response["items"]
        next_page_token = response.get("nextPageToken")

        if next_page_token is None:
            break

    for subscription in subscriptions:
        snippet = subscription["snippet"]
        channelId = snippet["resourceId"]["channelId"]
        response = youtube.channels().list(
            part="topicDetails",
            id=channelId
        ).execute()

        items = response.get("items", [])
        if items:
            topicDetails = items[0].get("topicDetails", {})
            topicCategories = topicDetails.get("topicCategories", [])
        else:
            topicCategories = []

        for topic in topicCategories:
            topic_count[topic] += 1

    return topic_count

Step 3: Visualize the Data with Matplotlib

Finally, we visualize the counted topics using Matplotlib.

Plotting the Topics

import matplotlib.pyplot as plt

def plot_topics(topic_count):
    topics, counts = zip(*topic_count.items())
    plt.bar(topics, counts)
    plt.xlabel('Topics')
    plt.ylabel('Counts')
    plt.title('Distribution of Topics in YouTube Subscriptions')
    plt.xticks(rotation='vertical')
    plt.show()

Running the Full Code

if __name__ == "__main__":
    youtube = get_authenticated_service()
    topic_count = get_subscriptions(youtube)
    plot_topics(topic_count)

Conclusion

We've created an application that authenticates with the YouTube API, analyzes subscriptions, and visualizes the distribution of topics. This is an excellent starting point for anyone interested in YouTube data analysis.

You can find the full code in the GitHub repository

kwisser / youtube-subscription-analyzer

YouTube Subscriptions Analyzer is a Python script that authenticates with the YouTube API, fetches a user's subscriptions, and visualizes the distribution of topics in a pie chart.

YouTube Subscriptions Analyzer

YouTube Subscriptions Analyzer is a Python script that authenticates with the YouTube API, fetches a user's subscriptions, and visualizes the distribution of topics in a pie chart.

Features

Retrieves a user's YouTube subscriptions
Aggregates topics across all subscriptions
Visualizes the distribution of topics in a pie chart

Requirements

Python 3.6 or higher
Google API credentials
Libraries: google-auth-oauthlib, googleapiclient, matplotlib

Setup

Clone the Repository:

git clone https://github.com/kwisser/YoutubeSubscriptions.git
cd youtube-subscriptions-analyzer

Install Dependencies:

pip install google-auth-oauthlib google-auth-httplib2 google-api-python-client matplotlib

Set up Google API credentials:
- Visit the Google Developer Console.
- Create a project and set up the YouTube API v3 credentials.
- Download the client_secret.json file and place it in the project's root directory.

Usage

Run the script with:

python main.py

Follow the on-screen instructions to authenticate with your Google account. The script will fetch your YouTube subscriptions and generate a pie chart.

Contributing

If you'd like to…

View on GitHub