Your own subscription for VLESS on a VPS: sub-store and automatic config updates

To create a unified VLESS subscription on a VPS with automatic config updates and convenient management of multiple servers, sub-store is used – a powerful tool that allows centralizing access and automating its delivery to clients. This article will detail how to deploy and configure your own sub-store on a virtual private server from Valebyte.com, so you can effectively manage your VLESS configurations, combine them into one convenient link, and ensure seamless auto-updates for all your users, regardless of the number of servers and their geographical location.

Why a Unified VLESS Subscription on VPS is Needed and Why It's Convenient?

Managing multiple VLESS servers located in different data centers or even with different providers can quickly become a headache. Each server has its unique configuration file or link. If you have multiple clients or use multiple devices yourself, the need to manually update or distribute these links with every change (e.g., port change, adding a new server, or blocking an old one) becomes extremely inefficient. A unified VLESS subscription on a VPS solves this problem by offering a centralized approach to access management.

Problems of Multi-Server Infrastructure Without Centralization

Without a single point of management, administrators and users face the following difficulties:

• Manual updates: With every configuration change (e.g., TLS certificate update, server address change, adding a new VLESS node), links must be manually updated on each client device. This is time-consuming and prone to errors.
• Distribution complexity: Sending dozens or hundreds of individual links to users becomes a logistical nightmare. How to ensure everyone always has up-to-date information?
• Lack of a single source: Clients cannot easily switch between servers. They have to manually add each server, which reduces usability and increases the entry barrier.
• Availability issues: If one server goes down, clients have to wait for a new link or manually switch to another if it was added previously. This disrupts continuous operation.
• Inefficient resource utilization: Without the ability to quickly switch users between less loaded servers, some nodes may be overloaded while others remain idle.

A centralized subscription system running on your VPS allows you to aggregate all VLESS configurations into one convenient link. The client adds this link once to their VLESS client (e.g., v2rayNG, Clash, Shadowrocket), and all available servers automatically appear in the list. With any changes on the server side, the client only needs to update the subscription, and the current data will be downloaded automatically. This significantly enhances convenience for end-users and simplifies life for administrators.

Advantages of Centralized VLESS Subscription on VPS

Deploying your own subscription system on a VPS brings several significant advantages:

• Convenience for users: One link instead of dozens. Clients can easily switch between servers, choosing the fastest or most stable option.
• Ease of administration: All changes are made in one place. Adding new servers, removing old ones, changing parameters – all this is reflected for clients after updating the subscription.
• Automatic VLESS config updates: Clients receive up-to-date configurations without manual intervention, which is critical for maintaining stable access, especially in conditions of frequent blockages or IP address changes.
• Flexibility and control: You have full control over which servers and in what order are provided to users. You can set up different subscription groups for different users.
• Resilience to blockages: If one of the servers is blocked, you can quickly replace it with a new one in the sub-store, and clients will receive the updated configuration with the next auto-update.
• Time saving: Reducing time spent on support and configuration distribution allows you to focus on more important tasks.

Using your own VPS to host the sub-store also gives you full control over data and privacy, which cannot be guaranteed when using third-party services. You choose a provider, such as Valebyte.com, which offers reliable VPS with high availability and performance, which is critical for the stable operation of your subscription system.

What is sub-store and How Does It Solve the Problem of Managing VLESS VPS subscriptions?

Sub-store is a lightweight yet powerful tool that acts as a proxy server for your subscriptions. It is not a full-fledged VLESS server, but rather an aggregator and converter of configurations. Its main task is to take multiple individual VLESS links (or other protocols) as input and output a single, unified subscription link that clients can use. This allows for efficient management of VLESS VPS subscriptions, significantly simplifying the entire process.

How sub-store Works

Sub-store operates on the following principle:

1. Configuration Collection: You provide sub-store with a list of URLs, each leading to a separate VLESS configuration (or a config for another protocol, such as Shadowsocks, VMess, Trojan, Reality, etc.). These links can be direct links to configurations or links to other subscriptions.
2. Aggregation and Normalization: Sub-store downloads all these configurations, parses them, normalizes them, and combines them into a single data array.
3. Conversion and Filtering: Upon client request, sub-store can convert the aggregated data into various subscription formats (e.g., Clash, Quantumult X, Surge, Base64-encoded URL list for V2RayNG). It can also apply filters, allowing specific servers to be included or excluded based on their names, regions, or other parameters.
4. Issuing a Single Link: Sub-store provides a public URL. When a client application sends a request to this URL, sub-store dynamically generates and delivers an up-to-date list of servers in the required format.

Thus, sub-store becomes a central hub for all your VLESS configurations. Instead of giving users 10 different links, you give them one that always leads to an up-to-date list of 10 (or more) servers.

Key Features of sub-store for Subscription Management

Sub-store offers a range of features that make it an indispensable tool for managing VLESS subscriptions:

• Support for multiple protocols: In addition to VLESS, sub-store typically supports VMess, Shadowsocks, Trojan, Snell, HTTP/HTTPS proxy, and others. This allows combining servers of different types into one subscription.
• Flexible source configuration: You can add direct links to VLESS configurations as well as links to other subscriptions, allowing for multi-level systems.
• Format conversion: One of the most important functions is the ability to convert the aggregated server list into formats understandable by various client applications (Clash, Quantumult X, Surge, Base64-encoded V2Ray/VLESS URL list).
• Filtering and sorting: Ability to filter servers by keywords in their names, by regions, by protocols. This allows for creating personalized subscriptions.
• Automatic updates: Since sub-store dynamically generates the server list, any changes in the original configurations are automatically reflected in the client's subscription upon the next update.
• Load balancing (limited): While sub-store itself is not a load balancer, it allows providing clients with an up-to-date list of servers from which they can choose the least loaded or closest one.
• Lightweight: Sub-store is usually written in Go or Python and consumes minimal resources, making it ideal for deployment even on the most budget-friendly VPS.

By using sub-store on your Valebyte.com VPS, you gain full control over the process of distributing VLESS configurations, ensuring maximum convenience and reliability for your users. This is especially relevant for those who provide access to VLESS servers to a small group of friends, family, or even as part of a small commercial project.

Preparing the VPS for sub-store Installation: Selection and Configuration

Before proceeding with sub-store installation, it is necessary to correctly choose and prepare your virtual private server. Choosing the right VPS is a key factor for the stable and fast operation of your subscription system. Valebyte.com offers various tariff plans that are suitable for this task.

Choosing the Optimal VPS for sub-store

Sub-store is not a resource-intensive application, so it does not require a powerful server to operate. However, if you plan to serve a large number of clients or aggregate hundreds of configurations, you should consider more powerful options. Here are the main recommendations for choosing a VPS:

• Processor (CPU): 1 vCPU with a frequency of 2.0 GHz or higher will be more than sufficient. Sub-store mainly performs network operations and text parsing, which does not require intensive computations.
• Random Access Memory (RAM): 512 MB – 1 GB RAM is usually enough with a margin. If you are using an operating system without a graphical interface (which is highly recommended), even 256 MB may be sufficient, but 512 MB offers more flexibility.
• Disk Space: 10-20 GB NVMe or SSD disk will be more than enough. Sub-store stores very little data. NVMe/SSD is preferable for overall system responsiveness.
• Operating System: It is recommended to use minimalistic Linux distributions such as Ubuntu Server (20.04 LTS or 22.04 LTS), Debian (11 or 12), or CentOS Stream 9. They are stable, well-documented, and consume minimal resources.
• VPS Location: Choose a location that is geographically close to your primary users to minimize latency when requesting a subscription. However, since sub-store only delivers text data, the impact of location on speed will be minimal; the main thing is a stable internet connection.

**Table: Recommended VPS Configurations for sub-store on Valebyte.com**

Pricing Plan (example)	vCPU	RAM	Disk (NVMe/SSD)	Traffic	Approximate Price/month	Recommended Load
Entry-Level	1 core (2.0+ GHz)	512 MB	10 GB NVMe	1 TB	from $3	Up to 50 active users, up to 20 VLESS servers
Standard	1 core (2.5+ GHz)	1 GB	20 GB NVMe	2 TB	from $5	Up to 200 active users, up to 50 VLESS servers
Advanced	2 cores (2.5+ GHz)	2 GB	40 GB NVMe	4 TB	from $10	Over 200 active users, more than 50 VLESS servers

*Prices are examples and may vary. For accurate information, see current tariffs on Valebyte.com.*

Initial Operating System Setup

After gaining access to your VPS (usually via SSH), follow these steps: 1. **System Update:** Always start by updating all packages to their latest versions.

sudo apt update && sudo apt upgrade -y

(For Ubuntu/Debian)

sudo yum update -y

(For CentOS/RHEL) 2. **Install Necessary Utilities:** Make sure `curl` or `wget` are installed for downloading files, and `git` (if you plan to clone the sub-store repository).

sudo apt install curl wget git -y

3. **Configure Firewall (UFW for Ubuntu/Debian):** It is recommended to configure a firewall for increased security. Allow only necessary ports: SSH (usually 22), HTTP (80), and HTTPS (443), as sub-store will operate via a web server.

sudo ufw allow OpenSSH
sudo ufw allow http
sudo ufw allow https
sudo ufw enable

Confirm with "y" when prompted. 4. **Create a New User (optional, but recommended):** Work as a regular user with `sudo` privileges, not as `root`.

sudo adduser valeuser
sudo usermod -aG sudo valeuser

Then log out of `root` and log in as `valeuser`. Your VPS is now ready for sub-store installation. Make sure you have a domain name pointing to your VPS's IP address if you plan to use HTTPS (which is highly recommended) for your subscription.

Installing sub-store on VPS: Step-by-Step Guide

Installing sub-store on a VPS can be done in several ways, depending on the chosen implementation (there are versions in Go, Python, and other languages). We will cover the installation of the most popular and performant version, typically written in Go, which compiles into a single executable file. For demonstration, we will use Ubuntu Server 22.04 LTS.

Installing Go and Compiling sub-store from Source

This method is preferred as it allows you to get the latest version and ensures compatibility. 1. **Install Go:** First, you need to install the Go compiler. Check the latest Go version on the official website (go.dev/dl/).

wget https://go.dev/dl/go1.22.4.linux-amd64.tar.gz # Replace with the actual version
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.22.4.linux-amd64.tar.gz
echo "export PATH=$PATH:/usr/local/go/bin" >> ~/.profile
source ~/.profile
go version

You should see the Go version, for example `go version go1.22.4 linux/amd64`. 2. **Clone the sub-store repository:** Find the current sub-store repository on GitHub. One popular option is `sub-store-ng` or `subconverter`. We will use the concept of `sub-store` as a general name. Assuming you found a suitable repository.

git clone https://github.com/your-sub-store-repo/sub-store.git # Replace with the actual repository
cd sub-store

3. **Compile sub-store:**

go build -o sub-store main.go # Or another entry-point file

After executing this command, an executable file named `sub-store` will appear in the current directory.

Running sub-store and Configuring Systemd

For reliable operation of sub-store in the background and automatic startup after server reboot, use `systemd`. 1. **Create the sub-store configuration file:** Sub-store usually requires a configuration file (e.g., `config.yaml` or `settings.json`) where subscription sources, ports, and other parameters are specified. Example `config.yaml` (structure may vary):

# config.yaml
listen: ":8080" # Port on which sub-store will listen
sources:
  - url: "https://your-vless-server1.com/config.json"
    name: "Server-1-Germany"
  - url: "https://your-vless-server2.com/vless_sub"
    name: "Server-2-USA"
    type: "vless" # Specify type if not auto-detect
rules:
  - name: "My-Combined-Subscription"
    filter: "Server-" # Include all servers containing "Server-" in their name
    format: "base64" # Output format for V2RayNG/v2rayN
    path: "/sub/my_vless_sub" # URL path for this subscription
    template: "default" # Template for formatting

Create this file in the `sub-store` directory (e.g., `/opt/sub-store/config.yaml`). 2. **Create a user for sub-store:** For security, it's best to run sub-store as a separate user.

sudo useradd -r -s /bin/false sub-store-user
sudo mkdir /opt/sub-store
sudo mv sub-store /opt/sub-store/sub-store
sudo mv config.yaml /opt/sub-store/config.yaml
sudo chown -R sub-store-user:sub-store-user /opt/sub-store

3. **Create a Systemd unit:** Create the `sub-store.service` file in `/etc/systemd/system/`.

sudo nano /etc/systemd/system/sub-store.service

Add the following content:

[Unit]
Description=Sub-store Subscription Converter
After=network.target

[Service]
User=sub-store-user
Group=sub-store-user
ExecStart=/opt/sub-store/sub-store -c /opt/sub-store/config.yaml # Specify the path to your config
Restart=on-failure
RestartSec=10
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

Save and close the file. 4. **Start and activate sub-store:**

sudo systemctl daemon-reload
sudo systemctl enable sub-store
sudo systemctl start sub-store
sudo systemctl status sub-store

Ensure the service is running and active (`active (running)`). Now sub-store is running and listening on port 8080 (or another port specified in your config). However, for HTTP/HTTPS access and using a domain name, you will need a web server proxy, such as Nginx.

Configuring Nginx as a Reverse Proxy

Nginx will accept requests on ports 80/443 of your domain and forward them to sub-store, which is running on port 8080. This will also allow easy SSL/TLS configuration. 1. **Install Nginx:**

sudo apt install nginx -y

2. **Configure Nginx:** Create a new configuration file for your domain (e.g., `yourdomain.com.conf`) in `/etc/nginx/sites-available/`.

sudo nano /etc/nginx/sites-available/yourdomain.com.conf

Add the following content:

server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com; # Replace with your domain

    location / {
        proxy_pass http://127.0.0.1:8080; # Port on which sub-store listens
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

3. **Activate configuration and restart Nginx:**

sudo ln -s /etc/nginx/sites-available/yourdomain.com.conf /etc/nginx/sites-enabled/
sudo nginx -t # Syntax check
sudo systemctl restart nginx

4. **Set up SSL/TLS with Certbot (recommended):** For secure access to subscriptions via HTTPS, install Certbot.

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

Follow Certbot's instructions. It will automatically modify the Nginx configuration to use SSL. Now your subscription is available at `https://yourdomain.com/sub/my_vless_sub`. Clients will be able to add this link to their applications.

Configuring sub-store: Adding Servers and Creating VLESS Links

After successfully installing and performing basic configuration of sub-store on your VPS, the next step is to configure VLESS server sources and create custom subscription links. This process involves editing the sub-store configuration file (usually `config.yaml` or `settings.json`) and applying the changes.

sub-store Configuration File Structure

The sub-store configuration file defines where to get VLESS configurations, how to process them, and in what format to provide them to clients. Let's look at the main sections using `config.yaml` as an example:

# config.yaml
listen: ":8080" # The port on which sub-store will listen locally. Nginx will proxy to it.

# 'sources' section - lists all VLESS configuration sources here.
# These can be direct links to a single VLESS config, or links to other subscriptions.
sources:
  - url: "vless://[email protected]:443?encryption=none&security=tls&sni=server1.example.com&fp=chrome&type=ws&path=%2Fws#Germany-Frankfurt"
    name: "VLESS-TLS-WS-DE" # Unique name for this server
    tag: "Germany,Fast" # Tags for filtering

  - url: "vless://[email protected]:443?encryption=none&security=reality&pbk=PUBLIC_KEY&sni=google.com&fp=chrome&type=tcp&flow=xtls-rprx-vision#USA-Reality"
    name: "VLESS-Reality-US"
    tag: "USA,Secure,Reality"

  - url: "https://another-sub-provider.com/api/v1/client/subscribe?token=YOUR_TOKEN" # Link to another subscription
    name: "External-Provider-Sub"
    type: "auto" # Sub-store will automatically detect the format
    interval: 3600 # How often to update this external subscription (in seconds)

# 'rules' section - defines the output subscription links and their parameters.
# Each "rule" creates a separate URL link for clients.
rules:
  - name: "All-VLESS-Servers"
    path: "/sub/all" # Path where this subscription will be available (e.g., https://yourdomain.com/sub/all)
    filter: "VLESS-" # Include all sources whose name contains "VLESS-"
    exclude: "Slow" # Exclude servers with the tag "Slow"
    format: "base64" # Output format: base64 (for V2RayNG), clash, quantumultx, etc.
    template: "default" # Template for formatting server names (optional)
    emoji: true # Add country emoji to server name

  - name: "USA-Only-Servers"
    path: "/sub/usa"
    filter: "USA" # Include only servers with the tag "USA"
    format: "clash" # Output format for Clash clients
    udp: true # Enable UDP support for Clash

  - name: "Fast-Servers-Base64"
    path: "/sub/fast"
    filter: "Fast" # Include only servers with the tag "Fast"
    format: "base64"
    sort: "latency" # Try to sort by latency (if sub-store supports it)

Adding VLESS Servers to sub-store

1. **Collect VLESS links:** First, obtain working VLESS links from your servers. These can be links generated by panels (such as Hiddify on VPS, Marzban) or manually created configurations. Example VLESS link:

vless://UUID@your_vps_ip:PORT?encryption=none&security=tls&sni=your_domain.com&fp=chrome&type=ws&path=%2Fyour_path#ServerName

or with Reality:

vless://UUID@your_vps_ip:PORT?encryption=none&security=reality&pbk=PUBLIC_KEY&sni=google.com&fp=chrome&type=tcp&flow=xtls-rprx-vision#ServerName-Reality

2. **Edit `config.yaml`:** Open your sub-store configuration file:

sudo nano /opt/sub-store/config.yaml

In the `sources` section, add each VLESS link as a separate list item. Be sure to assign a unique and descriptive `name` to each server, and also add a `tag` for easy filtering in the future. Example:

sources:
      - url: "vless://..."
        name: "Valebyte-DE-VLESS-1"
        tag: "Germany,Valebyte,TLS,WS"
      - url: "vless://..."
        name: "Valebyte-US-VLESS-2-Reality"
        tag: "USA,Valebyte,Reality"
      - url: "vless://..."
        name: "External-NL-VLESS-3"
        tag: "Netherlands,External"

You can also add links to other subscriptions so that sub-store aggregates them as well. This is useful if you have servers managed by another panel that already generates its own subscription.

Creating Custom Subscription Links

In the `rules` section, you define which servers will be included in a particular output subscription and in what format they will be presented. 1. **Define `path`:** This is the URL path where clients will receive the subscription. For example, `/sub/my_main_vless` will result in the link `https://yourdomain.com/sub/my_main_vless`. 2. **Using `filter` and `exclude`:** * `filter`: Includes servers whose `name` or `tag` contains the specified substring. * `exclude`: Excludes servers whose `name` or `tag` contains the specified substring. You can combine them for precise tuning. For example, `filter: "Valebyte"` and `exclude: "Slow"` will output all Valebyte servers except those tagged "Slow". 3. **Choose `format`:** This is a critically important parameter. * `base64`: Standard format for V2RayNG, v2rayN, Shadowrocket. This is simply a Base64-encoded list of VLESS links, separated by newlines. * `clash`: Format for Clash clients (YAML file). * `quantumultx`: Format for Quantumult X. * `surge`: Format for Surge. * `plain`: Simple text list without encoding (rarely used for VLESS). 4. **Additional options:** * `emoji: true/false`: Adds country flags to server names. * `template`: Allows using custom templates for formatting server names. * `sort`: Allows sorting servers (e.g., by name, latency, if supported). **Example of creating different subscriptions:**

rules:
  - name: "Android-Users-VLESS"
    path: "/sub/android"
    filter: "VLESS-"
    exclude: "External" # Exclude external if we only want our own
    format: "base64"
    emoji: true

  - name: "Clash-Config-for-Desktop"
    path: "/sub/clash"
    filter: "Valebyte" # Only Valebyte servers
    format: "clash"
    udp: true

  - name: "Fast-Germany-Servers"
    path: "/sub/de-fast"
    filter: "Germany,Fast" # Servers from Germany and fast ones
    format: "base64"
    emoji: true

Applying Changes and Testing

After making changes to `config.yaml`: 1. **Restart sub-store:**

sudo systemctl restart sub-store

2. **Check status:**

sudo systemctl status sub-store

Ensure the service restarted without errors. 3. **Test links:** Open each created subscription link in your browser (e.g., `https://yourdomain.com/sub/android`). You should see a list of VLESS configurations in the chosen format (Base64-encoded text, YAML for Clash, etc.). 4. **Add to client:** Copy the link and add it to your VLESS client (e.g., V2RayNG on Android). Make sure all servers are displayed and working correctly. Now you have a fully configured sub-store that aggregates your VLESS servers and provides them in a convenient format via unified subscription links. This significantly simplifies management and ensures automatic VLESS config updates for your clients.

Subscription Converter: How sub-store Works with Various Formats?

One of the key features of sub-store that makes it such a powerful tool is its ability to act as a universal subscription converter. It can take configurations of various proxy protocols and subscriptions in diverse formats as input, and then convert them into the format required by a specific client application. This frees the administrator from having to manually adapt configurations for each client type.

Supported Protocols and Sources

Sub-store is designed for maximum flexibility. It can work with a wide range of protocols:

• VLESS: With TLS, WebSocket, gRPC, Reality, XTLS-Vision.
• VMess: With TLS, WebSocket, gRPC.
• Shadowsocks (SS): With various encryptions and plugins (v2ray-plugin, simple-obfs).
• Trojan: With TLS.
• Socks5/HTTP/HTTPS: Basic proxies.
• Hysteria/Hysteria2: High-performance UDP protocols.
• TUIC: QUIC-based protocol.

Sources for these configurations can be:

• Direct URL links to individual VLESS/VMess/SS/Trojan and other configurations.
• Links to other subscriptions (e.g., a subscription from your provider, another control panel, or even other sub-store instances).
• Local files on the server containing configurations (less common but possible).

This versatility allows you to combine servers running under Xray, Sing-box, Clash, Hiddify, Marzban, and other systems into one subscription, providing the client with a single point of access.

Output Subscription Formats for Various Clients

After aggregating and processing all input configurations, sub-store can convert them into formats understandable by most popular proxy clients:

• Base64-encoded URL list: This is the most common format for V2Ray/Xray-based clients such as v2rayNG (Android), v2rayN (Windows), Shadowrocket (iOS), Kitsunebi (iOS), Pepi (iOS). Essentially, it's a list of VLESS links (or other protocols), each on a new line, with the entire list then Base64-encoded. The client application decodes it and displays the list of servers.
• Clash-compatible YAML: For Clash clients (Clash for Windows, ClashX, Clash Verge), sub-store can generate a full YAML file containing all proxies, proxy groups, routing rules (although routing rules are usually configured client-side or in a sub-store template). This allows Clash clients to use all their advanced features.
• Quantumult X-compatible file: For the popular iOS client Quantumult X.
• Surge-compatible file: For Surge clients (iOS/macOS).
• Mellow-compatible file: For the Mellow client.
• Sing-box JSON: For Sing-box clients.

In the sub-store configuration (the `rules` section), you specify the `format` for each output subscription. For example, if you are creating a subscription for Android users, you would choose `format: "base64"`. If for Windows users with Clash, then `format: "clash"`. **Example configuration with different formats:**

rules:
  - name: "Android-Users-VLESS"
    path: "/sub/android"
    filter: "VLESS-"
    format: "base64" # For v2rayNG, Shadowrocket
    emoji: true

  - name: "Clash-Users-Full"
    path: "/sub/clash"
    filter: "all" # Include all available servers
    format: "clash" # For Clash for Windows, ClashX
    udp: true

  - name: "QuantumultX-Users"
    path: "/sub/qx"
    filter: "Premium" # Only premium servers
    format: "quantumultx" # For Quantumult X

Such flexibility allows you to serve users with a wide variety of client applications, providing them with the same server base, but in a format adapted for their software. This significantly simplifies the distribution and support process, as you only need to maintain one central sub-store configuration file, rather than many separate files for different clients.

Automatic VLESS Config Updates for Clients: Mechanisms and Advantages

One of the most significant advantages of using sub-store is the ability to provide automatic VLESS config updates to all connected clients. This feature is critically important for maintaining stable and uninterrupted access, especially in situations where VLESS servers may be subject to blockages or require regular changes.

How Subscription Auto-Update Works

The mechanism for automatic VLESS config updates is based on the interaction of the client application with your sub-store server:

1. Client adds subscription URL: The user adds the URL provided by sub-store (e.g., `https://yourdomain.com/sub/android`) to their VLESS client application (v2rayNG, Shadowrocket, Clash, etc.) once.
2. Initial download: The client application sends an HTTP/HTTPS GET request to this URL, sub-store generates and returns an up-to-date list of servers in the requested format. The client parses this list and displays all available VLESS servers.
3. Periodic update: Most modern VLESS clients have a built-in function for periodic subscription updates. The user or administrator can configure the update interval (e.g., every 1, 3, 6, 12, or 24 hours).
4. Update request: After the specified interval, the client application automatically sends a new HTTP/HTTPS GET request to the same subscription URL.
5. Receiving up-to-date data: Sub-store again generates and returns the current list of servers. If changes were made on the sub-store side (servers added/removed, parameters changed), the client receives these updated data.
6. Applying changes: The client application updates its internal server list, displaying all current VLESS configurations. If the currently used server was removed or changed, the client can automatically switch to another available server or prompt the user to choose a new one.

This process is fully automated for the end-user after initial setup, which significantly enhances usability and reduces the need for manual interventions.

Advantages of Automatic Updates for Administrators and Users

For administrators:

• Reduced support load: No longer need to manually distribute new configurations with every change. Once sub-store is set up, you manage all servers from one place.
• Quick response to blockages: If one of the VLESS servers is blocked or its IP address changes, you simply update the link in sub-store's `config.yaml`. With the next subscription update, clients will automatically receive working configurations, minimizing downtime.
• Centralized management: All VLESS configurations are stored and managed in one file on your VPS. This simplifies auditing, backup, and scaling.
• Flexibility in resource management: Ability to quickly add new servers or redirect traffic from overloaded nodes to less loaded ones by simply updating the list in sub-store.

For users:

• Continuous access: Thanks to auto-updates, users always have access to an up-to-date list of working VLESS servers, ensuring uninterrupted connectivity.
• Ease of use: The user only needs to enter the subscription link once. Everything else happens automatically.
• Access to better servers: If the administrator regularly adds new, faster, or more stable servers, users automatically gain access to them without any additional actions.
• Fewer errors: Eliminates human error when manually copying and pasting complex VLESS links, which can be long and contain special characters.

To ensure maximum effectiveness of auto-updates, it is recommended to choose reliable VPS hosting, such as Valebyte.com, which guarantees high availability and stability of your sub-store server. This will ensure that your sub-store is always available for update requests from clients.

Optimization and Scaling: Best Practices for sub-store VPS

While sub-store is a lightweight application, proper optimization and scaling planning can significantly enhance its reliability and performance, especially when serving a large number of users or managing hundreds of VLESS servers. Using a powerful VPS, such as those offered by Valebyte.com, is a good starting point.

Optimizing sub-store Configuration

1. **Efficient use of tags and filters:** * Carefully design a tagging system (`tag`) for your VLESS servers. For example, `Germany, Fast, TLS, Valebyte`, `USA, Reality, Secure`. * Use these tags in `filter` and `exclude` rules to create the most relevant subscriptions for different user groups. This will reduce the size of each subscription and speed up its download by clients. * Avoid redundant rules or overly broad filters if they are not needed. 2. **Optimizing sources:** * If you are using links to external subscriptions (`type: "auto"`), set an adequate `interval` for their updates. There's no point in updating them every minute if they change once a day. For example, `interval: 3600` (1 hour) or `interval: 14400` (4 hours). * Regularly check the relevance and availability of all sources. Remove non-working links. 3. **Choosing the output format:** * Choose the `format` that most accurately matches your client applications. For example, `base64` for V2RayNG, `clash` for Clash. This minimizes client-side processing. * For the `base64` format, which is simply a text list, it is the most lightweight. 4. **Using Nginx caching:** * To further reduce the load on sub-store and speed up subscription delivery, you can configure caching in Nginx. This is especially useful if subscription content doesn't change frequently but there are many requests.

# Outside the server section, for example, in http { ... }
proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=sub_cache:10m inactive=60m;
proxy_cache_key "$scheme$request_method$host$request_uri";

# Inside the location / { ... } section of your server block
location /sub/ { # Cache only subscription paths
    proxy_cache sub_cache;
    proxy_cache_valid 200 302 10m; # Cache successful responses for 10 minutes
    proxy_cache_use_stale error timeout updating http_500 http_502 http_503 http_504;
    proxy_pass http://127.0.0.1:8080;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

This will allow Nginx to deliver a cached version of the subscription without contacting sub-store for every request within 10 minutes.

sub-store Scaling Strategies

1. **Monitoring VPS resources:** * Regularly monitor CPU, RAM, and network traffic usage on your VPS. Use utilities like `htop`, `glances`, `Prometheus/Grafana`. * If you see consistently high CPU usage (over 70-80%) or RAM exhaustion, it's a signal to upgrade your VPS plan or optimize your configuration. * Valebyte.com offers convenient panels for resource monitoring that will help you decide on scaling. 2. **Vertical scaling:** * The simplest way to scale is to upgrade your current VPS to a more powerful plan (more CPU cores, more RAM, faster disk). For sub-store, this is often a sufficient solution, as it does not require a distributed architecture. 3. **Horizontal scaling (for very high loads):** * If you are serving thousands of users and one VPS is no longer sufficient, you might consider deploying multiple sub-store instances. * You can host several sub-stores on different VPS, each with its own subscription, or use a load balancer (e.g., Nginx or HAProxy) in front of multiple sub-store instances running on different ports or IP addresses. * In this case, all sub-stores must have identical `config.yaml` files to deliver the same subscriptions. 4. **Splitting subscriptions:** * Instead of one "giant" subscription that contains all servers, create several specialized subscriptions (e.g., "Germany Only", "USA Only", "Fast Servers"). * This will reduce the size of each subscription and lower the load on sub-store during their generation, as well as on client devices during their parsing. 5. **Backup:** * Regularly back up your `config.yaml` file. This is the most important file for sub-store. * Automatic VPS backups offered by Valebyte.com are also a good precautionary measure. By following these recommendations, you can ensure stable, fast, and scalable operation of your sub-store on a VPS, effectively managing all your VLESS subscriptions.

Conclusion

Deploying your own VLESS subscription on a VPS using sub-store is an optimal solution for centralized management and automatic config updates. This approach significantly simplifies the administration of multiple VLESS servers and enhances convenience for end-users, providing them with continuous access to up-to-date configurations. Choose reliable and high-performance VPS from Valebyte.com for stable operation of your sub-store and effective scaling of your VLESS infrastructure.