Andreas/wekan
1
0
Fork 0
mirror of https://github.com/wekan/wekan.git synced 2026-03-11 16:12:34 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Reorganize docs.

Browse source
This commit is contained in:
Lauri Ojansivu 2024-06-27 13:07:52 +03:00
parent e0b9e80698
commit 0fb2f7fdd6
46 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

285
docs/Platforms/Propietary/Chromebook/Chromebook.md Normal file
View file

@ -0,0 +1,285 @@
## WARNING: PLEASE do not try on your Chromebook below info.
First, [download all your Google Account data as 4 GB .zip files](https://takeout.google.com/) and burn them to DVD or Blueray disks, where they can not be easily accidentally deleted.
Because this happened:
- Someone else had their Google Drive full.
- That someone else did not backup local data from Chromebook.
- Installing Linux etc did fill up Chromebook harddisk.
- Chromebook got stuck and messed up, and needed to be reinstalled.
- That someone else lost some data.
Below intructions only worked for xet7, because xet7 did have free disk space on Chromebook. There is **NO WARRANTY OF ANY KIND** for any of below info. If your Chomebook breaks, well, thank your backups, and have a nice day!
## Installing Wekan Snap to Chromebook
Installing to Asus Chromebook C223NA-GJ0007 11.6" laptop, that was cheapest available at local shop, did cost 199 euro.
It has:
- 4 GB RAM
- 32 GB eMMC disk
- Intel® Celeron® N3350 CPU
- Bluetooth
- webcam
- WLAN
- USB3
- 2 x USB-C, both work for charging (I have not tried data transfer yet)
- microSD slot
- package includes USB-C charger and USB mouse
- keys for fullscreen, switch apps, brighness, volume, those do not need any modifier keys like other laptops
- playing youtube videos fullscreen works very well
- speakers sound can be set to very loud if needed
- big enough keys, good keyboard layout
- small and lightweight laptop
- has Play Store Android apps and Linux apps that can work fullscreen
- I did not try yet replacing Chrome OS with full Linux https://galliumos.org that has some drivers Chromebook needs, but according to their [hardware compatibility](https://wiki.galliumos.org/Hardware_Compatibility) this model has Known issues: internal audio, suspend/resume, when using galliumos.
## 1) Install Linux Beta
At Chromebook settings, install Linux Beta. It will have Debian 10, that will be changed to Ubuntu 20.10 64bit.
## 2) Install Ubuntu Container
[Source](http://intertwingly.net/blog/2020/07/21/Ubuntu-20-04-on-Chromebook)
Start by entering the Chrome shell (crosh) by pressing CTRL+ALT+T, then enter the default termina VM:
```
vmc start termina
```
Delete the default penguin container that had Debian 10:
```
lxc stop penguin --force
lxc rm penguin
```
Create a new Ubuntu container named penguin:
```
lxc launch ubuntu:20.10 penguin
```
Enter the new container (as root):
```
lxc exec penguin -- bash
```
## 3) Import public keys
While Ubuntu 20.10 will install, various apt commands will fail due to an inability to verify GPG keys. This problem is not unique to Crostini, it is seen in other environments, like Raspberry Pis.
The fix is to import two public keys:
```
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 7638D0442B90D010
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 04EE7237B7D453EC
```
## 4) Update groups
```
groups ubuntu >update-groups
sed -i 'y/ /,/; s/ubuntu,:,ubuntu,/sudo usermod -aG /; s/$/ \$USER/' update-groups
killall -u ubuntu
userdel -r ubuntu # ignore warning about mail spool
sed -i '/^ubuntu/d' /etc/sudoers.d/90-cloud-init-users
```
## 5) Install Crostini packages
Prepare for installing Google's Crostini specific packages. First bring Ubuntu up to date:
```
apt update
apt upgrade -y
```
Now add the Crostini package repository to apt. This repository provides the Linux integration with Chrome OS (ignore RLIMIT_CORE warning):
```
echo "deb https://storage.googleapis.com/cros-packages stretch main" > /etc/apt/sources.list.d/cros.list
if [ -f /dev/.cros_milestone ]; then sudo sed -i "s?packages?packages/$(cat /dev/.cros_milestone)?" /etc/apt/sources.list.d/cros.list; fi
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 1397BC53640DB551
apt update
```
A work-around is needed for a cros-ui-config package installation conflict. First, install binutils to get the ar command:
```
apt install -y binutils
```
Then create the cros-ui-config work-around package:
```
apt download cros-ui-config # ignore any warning messages
ar x cros-ui-config_0.12_all.deb data.tar.gz
gunzip data.tar.gz
tar f data.tar --delete ./etc/gtk-3.0/settings.ini
gzip data.tar
ar r cros-ui-config_0.12_all.deb data.tar.gz
rm -rf data.tar.gz
```
Now install the Crostini packages and the "work-around" package, ignoring any warning messages. This will take awhile:
```
apt install -y cros-guest-tools ./cros-ui-config_0.12_all.deb
```
Delete the "work-around" package:
```
rm cros-ui-config_0.12_all.deb
```
Install the adwaita-icon-theme-full package. Without this package, GUI Linux apps may have a very small cursor:
```
apt install -y adwaita-icon-theme-full
```
Now, shut down the container:
```
shutdown -h now
```
Reboot Chrome OS and start the Terminal application from the launcher. If it fails to start the first time, try again and it should work.
Rebooting is by clicking desktop right bottom clock / Power icon. After Chromebook has shutdown, short press laptop power button to start Chromebook.
### 8) Optional, if you install some Snap GUI apps
These are from same [Source](http://intertwingly.net/blog/2020/07/21/Ubuntu-20-04-on-Chromebook)
but xet7 did not test them.
The fix is to copy the desktop and pixmap files to your .local environment:
```
mkdir -p ~/.local/share/pixmaps
cp /snap/code/current/snap/gui/com.visualstudio.code.png ~/.local/share/pixmaps
cp /snap/code/current/snap/gui/code.desktop ~/.local/share/applications
```
Finally, you will need to change three lines in the code.desktop file in your ~/.local directory.
First, you will need to change Exec=code to specify the full path, namely Exec=/snap/bin/code.
Next, in the two places where Icon= is defined, you will need to replace this with the path to the icon that you copied into your .local directory. In my case, the resulting lines look as follows:
Icon=/home/rubys/.local/share/pixmaps/com.visualstudio.code.png
Once these changes are made, you should be able to launch the application using the Launcher in the lower left hand corder of the screen, by clicking on the circle, entering code into the search box and then clicking on the Visual Studio Code icon. Once launched, the application will appear in the shelf at the bottom of the screen. Right clicking on this icon will give you the option to pin the application to the shelf.
It is still a beta, and the installation instructions (above) are still a bit daunting. More importantly, things that used to work can stop working at any time, like, for example, Ubuntu 18.04.
That being said, it is a full, no-compromise Ubuntu. I've developed and tested code using this setup. I even have installed my full development environment using Puppet.
The only glitch I do see is occasionally GUI applications don't receive keystrokes. This is generally fixed by switching focus to Chromebook application and then back again. Once the application is able to process keystrokes, it remains able to do so.
## 6) Install Wekan
At Ubuntu terminal:
```
sudo snap install wekan
```
#### a) Use Wekan locally
At Ubuntu terminal, type:
```
ip address
```
It shows container internal IP address. You can set it to use Wekan locally, for example:
```
sudo snap set wekan root-url='http://100.115.92.200'
sudo snap set wekan port='80'
```
Then Wekan works locally using Ubuntu webbrowser at http://100.115.92.200 , and you can open cards.
#### b) Use Wekan from other computers at LAN
Look at your Chromebook wifi settings `(i)`, what is your laptop IP address, and use it with below http address:
```
sudo snap set wekan root-url='http://192.168.0.2:2000'
sudo snap set wekan port='2000'
```
At Chromebook settings / Linux Beta / > / Port forwarding, forwart port `2000` with nickname like for example `wekan`. This does forward Chromebook port to inside Ubuntu 20.10 64bit LXC container where Wekan is running.
NOTE: Sometimes reboot stops port forwarding, then it needs to be enabled again at Chromebook settings.
But problem is, using that LAN IP address does not work from Chromebook's own browser like Chrome or Linux Firefox. So looking at that at the next option:
#### c) Use hosts file
At your Chromebook Ubuntu, edit hosts:
```
sudo nano /etc/hosts
```
There add:
```
127.0.0.1 localhost wekan
```
Then with Ubuntu webbrowser you can browse http://wekan:2000 .
At other LAN computer, edit hosts:
```
sudo nano /etc/hosts
```
There add:
```
192.168.0.2 wekan
```
Then you can browse http://wekan:2000 from LAN computers. But mobile phones like Android and iOS can not usually change those settings, and if you don't have a way to setup local network computer names, let's look at next option:
#### d) Use some subdomain
If you have some domain, you can set new record `wekan.example.com A 192.168.0.2` . That is internet wide, but resolves to your local IP address on your local network. Then on your LAN mobile phones you can browse to http://wekan.example.com:2000 .
At Chromebook Ubuntu:
```
sudo nano /etc/hosts
```
There add:
```
127.0.0.1 localhost wekan.example.com
```
So then you can browse to http://wekan.example.com:2000 from Chromebook Ubuntu Firefox, Chromebook Chrome, other LAN computers and mobile phones.
#### Mobile app icon
For iOS and Android, you can [create app PWA icon this way](PWA).
## 7) Optional: Change Linux desktop apps language and install Firefox
Here changing to Finnish:
```
sudo dpkg-reconfigure-locales
```
There add this language, and set is as default:
```
fi_FI.UTF8
```
And install Ubuntu 20.10 version Firefox and translation:
```
sudo apt install firefox firefox-locale-fi
```
Shutdown Ubuntu container:
```
sudo shutdown -h now
```
Reboot Chromebook by clicking desktop right bottom clock / Power icon. After Chromebook has shutdown, short press laptop power button to start Chromebook.
## 8) Optional: Install HP DeskJet 2600 multifunction printer/scanner
This inkjet printer was cheapest available, and does print excellent quality similar to laser color printer.
You should set your wireless network printer to have Static IP address.
[Source](https://chromeunboxed.com/how-to-use-your-hp-printer-with-linux-on-chrome-os/)
```
sudo apt install hplip hplip-gui cups system-config-printer
sudo xhost +
sudo hp-setup
```
Check:
```
[X] Network/Ethernet/Wireless newtork (direct connection or JetDirect)
```
Click:
```
> Show Advanced Options:
```
Check:
```
[X] Manual Discovery
IP Address or network name: [ YOUR-PRINTER-STATIC-IP-HERE, for example 192.168.0.200 ]
JetDirect port: [1]
```
Next, Next, Add Printer.
```
sudo system-config-printer
```
Set printer as Default.
You are also able to Scan images from your multifunction printer with XSane, that was installed with HP printer drivers.
You can print from Ubuntu Linux apps, like for example Firefox, LibreOffice, Inkscape, etc what you can install with apt.
## 9) Optional: Gimp
[Gimp PPA for Ubuntu 20.10 Groovy](https://launchpad.net/~ubuntuhandbook1/+archive/ubuntu/gimp). Note: Other versions of Gimp do not have all translations or do not create icons, like default Gimp from Ubuntu 20.10 repos and Snap.

186
docs/Platforms/Propietary/Cloud/AWS.md Normal file
View file

@ -0,0 +1,186 @@
[Scaling Meteor](https://medium.freecodecamp.org/scaling-meteor-a-year-on-26ee37588e4b)
## Production setup at AWS for thousands of users
* 3-4x m4.large for Node (ECS Cluster)
* 3x r4.large for Mongo (1 Primary for read and write, 2 replicas)
This setup runs very well for thousands of users.
To improve scalability even more, add [Redis Oplog support](https://github.com/cult-of-coders/redis-oplog), also see related [Redis Oplog discussion forum post](https://forums.meteor.com/t/meteor-scaling-redis-oplog-status-prod-ready/30855/479). At AWS you can use AWS ElastiCache that has Redis support.
### Mongo URL AND Oplog settings
From [comment at issue](https://github.com/wekan/wekan-mongodb/issues/2#issuecomment-378343587):
We've fixed our CPU usage problem today with an environment
change around Wekan. I wasn't aware during implementation
that if you're using more than 1 instance of Wekan
(or any MeteorJS based tool) you're supposed to set
MONGO_OPLOG_URL as an environment variable.
Without setting it, Meteor will perform a pull-and-diff
update of it's dataset. With it, Meteor will update from
the OPLOG. See here
https://blog.meteor.com/tuning-meteor-mongo-livedata-for-scalability-13fe9deb8908
After setting in [docker-compose.yml](https://github.com/wekan/wekan-mongodb/blob/master/docker-compose.yml):
```
MONGO_OPLOG_URL=mongodb://<username>:<password>@<mongoDbURL>/local?authSource=admin&replicaSet=rsWekan
```
the CPU usage for all Wekan instances dropped to an average
of less than 10% with only occasional spikes to high usage
(I guess when someone is doing a lot of work)
```
- MONGO_URL=mongodb://wekandb:27017/wekan
- MONGO_OPLOG_URL=mongodb://<username>:<password>@<mongoDbURL>/local?authSource=admin&replicaSet=rsWekan
```
If there is other ideas to improve scalability, add info to [existing scalability issue](https://github.com/wekan/wekan-mongodb/issues/2) or [scalability forum post](https://discourse.wekan.io/t/cpu-utilization-problems-with-large-userbase/579/15), there is also mentioned that smart-disconnect is already in Wekan.
For Enterprises using Wekan xet7 recommends participating in Wekan development, see [Benefits of contributing your features to Upstream Wekan](https://blog.wekan.team/2018/02/benefits-of-contributing-your-features-to-upstream-wekan/index.html), having your own developers working on Wekan daily, and using Commercial Support at https://wekan.team , as Wekan Team [already has access to high performance bare metal servers at CNCF / Packet for running high load testing](https://blog.wekan.team/2018/01/wekan-progress-on-x64-and-arm/index.html). With the benefits you get by using Wekan, it’s [time well spent](https://blog.wekan.team/2018/02/time-well-spent/index.html). Some [DTrace and eBPF info here](https://news.ycombinator.com/item?id=16375938).
## Single Server Install for small teams
1) Add AWS Security Group with for example name wekan, and incoming ports 80 and 443 for all. Only add ssh access to your own IP address CIDR like 123.123.123.123/32 so it means one IP address.
2) Start Ubuntu 17.10 64bit EC2 instance that has at least 2 GB RAM, 30 GB diskspace, probably you need more when you add more customers. Add your SSH public key to instance or let it create new.
3) Add new Elastic IP address pointing to your EC2 instance. That way IP address stays same, and you can also make snapshot of EC2 instance and start that as new EC2 instance with more RAM and change Elastic IP to point to new EC2 instance with minimal downtime, but prefer times when there is no active changes to Wekan.
4) Set your subdomain.yourdomain.com address DNS pointing to your Elastic IP address as A record in Route 53, Namecheap or elsewhere where your domain control panel is. It will take max 24h for DNS to propagate globally.
5) ssh to your server, for example:
```
ssh -i pubkey.pem ubuntu@server-ip-address
(or: root@)
```
6) Update all packages:
```
sudo apt update
sudo apt -y dist-upgrade
reboot
```
7) Install Docker CE and docker-compose for ubuntu from www.docker.com , also add user ubuntu to group docker in post-install step.
8) Install nginx, for example:
```
sudo apt install nginx
(or: nginx-full)
sudo systemctl start nginx
sudo systemctl enable nginx
```
[Example nginx config](Nginx-Webserver-Config)
Test nginx config with:
```
sudo nginx -t
```
And take config into use with:
```
sudo systemctl reload nginx
```
9) Install certbot from https://certbot.eff.org for Let's Encrypt SSL certs, redirect http to https
10) For different customers, you use different location /customer1 2 etc block and wekan running behind nginx proxy on different localhost port in same nginx virtualhost subdomain config file.
11) Get latest wekan release info from https://github.com/wekan/wekan/releases , read docker-compose.yml file from https://github.com/wekan/wekan-mongodb where all settings are explained, so you setup ROOT_URL=https://sub.yourdomain.com/customer1 and for example the 8080:80 for local server port 8080 to go inside docker port 80.
For example Wekan v0.70, use in docker-compose.yml file:
image: quay.io/wekan/wekan:v0.70
Only use release version tags, because latest tag can be broken sometimes.
12) For email, in AWS SES add email address to domain, verify SPF and DKIM with Route53 wizard if you have domain at Route53 as I recommend. At SES create new SMTP credentials and [add them to docker-compose.yml SMTP settings](Troubleshooting-Mail)
13) Start wekan and mongodb database containers with command:
```
docker-compose up -d
```
So it goes nginx SSL port 443 => proxy to localhost port 8080 or any other => wekan-app port 80 inside docker
14) For different customers have different docker-compose.yml script in directories named by customer names. You may need to rename docker containers from wekan-app to wekan-customer1 etc, and probably also docker internal network names.
15) [Backup, restore, and moving data outside/inside docker](Export-Docker-Mongo-Data)
16) Register as user at https://subdomain.yourdomain.com/customer1/sign-up and login at https://subdomain.yourdomain.com/customer1/sign-in , first user will be admin. Click your username at top right corner / Admin Panel, and there chang settings to invite only.
## Upgrading Wekan
1) Go to directory where docker-compose.yml is, as in install step 14) , and create directory for backup
```
cd wekan-customer1
mkdir backup-2018-02-03
cd backup-2018-02-03
```
2) Make backup of database outside docker in that backup directory, as in install step 15)
3) Edit docker-compose.yml to have new Wekan release number:
```
image: quay.io/wekan/wekan:v0.71
```
4) Restart Wekan:
```
docker-compose stop
docker-compose start
```
5) Login to Wekan and check at Admin Panel that Wekan version is updated.
6) If version is not updated, you could also need some of these:
Seeing what Docker containers are running:
```
docker ps
```
Seeing what Docker images are installed:
```
docker images
```
Stopping containers (or start, if starting containers)
```
docker stop wekan-app
docker stop CONTAINER-ID-HERE
```
Removing containers:
```
docker rm wekan-app
docker rm CONTAINER-ID-HERE
```
Removing images:
```
docker rmi quay.io/wekan/wekan:latest
docker rmi quay.io/wekan/wekan:v0.70
```
Starting new containers from docker-compose.yml file:
```
docker-compose up -d
```
TODO:
- allow resend invites https://github.com/wekan/wekan/issues/1320
- changing logo everywhere, whitelabeling https://github.com/wekan/wekan/issues/1196

180
docs/Platforms/Propietary/Cloud/Azure.md Normal file
View file

@ -0,0 +1,180 @@
### Install for example from:
- [Snap](Snap)
- [Docker](Docker)
*Make sure you are running at least **v2.21***
### Redirect URL
[About AZURE-NEW-APP-CLIENT-ID and AZURE-NEW-APP-SECRET](https://community.microfocus.com/t5/Identity-Manager-Tips/Creating-the-application-Client-ID-and-Client-Secret-from/ta-p/1776619). The redirect URL is your Wekan root-url+_oauth/oidc like this: https://boards.example.com/_oauth/oidc
<img src="https://wekan.github.io/azure-redirect.png" width="100%" alt="Wekan logo" />
AZURE_DIRECTORY_ID = TENANT-NAME-FOR-YOUR-ORGANIZATION
### If Azure Active Directory login does not work
Check that your CLIENT_SECRET = AZURE-NEW-APP-SECRET has not expired. If it has, delete old secret, and add new secret.
Add it like this, and also check that your Azure Directory ID is in server URL:
```
sudo snap set wekan oauth2-secret='AZURE-CLIENT-SECRET'
sudo snap set wekan oauth2-server-url='https://login.microsoftonline.com/AZURE_DIRECTORY_ID'
```
<img src="https://wekan.github.io/azure-app-client-secret.png" width="100%" alt="Azure App Client Secret" />
###
## Note: Mailjet is not available at Azure anymore
Instead, use O365 at upcoming Wekan v5.38 or newer.
### Mailjet: getaddrinfo ENOTFOUND
With Wekan Snap and Mailjet, if you get getaddrinfo ENOTFOUND error when you try to send a test email from within Wekan, it can be something with networking for the snap. Fix can be found in [Ubuntu DNS resolution issue affecting other snap packages](https://github.com/nextcloud/nextcloud-snap/issues/881). Thanks to [peterk for info](https://github.com/wekan/wekan/issues/3184#issuecomment-699669350).
### Mailjet: mail-from
When using sending email with Mailjet, set `mail-from` to some real email address so you get info if email bounces back.
### Snap settings
```
sudo snap set wekan debug='true'
sudo snap set wekan caddy-enabled='true'
sudo snap set wekan mail-from='Example Boards <BOARD-ADMIN@example.com>'
sudo snap set wekan mail-url='smtps://username:password@in-v3.mailjet.com:465/'
sudo snap set wekan oauth2-enabled='true'
sudo snap set wekan oauth2-request-permissions='openid'
sudo snap set wekan oauth2-client-id='AZURE-NEW-APP-CLIENT-ID'
sudo snap set wekan oauth2-secret='AZURE-NEW-APP-SECRET'
sudo snap set wekan oauth2-auth-endpoint='/oauth2/v2.0/authorize'
sudo snap set wekan oauth2-server-url='https://login.microsoftonline.com/AZURE_DIRECTORY_ID'
sudo snap set wekan oauth2-token-endpoint='/oauth2/v2.0/token'
sudo snap set wekan oauth2-userinfo-endpoint='https://graph.microsoft.com/oidc/userinfo'
sudo snap set wekan oauth2-email-map='email'
sudo snap set wekan oauth2-username-map='email'
sudo snap set wekan oauth2-fullname-map='name'
sudo snap set wekan oauth2-id-map='email'
sudo snap set wekan port='3001'
sudo snap set wekan richer-card-comment-editor='false'
sudo snap set wekan root-url='https://boards.example.com'
sudo snap set wekan with-api='true'
```
At Admin Panel / Settings / Email:
- SMTP Host: `in-v3.mailjet.com`
- SMTP Port: `465`
- Username: `MAILJET-USERNAME`
- Password: `MAILJET-PASSWORD`
- TLS Support: `[_]` (not checked)
If you use Caddy Let's Encrypt SSL for public server, that requires SSL cert validation from multiple not-listed IP addresses of Let's Encrypt, file `/var/snap/wekan/common/Caddyfile`
```
boards.example.com {
tls {
alpn http/1.1
}
proxy / localhost:3001 {
websocket
transparent
}
}
# If you have static main website in this directory, also add it:
example.com {
root /var/snap/wekan/common/example.com
tls {
alpn http/1.1
}
}
```
If you have private server that should be only accessible from private IP (limited by Azure firewall settings), and need SSL, you can not use Let's Encrypt free SSL that validates public availability from multiple non-disclosed IP addresses. For this purpose, you can get SSL certificate. Here is example of SSL cert from with SSL.com .
Join certificates together to .pem file, in order of:
1) privatekey of example.com
2) wildcard (or one subdomain cert) of example.com
3) sub ca
4) root ca
5) trusted network ca
```
cat example_com.key >> example.com.pem
cat STAR_example_com.crt >> example.com.pem
cat SSL_COM_RSA_SSL_SUBCA.crt >> example.com.pem
cat SSL_COM_ROOT_CERTIFICATION_AUTHORITY_RSA.crt >> example.com.pem
cat CERTUM_TRUSTED_NETWORK_CA.crt >> example.com.pem
```
Then transfer SSL cert to server:
```
scp example.com.pem ubuntu@example.com:/home/ubuntu
ssh ubuntu@example.com
sudo mkdir /var/snap/wekan/common/certs
sudo mv example.com.pem /var/snap/wekan/common/certs/
sudo chown root:root /var/snap/wekan/common/certs/example.com.pem
sudo chmod og-rwx /var/snap/wekan/common/certs/example.com.pem
sudo nano /var/snap/wekan/common/Caddyfile
```
At Caddyfile, add these settings for SSL cert:
```
# Static main website, if you have that, redirect to SSL
http://example.com {
redir https://example.com
}
# Wekan redirect to SSL
http://boards.example.com {
redir https://boards.example.com
}
# Static main website, if you have that in this directory
https://example.com {
root /var/snap/wekan/common/example.com
tls {
load /var/snap/wekan/common/certs
alpn http/1.1
}
}
# Wekan
https://boards.example.com {
tls {
load /var/snap/wekan/common/certs
alpn http/1.1
}
proxy / localhost:3001 {
websocket
transparent
}
}
```
Optionally you can would like to [disable all Snap automatic updates](https://github.com/wekan/wekan-snap/wiki/Automatic-update-schedule#if-required-you-can-disable-all-snap-updates) (not recommended, only required by some clients).
### There are two major steps for configuring Wekan to authenticate to Azure AD via OpenID Connect (OIDC)
Note: These old docs below don't have all settings listed that above new Snap settings have. Text case and _- is different, for example at Docker there is `OAUTH2_ENABLED=true` when at Snap same setting is `sudo snap set wekan oauth-enabled='true'`
1. Register the application with Azure. Make sure you capture the application ID as well as generate a secret key.
2. Configure the environment variables. This differs slightly by installation type, but make sure you have the following:
* OAUTH2_ENABLED = true
* OAUTH2_CLIENT_ID = xxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx (application GUID captured during app registration)
* OAUTH2_SECRET = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx (secret key generated during app registration)
* OAUTH2_SERVER_URL = https://login.microsoftonline.com/<tenant GUID specific to your organization>
* OAUTH2_AUTH_ENDPOINT = /oauth2/v2.0/authorize
* OAUTH2_USERINFO_ENDPOINT = https://graph.microsoft.com/oidc/userinfo
* OAUTH2_TOKEN_ENDPOINT = /oauth2/v2.0/token
* OAUTH2_ID_MAP = email (the claim name you want to map to the unique ID field)
* OAUTH2_USERNAME_MAP = email (the claim name you want to map to the username field)
* OAUTH2_FULLNAME_MAP = name (the claim name you want to map to the full name field)
* OAUTH2_EMAIL_MAP = email (the claim name you want to map to the email field)
I also recommend setting DEBUG = true until you have a working configuration. It helps.
You may also find it useful to look at the following configuration information:
https://login.microsoftonline.com/**the-tenant-name-for-your-organization**/v2.0/.well-known/openid-configuration
Some Azure links also at wiki page about moving from Sandstorm to Docker/Snap , and using Docker Swarm:
- https://github.com/wekan/wekan/wiki/Export-from-Wekan-Sandstorm-grain-.zip-file#azure-links

19
docs/Platforms/Propietary/Cloud/Cloudron.md Normal file
View file

@ -0,0 +1,19 @@
# Cloudron setup
Status:
- [Cloudron now uses upstream Wekan directly](https://github.com/wekan/wekan/issues/3035), so Cloudron users get all Wekan newest features and fixes
Cloudron is a complete solution for running apps on your server and keeping them up-to-date and secure.
1. First install Cloudron on your server with 3 simple commands - https://cloudron.io/get.html
2. Install Wekan from the Cloudron Store. Once installed, you will get automatic updates for Wekan as and when they get released.
[![Install](https://wekan.github.io/hosting/cloudron.svg)](https://cloudron.io/button.html?app=io.wekan.cloudronapp)
The source code for the package can be found [here](https://git.cloudron.io/cloudron/wekan-app/).
You can also test the wekan installation on the demo Cloudron instance - https://my.demo.cloudron.io (username: cloudron password: cloudron).
# Backup
[Backup Cloudron](Backup#Cloudron)

6
docs/Platforms/Propietary/Cloud/Dome.md Normal file
View file

@ -0,0 +1,6 @@
- Website: http://trydome.io
- Location: USA
- Free trial of WeKan Hosting at https://app.trydome.io/signup?package=wekan
- Paid SaaS hosting at propietary backend
- Hosted code examples at https://github.com/domeplatform
- Developer info at https://www.trydome.io/developer

14
docs/Platforms/Propietary/Cloud/Heroku.md Normal file
View file

@ -0,0 +1,14 @@
[![Deploy][heroku_button]][heroku_deploy]
[Heroku deployment quide needed](https://github.com/wekan/wekan/issues/693)
[Deploy error](https://github.com/wekan/wekan/issues/638)
[Problem with Heroku](https://github.com/wekan/wekan/issues/532)
Email to work on already working Heroku: Use 3rd party email like SendGrid, update process.env.MAIL_URL ,
change from email at Accounts.emailTeamplates.from , new file in server folder called smtp.js on code
`Meteor.startup(function () });` . TODO: Test and find a way to use API keys instead.
[heroku_button]: https://www.herokucdn.com/deploy/button.png
[heroku_deploy]: https://heroku.com/deploy?template=https://github.com/wekan/wekan/tree/devel

52
docs/Platforms/Propietary/Cloud/Metal.md Normal file
View file

@ -0,0 +1,52 @@
https://blog.wekan.team/2019/06/wekan-on-raspi3-and-arm64-server-now-works-and-whats-next-with-cncf/
https://github.com/cncf/cluster/issues/45
CNCF Packet is now part of Equinix Metal.
## Equinix Metal Console
https://console.equinix.com
## Ubuntu Reboot Fix
https://gist.github.com/vielmetti/dafb5128ef7535c218f6d963c5bc624e
```
sudo apt-get update
sudo apt-get install grub2-common
sudo grub-install --bootloader-id=ubuntu
```
Failure to reboot
If an affected system is rebooted, it might not come back online. Instead, the [serial over SSH](https://metal.equinix.com/developers/docs/resilience-recovery/serial-over-ssh/) or SOS console will show the system at the GRUB prompt.
To recover from this condition, log in to the SOS console, which will connect you to GRUB. Then issue the following command:
```
grub> configfile ($root)/EFI/GRUB/grub.cfg
```
The device will load the correct boot sequence and return to service.
## SSH SOS fix
https://osxdaily.com/2022/12/22/fix-ssh-not-working-macos-rsa-issue/
How to Fix SSH Not Working with RSA Signatures on MacOS Ventura
We’re going to modify the ssh_config file to allow for RSA host key again, here’s how to do this.
Open the Terminal (via Spotlight or through the Utilities folder) and enter the following command string:
```
sudo nano /etc/ssh/ssh_config
```
You’ll need to authenticate with the admin password.
Scroll all the way to the bottom of the ssh_config file and then add the following lines to the bottom of ssh_config:
```
HostkeyAlgorithms +ssh-rsa
PubkeyAcceptedAlgorithms +ssh-rsa
```
Hit Control+O to save, and Control+X to exit.

3
docs/Platforms/Propietary/Cloud/OVH.md Normal file
View file

@ -0,0 +1,3 @@
Currently only way is to get Wekan working at OVH is [install from source](Source).
OVH and Kimsufi servers have restricted OVH kernels, so you can't run Snap or Docker.

3
docs/Platforms/Propietary/Cloud/OpenVZ.md Normal file
View file

@ -0,0 +1,3 @@
Only [install from Source](Source) works.
OpenVZ does usually have 2.x kernel that would [support Snap](https://github.com/wekan/wekan-snap/issues/30) or [Docker](Docker).

3
docs/Platforms/Propietary/Cloud/PikaPods.md Normal file
View file

@ -0,0 +1,3 @@
Instantly run WeKan on [PikaPods.com](https://www.pikapods.com):
[![Run on PikaPods](https://wekan.github.io/hosting/pikapods.svg)](https://www.pikapods.com/pods?run=wekan)

4
docs/Platforms/Propietary/Cloud/Scalingo.md Normal file
View file

@ -0,0 +1,4 @@
[![Deploy to Scalingo][scalingo_button]][scalingo_deploy]
[scalingo_button]: https://cdn.scalingo.com/deploy/button.svg
[scalingo_deploy]: https://my.scalingo.com/deploy?source=https://github.com/wekan/wekan#master

175
docs/Platforms/Propietary/Cloud/Uberspace.md Normal file
View file

@ -0,0 +1,175 @@
# NEWEST:
[UberLab/Uberspace 7 Manual: Wekan](https://lab.uberspace.de/guide_wekan.html) - ([Source](https://github.com/wekan/wekan/issues/2009#issuecomment-817010524))
***
# OLD:
**NOTE**:
- [Newest Node/Mongo/Meteor versions](https://github.com/wekan/wekan/blob/main/Dockerfile).
- For x64 wekan-VERSION.zip is at https://releases.wekan.team and some related install info https://github.com/wekan/wekan/wiki/Raspberry-Pi
**Purpose**: Install latest Wekan release on [Uberspace](https://uberspace.de/) 6 and run as [daemontools](https://cr.yp.to/daemontools/faq/create.html) service in local userspace.
This script installs Wekan on a fresh Uberspace 6. It setup Node 4, MongoDB, a Port, installs Wekan and starts it as a service. It's tested with Wekan versions 0.32 and 0.63.
You have two Options to use it.
# Option 1:
You can run the commands of the following script step-by-step in the shell.
At first step set the SMTP-Password variable. Replace the `$1` with the password in that way `SMTP_PASS="smtp_password"` and continue line-by-line.
# Option 2:
Or you can run it automatically.
* Save it as script in file `install_wekan.sh`
* Make it executable `chmod +x install_wekan.sh`
* And run it. Pass the SMTP-Password as command line parameter `./install_wekan.sh smtp_password`.
## ./install_wekan.sh
```
#!/bin/sh
##
## Usage: ./install_wekan.sh SMTP-password
##
## Draft
## Install Wekan (v0.63) on Uberspace 6 by Noodle / Chris
##
## Sources:
## https://github.com/wekan/wekan/wiki/Install-and-Update#manual-installation-steps
## https://wiki.uberspace.de/database:mongodb
## https://wiki.uberspace.de/development:nodejs
## https://wiki.uberspace.de/system:daemontools
## https://github.com/wekan/wekan/issues/907
## Set SMTP password
# SMTP_PASS="xxxxxxxxxx"
SMTP_PASS="$1"
#####################
### Setup Node.js ###
#####################
cat <<__EOF__ > ~/.npmrc
prefix = $HOME
umask = 077
__EOF__
echo 'export PATH=/package/host/localhost/nodejs-4/bin:$PATH' >> ~/.bash_profile
source ~/.bash_profile
#####################
### Setup MongoDB ###
#####################
test -d ~/service || uberspace-setup-svscan
TEMPMDB="$(uberspace-setup-mongodb)"
MONGO_USER="${USER}_mongoadmin"
MONGO_PORT="$(echo ${TEMPMDB} | grep -E -o 'm#:\s[0-9]{5}\sUs' | cut -d' ' -f 2)"
MONGO_PASS="$(echo ${TEMPMDB} | grep -E -o 'rd:\s.+\sTo\sconn' | cut -d' ' -f 2)"
echo -e "MONGO_USER: ${MONGO_USER} \nMONGO_PORT: ${MONGO_PORT} \nMONGO_PASS: ${MONGO_PASS}"
############################
### Setup Websocket Port ###
############################
export FREE_PORT="$(uberspace-add-port --protocol tcp --firewall | grep -E -o '[0-9]{5}')"
echo "FREE_PORT: ${FREE_PORT}"
###################
### Setup Wekan ###
###################
## Issue #907 - Port must be speccified in root url, when Version > 0.10.1
MONGO_URL="mongodb://${MONGO_USER}:${MONGO_PASS}@127.0.0.1:${MONGO_PORT}/wekan?authSource=admin"
ROOT_URL="http://${USER}.${HOSTNAME}:${FREE_PORT}/"
MAIL_URL="smtp://${USER}:${SMTP_PASS}@${HOSTNAME}:587/"
MAIL_FROM="${USER}@${HOSTNAME}"
PORT="${FREE_PORT}"
echo -e "MONGO_URL: ${MONGO_URL} \nPORT: ${PORT} \nROOT_URL: ${ROOT_URL} \nMAIL_URL ${MAIL_URL} \nMAIL_FROM: ${MAIL_FROM}"
#####################
### Install Wekan ###
#####################
mkdir ~/wekan && cd ~/wekan
# Tested versions 0.32, 0.63
WEKAN_VERSION=0.63
curl -OL https://github.com/wekan/wekan/releases/download/v${WEKAN_VERSION}/wekan-${WEKAN_VERSION}.tar.gz && tar xzf wekan-${WEKAN_VERSION}.tar.gz && rm wekan-${WEKAN_VERSION}.tar.gz
cd ~/wekan/bundle/programs/server && npm install
cd ~
#####################
### Setup Service ###
#####################
cat <<__EOF__ > ~/etc/wekan-setup
#!/bin/bash
export MONGO_URL=${MONGO_URL}
export ROOT_URL=${ROOT_URL}
export MAIL_URL=${MAIL_URL}
export MAIL_FROM=${MAIL_FROM}
export PORT=${PORT}
__EOF__
cat <<__EOF__ > ~/etc/wekan-start
#!/bin/bash
source ~/etc/wekan-setup
exec node ~/wekan/bundle/main.js
__EOF__
chmod 700 ~/etc/wekan-setup
chmod a+x ~/etc/wekan-start
## Init & Start as servcie
uberspace-setup-service wekan ~/etc/wekan-start
## Setup & Start in bg for debugging
# source ~/etc/wekan-setup && node ~/wekan/bundle/main.js &
#####################
### Finish ###
#####################
echo -e "\n Login: ${ROOT_URL} \n\n"
```
# Control Wekan Service
Basic control of the Wekan service:
* Stop the service: `svc -d ~/service/wekan`
* Start the service: `svc -u ~/service/wekan`
* Keep an eye on the log while running the service: `tailf ~/service/wekan/log/main/current`
More about [daemontools](https://cr.yp.to/daemontools/faq/create.html).
# Uninstall Wekan
To remove Wekan from your uberspace you have to do the following steps.
* Stop and remove the service.
`uberspace-remove-service -s wekan`
* Remove the complete data.
```
mongo admin --port $MONGO_PORT -u $MONGO_USER -p $MONGO_PASS
use wekan
db.dropDatabase()
exit
```
* Remove the installation.
`rm -Rf ~/wekan/ ~/etc/wekan-*`

1
docs/Platforms/Propietary/Cloud/Vultr.md Normal file
View file

@ -0,0 +1 @@
https://www.vultr.com/docs/install-wekan-on-debian-10

143
docs/Platforms/Propietary/Mac/Mac.md Normal file
View file

@ -0,0 +1,143 @@
<img src="https://wekan.github.io/wekan-logo.svg" width="20%" alt="Wekan logo" />
<img src="https://wekan.github.io/donated/MacStadium-developerlogo.png" width="20%" alt="Powered by MacStadium" />
## ChangeLog
- Previously:
- Below info about Wekan on Mac x64
- [Wekan PWA on iOS Safari](PWA)
- Many mobile web fixes
- 2021-05-14 Wekan maintainer [xet7](https://github.com/xet7) got donated hardware [OpenSource MacStadium](https://www.macstadium.com/opensource) remote access to Mac Mini M1 that has 16 GB RAM and 1 TB SSD.
- 2021-05-15 xet7 bought Apple Developer access for 99 euro/year. Trying to figure out how to sign some test app for iPhone, did not get it working yet.
- 2021-05-16 Instructions added below by xet7 about how to run Wekan Server Node.js/MongoDB for development on M1.
- 2021-06-21 xet7 got iPhone 12 mini for testing prototypes locally. Some testing of coding tools on M1.
- 2022-02-12 [Enable drag handles on iPad landscape mode automatically](https://github.com/wekan/wekan/issues/3755).
- TODO:
- Trying to find out some way how to make macOS App Store and iOS iPhone/iPad App Store versions of Wekan.
## Docker: Easiest for install and use
1. Install Docker Desktop for Mac and start it. Then:
```
git clone https://github.com/wekan/wekan
cd wekan
```
2. Look what is your Mac IP address:
```
ifconfig | grep broadcast | grep 'inet ' | cut -d: -f2 | awk '{ print $2}' | cut -d '/' -f 1
```
3. Edit docker-compose.yml-arm64
```
nano docker-compose.yml-arm64
```
4. Change ROOT_URL to be your IP address, like http://192.168.0.100 :
https://github.com/wekan/wekan/blob/main/docker-compose.yml-arm64#L185
5. Save and exit: Cmd-o Enter Cmd-x.
6. Start WeKan:
```
docker-compose up -d -f docker-compose.yml-arm64
```
7. At same local network, use any webbrowser at any computer/smartphone/TV to browse to your WeKan IP address, like http://192.168.0.100
## Mac M1 Wekan development
Meteor includes Node.js and MongoDB version, when developing. But if not developing, those can be installed like below in Bundle section.
1) Install rosetta:
```
softwareupdate --install-rosetta --agree-to-license
```
2) Clone Wekan:
```
git clone https://github.com/wekan/wekan
cd wekan
```
3) Install Meteor etc
```
curl https://install.meteor.com/ | arch -x86_64 sh
arch -x86_64 meteor npm install --save @babel/runtime
```
3a) Run Meteor on localhost port 4000:
```
WRITABLE_PATH=.. WITH_API=true RICHER_CARD_COMMENT_EDITOR=false arch -x86_64 meteor --port 4000
```
3b) Run Meteor on computer IP address on local network port 4000:
```
WRITABLE_PATH=.. ROOT_URL=http://192.168.0.100:4000 PORT=4000 WITH_API=true RICHER_CARD_COMMENT_EDITOR=false arch -x86_64 meteor --port 4000
```
## Bundle for non-devepment use with start-wekan.sh
1. Download Node.js from https://github.com/wekan/node-v14-esm/releases/tag/v14.21.4 , and MongoDB 6.x from https://www.mongodb.com/try/download/community
2. Download wekan-VERSIONNUMBER.zip from https://releases.wekan.team
3. Unzip file you downloaded at step 2. There will be directory called `bundle`.
4. Download [start-wekan.sh script](https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.sh) to directory `bundle` and set it as executeable with `chmod +x start-wekan.sh`
5. Install Node.js version mentioned at https://wekan.github.io Download section
6. Install MongoDB version mentioned at https://wekan.github.io Download section [with Mac install info](https://docs.mongodb.com/manual/tutorial/install-mongodb-on-os-x/)
7. Edit `start-wekan.sh` so that it has for example:
```
export WRITABLE_PATH=..
export ROOT_URL=http://localhost:2000
export PORT=2000
export MONGO_URL=mongodb://127.0.0.1:27017/wekan
```
[More info about ROOT_URL](Settings)
8. Edit `start-wekan.sh` so that it starts in bundle directory command `node main.js`
## Build bundle from source and develop Wekan
1. Install XCode
2. [With steps 3-6 fork and clone your fork of Wekan](https://github.com/wekan/wekan-maintainer/wiki/Developing-Wekan-for-Sandstorm#3-fork-wekan-and-clone-your-fork)
## Docker
Note: With Docker, please don't use latest tag. Only use release tags. See https://github.com/wekan/wekan/issues/3874
- [Repair Docker](Repair-Docker)
- [Docker](Docker)
- [Docker Dev Environment](https://github.com/wekan/wekan-dev)
If you don't need to build Wekan, use prebuilt container with docker-compose.yml from https://github.com/wekan/wekan like this:
```
docker-compose up -d
```
If you like to build from source, clone Wekan repo:
```
git clone https://github.com/wekan/wekan
```
Then edit docker-compose.yml with [these lines uncommented](https://github.com/wekan/wekan/blob/main/docker-compose.yml#L132-L142) this way:
```
#-------------------------------------------------------------------------------------
# ==== BUILD wekan-app DOCKER CONTAINER FROM SOURCE, if you uncomment these ====
# ==== and use commands: docker-compose up -d --build
build:
context: .
dockerfile: Dockerfile
args:
- NODE_VERSION=${NODE_VERSION}
- METEOR_RELEASE=${METEOR_RELEASE}
- NPM_VERSION=${NPM_VERSION}
- ARCHITECTURE=${ARCHITECTURE}
- SRC_PATH=${SRC_PATH}
- METEOR_EDGE=${METEOR_EDGE}
- USE_EDGE=${USE_EDGE}
#-------------------------------------------------------------------------------------
```
Then you can build Wekan with
```
docker-compose up -d --build
```
## macOS Finder: Show hidden files
Q: Is there file manager, that shows all files and directories that are at directory? Or should I use mc at zsh? For example, if there is directory /Users/username/repos, it is not visible in Finder, until I move it to /Users/username/Downloads/repos
A: I just add my home directory to the list of favorites. You can also just go to any directory you want with CMD+Shift+G .
CMD+Shift+Period toggles hidden files on and off

8
docs/Platforms/Propietary/NAS/Qnap-NAS.md Normal file
View file

@ -0,0 +1,8 @@
## Qnap TS-469L
Related older info: https://github.com/wekan/wekan/issues/1180
Use wekan-VERSION.zip bundle from https://releases.wekan.team
with these instructions: https://github.com/wekan/wekan/wiki/Raspberry-Pi

103
docs/Platforms/Propietary/Windows/Install-Wekan-from-source-on-Windows.md Normal file
View file

@ -0,0 +1,103 @@
# Newest Windows info here
https://github.com/wekan/wekan/wiki/Offline
## OLD INFO BELOW, DOES NOT WORK
Also see: [Excel and VBA](Excel-and-VBA)
a) Lowest resource usage: [Windows Subsystem for Linux, build from source](https://github.com/wekan/wekan/issues/2066#issuecomment-468328001)
b) Docker for Windows, [prebuilt without --build option, or build from source](https://github.com/wekan/wekan-dev/issues/12#issuecomment-468657290)
***
### Source install required dependencies
Questions, comments to old closed issue about nexe https://github.com/wekan/wekan/issues/710
Beginnings of build and run scripts, please add PRs for additional fixes etc:
- https://github.com/wekan/wekan/blob/edge/rebuild-wekan.bat
- https://github.com/wekan/wekan/blob/edge/start-wekan.bat
Script for using MongoDB portable:
- https://github.com/wekan/wekan/issues/883#issuecomment-283755906
Requirements:
- Install [MeteorJS](https://www.meteor.com/)
- Install [NodeJS](https://nodejs.org/en/download/releases/) (Optional but recommended)
- Install Python 2.7 (Installation through Chocolatey(`choco install python2 -y`) is recomended)
- If you are on windows 7, Install .NET 4.5.1+
- **MUST MAKE SURE TO** Install [Visual C++ 2015 Build Tools](http://landinghub.visualstudio.com/visual-cpp-build-tools) or run this command from an elevated PowerShell or CMD.exe (run as Administrator) to install, `npm install --global --production windows-build-tools`
- Install Git
- Restart Windows (Optional but recommended)
From this point, it's advised to use **Git bash** to run commands to make sure everything works as is, but if you had trouble accessing meteor or npm commands via Git bash, windows CMD will most likely work without any problem.
Inside the Git Bash, run these commands:
```
npm config -g set msvs_version 2015
meteor npm config -g set msvs_version 2015
```
# Running Wekan
- Clone the repo (`https://github.com/wekan/wekan`)
- Browse the wekan directory and run `meteor`,
- If you see any error regarding **xss**, do `meteor npm i --save xss` to install xss.
- Set the Environment variables, or create a .env file with the following data.
- open your browser, make changes and see it reflecting real-time.
## Example of setting environment variables
You need to have start-wekan.bat textfile with that content of those environment variables.
In Windows, .bat files use DOS style of setting varibles.
Similar file for Linux bash is here:
https://github.com/wekan/wekan-maintainer/blob/master/virtualbox/start-wekan.sh
ROOT_URL examples are here:
https://github.com/wekan/wekan/releases
```
SET MONGO_URL=mongodb://127.0.0.1:27017/wekan
SET ROOT_URL=http://127.0.0.1/
SET MAIL_URL=smtp://user:pass@mailserver.example.com:25/
SET MAIL_FROM=admin@example.com
SET PORT=8081
```
## Example contents of `.env` file
```
MONGO_URL=mongodb://127.0.0.1:27017/wekan
ROOT_URL=http://127.0.0.1/
MAIL_URL=smtp://user:pass@mailserver.example.com:25/
MAIL_FROM=admin@example.com
PORT=8081
```
That URL format is: mongodb://ip-address-of-server:port/database-name
You can access MongoDB database with GUI like Robo 3T https://robomongo.org .
There is no username and password set by default.
## Overview,
Here is how it looks like,
```
git clone https://github.com/wekan/wekan
cd wekan
<SET ENV OR CREATE .env FILE>
meteor npm install --save xss
meteor
```
![](https://i.imgur.com/aNVBhj5.png)
# FAQ
### I am getting `node-gyp` related issues.
Make sure to install all required programs stated here, https://github.com/wekan/wekan/wiki/Install-Wekan-from-source-on-Windows#setup-required-dependencies
### I am getting `Error: Cannot find module 'fibers'` related problem.
Make sure to run the command `meteor` instead of `node`.

50
docs/Platforms/Propietary/Windows/Install-Windows.md Normal file
View file

@ -0,0 +1,50 @@
## 1. Get Windows 8/10/11 key, if there is no key sticker
1.1. Get USB stick (USB2 works better than USB3) that is 8 GB or a little bigger (not too big like 128 GB)
1.2. Download Rufus https://rufus.ie (or BalenaEtcher https://etcher.balena.io)
1.3. Download some live distro, for example:
- newest Linux Mint Mate https://linuxmint.com , .iso size about 4 GB
- UPupBB https://sourceforge.net/projects/zestypup/files/ , .iso size about 340 MB
- Puppy Linux https://puppylinux-woof-ce.github.io/ , .iso small download about 400 MB
1.4. With Rufus of BalenaEtcher, write .iso to USB stick
1.5. Boot from USB Linux Mint, usually after power on F8 key is boot menu, or F12
Windows 8 and Windows 10/11 OEM product key from BIOS when using Linux
```
sudo cat /sys/firmware/acpi/tables/MSDM | tail -1
```
## 2. Create bootable Windows Install USB stick
2.1. Download Rufus https://rufus.ie
2.2. Download Windows, big download
https://www.microsoft.com/software-download/windows11
https://www.microsoft.com/fi-fi/software-download/windows10ISO
2.3. If you are installing Windows to VirtualBox, newest VirtualBox has TPM 2.0 and Secure Boot emulation.
Win11 on VirtualBox may have some visual transparency bugs, that updates to VirtualBox
display drivers may fix later. Earlier OS shows correctly.
2.4. If you are installing Windows 11 to computer that does not support Windows 11
Try adding some Windows Registry keys:
https://blogs.oracle.com/virtualization/post/install-microsoft-windows-11-on-virtualbox
2.5. Boot from USB Instal Windows stick, usually after power on F8 key is boot menu, or F12
2.6. If using same license key at dual boot:
- Win11
- Ubuntu host, VirtualBox Win11 Guest
If some activation phone call asks in how many computers you use license at, answer 1.

179
docs/Platforms/Propietary/Windows/Offline.md Normal file
View file

@ -0,0 +1,179 @@
Also see: [Windows](Windows)
[Other CPU/OS On-Premise WeKan install](https://github.com/wekan/wekan/wiki/Raspberry-Pi)
## Wekan Windows 64bit version On-Premise
This is without container (without Docker or Snap).
Right click and download files 1-4:
1. [wekan-7.49-amd64-windows.zip](https://github.com/wekan/wekan/releases/download/v7.49/wekan-7.49-amd64-windows.zip)
2. [node.exe](https://nodejs.org/dist/latest-v14.x/win-x64/node.exe)
3. [mongodb-windows-x86_64-6.0.15-signed.msi](https://fastdl.mongodb.org/windows/mongodb-windows-x86_64-6.0.15-signed.msi)
4. [start-wekan.bat](https://raw.githubusercontent.com/wekan/wekan/main/start-wekan.bat)
5. Copy files from steps 1-4 with USB stick or DVD to offline Windows computer
6. Double click `mongodb-windows-x86_64-6.0.15-signed.msi` . In installer, uncheck downloading MongoDB compass.
7. Unzip `wekan-7.49-amd64-windows.zip` , inside it is directory `bundle`, to it copy other files:
```
bundle (directory)
|_ start-wekan.bat (downloaded file)
|_ node.exe (downloaded file)
|_ main.js (extracted file)
```
8. Edit `start-wekan.bat` with Notepad. There add [Windows computer IP address](https://support.microsoft.com/en-us/windows/find-your-ip-address-in-windows-f21a9bbc-c582-55cd-35e0-73431160a1b9) , like this, then Wekan will be at http://IP-ADDRESS-HERE/sign-in , for example http://192.168.0.100/sign-in but your different IP address. Add there wekan server computer IP address, not localhost. `node.exe main.js` is at bottom of `start-wekan.bat`, change there longer filename:
```
SET ROOT_URL=http://IP-ADDRESS-HERE
SET PORT=80
node.exe main.js
```
If there is already some webserver at port 80, change to other port:
```
REM # Writable path required to exist and be writable for attachments to migrate and work correctly
SET WRITABLE_PATH=..
SET ROOT_URL=http://IP-ADDRESS-HERE:2000
SET PORT=2000
```
Then Wekan will be at http://IP-ADDRESS-HERE:2000/sign-in , for example http://192.168.0.100/sign-in , but with your different IP address.
9. Double click `start-wekan.bat` to run it. Give permission to network. If it does not work, try instead with right click, Run as Administrator.
10. For mobile devices, you can [create PWA app icon](PWA) using that http://IP-ADDRESS-HERE:2000/sign-in
RELATED INFO:
- Windows 2022 server example https://github.com/wekan/wekan/issues/5084
- Other settings example https://github.com/wekan/wekan/issues/4932
## Docker WeKan Offline
At Internet connected computer, download:
1. Docker for Windows
2. docker-compose.yml from https://github.com/wekan/wekan
3. `docker-compose up -d` at Internet connected computer
4. Save wekan-app and wekan-db containers to files https://docs.docker.com/engine/reference/commandline/save/
At Offline Windows computer:
1. Install Docker for Windows
2. Load `wekan-app` container from file https://docs.docker.com/engine/reference/commandline/load/
3. Check what is ID of `wekan-app` container with `docker images`
4. Change at `docker-compose.yml` wekan-app contaier `image:gc....` to `image:ID` where ID from step 3 above
5. Do steps 2-4 also for `wekan-db` container
6. `docker-compose up -d`
## WeKan Updates
1. Updating only WeKan. Not updating Node.js and MongoDB.
1.1. Make backup, look at steps 2.1. and 2.2 below.
1.2. Download newest WeKan bundle .zip file from https://github.com/wekan/wekan/releases
1.3. Replace old bundle with new from that .zip file.
1.4. Start WeKan with `start-wekan.sh`
2. If it does not work, you maybe need to update Node.js and MongoDB.
2.1. Backup part 1/2. Try mongodump to backup database like this command. If mongodump command does not exist, download MongoDB Tools from https://www.mongodb.com/try/download/database-tools . Make backup:
```
mongodump
```
Backup will be is in directory `dump`. More info at https://github.com/wekan/wekan/wiki/Backup
2.2. Backup part 2/2. If there is files at `WRITABLE_PATH` directory mentioned at `start-wekan.bat` of https://github.com/wekan/wekan , also backup those. For example, if there is `WRITABLE_PATH=..`, it means previous directory. So when WeKan is started with `node main.js` in bundle directory, it may create in previous directory (where is bundle) directory `files`, where is subdirectories like `files\attachments`, `files\avatars` or similar.
2.3. Check required compatible version of Node.js from https://wekan.github.io `Install WeKan ® Server` section and Download that version node.exe for Windows 64bit from https://nodejs.org/dist/
2.4. Check required compatible version of MongoDB from https://wekan.github.io `Install WeKan ® Server` section and Download that version Windows MongoDB .msi installer from https://www.mongodb.com/try/download/community
2.5. Remove old Node.js and MongoDB (at Windows, Control Panel / Add Remove Programs).
2.6. Install newest Node.js and MongoDB.
2.7. Restore database with mongorestore, like this:
```
mongorestore --drop
```
If there are errors, try this instead:
```
mongorestore --drop --noIndexRestore
```
2.8. Start wekan with `start-wekan.bat`
2.9. If WeKan does not start with your old start-wekan.bat, download newest [start-wekan.bat](https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.bat) and look are there differences to your old start-wekan.bat . For example, with this command, could work on WSL or PowerShell or Linux or after installing git:
```
diff old-start-wekan.bat start-wekan.bat
```
## b) How to fix errors on Linux bundle to create Windows bundle
Download Linux bundle wekan-VERSION.zip from from https://github.com/wekan/wekan/releases or https://releases.wekan.team/
```
npm install -g node-pre-gyp
cd bundle\programs\server\npm\node_modules\meteor\accounts-password
npm remove bcrypt
npm install bcrypt
```
## c) WSL
[WSL](WSL)
## d) Wekan to VirtualBox Ubuntu offline
1. Install newest [VirtualBox](https://www.virtualbox.org/)
2. Install newest [Ubuntu 64bit](https://ubuntu.com) to VirtualBox
3. Install Wekan [Snap](https://github.com/wekan/wekan-snap/wiki/Install) version to Ubuntu with these commands:
```
sudo snap install wekan
```
4. Shutdown Ubuntu
5. At VirtualBox menu, export appliance to `wekan.ova` file
6. Copy `virtualbox-install.exe` and `wekan.ova` to offline computer
7. At offline computer, install virtualbox and import wekan.ova
8. Set virtualbox network to bridged:
https://github.com/wekan/wekan/wiki/virtual-appliance#how-to-use
9. Start VirtualBox and Ubuntu
10. In Ubuntu, type command:
```
ip address
```
=> it will show Ubuntu IP address
11. In Ubuntu Terminal, type with your IP address,
at below instead of 192.168.0.100:
```
sudo snap set wekan root-url='http://192.168.0.100'
sudo snap set wekan port='80'
```
12. Then at local network Wekan is at:
http://192.168.0.100

69
docs/Platforms/Propietary/Windows/WSL.md Normal file
View file

@ -0,0 +1,69 @@
https://learn.microsoft.com/en-us/windows/wsl/install
```
wsl --install
wsl --list --online
wsl --install -d Ubuntu-22.04
```
https://ubuntu.com/blog/ubuntu-wsl-enable-systemd
## If GitHub problems in WSL
If you have these problems in WSL:
```
~/repos/wekan$ git pull
ssh: Could not resolve hostname github.com: Name or service not known
fatal: Could not read from remote repository.
Please make sure you have the correct access rights
and the repository exists.
```
Then edit `/etc/wsl.conf`:
```
sudo nano /etc/wsl.conf
```
There have these:
```
[boot]
systemd=true
[network]
generateResolvConf = false
```
Then edit `/etc/resolf.conf`:
```
sudo nano /etc/resolv.conf
```
There have for example this, CloudFlare nameserver:
```
nameserver 1.1.1.1
```
Then edit Windows Internet network settings. There:
- Have only IPv4 enabled (not IPv6)
- DNS: 1.1.1.1 with HTTPS Automatic encryption settings.
## WeKan Snap amd64 on WSL2
1. At https://ubuntu.com/blog/ubuntu-wsl-enable-systemd read `How to enable systemd in Ubuntu WSL` to install WSL2 and SystemD.
2. `sudo snap install wekan --channel=latest/candidate`
3. Your Windows computer IP address, change there: `sudo snap set wekan root-url='http://192.168.0.200'`
4. Your Windows compoter webserver port: `sudo snap set wekan port='80'`
5. Use Chromium Edge (or Chromium/Firefox/Safari based browsers) to browse http://192.168.0.200 (your computer IP address there)
6. For mobile devices, make PWA icon like https://github.com/wekan/wekan/wiki/PWA
7. Optional: For SSL/TLS, look at Caddy/Apache/Nginx configs at https://github.com/wekan/wekan/wiki right menu, and https://github.com/wekan/wekan/wiki/Settings
## Related
- https://github.com/wekan/wekan/wiki/Offline
- https://ubuntu.com/blog/ubuntu-wsl-enable-systemd
- https://github.com/wekan/wekan-snap/wiki/Install
- https://github.com/wekan/wekan/wiki/Windows

262
docs/Platforms/Propietary/Windows/Windows.md Normal file
View file

@ -0,0 +1,262 @@
Use these instructions instead: [Offline](Offline)
***
Windows Updates:
1) WuMgr: Windows Update but Not Automatic
- https://github.com/DavidXanatos/wumgr
- https://news.ycombinator.com/item?id=34175466
2) Legacy Update
- https://legacyupdate.net
- https://news.ycombinator.com/item?id=34019900
3) Win7 Extended Security Updates Ending
- https://news.ycombinator.com/item?id=34307029
- How to create Win7.iso with all updates
- https://www.youtube.com/watch?v=l5ADP-VZMsw
- https://en.wikipedia.org/wiki/Windows_Update_MiniTool
4) Snappy Driver installer
- https://sdi-tool.org
***
## OLD BELOW: a) Bundle with Windows Node+MongoDB
This has **highest performance and lowest RAM usage**, because there is no virtualization like Docker, Windows Subsystem for Linux, etc. Wekan is run with Windows native version of Node.js and MongoDB, directly at Windows filesystem.
1. If you have important data in Wekan, do [backup](Backup).
2. Install newest Node.js LTS v12.x for Windows from https://nodejs.org . When installing, checkmark "Install additional tools" that will install also Chocolatey etc.
3. Run cmd.exe as Administrator, and there type:
```
choco install -y mongodb
```
4. Download and newest Wekan bundle wekan-x.xx.zip from https://releases.wekan.team
5. Unzip wekan-x.xx.zip, it has directory name `bundle`
6. Download [start-wekan.bat](https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.bat) to your bundle directory. Default settins are: `ROOT_URL=http://localhost` and `PORT=80`, so it works only in local [compatible browser](Browser-compatibility-matrix). You can edit [ROOT_URL](Settings) to be or `http://YOUR-IP-ADDRESS` so it works on local network with `http://YOUR-IP-ADDRESS` .
7. Start Wekan in cmd.exe as Administrator:
```
cd bundle
start-wekan.bat
```
8. Start MongoDB cmd.exe as Administrator:
```
net start mongodb
```
You can also stop MongoDB this way:
```
net stop mongodb
```
When you have MongoDB running, you can connect to database with nosqlbooster GUI, to localhost 27017.
You can create backup of MongoDB database with this mongodump command, that is similar to mysqldump:
```
"C:\Program Files\MongoDB\Server\4.2\bin\mongodump"
```
It will create subdirectory `dump` that contains backup. You can restore with:
```
"C:\Program Files\MongoDB\Server\4.2\bin\mongorestore"
```
You can connect to MongoDB CLI with this command:
```
"C:\Program Files\MongoDB\Server\4.2\bin\mongo"
```
There you can show databases. One MongoDB server can have many databases, similarly like MySQL server can have many databases created with MySQL `CREATE DATABASE` command:
```
show dbs
```
Then use Wekan database:
```
use wekan
```
List wekan database collections/tables:
```
show collections
```
Show content of users collection/table:
```
db.users.find()
```
Create new database:
```
use testing
```
Delete current database:
```
db.dropDatabase()
```
List databases again to show that database testing is not there anymore:
```
show dbs
```
Also see [Forgot Password](Forgot-Password)
Exit MongoDB CLI:
```
exit
```
You should not backup Windows MongoDB RAW database files that are here, when you in File Explorer folder properties show hidden system files and file extensions:
```
C:\ProgramData\MongoDB\data\db
```
[More info about MongoDB](Export-from-Wekan-Sandstorm-grain-.zip-file)
9. [Add users](Adding-users).
***
## b) [Docker](Docker)
Note: With Docker, please don't use latest tag. Only use release tags. See https://github.com/wekan/wekan/issues/3874
[Repair Docker](Repair-Docker)
If you don't need to build Wekan, use prebuilt container with docker-compose.yml from https://github.com/wekan/wekan like this:
```
docker-compose up -d
```
If you like to build from source, clone Wekan repo:
```
git clone https://github.com/wekan/wekan
```
Then edit docker-compose.yml with [these lines uncommented](https://github.com/wekan/wekan/blob/main/docker-compose.yml#L132-L142) this way:
```
#-------------------------------------------------------------------------------------
# ==== BUILD wekan-app DOCKER CONTAINER FROM SOURCE, if you uncomment these ====
# ==== and use commands: docker-compose up -d --build
build:
context: .
dockerfile: Dockerfile
args:
- NODE_VERSION=${NODE_VERSION}
- METEOR_RELEASE=${METEOR_RELEASE}
- NPM_VERSION=${NPM_VERSION}
- ARCHITECTURE=${ARCHITECTURE}
- SRC_PATH=${SRC_PATH}
- METEOR_EDGE=${METEOR_EDGE}
- USE_EDGE=${USE_EDGE}
#-------------------------------------------------------------------------------------
```
Then you can build Wekan with
```
docker-compose up -d --build
```
## c) Windows Subsystem for Linux on Windows 10
- [Install Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/wsl2-install) in PowerShell as Administrator `Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux` and reboot
- Install Ubuntu 18.04 from Windows Store
If you don't need to build from source, download newest wekan-VERSION.zip from https://releases.wekan.team and unzip it. Then:
```
sudo apt update
sudo apt install npm mongodb-server mongodb-clients
sudo npm -g install n
sudo n 12.16.1
sudo npm -g install npm
```
Then edit `start-wekan.sh` to start at correct port, ROOT_URL setting, and MONGO_URL to port 27017, cd to correct bundle directory where `node main.js` can be run, and then:
```
./start-wekan.sh
```
More info at https://github.com/wekan/wekan/wiki/Raspberry-Pi
- You could try to proxy from IIS SSL website to Wekan localhost port, for example when ROOT_URL=https://example.com and PORT=3001 , and you make IIS config that supports websockets proxy to Wekan http port 3001.
If you need to build from source, do as above, and build Wekan with `wekan/rebuild-wekan.sh`.
After building, if you like to start meteor faster by excluding some parts, have rebuilds after file change, and test on local network devices, try with your computer IP address:
```
WITH_API=true RICHER_CARD_COMMENT_EDITOR=false ROOT_URL=http://192.168.0.200:4000 meteor --exclude-archs web.browser.legacy,web.cordova --port 4000
```
## d) VirtualBox with Ubuntu 19.10 64bit
Install Ubuntu to VirtualBox and then Wekan, for example Wekan Snap.
Currently Snap works only when installed to Ubuntu 19.10 64bit running on VirtualBox VM.
https://github.com/wekan/wekan-snap/wiki/Install
[Related VM info how to expose port with bridged networking](Virtual-Appliance)
[UCS has prebuilt VirtualBox VM](Platforms#production-univention-platform-many-apps-and-wekan)
***
# BELOW: DOES NOT WORK
## e) Probaby does not work
[Install from source directly on Windows](Install-Wekan-from-source-on-Windows) to get Wekan running natively on Windows. [git clone on Windows has been fixed](https://github.com/wekan/wekan/issues/977). Related: [running standalone](https://github.com/wekan/wekan/issues/883) and [nexe](https://github.com/wekan/wekan/issues/710).
## f) Install Meteor on Windows - does not build correctly, gives errors
https://github.com/zodern/windows-meteor-installer/
```
REM Install Chocolatey from
REM https://chocolatey.org/install
REM in PowerShell as Administrator
Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
REM Install with cmd.exe or PowerShell as Administrator
REM - nodejs-lts, that is 12.x
REM - ndm, that is npm package manager for Windows
choco install -y nodejs-lts ndm git
REM Close and open cmd.exe or PowerShell as normal user.
REM Update npm:
npm -g install npm
REM Install meteor using https://github.com/zodern/windows-meteor-installer/
npm i -g @zodern/windows-meteor-installer
REM Close and open cmd.exe or PowerShell as normal user.
git clone https://github.com/wekan/wekan
cd wekan
REM a) For development, available at local network, at your computer IP address. Does rebuild when code changes.
SET WITH_API=true
SET RICHER_CARD_EDITOR=false
SET ROOT_URL=http://192.168.0.200:4000
meteorz --port 4000
REM b) For development, available only at http://localhost:4000 . Does rebuild when code changes.
SET WITH_API=true
SET RICHER_CARD_EDITOR=false
meteorz --port 4000
REM c) For production, after Wekan is built to "wekan/.build/bundle",
REM edit "start-wekan.bat" to "cd" to correct bundle directory to run "node main.js"
```
## g) Snap
[WSL](WSL)
## Related
[Linux stuff in Windows 10 part 1](https://cepa.io/2018/02/10/linuxizing-your-windows-pc-part1/) and [part 2](https://cepa.io/2018/02/20/linuxizing-your-windows-pc-part2/).