Cloudron Forum

Haha, yeah, it's true. In fact I did the initial packages of these Apps:

• it-tools (released)
• linkding (released)
• audiobookshelf (released)
• stirling-pdf (released)
• teddit (released)
• chatpad (not yet released)
• blocky (not yet released, very unpolished)
• fluffychat (not released, not announced)

But linkding was my trigger to start packaging for Cloudron and my first package I was working on. Glad to see the progress.

Thank you guys for all the appreciation of my work

And not to forget to mention, @girish and @vladimir-d are doing a lot of work after my initial packages. Kudos for their work

Hi there,

I didn't find anything like this in the App Wishlist so far. I tried it on my local Docker server and i really like the way it works. It would be handy to have this on Cloudron?

The GUI of the application (Firefox) is accessed through a modern web browser (no installation or configuration needed on the client side) or via any VNC client.

https://github.com/jlesage/docker-firefox

Hi,

In general, the number of cores and clock speed are both important factors to consider when evaluating the performance of a CPU.

A higher number of cores can improve multithreaded performance, as more tasks can be handled simultaneously. This can be particularly beneficial for server workloads that require parallel processing, such as hosting multiple websites and managing databases.

On the other hand, a higher clock speed on a CPU can be beneficial for tasks that require single-threaded performance, such as gaming or running single-threaded applications.

When comparing two CPUs, it's important to consider the specific workload or applications that will be running on the server. If the server workload includes tasks that can be parallelized effectively, then a CPU with more cores may provide better performance. However, if the workload is more focused on single-threaded performance, then a CPU with a higher clock speed may be more appropriate.

Regarding Cloudron, it is designed to be multi-threaded and should utilize multiple cores if available, but the specific degree of performance improvement with higher number of cores and lower frequency may vary depending on the specific workload of your Cloudron server.

Hi there,

I am working on packaging the IT-Tools App (Source: https://github.com/CorentinTh/it-tools ) to Cloudron.

It is a great Collection of handy online tools for developers, with great UX.

Best,
Michael

Application: Blocky
URL: https://github.com/0xERR0R/blocky

Blocky
Blocky is a DNS proxy and ad-blocker for the local network written in Go with following features:

Features
Blocking - Blocking of DNS queries with external lists (Ad-block, malware) and whitelisting

Definition of black and white lists per client group (Kids, Smart home devices, etc.)
Periodical reload of external black and white lists
Regex support
Blocking of request domain, response CNAME (deep CNAME inspection) and response IP addresses (against IP lists)
Advanced DNS configuration - not just an ad-blocker

Custom DNS resolution for certain domain names
Conditional forwarding to external DNS server
Upstream resolvers can be defined per client group
Performance - Improves speed and performance in your network

Customizable caching of DNS answers for queries -> improves DNS resolution speed and reduces amount of external DNS queries
Prefetching and caching of often used queries
Using multiple external resolver simultaneously
Low memory footprint
Various Protocols - Supports modern DNS protocols

DNS over UDP and TCP
DNS over HTTPS (aka DoH)
DNS over TLS (aka DoT)
Security and Privacy - Secure communication

Supports modern DNS extensions: DNSSEC, eDNS, ...
Free configurable blocking lists - no hidden filtering etc.
Provides DoH Endpoint
Uses random upstream resolvers from the configuration - increases your privacy through the distribution of your DNS traffic over multiple provider
Blocky does NOT collect any user data, telemetry, statistics etc.
Integration - various integration

Prometheus metrics
Prepared Grafana dashboards (Prometheus and database)
Logging of DNS queries per day / per client in CSV format or MySQL/MariaDB/PostgreSQL database - easy to analyze
Various REST API endpoints
CLI tool
Simple configuration - single or multiple configuration files in YAML format

Simple to maintain
Simple to backup
Simple installation/configuration - blocky was designed for simple installation

Stateless (no database, no temporary files)
Docker image with Multi-arch support
Single binary
Supports x86-64 and ARM architectures -> runs fine on Raspberry PI
Community supported Helm chart for k8s deployment

@robi Amazing piece of software! I created an initial package and it works great on my Cloudron. Tested with Macbook, iPhone and iPad.

The initial package can be found in the Git Repo

I think I will have a look to create a initial package for mumble - not sure if I can really make it!

Here is a nice directory of Self-Hosted Applications:
https://selfh.st/apps/

Hi there,

as suggested by @robi I tried together with him to find a way to make it easier to deploy a custom App to Cloudron.

As it becomes more complex now, I would like to start to share what we have.

The current idea is to use a surfer App instance to install the Cloudron CLI tool and use a config.yml to provision a custom App to an Cloudron Instance.

It is just shared to get more point of views and ideas from the Cloudron Community!
Here is the shell script that is already working, but still not complete and still in progress!

HOW-TO use this app installer for custom Cloudron Apps

• Create a surfer App instance in your Cloudron instance
• create a sub-folder with File Manager in the surfer app instance
• copy this script (app-installer.sh) to the new created sub-folder of the surfer instance (via File Manager)
• you may need to run dos2unix app-installer.sh
• you should check if you copy & paste the script, that no line breaks are breaking the code (have a look at long lines!)
• copy the CloudronManifest.json and favicon.png to the new created sub-folder
• go to terminal and execute the command: chmod +x app-installer.sh
• execute ./app-installer.sh
• it should create a config.yml file
• provide your details to the config.yml
• execute ./app-installer.sh again to deploy the custom app according to the configuration in config.yml

You will find the app-installer.sh script in Git Repo

A big thanks to @robi for supporting me during the creation of this!

UPDATE: I have updated the How-To and script

Okay, my initial package is done and pushed to my repo https://git.cloudron.io/kubernetes/cloudron-stirling-pdf

This version is without OCR features

@robi I will have a look, but it could take some time as I am a bit busy with other projects at the moment. Not an excuse, just making it transparent

10-second pitch: Redlib is a private front-end like Invidious but for Reddit. Browse the coldest takes of r/unpopularopinion without being tracked.

Fast: written in Rust for blazing-fast speeds and memory safety
️ Light: no JavaScript, no ads, no tracking, no bloat
Private: all requests are proxied through the server, including media
Secure: strong Content Security Policy prevents browser requests to Reddit

Source: https://github.com/redlib-org/redlib

Screenshot:

@scooke When you set up two-factor authentication (2FA) for a website using a specific authenticator app, such as Authy or Google Authenticator, the website generates a unique secret key that is shared securely between the website and the authenticator app. This secret key is used to generate the one-time codes that you enter when logging in.

If you are using a self-hosted 2FA solution on Cloudron, the website follows a similar process. When you set up 2FA with your self-hosted 2FA solution, the website provides you with a unique secret key that is used by your self-hosted 2FA solution to generate the one-time codes.

The website does not necessarily know which specific authenticator app or method you are using to generate the 2FA codes. Instead, it relies on the secret key that is securely shared between the website and your chosen 2FA method to verify the code you enter during the login process. As long as the code generated by your self-hosted 2FA solution matches the expected code based on the shared secret key, the website will authenticate you successfully.

In summary, the website identifies you based on the secret key provided during the 2FA setup process, regardless of the specific 2FA method or app you use to generate the codes.

Just a quick update, since I am using this since March.

I didn't had any issues with that kind of storage usage for the Docker during normal operations.

As I didn't have an situation with restore or bare metal recovery, I still don't have any experience for these use cases.

So far, I am pretty happy to offload the Docker Images to the Hetzner Volume.

I created a early package, it builds, but the App shows an 500 Error. If someone wants to take a look, you find it in this repo

I have it already running as a personal app on Cloudron. However I suggest to run it with Surfer App.

Drumroll

Here we go, I was able to create a basic initial package which works already on my Cloudron.

Remarks:

• If I access the PairDrop on my Cloudron from 2 devices, they do not see each other until I create a room for sharing
• Sharing between two devices did work fine (in a extra room)

Not sure if TURN configuration is required?

You will find the current state in my Repo

I have added the easy installation to the repo and the required steps in the Readme.

@eddowding Yes, this is right. OpenVPN is much more used like VPN was intended to be used for. Secure the network transport layer to your "network". So a common use case for using OpenVPN for private is that you can secure the access to internet when you don't trust the WiFi access you might have in a Hotel or at the Airport and so on...

I think this may give some ideas...

The cloudron/base Docker image is specifically designed for use in Cloudron, a platform for hosting and managing web applications. There are a few key reasons why this image is recommended as a base for Cloudron-based applications:

1. Security: The cloudron/base image is built with security best practices in mind. It includes hardened system configurations, minimal package installations, and regular security updates. This ensures that your application has a solid foundation with proper security measures.

2. Compatibility: Cloudron uses a specific runtime environment and configuration for running applications. The cloudron/base image is optimized to work seamlessly within this environment. Using other base images, such as Alpine, may lead to compatibility issues as they may lack the required dependencies or configurations.

3. Standardization: By using the cloudron/base image as a base, you ensure a consistent development and deployment experience across different Cloudron applications. It provides a set of standard tools, libraries, and configurations that are commonly used in Cloudron apps.

It's worth noting that the cloudron/base image is built on top of Ubuntu and includes commonly used web server components like Nginx and PHP. It also has additional features to handle the complexities of running web applications in a multi-tenant environment.