Dataiku Docker install JDBC MySQL

August 21, 2021

Download Driver Jar from maven

https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.26/mysql-connector-java-8.0.26.jar

wget https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.26/mysql-connector-java-8.0.26.jar

Copy jdbc.jar in Container

docker cp mysql-connector-java-8.0.26.jar <Container Name>:/home/dataiku/dss/lib/jdbc

Restart Service in Container

docker exec -it <Container Name> /home/dataiku/dss/bin/dss restart


Docker on Elementary OS 6.0 Odin

August 16, 2021

Uninstall old versions

sudo apt-get remove docker docker-engine docker.io containerd runc

Install using the repository

sudo apt-get update
sudo apt-get install \ apt-transport-https \ ca-certificates \ curl \ gnupg \ lsb-release
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo \
  "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  focal stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Install Docker Engine

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

Install docker-compose

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Manage Docker as a non-root user

sudo groupadd docker
sudo usermod -aG docker $USER

Appsmith on elementaryOS Docker

August 2, 2021

1. Download regular install script

curl -O https://raw.githubusercontent.com/appsmithorg/appsmith/master/deploy/install.sh

2. edit line 136 to local os_name="ubuntu"

or

Download ready to use script:

curl -O https://gist.githubusercontent.com/CeeFeS/3cd18f7adc61d7ba949eca4ea5083ccf/raw/006415b53fde76593e10fc2438cf06a6a5b19518/appsmith_install.sh

Docker Nextcloud 22.0 Error solved: Docker-Compose for Nextcloud 22.0

Juli 26, 2021

Don't use latest MariaDB version 

Just use > MariaDB 10.6

version: '2' 

services:

db: image: mariadb:10.5 command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW restart: always volumes:
- ./db:/var/lib/mysql environment:
- MYSQL_ROOT_PASSWORD=test123
- MYSQL_PASSWORD=test123
- MYSQL_DATABASE=nextcloud
- MYSQL_USER=nextcloud
app: image: nextcloud ports:
- 1234:80 links: - db volumes: - ./nextcloud:/var/www/html - ./nextcloud/php.ini:/usr/local/etc/php/php.ini"
restart: always

pull images

sudo docker-compose pull

Disable maintenance mode

docker-compose exec --user www-data app php occ maintenance:mode --off

Humanistische Dokumentation von KI- Anwendungen (Ergänzung zu Richard David Precht)

Juli 16, 2021

Dieser Blogeintrag bezieht sich ergänzend auf das Buch "Künstliche Intelligenz und der Sinn des Lebens" von Richard David Precht. 

Precht stellt im Buch fest, dass der Trans- und Posthumanismus Menschlichkeit in seinem vielschichtigen Kontext verklärt und den Menschen zum Wohle der Innovation versachlicht. Innovation und Fortschritt sind, so Precht, kein Synonym. Der Transhumanismus, welcher KI gestützte Systeme als evolutionär vorherbestimmt sieht, erkennt nicht, dass KI viele Aspekte des menschlichen Lebens nicht ersetzen kann und auch nicht den erhofften Fortschritt liefert. Software und KI sollten dem Menschen als unterstützende Werkzeuge dienen. 

Meine Software Technische Sichtweise verleitet meine Kollegen oftmals zum utilitaristischen und pragmatischen Denken, was und wie lässt sich etwas softwaretechnisch und nun auch KI gestützt implementieren. Meine ergänzende Idee sind somit einfache Fragen, welche man sich vor und während der Umsetzung eines KI- Projektes stellen sollte und die Beantwortung dieser in die technische Dokumentation mit einbezieht. Sie sollen die Sinnhaftigkeit des Werkzeuges KI für die Menschen, aber auch die Nicht-Sinnhaftigkeit klären und sollen die Sichtweise darauf lenken, die Software einen passenden Platz innerhalb eines Prozesses zu geben und nicht dem Menschen dem Platz zu zuordnen. Das Denkframework richtet sich an Entwickler, aber auch Nutzer KI gestützter Systeme.

Denk- Framework

Grundsätzliche Festlegungen, wozu KI nicht in der Lage ist:

  • Bewusstsein: KI weiß nicht was sie selbst ist und was sie macht, sie hat eine Zielsetzung oder Problem was es zu erreichen oder zu lösen gilt
  • moralische Einschätzungen: "moralischer Code" ist eine Simplifizierung von kulturellen Maßstäben, welche auf die gesamte Menschheit oder Kulturkreis eingekürzt werden. Individuelle moralische Werte werden missachtet. KI kennt keine Kultur und Individualität. Wer gibt vor was Moral ist? Moral != Gesetz! 
  • Unterbewusstsein: KI ist absolut transparent, die Regeln ihres Handelns sind in Code festgeschrieben. Auch wenn sich irgendwann das Handeln von KI der menschlichen Logik entzieht,  ist es für die KI selber nachvollziehbar und anhand mathematischer Regeln transparent. Der Mensch hingegen ist sich mancher genauer Verhaltensweisen nicht bewusst, warum er in diesem Maße nun handelt.
  • Irrationale Entscheidungen: Entscheidungsfindung beruht auf absoluter Rationalität von stochastischen Einschätzungen. Es ist kein Bauchgefühl vorhanden.
  • Instinktive Reaktionen: Aktionen die fernab von dem Pfad der Zielsetzung liegen und nicht der Erfüllung des vorher bestimmten Ziels liegen werden nicht ausgeführt
  • Verständnis zu Individuen: KI ist weder ein Individuum noch respektiert es andere, erkennt oder versteht Individualität
  • Situative Neuausrichtung: KI beurteilt neue Inputs aufgrund alter Daten und statistischen Wahrscheinlichkeiten, "Denkmuster" bleiben somit erhalten
  • Kreativität: "etwas zu erschaffen, was neu oder originell und dabei nützlich oder brauchbar ist", NEU und ORIGINELL wird an ALTEN Werten durch KI bemessen

Allgemeine Fragen für Entwickler und Nutzer sollen auch im Diskurs geklärt werden, die individuelle Beantwortung der Fragen sollte berücksichtigt und nicht generalisiert werden.

  • Welchen Platz nimmt die KI im Prozess ein?
  • Was KANN sie NICHT im Gegensatz zum Menschen?
  • Was SOLL sie NICHT im Prozess einnehmen?
  • Differenzen zwischen dem können und dem sollen für Entwickler und Nutzer?

Fragen für Entwickler beziehen sich auf die technische Umsetzung

  • Werden menschliche Individuen als objektifizierte Klassen generalisiert?
  • Aus welchen Attributen setzen sich Individuen im System zusammen?
  • Aus welchen Input-Datensätzen bestehen meine Prognosen? Sind diese übertragbar oder generalisiert?
  • Wird versucht Grenzen technischer Umsetzbarkeit KI, gemessen an den festgelegten Grenzen (siehe oben), zu überschreiten?

Fragen für Nutzer beziehen sich auf die individuellen Empfindungen und Wünsche:

  • Welches Problem löst die KI?
  • Ist das gelöste Problem überhaupt ein Problem für MICH?
  • Was soll die KI NICHT für mich machen?
  • Was macht sie trotzdem für mich?
  • Nimmt die KI mir Entscheidungen ab oder nimmt sie mir die Entscheidungsfreiheit?

Abschließende Frage:

Wie intelligent ist künstliche Intelligenz? Ist es die Summe aller Neuronen? Die Performanz aller Berechnungen und Speicherkapazität?

Wenn KI so wenig mit echter menschlicher Intelligenz zutun hat, warum heißt es dann KI?

"Maschinelles Lernen" oder "Machine Learning" wird der Vorstellung von performanten Vorhersagealgorithmen der realen Anwendungsdomäne gerechter.


Redmine API delete query

Juni 30, 2021

If Redmine starts to become slow, this may be due to too many tickets and especially subordinate tickets. The only thing that helps here is to delete redundant, expired or finished tickets. To do this, you usually create a filter, select all tickets and then remove them with one click. However, it happens that the performance of the system has become so bad that the process stops after a certain time. For this purpose, here is a small script that can delete tickets through the API slowly, but safely and cleanly: 

Required is the package: python-redmine

pip install python-redmine

Code:

from redminelib import Redmine
from getpass import getpass
import time

input_login_username= input("Username:")
input_login_password = getpass()

redmine = Redmine('##Redmine URL##', username=input_login_username, password=input_login_password)
input_query_id=input("ID Query:")
issues = redmine.issue.filter(query_id=input_query_id)

print("Please wait....")
print("===============Checking================")
print("First Issue: " , issues[0].id)
laenge_issues= len(issues)
print("Last Issue: " , issues[laenge_issues-1].id)
print("Number of issues to be deleted: ", laenge_issues)
print("===========================================================")
input_confimation = input("Do you really want to delete the selected area? (y/n)")

if(input_confimation.lower()=="y"): index=0 for issue in issues: issue.delete() print ("Issue: ", index, " von ", laenge_issues, end="\r") index = index+1 print("Deletion executed") else: print("Aborted!") time.sleep(3)

install Steam on elementary os (hera)

Juni 1, 2021

install 32-bit libraries

sudo apt-get -f install 

sudo apt-get update

sudo apt-get install libc6-i386 libgl1-mesa-dri:i386 libgl1:i386

install Steam

sudo apt-get install steam 

start Steam

steam

Nginx proxy for your home network

Mai 18, 2021

How can you make your home network secure, easy accessible and host your own services?

How do you implement this structure in your own network?


Reverse geocoding UTM to Longitude and Latitude

Mai 18, 2021

Requirements

  • pip3 install utm
  • pip3 install geopy

Imports

from geopy.geocoders import Nominatim

import utm

import getpass

from os import system, name

In which UTM zone do I live in?




Source code for reverse geocoding with nominatim

input_utm_zone = 

# input latitude (x) UTM33 (float)
input_x =

# input longtude (y) UTM33 (float)

input_y = 

# utm (UTM33) to DG

long_lat = utm.to_latlon(input_x, input_y, input_utm_zone, 'U')

# useragent is current username

username = getpass.getuser()

# reverse geo engineer with DG

geolocator = geolocator = Nominatim(user_agent=username)

location = geolocator.reverse(long_lat)


#print results

print(long_lat)

print(location.address)

Deploy Office 365 AddIns on Linux

Mai 18, 2021

How to deploy your own JavaScript Office 365 AddInn Instance on Linux:

Development enviroment: 

  • Visual Studio Code: https://code.visualstudio.com/
  • Addons: ESLint, TSLint, HTML CSS Support
  • curl -sL https://deb.nodesource.com/setup_14.x | sudo -E bash -
    sudo apt install nodejs
  • npm install -g yo generator-office
  • yo office

Adjust ports for hosting (bash script)

#!/bin/bash

# Assign the filename
filename_port="./package.json"
filename_ip="./manifest.xml"
search_ip="localhost:3000"
search_port="3000"

# Take the search string
read -p "Port eingeben: " replace_port

# Take the replace string
read -p "<IP:Port> eingeben " replace_ip

echo "Gibt es Port schon?"
netstat -ano | grep :$replace_port

if [[ $search_ip != "" && $replace_ip != "" ]]; then
sed -i "s/$search_ip/$replace_ip/" $filename_ip
fi

if [[ $search_port != "" && $replace_port != "" ]]; then
sed -i "s/$search_port/$replace_port/" $filename_port
fi

Deployment on Linux (Node)

IMPORTANT: the declared ports in package.json should be available

netstat -ano | grep :<port in package.json:12>

  • npm install office-addin-dev-certs
  • npm install
  • npm start

Port forwarding (get public access)

socat tcp-listen: "$port_extern"",reuseaddr,fork tcp:localhost:"$port_intern" 

port_intern: Port that you specified with the bash script (Port in package.json)

port_extern: Port over which public access should take place

View all node instances
ps -fC node
Kill all instances
killall node

Staking and Snarking Mina in Docker

Mai 15, 2021
Mina is the first cryptocurrency protocol with a succinct blockchain. Current cryptocurrencies like Bitcoin and Ethereum store hundreds of gigabytes of data, and as time goes on, their blockchains will only increase in size. With Mina however, no matter how much the usage grows, the blockchain always stays the same size - about 22kb. This means participants can quickly sync and verify the network. This breakthrough is made possible due to zk-SNARKs - a type of succinct cryptographic proof. Each time a Mina node produces a new block, it also generates a SNARK proof verifying that the block was valid. All nodes can then store the small proof, as opposed to the entire chain. By not having to worry about block size, the Mina protocol enables a blockchain that is decentralized at scale.
official documentation: https://docs.minaprotocol.com/en

Generating a Keypair

Adding Mina Repo

echo "deb [trusted=yes] http://packages.o1test.net release main" | sudo tee /etc/apt/sources.list.d/mina.list 
sudo apt-get update
sudo apt-get install -y curl unzip mina-mainnet=1.1.5-a42bdee

Installing Mina

sudo apt-get install mina-generate-keypair=0.2.12-718eba4

Generating Keys

mkdir ~/keys && chmod 700 ~/keys
mina-generate-keypair -privkey-path ~/keys/my-wallet && chmod 600 ~/keys/my-wallet 
mina-validate-keypair -privkey-path ~/keys/my-wallet

Starting node in Docker Container

mkdir ~/.mina-config

docker run --name mina -d \

-p 8302:8302 \

--restart=always \

--mount "type=bind,source=`pwd`/keys,dst=/keys,readonly" \

--mount "type=bind,source=`pwd`/.mina-config,dst=/root/.mina-config" \

-e CODA_PRIVKEY_PASS="PASSWORD" \

minaprotocol/mina-daemon-baked:1.1.5-a42bdee \

daemon \

--block-producer-key /keys/my-wallet \

--insecure-rest-server \

--file-log-level Debug \

--log-level Info \

--peer-list-url https://storage.googleapis.com/mina-seed-lists/mainnet_seeds.txt



Checking connectivity

docker exec -it mina mina client status

After a while, your node should connect to more peers and then should move into Sync Status: Catchup, which means we're gathering the most recent blocks and state trying to catch up the the highest block. When sync status reaches Synced and the node is connected to 1 or more peers, we will have successfully connected to the network. We will also see a corresponding daemon log once we've synced: [Info] Mina daemon is now synced.

Check your account

Import keys

docker exec -it mina mina accounts import -privkey-path ~/keys/my-wallet 

Check account balance

docker exec -it mina mina client get-balance -public-key PUBLIC_KEY

Mining (snarking)

mina client set-snark-work-fee 0.000001 

mina client set-snark-worker -address $MINA_PUBLIC_KEY

Snark-work-fee has to be adjusted supply and demand

Mina Coin is partnered with CoinList and will be available for sale on: https://coinlist.co/


Balance Agile and Plan-Driven Methods: How agile or plan-driven should or can my project? (five critical factors)

April 28, 2021

five critical factors by Richard Turner and Barry Boehm 

Barry Boehm and Richard Turner offer a model, which with the help of critical factors, rates the degree of agility or degree of planning drift of a project. These factors are as follows:

  • Personnel: Personnel describes the development skills of teams. There the Cockburn scale is used, which in a simplified way represents the abilities the developer divides into level 1: junior to level 3: senior. An agile approach requires that at least 30 percent of developers have a level 2 or higher. A plan-driven approach comes with less experienced employees.
  • Dynamism: The dynamism factor describes the rate of change of Conditions. Agile developments make sense if at least 30 percent of the defined requirements change per month. If the value is less than 30 percent plan-driven methods are preferable.
  • Culture: describes the working culture of individuals. When employees are That is to feel at ease when they are given defined roles and tasks to prefer a plan-driven approach. However, people are used to one a high degree of freedom and decision-making power over their work area the agile approach is more advantageous.
  • Size (team size): The team size is a deciding factor when choosing the team Method. The bigger the team, the sooner a plan-driven one comes along Approach in question.
  • Criticality: This factor refers to the critical level of the Application and the associated risk in the event of an error. Bohm points out, that there is a very critical system when there is a life-threatening risk. In the case of critical systems, plan-driven procedures are more likely to be used.

Read more

Nginx reverse proxy: subdomain and SSL

April 28, 2021

Seven easy steps to configure a full nginx reverse proxy with ssl:

  • 1: go to your nginx folder
    cd /etc/nginx/sites-available
  • 2: create a new config file with your domain or subdomain name
    nano {subdomain.domain.de.conf}
  • 3: copy this and replace the right values
    map $http_upgrade $connection_upgrade {
      default upgrade;
      ''      close;
    }
    server {
      listen 80;
      server_name {subdomain.domain.de};
      return 301 https://$host$request_uri;
    }
    
    # SSL configuration
    server {
      listen 443 ssl;
      server_name {subdomain.domain.de};
      ssl_certificate      /etc/letsencrypt/live/{subdomain.domain.de}/fullchain.pem;
      ssl_certificate_key  /etc/letsencrypt/live/{subdomain.domain.de}/privkey.pem;
    
      # Improve HTTPS performance with session resumption
      ssl_session_cache shared:SSL:10m;
      ssl_session_timeout 5m;
    
      # Enable server-side protection against BEAST attacks
      ssl_prefer_server_ciphers on;
      ssl_ciphers ECDH+AESGCM:ECDH+AES256:ECDH+AES128:DH+3DES:!ADH:!AECDH:!MD5;
    
      # Disable SSLv3
      ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    
      # Diffie-Hellman parameter for DHE ciphersuites
      ssl_dhparam /etc/ssl/certs/dhparam.pem;
    
      # Enable HSTS (https://developer.mozilla.org/en-US/docs/Security/HTTP_Strict_Transport_Security)
      add_header Strict-Transport-Security "max-age=63072000; includeSubdomains";
    
      # Enable OCSP stapling (http://blog.mozilla.org/security/2013/07/29/ocsp-stapling-in-firefox)
      ssl_stapling on;
      ssl_stapling_verify on;
      ssl_trusted_certificate /etc/letsencrypt/live/{subdomain.domain.de}/fullchain.pem;
      resolver 8.8.8.8 8.8.4.4 valid=300s;
      resolver_timeout 5s;
    
      location / {
        proxy_pass http://{ip}:{port};
        proxy_set_header Host $host;
        proxy_redirect http:// https://;
        proxy_http_version 1.1;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
      }
    }
  • 4: if you have never certified a domain with certbot please execute openssl as follows:
    sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096
  • 5: register the domain on domain provider {subdomain.domain.de} has to point with an A-Record to your public IP adress

  • 6: certificate request
    • sudo systemctl stop nginx
    • sudo certbot certonly -d {subdomain.domain.de}
    • select: Spin up a temporary webserver (standalone) 
    • sudo systemctl start nginx
  • 7: last step symlink
    sudo ln -s /etc/nginx/sites-available/{subdomain.domain.de.conf} /etc/nginx/sites-enabled/

Bludit persistent install: docker-compose

April 27, 2021

The prebuilt official Docker image can be ran easily, but if you want  to make the content persistent, the plugins available and the themes customizable the shot documentation isn´t helpful enough.

I´ve created a easy to use docker-compose file, for a ready to use installation. Only prerequisite: docker and docker-compose. Installation: https://docs.docker.com/engine/install/ and https://docs.docker.com/compose/install/

version: "3.9"
services:
  bludit:
    image: "bludit/docker:latest"
    ports:
      - 8123:80
    volumes:
      - ./content:/usr/share/nginx/html/bl-content
      - ./plugins:/usr/share/nginx/html/bl-plugins
      - ./kernel:/usr/share/nginx/html/bl-kernel
      - ./themes:/usr/share/nginx/html/bl-themes
      - ./languages:/usr/share/nginx/html/bl-languages

RK3328 als Server für einfache Webapplikationen nutzen

April 27, 2021

Der Rockship Rk3328 mit dem Quad-core Cortex-A53 (Datasheet: https://www.rock-chips.com/a/en/products/RK33_Series/2017/0118/829.html) bietet eine kostengünstige Variante, um einfache Applikationen ressourcenschonend, dank Arm-Architektur, zu hosten. Dieser lässt sich oftmals in Android TV Boxen erhalten und nutzen. Die vorhandene Android Version wird gejailbreaked und die auf dem Board vorhandene EMMC mit einer für Arm optimierten Debian Version (Armbian) überspielt.

Was kann man darauf laufen lassen?

  • Emulatoren
  • Docker (Docker Container, welche ARM geeignet sind)
  • Nextcloud
  • Webserver
  • etc.

Warum ist diese Version von Vorteil?

  • Kostengünstig in der Anschaffung
  • sehr geringer Stromverbrauch
  • viele Möglichkeiten

Benötigte Hardware

Installation von Armbian

  • Eine Armbian Version wählen: https://disk.yandex.ru/d/DSO6euzB3ahemo/ARMBIAN/20.07/20200714-933  runterladen und entpacken
  • Mithilfe von Balena Etcher: https://www.balena.io/etcher/ Image auf SD Card flashen
  • TV-Box mit eingelegter SD-Card starten und die Einrichtung starten
  • Bevor die eMMC geflasht wird, sollte ein Backup erstellt werden. Dies erfolgt mithilfe von ddbr
  • mv /boot/mvr9-uboot.img /boot/uboot.img  #Umbennenen von mvr8-uboot.img in uboot.img
  • sudo bash /boot/create-mbr-linux.sh
  • sudo bash /root/install.sh

Das installierte Image und teile der Einleitung beziehen sich auf "Balbes 150" (18. August 2018) Zusätzliche Hilfe auf: https://forum.armbian.com/topic/8082-armbian-for-tv-box-rk3328/

Installation von Webservice: Bludit

sudo apt install apache2 php libapache2-mod-php php-mbstring php-gd php-xml php-json
sudo apt-get install git
git clone https://github.com/mhancoc7/Bludit-Pi.git
cd Bludit-Pi
bash build.sh