Portainer Templates logo

Portainer Templates

Flame Flame

Container

OtherTools

Flame is self-hosted startpage for your server. Its design is inspired (heavily) by SUI. Flame is very easy to setup and use. With built-in editors, it allows you to setup your very own application hub in no time - no file editing necessary.

Image details

Pulls: 10.8M
Architecture: amd64, arm64, arm/v7
Image size: 67 MB
Latest: 2.4.0
User: pawelmalak
Created: Jun 01, 2021
Updated: 3 months ago
Status: active

Source details

Stars: 7k
Forks: 348
Language: TypeScript
License: MIT
Updated: 1 month ago

Configuration

Type
Container
Platform
linux
Image
pawelmalak/flame:multiarch
Ports
5005:5005/tcp
Volumes
/app/data : /portainer/Files/AppData/Config/Flame/data/var/run/docker.sock : /var/run/docker.sock
Env vars
PASSWORD=
Restart
unless-stopped

Template by novaspirit

Notes

Template created by Pi-Hosted Series
Check our Github page: https://github.com/pi-hosted/pi-hosted

Official Webpage: https://github.com/pawelmalak/flame
Official Docker Documentation: https://github.com/pawelmalak/flame#with-docker-recommended


Standalone Install

Select an install method, to see config/commands for deploying Flame

Installation method

Install on Portainer

Import all app templates into your Portainer instance, for easy 1-click deploys

  1. Ensure both Docker and Portainer are installed, and up-to-date
  2. Log into your Portainer web UI
  3. Under Settings → App Templates, paste the below URL
  4. Head to Home → App Templates, and the list of apps will show up
  5. Select Flame, fill in any config options, and hit Deploy

Template Import URL

https://raw.githubusercontent.com/Lissy93/portainer-templates/main/templates.json
Show Me demo

More install options in our documentation, or see pawelmalak/flame for app-specific guidance.

Flame

Homescreen screenshot

Description

Flame is self-hosted startpage for your server. Its design is inspired (heavily) by SUI. Flame is very easy to setup and use. With built-in editors, it allows you to setup your very own application hub in no time - no file editing necessary.

Functionality

  • 📝 Create, update, delete your applications and bookmarks directly from the app using built-in GUI editors
  • 📌 Pin your favourite items to the homescreen for quick and easy access
  • 🔍 Integrated search bar with local filtering, 11 web search providers and ability to add your own
  • 🔑 Authentication system to protect your settings, apps and bookmarks
  • 🔨 Dozens of option to customize Flame interface to your needs, including support for custom CSS and 15 built-in color themes
  • ☀️ Weather widget with current temperature, cloud coverage and animated weather status
  • 🐳 Docker integration to automatically pick and add apps based on their labels

Installation

With Docker (recommended)

Docker Hub link
docker pull pawelmalak/flame

# for ARM architecture (e.g. RaspberryPi)
docker pull pawelmalak/flame:multiarch

# installing specific version
docker pull pawelmalak/flame:2.0.0

Deployment

# run container
docker run -p 5005:5005 -v /path/to/data:/app/data -e PASSWORD=flame_password flame

Building images

# build image for amd64 only
docker build -t flame -f .docker/Dockerfile .

# build multiarch image for amd64, armv7 and arm64
# building failed multiple times with 2GB memory usage limit so you might want to increase it
docker buildx build \
  --platform linux/arm/v7,linux/arm64,linux/amd64 \
  -f .docker/Dockerfile.multiarch \
  -t flame:multiarch .

Docker-Compose

version: '2.1'
services:
  flame:
    image: pawelmalak/flame:latest
    container_name: flame
    volumes:
      - <host_dir>:/app/data
      - /var/run/docker.sock:/var/run/docker.sock # optional but required for Docker integration feature
    ports:
      - 5005:5005
    environment:
      - PASSWORD=flame_password
    restart: unless-stopped

Skaffold

# use skaffold
skaffold dev

Without Docker

Follow instructions from wiki: Installation without Docker

Development

Technology

  • Backend
- Node.js + Express - Sequelize ORM + SQLite
  • Frontend
- React - Redux - TypeScript
  • Deployment
- Docker - Kubernetes

Creating dev environment

# clone repository
git clone https://github.com/pawelmalak/flame
cd flame

# run only once
npm run dev-init

# start backend and frontend development servers
npm run dev

Screenshots

Apps screenshot
Bookmarks screenshot
Settings screenshot
Themes screenshot

Usage

Authentication

Visit project wiki to read more about authentication

Search bar

Searching

The default search setting is to search through all your apps and bookmarks. If you want to search using specific search engine, you need to type your search query with selected prefix. For example, to search for "what is docker" using google search you would type: /g what is docker.
For list of supported search engines, shortcuts and more about searching functionality visit project wiki.

Setting up weather module

  1. Obtain API Key from Weather API.
> Free plan allows for 1M calls per month. Flame is making less then 3K API calls per month.
  1. Get lat/long for your location. You can get them from latlong.net.
  2. Enter and save data. Weather widget will now update and should be visible on Home page.

Docker integration

In order to use the Docker integration, each container must have the following labels:
labels:
  - flame.type=application # "app" works too
  - flame.name=My container
  - flame.url=https://example.com
  - flame.icon=icon-name # optional, default is "docker"
# - flame.icon=custom to make changes in app. ie: custom icon upload

"Use Docker API" option must be enabled for this to work. You can find it in Settings > Docker

You can also set up different apps in the same label adding ; between each one.
labels:
  - flame.type=application
  - flame.name=First App;Second App
  - flame.url=https://example1.com;https://example2.com
  - flame.icon=icon-name1;icon-name2

If you want to use a remote docker host follow this instructions in the host:
  • Open the file /lib/systemd/system/docker.service, search for ExecStart and edit the value

ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:${PORT} -H unix:///var/run/docker.sock

>The above command will bind the docker engine server to the Unix socket as well as TCP port of your choice. “0.0.0.0” means docker-engine accepts connections from all IP addresses.
  • Restart the daemon and Docker service

sudo systemctl daemon-reload
sudo service docker restart

  • Test if it is working

curl http://${IP}:${PORT}/version

Kubernetes integration

In order to use the Kubernetes integration, each ingress must have the following annotations:
metadata:
  annotations:
  - flame.pawelmalak/type=application # "app" works too
  - flame.pawelmalak/name=My container
  - flame.pawelmalak/url=https://example.com
  - flame.pawelmalak/icon=icon-name # optional, default is "kubernetes"

"Use Kubernetes Ingress API" option must be enabled for this to work. You can find it in Settings > Docker

Import HTML Bookmarks (Experimental)

  • Requirements
- python3 - pip packages: Pillow, beautifulsoup4
  • Backup your db.sqlite before running script!
  • Known Issues:
- generated icons are sometimes incorrect
pip3 install Pillow, beautifulsoup4

cd flame/.dev
python3 bookmarks_importer.py --bookmarks <path to bookmarks.html> --data <path to flame data folder>

Custom CSS and themes

See project wiki for Custom CSS and Custom theme with CSS.

Serve Flame on your own domain behind Caddy, Nginx or Traefik. Fill in your domain and copy the result. It's a starting point, some apps need their own base URL or extra headers set too.

Proxying flame.example.com to http://Flame:5005

Add this to your Caddyfile

flame.example.com {
	reverse_proxy http://Flame:5005
}

Check the logs first

Nine times out of ten the logs tell you exactly what went wrong.

  • In Portainer, go to Containers, click the container, then Logs. Or run docker logs Flame
  • Exit codes help too: 137 means killed, usually out of memory. 126 or 127 means the command inside the image is broken.

Port already in use

If deployment fails with "Bind for 0.0.0.0:5005 failed: port is already allocated", something else on your server is using that port.

  • Find what's using it: sudo ss -tlnp | grep :5005
  • Stop the other service, or pick a different host port. In 5005:5005 only the left number is yours to change, the right one belongs to the app.

Running but the page won't load

The container is up but nothing appears in your browser.

  • Use your server's real IP: http://your-server-ip:5005. The 0.0.0.0 link Portainer shows isn't a real address.
  • Give it a minute after first deploy, Flame can take a while to initialise.
  • Make sure your firewall allows the port, e.g. sudo ufw allow 5005

Permission denied on volumes

If the logs show "permission denied", the app can't write to its data folder on the host.

  • Fix the ownership: sudo chown -R 1000:1000 /portainer/Files/AppData/Config/Flame/data

Can't reach the Docker socket

Flame talks to Docker through /var/run/docker.sock. If the logs show "permission denied while trying to connect to the Docker daemon socket", the app's user can't access it.

  • Check the socket exists on the host: ls -l /var/run/docker.sock
  • Run the container as root, or add the docker group's id to the container with group_add.

Image won't pull

Test the pull directly on the host: docker pull pawelmalak/flame:multiarch

  • "manifest unknown" means the tag no longer exists.
  • "toomanyrequests" is the Docker Hub rate limit. Log in with docker login to raise it.
  • "no space left on device" means a full disk. Reclaim space with docker system prune

"exec format error"

This means the image was built for a different CPU architecture than your server.

  • This image supports: amd64, arm64, arm/v7
  • Check yours with uname -m: x86_64 is amd64, aarch64 is arm64. Raspberry Pi and other ARM boards are the usual culprits.

Container keeps restarting

The unless-stopped restart policy relaunches the app after every crash, so the real error can scroll past.

  • Check the logs right after a restart, the last few lines before it died are the useful ones.
  • Get the exit code with docker inspect Flame --format '{{.State.ExitCode}}'
  • Still stuck? Redeploy once with the restart policy set to no so the failure stays visible.

Required settings are blank

PASSWORD has no default value, and Flame may crash or misbehave if left empty.

  • Fill it in on the deploy screen before hitting deploy.

Raise an issue

Found something which isn't working as it should? Here's how to report it.

A single container

Flame runs as one container, the simplest kind of app here. Just the one image to pull and nothing else wired up alongside it.

The app image

An image is the app packed up ready to go, everything Flame needs bundled into one download. This template pulls pawelmalak/flame:multiarch, which Docker fetches once (about 67 MB) and then starts your own copy from.

Where the image comes from

Docker pulls its images from registries, public libraries of ready-built apps. Flame's comes from Docker Hub, published by pawelmalak.

Version tags

The bit after the colon in the image name is the version tag. This one pins multiarch, so every redeploy gives you that exact build until you bump it yourself.

Which machines it runs on

Every image is built for particular CPU types. This one ships for amd64, arm64, arm/v7, so it runs on both regular x86 servers and ARM boards like a Raspberry Pi.

Ports

A port is the door the app answers on. A mapping like 5005:5005 means it's reachable on port 5005 of your server, where the left number is yours to change and the right one belongs to the app. It opens:

  • 5005:5005

Volumes

A volume is where Flame keeps its files so they survive an update or a restart. Without one, anything it saves would sit inside the container and vanish the moment it's recreated. This template mounts:

  • /app/data from /portainer/Files/AppData/Config/Flame/data on the host
  • /var/run/docker.sock from /var/run/docker.sock on the host (a socket it talks to, not storage)

Environment variables

Environment variables are the settings you hand over when you deploy, things like a password or a timezone. Flame takes 1 of them, and one needs a value before it'll start properly:

  • PASSWORD, needs a value. Flame Password

Restart policy

The restart policy here is unless-stopped, so Docker restarts Flame after a crash or reboot, but leaves it off when you stop it on purpose. You can change this on the deploy screen. The choices are no (never restart), on-failure (only after a crash), unless-stopped (restart unless you stop it), and always (bring it back no matter what).

Networking

Nothing custom is set, so Flame sits on Docker's default bridge network: its own private space that reaches the outside world only through the ports it publishes.

Container name

Once it's deployed, Portainer names the container Flame. That's what you'll spot in the containers list and use in commands like docker logs Flame.

Platform

The platform is linux, the kind of system the container is built to run on. Docker and Portainer handle this on a normal Linux server.

Open source license

Flame is open source, released under the MIT license. In plain terms the code is out in the open, so you're free to run it and change it to fit what you need.

Portainer app templates

Zooming out, this whole page comes from a Portainer app template: a short recipe telling Portainer how to set Flame up. Add the template list to Portainer once, then deploying Flame is a click rather than a wall of config.