LocalXpose

https://localxpose.io/docs
Admin
LocalXpose is a reverse proxy that enables you to expose your localhost services to the public...
Tokens:22,821
Snippets:357
Trust Score:9.2
Update:5 months ago
Show doc for...
Tokens:
Raw
### Start Minikube Cluster

Source: https://localxpose.io/docs/tutorials/expose-localhost-kubernetes

Use this command to start a local Kubernetes cluster with Minikube. Ensure Minikube is installed and configured before running.

```bash
minikube start
```

--------------------------------

### Install LocalXpose via Snap

Source: https://localxpose.io/docs

Use snap to install the LocalXpose CLI on Linux systems. This is a quick way to get the command-line tool.

```bash
$ snap install localxpose
```

--------------------------------

### LocalXpose Service Help

Source: https://localxpose.io/docs/cli

Displays help information for managing the LocalXpose background service, including commands for installation, uninstallation, starting, stopping, restarting, and checking status.

```bash
loclx service -h
```

--------------------------------

### Start LocalXpose GUI

Source: https://localxpose.io/docs/gui

Launch the LocalXpose GUI from the terminal. This command starts the GUI listening on the default address `localhost:54537`.

```bash
loclx gui
```

--------------------------------

### Docker Compose Example for LocalXpose Tunnel

Source: https://localxpose.io/docs/cli/docker

A complete docker-compose.yml example demonstrating how to run both your application (e.g., Traefik's whoami) and the LocalXpose tunnel service. This setup allows the tunnel to connect to your application within the same Docker network. Ensure your LX_ACCESS_TOKEN is exported before running 'docker compose up'.

```yaml
version: '3.8'
 
services:
  # Your application
  web-app:
    image: traefik/whoami
    ports:
      - '8080:80'
 
  # LocalXpose tunnel
  tunnel:
    image: localxpose/localxpose:latest
    restart: unless-stopped
    environment:
      - LX_ACCESS_TOKEN
    volumes:
      - ./lx-data:/home/nonroot/.localxpose # Persist certificates
    command: tunnel http --to web-app:80
    ports:
      - '54538:54538' # Only if using Let's Encrypt
```

--------------------------------

### Start PocketBase Service

Source: https://localxpose.io/docs/tutorials/expose-pocketbase-backend

Run the PocketBase server locally. This command starts the embedded database and API server.

```bash
./pocketbase serve
# > Server started at: http://localhost:8090
#   - REST API: http://localhost:8090/api/
#   - Admin UI: http://localhost:8090/_/
```

--------------------------------

### Start SSH and LocalXpose Services

Source: https://localxpose.io/docs/tutorials/access-localhost-keepass

Manually start the SSH service and the LocalXpose service to establish the tunnel.

```bash
sudo systemctl start ssh.service && sudo systemctl start localxposessh.service
```

--------------------------------

### Production setup with Traefik and Docker Compose

Source: https://localxpose.io/docs/cli/docker

A complete Docker Compose example for a production setup integrating localxpose with Traefik. This configuration includes persistent certificate storage and routing for multiple subdomains.

```yaml
version: '3.8'
services:
  traefik:
    image: traefik:v2.10
    command:
      - '--providers.docker=true'
      - '--entrypoints.web.address=:80'
    volumes:
      - '/var/run/docker.sock:/var/run/docker.sock:ro'
 
  localxpose:
    image: localxpose/localxpose:latest
    environment:
      - LX_ACCESS_TOKEN
    volumes:
      - ./lx-data:/home/nonroot/.localxpose # Persist certificates
    ports:
      - '54538:54538' # For Let's Encrypt
    command: tunnel http --to traefik:80 --reserved-domain "*.yourdomain.com"
 
  app1:
    image: traefik/whoami
    labels:
      - 'traefik.enable=true'
      - 'traefik.http.routers.app1.rule=Host(`app1.yourdomain.com`)'
 
  app2:
    image: traefik/whoami
    labels:
      - 'traefik.enable=true'
      - 'traefik.http.routers.app2.rule=Host(`app2.yourdomain.com`)'
```

--------------------------------

### Start LocalXpose GUI on a Specific Address

Source: https://localxpose.io/docs/gui

Start the LocalXpose GUI and make it accessible from other machines or networks by specifying the listening address. Use `0.0.0.0` to listen on all available network interfaces.

```bash
loclx gui --address 0.0.0.0:54537
```

--------------------------------

### Install LocalXpose via npm

Source: https://localxpose.io/docs

Install the LocalXpose CLI globally using npm. This method is suitable for Node.js environments.

```bash
$ npm install -g loclx
```

--------------------------------

### Install Netdata with Docker

Source: https://localxpose.io/docs/tutorials/expose-localhost-netdata

Run the Netdata Docker image to set up the monitoring service. This command configures persistent storage and necessary host system access.

```bash
docker run -d --name=netdata_localxpose \
  -p 19999:19999 \
  -v netdatalib:/var/lib/netdata \
  -v netdatacache:/var/cache/netdata \
  -v /etc/passwd:/host/etc/passwd:ro \
  -v /etc/group:/host/etc/group:ro \
  -v /proc:/host/proc:ro \
  -v /sys:/host/sys:ro \
  -v /etc/os-release:/host/etc/os-release:ro \
  --restart unless-stopped \
  --cap-add SYS_PTRACE \
  --security-opt apparmor=unconfined \
  netdata/netdata
```

--------------------------------

### Install kubectl on Linux

Source: https://localxpose.io/docs/tutorials/expose-localhost-kubernetes

Commands to download, make executable, and install the kubectl binary on a Linux system. This CLI tool is essential for interacting with your Kubernetes cluster.

```bash
# Download the kubectl binary
curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl

# Make the binary executable
chmod +x ./kubectl

# Move kubectl into $PATH
sudo mv ./kubectl /usr/bin/kubectl
```

--------------------------------

### Start LocalXpose Service

Source: https://localxpose.io/docs/tutorials/access-your-raspberry-pi-remotely

Manually start the LocalXpose service to begin tunneling traffic.

```bash
sudo systemctl start localxpose.service
```

--------------------------------

### Enable LocalXpose Service on Boot

Source: https://localxpose.io/docs/tutorials/access-your-raspberry-pi-remotely

Configure the LocalXpose service to start automatically when the Raspberry Pi boots up.

```bash
sudo systemctl enable localxpose.service
```

--------------------------------

### Install LocalXpose Service

Source: https://localxpose.io/docs/cli

Installs the LocalXpose background service on your operating system, using a specified configuration file. This creates a service named 'localxpose'.

```bash
loclx service install --config /path/to/config.yaml
```

--------------------------------

### Check PostgreSQL Installation Version

Source: https://localxpose.io/docs/tutorials/expose-localhost-database-server

Verifies that PostgreSQL has been installed correctly by checking its version.

```bash
$ psql --version
```

--------------------------------

### Start TLS Tunnel with Generated Certificate

Source: https://localxpose.io/docs/tutorials/make-lets-encrypt-certificate

Once a certificate is generated, use this command to start a TLS tunnel. Ensure the certificate and key file paths are correct.

```bash
loclx tunnel tls \
    --reserved-domain yourdomain.example.com \
    --crt ~/.localxpose/yourdomain.example.com-cert.pem \
    --key ~/.localxpose/yourdomain.example.com-key.pem \
    --to localhost:443
```

--------------------------------

### Start HTTP Tunnel with LocalXpose

Source: https://localxpose.io/docs/tutorials/expose-local-web-server

Use this command to create an HTTP tunnel to your local web server. Replace `hello-world` with your desired subdomain and `127.0.0.1:8081` with your local server's address and port.

```bash
loclx tunnel http --to 127.0.0.1:8081 --subdomain hello-world
```

--------------------------------

### Run HTTP Tunnel with Plugins

Source: https://localxpose.io/docs/cli

Starts an HTTP tunnel with added functionalities like basic authentication and custom request headers.

```bash
loclx tunnel http --basic-auth user:pass --request-header role:internal
```

--------------------------------

### Start TLS Tunnel with Certificate

Source: https://localxpose.io/docs/tutorials/expose-apache-nginx-web-server

Establish a TLS tunnel where the LocalXpose client handles TLS termination. Provide paths to your certificate and key files.

```bash
loclx tunnel tls --to localhost:3000 --crt /path/to/crt.pem --key /path/to/key.pem
```

--------------------------------

### Sample LocalXpose YAML Configuration

Source: https://localxpose.io/docs/cli/config.yaml

An example of a LocalXpose YAML configuration file demonstrating various tunnel types, regions, ports, subdomains, and plugin configurations.

```yaml
dev:
  type: http
  region: us
  to: localhost:9090
 
ssh:
  type: tcp
  region: us
  port: 7676
  to: localhost:22
  plugins:
    ip_whitelist:
      - 127.0.0.1
 
portal:
  type: http
  subdomain: hello
  region: us
  to: localhost:8080
  plugins:
    basic_auth: user:pass
    ip_whitelist:
      - 127.0.0.1
      - 192.0.2.0/24
 
chat:
  type: tls
  subdomain: secure
  region: us
  to: localhost:2090
 
work:
  type: http
  region: us
  to: localhost:9090
  plugins:
    request_header:
      - host:mydomain.com
      - X-Token:secureToken
    response_header:
      - role:admin
 
file-server:
  type: http
  region: us
  reserved_domain: mydomain.com
  apps:
    file_server:
      path: ./

```

--------------------------------

### Start Kubernetes Proxy with Kubectl

Source: https://localxpose.io/docs/tutorials/expose-localhost-kubernetes

Start a local proxy server for your Kubernetes cluster using kubectl. This command exposes the API server to localhost on port 8001 and disables request filtering, which may pose a security risk.

```bash
kubectl proxy --address='0.0.0.0' --disable-filter=true
```

```text
[W0529 01:25:13.905234   23151 proxy.go:167] Request filter disabled, your proxy is vulnerable to XSRF attacks, please be cautious
Starting to serve on [::]:8001
```

--------------------------------

### Run WireGuard Server with Docker

Source: https://localxpose.io/docs/tutorials/access-local-wireguard-server

Starts the wg-easy WireGuard server container. Replace YOUR_ADMIN_PASSWORD_HASH with a secure hash generated using the provided command.

```bash
docker run -d \
  --name=wg-easy \
  -e LANG=en \
  -e WG_HOST=127.0.0.1 \
  -e PASSWORD_HASH=<🚨YOUR_ADMIN_PASSWORD_HASH> \
  -e PORT=51821 \
  -e WG_PORT=51820 \
  -v ~/.wg-easy:/etc/wireguard \
  -p 51820:51820/udp \
  -p 51821:51821/tcp \
  --cap-add=NET_ADMIN \
  --cap-add=SYS_MODULE \
  --sysctl="net.ipv4.conf.all.src_valid_mark=1" \
  --sysctl="net.ipv4.ip_forward=1" \
  --restart unless-stopped \
  ghcr.io/wg-easy/wg-easy
```

--------------------------------

### Launch Docker Compose Stack

Source: https://localxpose.io/docs/tutorials/use-localxpose-with-traefik

Export your LocalXpose access token as an environment variable and then start all services defined in the docker-compose.yml file in detached mode.

```bash
# Export your access token
export LX_ACCESS_TOKEN=your_token_here
 
# Start all services
docker compose up -d
```

--------------------------------

### Install PostgreSQL on Debian-based Linux

Source: https://localxpose.io/docs/tutorials/expose-localhost-database-server

Installs PostgreSQL version 12 using the apt package manager. Ensure you have the necessary permissions.

```bash
$ sudo apt install postgresql-12
# for debian based distros.
```

--------------------------------

### Create LocalXpose systemd Service File

Source: https://localxpose.io/docs/tutorials/access-your-raspberry-pi-remotely

Create a systemd unit file to manage the LocalXpose service. This allows it to run in the background and start on boot.

```bash
nano localxpose.service
```

```systemd
[Unit]
Description=localxpose
After=network-online.target

[Service]
ExecStart=/home/pi/loclx tunnel http --reserved-domain pi.xtestgo.xyz --to 8000
Restart=always
RestartSec=15

[Install]
WantedBy=multi-user.target
```

--------------------------------

### Start a tunnel with a reserved wildcard domain

Source: https://localxpose.io/docs/reservations/domain

Use this command to start an HTTP/S or TLS tunnel with a previously reserved wildcard domain. The domain can be the wildcard itself or any subdomain matching it.

```bash
loclx tunnel http --reserved-domain '*.example.com` # or 'anything.example.com`
```

--------------------------------

### Generate Let's Encrypt Certificate (Standard)

Source: https://localxpose.io/docs/tutorials/make-lets-encrypt-certificate

Use this command for standard installations to request a certificate from Let's Encrypt, complete the HTTP-01 challenge on port 54538, and save the certificate files.

```bash
loclx domain letsencrypt --domain yourdomain.example.com
```

--------------------------------

### Start LocalXpose Service

Source: https://localxpose.io/docs/cli

Starts the LocalXpose background service, which will then manage tunnels configured in the `config.yaml` file. To change tunnel settings, stop the service, modify the config file, and restart the service.

```bash
loclx service start
```

--------------------------------

### Start Multiple Tunnels with Config File

Source: https://localxpose.io/docs/cli/config.yaml

Launches multiple LocalXpose tunnels based on the configurations defined in a specified YAML file.

```bash
loclx tunnel config -f /path/to/config.yaml
```

--------------------------------

### Start Tunnel with Reserved Custom Domain

Source: https://localxpose.io/docs/tutorials/create-a-custom-domain-name

Initiate a tunnel using your reserved custom domain name to make your local service publicly accessible.

```bash
loclx tunnel http --reserved-domain www.xtestgo.xyz
```

--------------------------------

### Reload Systemd and Enable Service

Source: https://localxpose.io/docs/tutorials/access-localhost-keepass

After creating or modifying a systemd service file, reload the daemon and enable the service to start on boot.

```bash
sudo systemctl daemon-reload && sudo systemctl enable localxposessh.service
```

--------------------------------

### Start a LocalXpose File Server Tunnel

Source: https://localxpose.io/docs/tutorials/sharing-files-from-localhost

Use this command to create a tunnel for serving files from a local directory. Basic authentication is included for security. Access the shared files via the provided tunnel link.

```bash
loclx tunnel http --subdomain mypics --basic-auth user:pass --file-server /home/pics
```

--------------------------------

### Start TLS Tunnel without Client Termination

Source: https://localxpose.io/docs/tutorials/expose-apache-nginx-web-server

Configure your web server for TLS termination and start a TLS tunnel. The LocalXpose client will then forward traffic to your server's TLS port (typically 443).

```bash
loclx tunnel tls --to localhost:443
```

--------------------------------

### Start Basic HTTP Tunnel

Source: https://localxpose.io/docs/tunnels/http

Expose your local web server to the internet with a shareable URL. This command forwards traffic to localhost:8080.

```bash
loclx tunnel http
```

--------------------------------

### Start HTTP Tunnel to Localhost

Source: https://localxpose.io/docs/tutorials/expose-apache-nginx-web-server

Initiate an HTTP tunnel using the LocalXpose client to expose your local web server running on localhost:3000. A subdomain can be specified for easier access.

```bash
loclx tunnel http --subdomain apache --to localhost:3000
```

--------------------------------

### Deploy Nginx to Kubernetes

Source: https://localxpose.io/docs/tutorials/expose-localhost-kubernetes

Create a deployment for an Nginx web server within your Kubernetes cluster. This command pulls the Nginx image and starts a pod.

```bash
# Deploy the nginx image to our cluster:
kubectl create deployment nginx-server --image=nginx

# Get the status of the running nginx pods:
kubectl get pods
```

--------------------------------

### Run TCP Tunnel with Temporary Port

Source: https://localxpose.io/docs/cli

Starts a TCP tunnel in a specified region, allocating a temporary port for the connection.

```bash
loclx tunnel tcp --region eu --port 9999
```

--------------------------------

### Run HTTP Tunnel with Specific Subdomain and Region

Source: https://localxpose.io/docs/cli

Starts an HTTP tunnel using a specified subdomain and a particular geographical region.

```bash
loclx tunnel http --subdomain hello --region ap
```

--------------------------------

### Verify Netdata Container Status

Source: https://localxpose.io/docs/tutorials/expose-localhost-netdata

Check if the Netdata Docker container is running correctly after installation.

```bash
docker ps
CONTAINER ID        IMAGE               COMMAND              CREATED             STATUS              PORTS                      NAMES
83ef28036e03        netdata/netdata     "/usr/sbin/run.sh"   1 minutes ago      Up 1 minutes       0.0.0.0:19999->19999/tcp   netdata_localxpose
```

--------------------------------

### Docker Compose for persistent certificate setup

Source: https://localxpose.io/docs/cli/docker

Set up Docker Compose to persist Let's Encrypt certificates using a volume mount. This is critical to avoid Let's Encrypt rate limits, especially when restarting the container frequently.

```yaml
services:
  localxpose:
    image: localxpose/localxpose:latest
    volumes:
      # CRITICAL: Persist certificates to avoid rate limits
      - ./lx-data:/home/nonroot/.localxpose
    ports:
      - '54538:54538' # Required for Let's Encrypt HTTP-01
    environment:
      - LX_ACCESS_TOKEN
    command: >
      tunnel http 
      --reserved-domain yourdomain.loclx.net
      --to web-app:80
```

--------------------------------

### Start TCP Tunnel to Localhost Port

Source: https://localxpose.io/docs/tutorials/expose-apache-nginx-web-server

Create a TCP tunnel to expose a local service running on a specific port. This is useful for non-HTTP traffic or when HTTP middlewares are not needed.

```bash
loclx tunnel tcp --port 8888 --to 3000
```

--------------------------------

### Initialize Rasa Project

Source: https://localxpose.io/docs/tutorials/expose-localhost-rasa-chatbot

Use this command to set up a new Rasa project without interactive prompts.

```bash
$ rasa init --no-prompt
```

--------------------------------

### Check kubectl Version and Cluster Status

Source: https://localxpose.io/docs/tutorials/expose-localhost-kubernetes

Verify your kubectl installation and check the status of your local Kubernetes cluster nodes and pods. This confirms that your cluster is running correctly.

```bash
kubectl version --client
```

```bash
kubectl get nodes
```

```bash
kubectl get po -A
```

--------------------------------

### Get Kubernetes Dashboard URL with Minikube

Source: https://localxpose.io/docs/tutorials/expose-localhost-kubernetes

Retrieve the URL for accessing the Kubernetes Dashboard when using Minikube. This command also starts a proxy to make the dashboard accessible.

```bash
minikube dashboard --url=true
```

```text
🤔  Verifying dashboard health ...
🚀  Launching proxy ...
🤔  Verifying proxy health ...
http://127.0.0.1:36537/api/v1/namespaces/kubernetes-dashboard/services/http:kubernetes-dashboard:/proxy/
```

--------------------------------

### LocalXpose Settings Help

Source: https://localxpose.io/docs/cli

Displays help information for managing LocalXpose settings, including commands for setting up HTTP proxies and listing current settings.

```bash
loclx setting -h
```

--------------------------------

### LocalXpose Tunnel to Container Service

Source: https://localxpose.io/docs/cli/docker

Example docker-compose.yml snippet for a LocalXpose tunnel connecting to another service (e.g., 'webapp') within the same Docker network. This is a common setup for containerized applications.

```yaml
services:
  # Your application
  webapp:
    image: traefik/whoami # some app listening on port 80
 
  # LocalXpose tunnel - connects to webapp service
  tunnel:
    image: localxpose/localxpose:latest
    environment:
      - LX_ACCESS_TOKEN
    command: tunnel http --to webapp:80 # Use service name
```

--------------------------------

### Add a Custom Node.js Service to Traefik

Source: https://localxpose.io/docs/tutorials/use-localxpose-with-traefik

Example configuration for adding a custom Node.js application to the Docker Compose setup. It defines Traefik labels to route traffic for a specific subdomain to the Node.js service running on port 3000.

```yaml
myapp:
  image: node:18
  working_dir: /app
  volumes:
    - ./myapp:/app
  command: npm start
  labels:
    - 'traefik.enable=true'
    - 'traefik.http.routers.myapp.rule=Host(`app.example.com`)'
    - 'traefik.http.routers.myapp.entrypoints=web'
    - 'traefik.http.services.myapp.loadbalancer.server.port=3000'
```

--------------------------------

### Reserve a custom domain

Source: https://localxpose.io/docs/reservations/domain

Reserve a custom domain like `example.com`. This command requires the `--domain` flag and optionally accepts a `--region`. It returns a DNS record that must be added to your domain's DNS settings.

```bash
loclx domain reserve --domain example.com --region ap
```

--------------------------------

### Run LocalXpose with Configuration File

Source: https://localxpose.io/docs/cli/docker

Execute LocalXpose using a mounted configuration file. Ensure LX_ACCESS_TOKEN is provided as an environment variable.

```bash
# Mount and use config file
docker run -v $(pwd)/config.yaml:/config.yaml \
    -e LX_ACCESS_TOKEN \
    localxpose/localxpose:latest \
    tunnel config -f /config.yaml
```

--------------------------------

### Initialize LocalXpose Config File

Source: https://localxpose.io/docs/cli/config.yaml

Creates a sample YAML configuration file in the current directory. Modify this file to define your tunnel settings.

```bash
loclx tunnel config init
```

--------------------------------

### Multi-Stage Dockerfile with LocalXpose

Source: https://localxpose.io/docs/cli/docker

Build an application in a Go environment and then copy the compiled binary into a LocalXpose image for tunneling. This creates a lean runtime image.

```dockerfile
# Build stage
FROM golang:1.20 as builder
WORKDIR /app
COPY . .
RUN go build -o myapp

# Runtime with LocalXpose
FROM localxpose/localxpose:latest
COPY --from=builder /app/myapp /app/myapp
CMD ["/app/myapp"]
```

--------------------------------

### LocalXpose Account Command Help

Source: https://localxpose.io/docs/cli

Displays help information for the 'account' command, including available subcommands and options.

```bash
loclx account -h
```

--------------------------------

### LocalXpose Domain Command Help

Source: https://localxpose.io/docs/cli

Displays help information for the 'domain' command, outlining domain management operations.

```bash
loclx domain -h
```

--------------------------------

### Run LocalXpose Tunnel with Docker

Source: https://localxpose.io/docs/cli/docker

Export your access token and then run the LocalXpose Docker image, specifying the tunnel type and the service to expose. Replace YOUR_SERVICE:PORT with your actual service details.

```bash
# First, export your access token
export LX_ACCESS_TOKEN=your_token_here  # Get from https://localxpose.io/dashboard/access
 
# Then run LocalXpose, pointing to your service
docker run -it -e LX_ACCESS_TOKEN \
    localxpose/localxpose:latest tunnel http --to YOUR_SERVICE:PORT
```

--------------------------------

### Expose IP Camera with Basic Authentication

Source: https://localxpose.io/docs/tutorials/access-your-ip-camera-remotely

Expose your IP camera feed with basic authentication enabled. Replace '<user>' and '<password>' with your desired credentials.

```bash
loclx tunnel http --reserved-domain ipcamera.ap.loclx.io --to 192.168.1.249:8080 --basic-auth <user>:<password>
✓ Creating HTTP tunnel...

Tunneling http://ipcamera.ap.loclx.io --> 192.168.1.249:8080
Tunneling https://ipcamera.ap.loclx.io --> 192.168.1.249:8080
```

--------------------------------

### Get Nginx Service NodePort

Source: https://localxpose.io/docs/tutorials/expose-localhost-kubernetes

Retrieve the NodePort assigned to the Nginx service. This port is used to access the service from outside the cluster.

```bash
$kubectl get svc
```

```bash
kubectl get --namespace default -o jsonpath="{.spec.ports[0].nodePort}" services nginx-server
```

--------------------------------

### Generate Let's Encrypt Certificate (Docker)

Source: https://localxpose.io/docs/tutorials/make-lets-encrypt-certificate

For Docker users, this command mounts a volume for persistence and exposes the challenge port. It then runs LocalXpose to generate the certificate.

```bash
# Mount a volume for persistence and expose the challenge port
docker run -v $(pwd)/lx-data:/home/nonroot/.localxpose \
    -p 54538:54538 \
    -e LX_ACCESS_TOKEN \
    localxpose/localxpose:latest \
    domain letsencrypt --domain yourdomain.example.com
```

--------------------------------

### Connect to Host Services from Docker Desktop (Mac/Windows)

Source: https://localxpose.io/docs/troubleshoot/common-errors

Use `host.docker.internal` to expose host services to LocalXpose running inside a Docker container on Mac or Windows.

```bash
docker run -e LX_ACCESS_TOKEN \
    localxpose/localxpose:latest \
    tunnel http --to host.docker.internal:8080
```

--------------------------------

### List Generated SSL Certificate Files

Source: https://localxpose.io/docs/tutorials/expose-localhost-database-server

Lists the generated certificate and key files in the specified directory after obtaining them from Let's Encrypt.

```bash
$ ls $HOME/localxpose
psql.xtestgo.xyz-cert.pem  psql.xtestgo.xyz-key.pem
```

--------------------------------

### LocalXpose Endpoint Command Help

Source: https://localxpose.io/docs/cli

Displays help information for the 'endpoint' command, detailing endpoint reservation and management.

```bash
loclx endpoint -h
```

--------------------------------

### Create WireGuard Configuration Directory

Source: https://localxpose.io/docs/tutorials/access-local-wireguard-server

Creates a directory to store WireGuard configuration files. Ensure this path is accessible by Docker.

```bash
mkdir ~/.wg-easy
```

--------------------------------

### Connect to PostgreSQL using psql

Source: https://localxpose.io/docs/tutorials/expose-localhost-database-server

Connects to the PostgreSQL server using the psql command-line client. Requires specifying the username, hostname (your LocalXpose domain), and database name.

```bash
psql -U test -h psql.xtestgo.xyz test_db
```

--------------------------------

### Expose Local Folder with Basic Authentication

Source: https://localxpose.io/docs/tunnels/http/http-apps

This command exposes a local folder as an HTTP server and protects it with basic authentication. Provide the username and password for authentication.

```bash
loclx tunnel http --file-server /home/shared --basic-auth user:pass
```

--------------------------------

### Run LocalXpose GUI with External Access in Docker

Source: https://localxpose.io/docs/troubleshoot/common-errors

Configure the LocalXpose GUI to listen on all interfaces (0.0.0.0) instead of just localhost for external accessibility within a Docker container.

```bash
docker run -e LX_ACCESS_TOKEN \
    -e HTTP_LISTEN_ADDRESS=0.0.0.0:54537 \
    -p 54537:54537 \
    localxpose/localxpose:latest gui
```

--------------------------------

### Generate Let's Encrypt certificate with Docker

Source: https://localxpose.io/docs/cli/docker

Generate a Let's Encrypt certificate using `docker run`. Ensure the volume is mounted to persist the certificate and avoid hitting Let's Encrypt rate limits.

```bash
# Generate certificate (persisted via volume)
docker run -v $(pwd)/lx-data:/home/nonroot/.localxpose \
    -p 54538:54538 \
    -e LX_ACCESS_TOKEN \
    localxpose/localxpose:latest \
    domain letsencrypt --domain yourdomain.loclx.net
```

--------------------------------

### LocalXpose Tunnel to Host Service (Linux Docker Compose)

Source: https://localxpose.io/docs/cli/docker

Configure a LocalXpose tunnel in docker-compose.yml to connect to a service on the Linux host. This example shows two options: using `extra_hosts` to map `host.docker.internal` to the host's gateway IP, or using `network_mode: host` for direct access (less isolated).

```yaml
services:
  tunnel:
    image: localxpose/localxpose:latest
    environment:
      - LX_ACCESS_TOKEN
    # Option 1: Add host entry for Linux
    extra_hosts:
      - 'host.docker.internal:host-gateway' # or "host.docker.internal:172.17.0.1"
    command: tunnel http --to host.docker.internal:8080
 
    # Option 2: Use host network mode (simpler but less isolated)
    # network_mode: host
    # command: tunnel http --to localhost:8080
```

--------------------------------

### Expose Local Folder as HTTP Server

Source: https://localxpose.io/docs/tunnels/http/http-apps

Use this command to expose a local folder to the internet as an HTTP server. Specify the folder path for the file server.

```bash
# *nix based
loclx tunnel http --file-server /home/shared

# windows
loclx tunnel http --file-server C:\Users\ali\shared
```

--------------------------------

### Reserve a Subdomain with LocalXpose

Source: https://localxpose.io/docs/tutorials/expose-localhost-rasa-chatbot

Reserve a subdomain for your project using the LocalXpose CLI. This subdomain will be used for your bot's webhook.

```bash
loclx domain reserve --subdomain mybot
```

--------------------------------

### Create a Basic UDP Tunnel

Source: https://localxpose.io/docs/tunnels/udp

Use this command to create a simple UDP tunnel. No additional configuration is required.

```bash
loclx tunnel udp
```

--------------------------------

### Configure PostgreSQL SSL Settings

Source: https://localxpose.io/docs/tutorials/expose-localhost-database-server

Updates the PostgreSQL configuration file to enable SSL and specify the paths to the SSL certificate and key files. Adjust file paths as necessary.

```bash
$ sudo nano /etc/postgresql/12/main/postgresql.conf

# - SSL -
ssl = on
ssl_cert_file = '/root/localxpose/psql.xtestgo.xyz-cert.pem '
ssl_key_file = '/root/localxpose/localxpose/psql.xtestgo.xyz-key.pem'
ssl_prefer_server_ciphers = on
```

--------------------------------

### LocalXpose Tunnel Command Help

Source: https://localxpose.io/docs/cli

Displays help information for the 'tunnel' command, detailing tunnel types and options.

```bash
loclx tunnel -h
```

--------------------------------

### Run the Flask Application

Source: https://localxpose.io/docs/tutorials/testing-stripe-webhook

Command to execute the Python Flask webhook script.

```bash
python stripe_webhook.py
```

--------------------------------

### Copy Service File to System Directory

Source: https://localxpose.io/docs/tutorials/access-your-raspberry-pi-remotely

Copy the created service file to the systemd system directory to make it available for system management.

```bash
sudo cp localxpose.service /etc/systemd/system/
```

--------------------------------

### Set Access Token Environment Variable

Source: https://localxpose.io/docs/cli

How to set the ACCESS_TOKEN environment variable for authentication on *nix and Windows systems.

```bash
# *nix systems
export ACCESS_TOKEN=your_access_token 

# windows
set ACCESS_TOKEN=your_access_token
```

```bash
# then, all subsequent commands will be authenticated, for example:
loclx tunnel http
```

--------------------------------

### Verify CNAME Record Configuration

Source: https://localxpose.io/docs/tutorials/create-a-custom-domain-name

Use this command to check if your CNAME record has been successfully set up and propagated.

```bash
loclx domain status --domain www.xtestgo.xyz
```

--------------------------------

### Login to LocalXpose Account via CLI

Source: https://localxpose.io/docs

Log in to your LocalXpose account using the command-line interface. You will need your access token.

```bash
loclx account login
```

```bash
# or, on windows
loclx.exe account login
```

--------------------------------

### Download LocalXpose CLI

Source: https://localxpose.io/docs/tutorials/access-your-raspberry-pi-remotely

Download the LocalXpose Linux ARM binary. This command fetches the necessary executable for your Raspberry Pi.

```bash
wget https://api.localxpose.io/api/v2/downloads/loclx-linux-arm.zip
```

--------------------------------

### Activate WireGuard VPN Connection

Source: https://localxpose.io/docs/tutorials/access-local-wireguard-server

Use this command to bring up your WireGuard interface and establish the VPN connection.

```bash
wg-quick up wg0
```

--------------------------------

### Reserve a subdomain

Source: https://localxpose.io/docs/reservations/domain

Use this command to reserve a subdomain of the form `sub.loclx.io`. Specify the desired subdomain name. For other regions, use the `--region` flag.

```bash
loclx domain reserve --subdomain dev
```

--------------------------------

### Expose Netdata Port with LocalXpose

Source: https://localxpose.io/docs/tutorials/expose-localhost-netdata

Use the LocalXpose CLI to create an HTTP tunnel for Netdata's port, optionally setting up basic authentication.

```bash
loclx tunnel http --basic-auth user:pass --to :19999
```

--------------------------------

### Create a Basic TCP Tunnel

Source: https://localxpose.io/docs/tunnels/tcp

Use this command to create a simple TCP tunnel. No additional configuration is required.

```bash
loclx tunnel tcp
```

--------------------------------

### Obtain Let's Encrypt SSL Certificates with LocalXpose

Source: https://localxpose.io/docs/tutorials/expose-localhost-database-server

Uses LocalXpose's built-in Let's Encrypt integration to generate SSL certificates for your domain. Ensure no tunnel is active for the domain and port 54538 is free.

```bash
sudo loclx letsencrypt --domain psql.xtestgo.xyz
```

--------------------------------

### Run Apache/Nginx Web Server with Docker

Source: https://localxpose.io/docs/tutorials/expose-apache-nginx-web-server

Use Docker to run either Apache (httpd) or Nginx web server locally. This prepares your web server to be exposed.

```bash
docker run -p 3000:80 httpd
```

```bash
docker run -p 3000:80 nginx
```

--------------------------------

### Create a Let's Encrypt certificate for a custom domain

Source: https://localxpose.io/docs/reservations/domain

Generate a Let's Encrypt certificate for your reserved custom domain. Ensure no tunnel is using the domain and port 54538 is free. This is primarily for TLS tunnels; HTTP tunnels generate certificates automatically.

```bash
loclx domain letsencrypt --domain example.com
```

--------------------------------

### LocalXpose CLI Usage

Source: https://localxpose.io/docs/cli

Basic syntax for using the LocalXpose CLI on different operating systems.

```bash
# *nix systems
loclx <COMMAND> <SUBCOMMAND> <FLAG> 

# windows
loclx.exe <COMMAND> <SUBCOMMAND> <FLAG>
```

--------------------------------

### Mount volume for persistent data

Source: https://localxpose.io/docs/cli/docker

Mount a volume to `/home/nonroot/.localxpose` (or `/app/.localxpose` for older versions) to persist Let's Encrypt certificates, access tokens, and configuration files. The local directory name is arbitrary.

```bash
docker run -v $(pwd)/lx-data:/home/nonroot/.localxpose \
    localxpose/localxpose:latest
```

--------------------------------

### Check DNS configuration for a custom domain

Source: https://localxpose.io/docs/reservations/domain

Verify if your DNS settings are correctly configured for a reserved custom domain. The status may take time to update to 'verified' due to DNS propagation.

```bash
loclx domain status --domain example.com
```

--------------------------------

### Create UDP Tunnel with Custom Local Address and Port

Source: https://localxpose.io/docs/tunnels/udp

Forward the UDP tunnel to a specific local IP address and port. Ensure the target address is reachable.

```bash
loclx tunnel udp --port 4545 --to 192.168.10.3:6655
```

--------------------------------

### Find PostgreSQL Configuration File Path

Source: https://localxpose.io/docs/tutorials/expose-localhost-database-server

Retrieves the absolute path to the main PostgreSQL configuration file (`postgresql.conf`) for the current PostgreSQL instance.

```bash
$ sudo -u postgres psql -U postgres -c "SHOW config_file"
               config_file
-----------------------------------------
 /etc/postgresql/12/main/postgresql.conf
(1 row)
```

--------------------------------

### Expose Local Webhook with LocalXpose

Source: https://localxpose.io/docs/tutorials/testing-stripe-webhook

Uses the LocalXpose CLI to create an HTTP tunnel for the local webhook running on port 8080. Includes optional basic authentication.

```bash
loclx tunnel http  --basic-auth stripeuser:stripepwd
# also using in-built basic authentication feature (Optional)

```

--------------------------------

### Create a Simple Flask Webhook Receiver

Source: https://localxpose.io/docs/tutorials/testing-stripe-webhook

Sets up a basic Flask application to listen for POST requests on port 8080 and return a success message. Ideal for local testing.

```python
from flask import Flask, jsonify, request
app = Flask(__name__)

@app.route('/', methods=['POST'])      #You may add other route eg: '/webhook'
def webhook():
    data = request.get_json(silent=True)
    print(data)                        #Prints payload
    return jsonify('Yey! Success')     #Returns happy message

if __name__ == '__main__':
    app.run(port=8080)                 #Running on port 8080

```

--------------------------------

### LocalXpose Tunnel to Host Service (Docker Desktop)

Source: https://localxpose.io/docs/cli/docker

Run a LocalXpose tunnel from a Docker container to a service running on the host machine using the special `host.docker.internal` DNS name, which is available in Docker Desktop environments (Mac/Windows).

```bash
# Docker Desktop provides host.docker.internal
docker run -e LX_ACCESS_TOKEN \
    localxpose/localxpose:latest \
    tunnel http --to host.docker.internal:8080
```

--------------------------------

### Connect to Host Services from Docker on Linux

Source: https://localxpose.io/docs/troubleshoot/common-errors

Access host services from a Docker container on Linux by either using the host's IP address or running the container in host network mode.

```bash
# Option 1: Use host IP
HOST_IP=$(hostname -I | awk '{print $1}')
docker run -e LX_ACCESS_TOKEN \
    localxpose/localxpose:latest \
    tunnel http --to $HOST_IP:8080
```

```bash
# Option 2: Host network mode
   ```shell copy
   docker run --network host \
       -e LX_ACCESS_TOKEN \
       localxpose/localxpose:latest \
       tunnel http --to localhost:8080
```
```

--------------------------------

### Create Stripe CLI Forwarding Listener

Source: https://localxpose.io/docs/tutorials/testing-stripe-webhook

Sets up a Stripe CLI listener to forward webhook events to a specified URL, which can be a LocalXpose tunnel for testing.

```bash
stripe listen --forward-to https://stripeuser:stripepwd@hawlmbpb6j19.loclx.io
# Ideally you would want to setup a listner in server, but if you can't, you can
# forward using localxpose's url to forward webhook events like such.

```

--------------------------------

### Access wg-easy Docker Container

Source: https://localxpose.io/docs/tutorials/access-local-wireguard-server

Execute this command to enter the running wg-easy Docker container for debugging or inspection.

```bash
docker exec -it wg-easy /bin/bash
```

--------------------------------

### Log in to LocalXpose Account

Source: https://localxpose.io/docs/tutorials/access-local-wireguard-server

Logs into your LocalXpose account using your access token. Follow the prompts to complete the authentication.

```bash
loclx account login
```

--------------------------------

### Create LocalXpose SSH Systemd Service

Source: https://localxpose.io/docs/tutorials/access-localhost-keepass

Create a systemd unit file to manage the LocalXpose SSH tunnel service. This ensures it runs in the background and restarts automatically.

```bash
sudo nano /etc/systemd/system/localxposessh.service
```

```systemd
[Unit]
Description=LocalXpose Service to expose SSH port
After=network-online.target ssh.service

[Service]
ExecStart=/home/pi/loclx tunnel tcp --reserved-endpoint ap-1.loclx.io:2222 --to 22
Restart=always
RestartSec=15

[Install]
WantedBy=multi-user.target
```

--------------------------------

### Create TLS Tunnel for TLS-Wrapped Applications

Source: https://localxpose.io/docs/tunnels/tls

Use this command to create a TLS tunnel for applications that already handle TLS, such as FTPS or SMTPS. No certificate is needed as the application manages TLS.

```bash
loclx tunnel tls
```

--------------------------------

### Unzip LocalXpose Archive

Source: https://localxpose.io/docs/tutorials/access-your-raspberry-pi-remotely

Extract the downloaded LocalXpose zip file to make the executable available.

```bash
unzip loclx-linux-arm.zip
```

--------------------------------

### Restart PostgreSQL Server

Source: https://localxpose.io/docs/tutorials/expose-localhost-database-server

Restart the PostgreSQL server to apply configuration changes. Ensure you have the necessary permissions.

```bash
sudo systemctl restart postgresql
```

--------------------------------

### Create UDP Tunnel with Custom Port

Source: https://localxpose.io/docs/tunnels/udp

Specify a temporary custom port for your UDP tunnel. The port must be available.

```bash
loclx tunnel udp --port 4545
```

--------------------------------

### Create LocalXpose Tunnel

Source: https://localxpose.io/docs/tutorials/expose-pocketbase-backend

Create an HTTP tunnel using LocalXpose to expose your local PocketBase service to the internet. This command forwards traffic from a public URL to your local server.

```bash
loclx tunnel http --to localhost:8090
```

--------------------------------

### Run localxpose with TTY raw mode

Source: https://localxpose.io/docs/cli/docker

Use the `--raw-mode` or `-r` flag when running in Docker to resolve TTY issues in non-interactive containers. This ensures proper output handling.

```bash
command: tunnel -r http --to webapp:80
```

--------------------------------

### Reserve a Wildcard Domain with LocalXpose

Source: https://localxpose.io/docs/tutorials/use-localxpose-with-traefik

Reserve a wildcard domain to manage all subdomains for your LocalXpose tunnel. Ensure you add the required CNAME record to your DNS provider.

```bash
loclx domain reserve --domain '*.yourdomain.com'
```

--------------------------------

### Expose Minecraft Server Port with LocalXpose

Source: https://localxpose.io/docs/tutorials/exposing-localhost-minecraft-server

Use this command to expose your local Minecraft server's TCP port to the internet. Ensure you replace `42424` with your desired public port and `46629` with your Minecraft server's actual port. Choose a region closest to you for lower latency.

```bash
loclx tunnel tcp --port 42424 --region ap --to 127.0.0.1:46629
```

--------------------------------

### Create HTTP Tunnel for WireGuard Web Interface

Source: https://localxpose.io/docs/tutorials/access-local-wireguard-server

Creates an HTTP tunnel to access the WireGuard Easy web interface remotely. This allows remote access to the admin panel via the provided tunnel URL.

```bash
loclx tunnel http --to 127.0.0.1:51821
```

--------------------------------

### List Relations in PostgreSQL

Source: https://localxpose.io/docs/tutorials/expose-localhost-database-server

Displays a list of tables and views within the current PostgreSQL database.

```sql
test_db-# \dt
```

--------------------------------

### Prefix Request Path

Source: https://localxpose.io/docs/tunnels/http/http-plugins

Prepend a custom path to incoming request URLs before forwarding them to your localhost server.

```bash
loclx tunnel http --prefix-path /foo/bar
```

--------------------------------

### Create TLS Tunnel for TCP Applications

Source: https://localxpose.io/docs/tunnels/tls

Use this command to create a TLS tunnel for standard TCP applications. You must provide the TLS certificate and key for LocalXpose to terminate the TLS traffic.

```bash
loclx tunnel tls --crt /home/secure/tls.crt --key /home/secure/tls.key
```

--------------------------------

### LocalXpose Configuration File

Source: https://localxpose.io/docs/cli/docker

Define multiple tunnels using a YAML configuration file. This allows for flexible routing of different subdomains to various services.

```yaml
tunnels:
  web:
    type: http
    to: webapp:3000
    subdomain: myapp
 
  api:
    type: http
    to: api:8080
    subdomain: api-myapp
```

--------------------------------

### Reserve a Subdomain for IP Camera

Source: https://localxpose.io/docs/tutorials/access-your-ip-camera-remotely

Reserve a specific subdomain for your IP camera feed. Replace 'ipcamera' with your desired subdomain and 'ap' with your preferred region.

```bash
loclx domain reserve --subdomain ipcamera --region ap
```

```bash
loclx domain reserve --subdomain ipcamera --region ap
✓ Reserving a Domain...
subdomain is reserved -> ipcamera.ap.loclx.io
```

--------------------------------

### Docker Debug Commands

Source: https://localxpose.io/docs/cli/docker

A collection of Docker commands for debugging LocalXpose containers, including checking logs, environment variables, and file system contents.

```bash
# Check container logs
docker logs container_name

# Verify environment variables
docker exec container_name env | grep -E '(LX_ACCESS_TOKEN|HTTP_LISTEN)'

# Test connectivity from container
docker exec container_name wget -O- http://target:port

# Check certificate persistence
docker exec container_name ls -la /home/nonroot/.localxpose/
```

--------------------------------

### LocalXpose Tunnel Configuration Syntax

Source: https://localxpose.io/docs/cli/config.yaml

Details the syntax for defining various tunnel types (HTTP, TCP, TLS) and their associated configurations, including plugins like authentication, IP whitelisting, and header manipulation.

```yaml
dev: # give your tunnel a name so you can identify it later in the terminal
  type: http # tunnel type
  to: localhost:80 # the localhost service address
  region: us # region name to start a tunnel at, possible values (us, ap and eu)
  subdomain: hello # a temporary subdomain that your tunnel will be accessible at
  reserved_domain: hello.example.com # if you have a reserved subdomain or custom domain it should be here
  plugins: # the middlewares that you wanna use for this tunnel, read more here https://localxpose.io/docs/tunnels/http/http-middlewares
    https_redirect: true # redirect http requests to https
    basic_auth: user:pass # use basic authentication to access the tunnel
    ip_whitelist: 127.0.0.1,82.87.12.199 # only allow specific ip adresses to access
    request_header: # edit request headers before forwarding the traffic to your service
      - host:mydomain.com
      - X-Token:secureToken
    response_header: # edit response headers before forwarding the traffic to your service
      - role:admin
    prefix_path: /api # prefix the URL path before reaching your localhost service
    rate_limit: 20 # limit the incoming requests to 20/s
    key_auth: secure_toke # protect the tunnel with a key authentication
 
ssh:
  type: tcp
  to: localhost:22
  region: ap
  port: 2233 # temporary port number
  reserved_endpoint: us.loclx.io:2255 # if you have a reserved endpoint
 
  ftps:
    type: tls
    to: 21
    crt: /path/to/crt # path to your TLS certificate
    key: /path/to/key # path to your TLS key

```
Tokens:
Raw