Author: Stefan

Key expired or missing – Ubuntu error
Thanks to: https://chrisjean.com/fix-apt-get-update-the-following-signatures-couldnt-be-verified-because-the-public-key-is-not-available/

Example error message in terminal at running apt-get:

[chris@server ~]$ sudo apt-get update Ign http://security.ubuntu.com trusty-security InRelease Get:1 http://security.ubuntu.com trusty-security Release.gpg [933 B] … Fetched 21.9 MB in 14s (1,537 kB/s) Reading package lists… Done W: GPG error: http://security.ubuntu.com trusty-security Release: The following signatures couldn’t be verified because the public key is not available: NO_PUBKEY 40976EAF437D05B5 NO_PUBKEY 3B4FE6ACC0B21F32 W: GPG error: http://archive.canonical.com trusty Release: The following signatures couldn’t be verified because the public key is not available: NO_PUBKEY 40976EAF437D05B5 NO_PUBKEY 3B4FE6ACC0B21F32 W: GPG error: http://archive.ubuntu.com trusty Release: The following signatures couldn’t be verified because the public key is not available: NO_PUBKEY 40976EAF437D05B5 NO_PUBKEY 3B4FE6ACC0B21F32 W: GPG error: http://archive.ubuntu.com trusty-updates Release: The following signatures couldn’t be verified because the public key is not available: NO_PUBKEY 40976EAF437D05B5 NO_PUBKEY 3B4FE6ACC0B21F32 [chris@server ~]$

Reading the text above, you can see for example that public key ‘3B4FE6ACC0B21F32’ can’t be found. This has to retrieved from a key server. We’re gonna fix this by running the following command:
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 3B4FE6ACC0B21F32
You’ll see that the key will be downloaded en registered. Problem solved!
Run the command apt-get upgrade again. The error message should be gone.
March 21, 2017
Raspberry RTL-SDR RX-Igate
With help from this manual you can make your own APRS Igate with a Raspberry Pi and RTL-SDR dongle.

If you find any incorrect information or you have additional info, please leave a comment!

Offcourse change some of the commands to your personal settings like Callsign, gain, correction factor etc.

Installation

Warning, don´t put the RTL-SDR in your Raspberry Pi yet. Wait till the installation is complete.

Raspbian
Install Raspian operation system to your Raspberry Pi. See: Installation manual
My advice is to let the system boot to termial in stead of the graphical user interface (GUI). This will keep as much as possibile processor power and memory free.

Update your Raspberry:
sudo apt-get update sudo apt-get upgrade sudo apt-get dist-upgrade sudo raspi-config mkdir ~/src
Prevent the default RTL-SDR drivers from being loaded automatically. Open the file raspi-blacklist.
sudo nano /etc/modprobe.d/raspi-blacklist.conf
Add the next lines to the file:
blacklist dvb_usb_rtl28xxu blacklist dvb_usb_v2 blacklist rtl_2830 blacklist rtl_2832 blacklist r820t
Reboot the Raspberry PI.
sudo reboot
Install driver for RTL-SDR dongle
cd ~/src sudo apt-get install git build-essential cmake libusb-1.0-0-dev git clone git://git.osmocom.org/rtl-sdr.git cd rtl-sdr mkdir build cd build cmake ../ -DDETACH_KERNEL_DRIVER=ON -DINSTALL_UDEV_RULES=ON make sudo make install sudo ldconfig
Connect RTL-SDR dongle to Raspberry Pi.

Install MultimonNG decoder
cd ~/src sudo apt-get install qt4-qmake qt4-default libpulse-dev libx11-dev patch pulseaudio git clone https://github.com/EliasOenal/multimonNG.git cd multimonNG mkdir build cd build qmake ../multimon-ng.pro make sudo make install
Install calibratie tool
cd ~/src sudo apt-get install libtool autoconf automake libfftw3-dev git clone https://github.com/asdil12/kalibrate-rtl.git cd kalibrate-rtl git checkout arm_memory ./bootstrap ./configure make sudo make install
Calibration example of a RTL-SDR dongle (write down PPM value for later)
kal -s GSM900 kal -c 36
(Channel 36 was strongest at my place. You may find another channel to be stronger)
Install APRS IGate software
cd ~/src sudo apt-get install python2.7 python-pkg-resources git clone https://github.com/asdil12/pymultimonaprs.git cd pymultimonaprs sudo python2 setup.py install
Make bootscript
sudo cp pymultimonaprs.init /etc/init.d/pymultimonaprs sudo chmod +x /etc/init.d/pymultimonaprs sudo update-rc.d pymultimonaprs defaults
Generate APRS-IS password for your callsign
(If you allready have a APRS password, you can use that offcourse.)
Change ‘CALLSIGN’ to your own callsign. Don´t add the SSID like CALLSIGN-10. That would give you another (wrong) key.
cd ~/src/pymultimonaprs ./keygen.py CALLSIGN Key for CALLSIGN: 12345
Change the configfile (Call, password, position, gain, ppm, etc.)
sudo nano /etc/pymultimonaprs.json
Test system
Start system to test funtionallity. (Ctrl+C for stop)
rtl_fm -f 144800000 -s 22050 -p 18 -g 42.0 - | multimon-ng -a AFSK1200 -A -t raw -
The -p 18 is correction in PPM, -g 42.0 is one of the possible gain factors. You have to make a choice from the following supported values:
Supported gain values (29): 0.0 0.9 1.4 2.7 3.7 7.7 8.7 12.5 14.4 15.7 16.6 19.7 20.7 22.9 25.4 28.0 29.7 32.8 33.8 36.4 37.2 38.6 40.2 42.1 43.4 43.9 44.5 48.0 49.6

Start Igate
Start pymultimonaprs
sudo /etc/init.d/pymultimonaprs start
Troubleshooting

USB_open error -3
See which USB number the RTL-SDR dongle has:
lsusb
Check by USB number if the group by RTL-SDR device is ‘input’. ls –lR /dev/bus/usb

For example: If RTL-SDR device is in (group) Bus 001 and Device 004:
cd /dev/bus/usb/001 sudo chgrp input 004
Source: https://yd0nxx.wordpress.com/2013/04/30/aprs-igate-using-raspberry-pi-board/
March 21, 2017

Valuable linux commands

docker volume ls -qf dangling=true | xargs -r docker volume rm

March 21, 2017

RF-V16 Config commands
Set master phone number
Password = 123456 (default)
Phonenumber = +31619xxxxxx (fill in complete number)
123456,sos1,0031619xxxxxx#
Return message:
0031619xxxxxx has been set for the master number sucessfully.
Set APN settings
for example Dutch provider Simyo.nl
APN = portalmmm.nl
Port = 5080
User = empty
Password = empty
apn,portalmmm.nl,user,,pd,,pport,5080#
Return message:
Apn set succesfully! Reboot system now ...
Optional commands

lag,1# — Change the language to 1=Chinese (default), 2=English, 3=Russian dsp# — Device status and work situation
gon# — Turn on the tracking function (factory default)
goff# — Turn off the tracking function
aj# — Set push to answer incoming call (fatory default)
mt# — Auto-answer handsfree incoming call
jy# — Silence monitoring
dw# — Check position
tim,10# — Setting interval of the position data upload (factory default is 10 mins)
lon# — Turn on indicator light (factory default)
loff# — Turn off indicator light
dndoff# — Turn off DO NOT DISTURB in push-to-talk mode (factory default)
dndon# — Turn on DO NOT DISTURB in push-to-talk mode

See also:
http://en.rf-gsm.com/uploads/soft/140407/RF-V16-Spec.pdf

Direct mirror
March 21, 2017
Docker commands -2-
Docker commands

Containers
Show running containers
```
docker ps
```
Show all containers
```
docker ps -a
```
Docker start container
```
docker start xxx
```
Docker stop container
```
docker stop xxx
```
Docker restart container
```
docker restart xxx
```
Docker remove container
```
docker rm xxx
```
Images
Show images
```
docker images
```
Remove images
```
docker rmi xxx
```
Volumes
List volumes
```
docker volume ls
```
Remove volume
```
docker volume rm xxx
```
Remove unused (dangling) volumes
```
docker volume ls -qf dangling=true | xargs -r docker volume rm
```
March 21, 2017
Docker installation
Docker is supported on these Ubuntu operating systems:
* Ubuntu Xenial 16.04 (LTS)
* Ubuntu Wily 15.10
* Ubuntu Trusty 14.04 (LTS)
* Ubuntu Precise 12.04 (LTS)

This page instructs you to install using Docker-managed release packages and installation mechanisms. Using these packages ensures you get the latest release of Docker. If you wish to install using Ubuntu-managed packages, consult your Ubuntu documentation.

* Note: Ubuntu Utopic 14.10 and 15.04 exist in Docker’s APT repository but are no longer officially supported.

Prerequisites
Docker requires a 64-bit installation regardless of your Ubuntu version. Additionally, your kernel must be 3.10 at minimum. The latest 3.10 minor version or a newer maintained version are also acceptable.

Kernels older than 3.10 lack some of the features required to run Docker containers. These older versions are known to have bugs which cause data loss and frequently panic under certain conditions.

To check your current kernel version, open a terminal and use uname -r to display your kernel version:
```
$ uname -r
3.11.0-15-generic
```
* Note: If you previously installed Docker using APT, make sure you update your APT sources to the new Docker repository.
Update your apt sources
Docker’s APT repository contains Docker 1.7.1 and higher. To set APT to use packages from the new repository:

1. Log into your machine as a user with sudo or root privileges.
2. Open a terminal window.
3. Update package information, ensure that APT works with the https method, and that CA certificates are installed.
$ sudo apt-get update
```
$ sudo apt-get install apt-transport-https ca-certificates
```
4. Add the new GPG key.
```
$ sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
```
5. Open the /etc/apt/sources.list.d/docker.list file in your favorite editor.
If the file doesn’t exist, create it.
Remove any existing entries.

Add an entry for your Ubuntu operating system.

The possible entries are:

On Ubuntu Precise 12.04 (LTS)
```
deb https://apt.dockerproject.org/repo ubuntu-precise main
```
On Ubuntu Trusty 14.04 (LTS)
```
deb https://apt.dockerproject.org/repo ubuntu-trusty main
```
Ubuntu Wily 15.10
```
deb https://apt.dockerproject.org/repo ubuntu-wily main
```
Ubuntu Xenial 16.04 (LTS)
```
deb https://apt.dockerproject.org/repo ubuntu-xenial main
```
* Note: Docker does not provide packages for all architectures. You can find nightly built binaries in https://master.dockerproject.org. To install docker on a multi-architecture system, add an [arch=…] clause to the entry. Refer to the Debian Multiarch wiki for details.
Save and close the /etc/apt/sources.list.d/docker.list file.
Update the APT package index.
```
$ sudo apt-get update
```
Purge the old repo if it exists.
```
$ sudo apt-get purge lxc-docker
```
Verify that APT is pulling from the right repository.
```
$ apt-cache policy docker-engine
```
From now on when you run apt-get upgrade, APT pulls from the new repository.
Prerequisites by Ubuntu Version
* Ubuntu Xenial 16.04 (LTS) * Ubuntu Wily 15.10 * Ubuntu Trusty 14.04 (LTS)

For Ubuntu Trusty, Wily, and Xenial, it’s recommended to install the linux-image-extra kernel package. The linux-image-extra package allows you use the aufs storage driver.

To install the linux-image-extra package for your kernel version:

1. Open a terminal on your Ubuntu host.

2. Update your package manager.
```
$ sudo apt-get update
```
3. Install the recommended package.
```
$ sudo apt-get install linux-image-extra-$(uname -r)
```
Go ahead and install Docker.

If you are installing on Ubuntu 14.04 or 12.04, apparmor is required. You can install it using:
```
apt-get install apparmor
```
Ubuntu Precise 12.04 (LTS)
For Ubuntu Precise, Docker requires the 3.13 kernel version. If your kernel version is older than 3.13, you must upgrade it. Refer to this table to see which packages are required for your environment:

linux-image-generic-lts-trusty Generic Linux kernel image. This kernel has AUFS built in. This is required to run Docker.
linux-headers-generic-lts-trusty Allows packages such as ZFS and VirtualBox guest additions which depend on them. If you didn’t install the headers for your existing kernel, then you can skip these headers for the”trusty” kernel. If you’re unsure, you should include this package for safety.
xserver-xorg-lts-trusty Optional in non-graphical environments without Unity/Xorg. Required when running Docker on machine with a graphical environment.

To learn more about the reasons for these packages, read the installation instructions for backported kernels, specifically the LTS Enablement Stack — refer to note 5 under each version.
libgl1-mesa-glx-lts-trusty

To upgrade your kernel and install the additional packages, do the following:
* Open a terminal on your Ubuntu host. * Update your package manager.
```
$ sudo apt-get update
```
Install both the required and optional packages.
```
$ sudo apt-get install linux-image-generic-lts-trusty
```
Depending on your environment, you may install more as described in the preceding table.

Reboot your host.
```
$ sudo reboot
```
After your system reboots, go ahead and install Docker.
Install
Make sure you have installed the prerequisites for your Ubuntu version.

Then, install Docker using the following:

Log into your Ubuntu installation as a user with sudo privileges.

Update your APT package index.
```
$ sudo apt-get update
```
Install Docker.
```
$ sudo apt-get install docker-engine
```
Start the docker daemon.
```
$ sudo service docker start
```
Verify docker is installed correctly.
```
$ sudo docker run hello-world
```
This command downloads a test image and runs it in a container. When the container runs, it prints an informational message. Then, it exits.
Optional configurations

This section contains optional procedures for configuring your Ubuntu to work better with Docker.
* Create a docker group
* Adjust memory and swap accounting
* Enable UFW forwarding
* Configure a DNS server for use by Docker
* Configure Docker to start on boot

Create a Docker group
The docker daemon binds to a Unix socket instead of a TCP port. By default that Unix socket is owned by the user root and other users can access it with sudo. For this reason, docker daemon always runs as the root user.

To avoid having to use sudo when you use the docker command, create a Unix group called docker and add users to it. When the docker daemon starts, it makes the ownership of the Unix socket read/writable by the docker group.

* Warning: The docker group is equivalent to the root user; For details on how this impacts security in your system, see Docker Daemon Attack Surface for details.

To create the docker group and add your user: 1. Log into Ubuntu as a user with sudo privileges.
2. This procedure assumes you log in as the ubuntu user. 3. Create the docker group.
```
$ sudo groupadd docker
```
Add your user to docker group.
```
$ sudo usermod -aG docker ubuntu
```
Log out and log back in.

This ensures your user is running with the correct permissions.

Verify your work by running docker without sudo.
```
$ docker run hello-world
```
If this fails with a message similar to this:
```
Cannot connect to the Docker daemon. Is 'docker daemon' running on this host?
```
Check that the DOCKER_HOST environment variable is not set for your shell. If it is, unset it.
Adjust memory and swap accounting
When users run Docker, they may see these messages when working with an image:

WARNING: Your kernel does not support cgroup swap limit. WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.

To prevent these messages, enable memory and swap accounting on your system. Enabling memory and swap accounting does induce both a memory overhead and a performance degradation even when Docker is not in use. The memory overhead is about 1% of the total available memory. The performance degradation is roughly 10%.

To enable memory and swap on system using GNU GRUB (GNU GRand Unified Bootloader), do the following:
1. Log into Ubuntu as a user with sudo privileges.
2. Edit the /etc/default/grub file.
3. Set the GRUB_CMDLINE_LINUX value as follows:
```
GRUB_CMDLINE_LINUX="cgroup_enable=memory swapaccount=1"
```
4. Save and close the file
5. Update GRUB.
```
$ sudo update-grub
```
6. Reboot your system.
```
$ sudo reboot now
```
Enable UFW forwarding
If you use UFW (Uncomplicated Firewall) on the same host as you run Docker, you’ll need to do additional configuration. Docker uses a bridge to manage container networking. By default, UFW drops all forwarding traffic. As a result, for Docker to run when UFW is enabled, you must set UFW’s forwarding policy appropriately.

Also, UFW’s default set of rules denies all incoming traffic. If you want to reach your containers from another host allow incoming connections on the Docker port. The Docker port defaults to 2376 if TLS is enabled or 2375 when it is not. If TLS is not enabled, communication is unencrypted. By default, Docker runs without TLS enabled.

To configure UFW and allow incoming connections on the Docker port:
1. Log into Ubuntu as a user with sudo privileges.
2. Verify that UFW is installed and enabled.
```
$ sudo ufw status
```
3. Open the /etc/default/ufw file for editing.
```
$ sudo nano /etc/default/ufw
```
4. Set the DEFAULT_FORWARD_POLICY policy to:
```
DEFAULT_FORWARD_POLICY="ACCEPT"
```
5. Save and close the file.
6. Reload UFW to use the new setting.
```
$ sudo ufw reload
```
7. Allow incoming connections on the Docker port.
```
$ sudo ufw allow 2375/tcp
```
Configure a DNS server for use by Docker
Systems that run Ubuntu or an Ubuntu derivative on the desktop typically use 127.0.0.1 as the default nameserver in /etc/resolv.conf file. The NetworkManager also sets up dnsmasq to use the real DNS servers of the connection and sets up nameserver 127.0.0.1 in /etc/resolv.conf.

When starting containers on desktop machines with these configurations, Docker users see this warning:

WARNING: Local (127.0.0.1) DNS resolver found in resolv.conf and containers can’t use it. Using default external servers : [8.8.8.8 8.8.4.4]

The warning occurs because Docker containers can’t use the local DNS nameserver. Instead, Docker defaults to using an external nameserver.

To avoid this warning, you can specify a DNS server for use by Docker containers. Or, you can disable dnsmasq in NetworkManager. Though, disabling dnsmasq might make DNS resolution slower on some networks.

The instructions below describe how to configure the Docker daemon running on Ubuntu 14.10 or below. Ubuntu 15.04 and above use systemd as the boot and service manager. Refer to control and configure Docker with systemd to configure a daemon controlled by systemd.

To specify a DNS server for use by Docker:
1. Log into Ubuntu as a user with sudo privileges.
2. Open the /etc/default/docker file for editing.
```
$ sudo nano /etc/default/docker
```
3. Add a setting for Docker.
```
DOCKER_OPTS="--dns 8.8.8.8"
```
Replace 8.8.8.8 with a local DNS server such as 192.168.1.1. You can also specify multiple DNS servers. Separated them with spaces, for example:
1. -dns 8.8.8.8 –dns 192.168.1.1
* Warning: If you’re doing this on a laptop which connects to various networks, make sure to choose a public DNS server.
Save and close the file.
Restart the Docker daemon.
```
$ sudo service docker restart
```
Or, as an alternative to the previous procedure, disable dnsmasq in NetworkManager (this might slow your network).
Open the /etc/NetworkManager/NetworkManager.conf file for editing.
```
$ sudo nano /etc/NetworkManager/NetworkManager.conf
```
Comment out the dns=dnsmasq line:
```
dns=dnsmasq
```
Save and close the file.

Restart both the NetworkManager and Docker.
```
$ sudo restart network-manager
$ sudo restart docker
```
Configure Docker to start on boot
Ubuntu uses systemd as its boot and service manager 15.04 onwards and upstart for versions 14.10 and below.

For 15.04 and up, to configure the docker daemon to start on boot, run
```
$ sudo systemctl enable docker
```
For 14.10 and below the above installation method automatically configures upstart to start the docker daemon on boot
Upgrade Docker
To install the latest version of Docker with apt-get:
```
$ sudo apt-get upgrade docker-engine
```
Uninstallation
To uninstall the Docker package:
```
$ sudo apt-get purge docker-engine
```
To uninstall the Docker package and dependencies that are no longer needed:
```
$ sudo apt-get autoremove --purge docker-engine
```
The above commands will not remove images, containers, volumes, or user created configuration files on your host. If you wish to delete all images, containers, and volumes run the following command:
```
$ rm -rf /var/lib/docker
```
You must delete the user created configuration files manually.
March 21, 2017

Install Domoticz in docker

Just run the following command!

docker run -d -p 8080:8080 --name=domoticz -v /home/pi/domoticz-config:/config -v /etc/localtime:/etc/localtime:ro -v /dev/bus/usb:/dev/bus/usb sdesbure/domoticz

More information about this project at:
https://hub.docker.com/r/sdesbure/domoticz/

March 21, 2017

Docker container: Backup and Recovery
This config will describe a procedure of how to back up a Docker container as well as it will also show how to recover a Docker container from backup.

To understand the Docker container backup and recovery process we first need to understand the difference between docker image and docker container. A docker image contains an operating system with possibly one or more prefigured applications. Whereas, a docker container is a running instance created from an image.

1. Docker container backup
When we need make a backup of a docker container we commit its current state and save it as a docker image.
# docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 78727078a04b debian:8 "/bin/bash" 13 seconds ago Up 11 seconds container1
From the above output we see a running docker container named container1 with an ID 78727078a04b. We now use commit command to take a snapshot of its current running state:
# docker commit -p 78727078a04b container1 e09f9ac65c8b3095927c14ca0594868f73831bde0800ce66415afeb91aea93cf
With do above command we have first paused a running container with -p option, made a commit to save the entire snapshot as a docker image with a name container1:
# docker images REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE container1 latest e09f9ac65c8b 39 seconds ago 125.1 MB
Now we have a container backup saved as an image waiting to be redeployed again. If we wish to redeploy our container1 image on another docker host system we may push the image to some private docker repository:
# docker login # docker push container1
or we can save it as a tar file and move it freely to any desired docker host system for a deployment:
# docker save -o ~/container1.tar container1 [root@localhost lubos]# ls -l ~/container1.tar -rw-r--r--. 1 root root 131017216 Jun 14 20:31 /root/container1.tar
2. Docker container recovery
The above paragraphs explained how to backup a docker container. In this section we will discuss how recover from a docker backup.

In case that we have pushed our backed up docker container image to a private repository we can simply use docker run command to start a new instance from the container1 image. If we have transferred our container1.tar backup file to another docker host system we first need to load backed up tar file into a docker’s local image repository:
# docker load -i /root/container1.tar
Confirm that the image was loaded with:
# docker images
Now we can use docker run command to start a new instance from the above loaded container1 image.
March 21, 2017
Docker clean-up commands
Remove stopped containers
```
$ drm
```
Remove unused volumes
```
$ drmv
```
Remove dangling volumes
```
$ drmi
```
March 21, 2017

Docker autostart container

Create service

make file in /etc/systemd/system/

cd /etc/systemd/system
nano /docker-[containername].service

Insert following code:

[Unit]
Description=Docker [containername] server
Requires=docker.service
After=docker.service
[Service]
Restart=always
ExecStart=/usr/bin/docker start -a [containername]
ExecStop=/usr/bin/docker stop -t 2 [containername]
[Install]
WantedBy=default.target

Add service to systemd

systemctl enable docker-[containername].service

When system reboots, service will be started.

March 21, 2017

Author: Stefan

Installation

Warning, don´t put the RTL-SDR in your Raspberry Pi yet. Wait till the installation is complete.

Raspbian

Update your Raspberry:

Prevent the default RTL-SDR drivers from being loaded automatically. Open the file raspi-blacklist.

Reboot the Raspberry PI.

Install driver for RTL-SDR dongle

Connect RTL-SDR dongle to Raspberry Pi.

Install MultimonNG decoder

Install calibratie tool

Calibration example of a RTL-SDR dongle (write down PPM value for later)

Install APRS IGate software

Make bootscript

Generate APRS-IS password for your callsign

Change the configfile (Call, password, position, gain, ppm, etc.)

Test system

Start Igate

Troubleshooting

USB_open error -3

Set master phone number

Set APN settings

Optional commands

Docker commands

Containers

Images

Volumes

Prerequisites

Update your apt sources

Prerequisites by Ubuntu Version

Install

Optional configurations

Create a Docker group

Adjust memory and swap accounting

Enable UFW forwarding

Configure a DNS server for use by Docker

Configure Docker to start on boot

Upgrade Docker

Uninstallation

1. Docker container backup

2. Docker container recovery

Create service