aus wiki übernommen und sql erweitert

Blender.md

@@ -0,0 +1,117 @@
+# Blender
+
+## Vom Cursor eine Linie in negativer y-Richtung mit Länge 11.2 mm
+
+```python
+import bpy
+from mathutils import Vector
+
+# Definiere die Länge der Linie
+line_length = -1.12  # 11.2 mm
+ 
+# Hole die 3D-Cursor-Position
+cursor_position = bpy.context.scene.cursor.location
+
+# Berechne die Endposition der Linie
+end_position = cursor_position + Vector((line_length, 0, 0))
+
+# Erstelle eine neue Linie
+vertices = [cursor_position, end_position]
+edges = [(0, 1)]
+mesh = bpy.data.meshes.new(name="LineMesh")
+line_obj = bpy.data.objects.new(name="LineObject", object_data=mesh)
+bpy.context.collection.objects.link(line_obj)
+mesh.from_pydata(vertices, edges, [])
+mesh.update()
+```
+
+## Ein bestehendes Objekt mittel bmesh verändern
+
+https://www.youtube.com/watch?v=TFQMNcTj5Jw
+
+```python
+import bpy
+import bmesh
+
+
+# Holen einer Referenz auf das aktuelle Objekt
+mesh_obj = bpy.context.active_object
+
+# Erzeugen eines neuen bmesh-Objektes
+bm = bmesh.new()
+
+# Initialisieren des bmesh-Objektes mit den Daten des vorhandenen Objektes
+bm.from_mesh(mesh_obj.data)
+
+bmesh.ops.bevel(bm, geom=bm.verts, offset=0.5)
+
+
+# Schreiben der bmesh-Daten in die mesh-Daten
+bm.to_mesh(mesh_obj.data)
+
+# Optional: updaten der mesh-Daten
+mesh_obj.data.update()
+
+# freigeben des Speichers der von bmesh genutzt wurde
+bm.free()
+```
+
+![](/Volumes/Daten02/Projekte/Snippets/Blender1.png)
+
+```python
+import bpy
+import bmesh
+
+
+# Holen einer Referenz auf das aktuelle Objekt
+mesh_obj = bpy.context.active_object
+
+# Erzeugen eines neuen bmesh-Objektes
+bm = bmesh.new()
+
+# Initialisieren des bmesh-Objektes mit den Daten des vorhandenen Objektes
+bm.from_mesh(mesh_obj.data)
+
+bmesh.ops.bevel(
+                bm, 
+                geom=bm.edges,
+                offset=0.2,
+                segments=4,
+                affect="EDGES",
+                profile=0.5,
+)
+
+
+# Schreiben der bmesh-Daten in die mesh-Daten
+bm.to_mesh(mesh_obj.data)
+
+# Optional: updaten der mesh-Daten
+mesh_obj.data.update()
+
+# freigeben des Speichers der von bmesh genutzt wurde
+bm.free()
+```
+
+![Blender2](/Volumes/Daten02/Projekte/Snippets/Blender2.png)
+
+## Erzeugen eines Objektes von stretch
+
+```
+import bpy
+
+obj_name = "my_shape"
+
+
+# Erzeugen der mesh Daten
+mesh_data = bpy.data.meshes.new(f"{obj_name}_data")
+
+# Erzeugen des Mesh-Objektes unter Nutzng der Mesh-Daten 
+mesh_obj = bpy.data.objects.new(obj_name, mesh_data)
+
+# Hinzufügen des Mesh-Obektes zur Szene
+bpy.context.scene.collection.objects.link(mesh_obj)
+```
+
+![](/Volumes/Daten02/Projekte/Snippets/2024-03-25_18-39.png)
+
+https://www.youtube.com/watch?v=N3U2noAHgBo&t=88s

Docker.md

@@ -0,0 +1,152 @@
+# Docker
+
+## docker install
+
+```
+curl https://get.docker.com | bash
+```
+
+## Historie eines Images abrufen
+
+```
+docker image history ubuntu
+```
+
+Full (no trucated)
+
+```
+docker image history --no-trunc ubuntu
+```
+
+## Übersicht über alle lokalen Images
+
+`docker image ls` bzw. `docker images`
+
+## docker commit
+
+Allows saving changes made in a Docker container
+
+## Kontrollieren der genutzten Volumes
+
+```
+docker volume ls
+```
+
+## Aufräumen von ungenutzten Volumes
+
+```
+docker volume prune
+```
+
+## Nur den Mountpoint des Volumes anzeigen
+
+```
+docker volume inspect --format '{{ .Mountpoint }}' <volume>
+```
+
+## Anzeigen der laufenden Mountpoints eines Dockercontainers
+
+1. mittels `docker ps` die ID oder den Namen identifizieren
+2. `docker inspect -f '{{ .Mounts }}' <id/Name>`
+
+## Löschen von Containern, Images, Volumes uns Netzwerke
+
+### Löschen von ungenutzten Containern (die unreferenziert (also nicht mit einem Container verknüpft) sind)
+
+```
+docker system prune
+```
+
+### Löschen auch von angehalteten Containern und nichtverwendeten Images (nicht nur unreferenziert)
+
+```
+docker system prune -a
+```
+
+## Entfernen von Docker-Images
+
+### Entfernen von einem oder mehreren spezifischen Images
+
+Verwenden Sie den Befehl `docker images` mit dem Flag `-a`, um die ID der Images zu finden, die Sie entfernen möchten. Dadurch wird Ihnen jedes Image angezeigt, einschließlich dazwischenliegender Image-Ebenen. Wenn Sie die Images gefunden haben, die Sie löschen möchten, können Sie ihre ID oder ihr Tag `docker rmi` übergeben:
+
+Auflisten:
+
+```
+docker images -a
+```
+
+Entfernen:
+
+```
+docker rmi <image-tag> oder <image-id>
+```
+
+### Entfernen von unreferenzierten Images
+
+Docker-Images bestehen aus mehreren Ebenen. Unreferenzierte Images sind Ebenen, die keine Beziehung zu getaggten Images haben. Sie dienen keinem Zweck mehr und verbrauchen Festplattenspeicher.
+
+**Anmerkung**: Wenn ein Image erstellt wird, ohne es mit einem Tag zu versehen, dann wird das Image in der Liste der unreferenzierten Images angezeigt, da es keine Zuordnung zu einem getaggten Image aufweist. Diese Situation kann man vermeiden in dem man beim Erstellen ein Tag angibt, sonst im Nachhinein das Image mittels `docker tag` mit einem Tag versehen.
+
+Auflisten:
+
+```
+docker images -f dangling=true
+```
+
+Entfernen:
+
+```
+docker images purge
+```
+
+Entfernen von Images nach Muster Auflisten:
+
+```
+docker images -a |  grep "pattern"
+```
+
+Entfernen:
+
+```
+docker images -a | grep "pattern" | awk '{print $3}' | xargs docker rmi
+```
+
+### Alle Images entfernen
+
+Alle Docker-Images in einem System können mit `docker images -a` aufgelistet werden.
+
+Auflisten:
+
+```
+docker images -a
+```
+
+Entfernen:
+
+```
+docker rmi $(docker images -a -q)
+```
+
+`-q` übergibt die Image-ID
+
+https://www.digitalocean.com/community/tutorials/how-to-remove-docker-images-containers-and-volumes-de
+
+### Ein Dockerimage sichern
+
+```
+docker save image
+
+gzip <image.tar>
+```
+
+### Ein gesichertes Dockerimage einspielen
+
+```
+docker load -i <image.tar.gz>
+```
+
+## Im Container arbeiten
+
+```
+docker exec -it <id> bash
+```

Kafka.md

@@ -0,0 +1,595 @@
+# Neues Repo
+
+https://github.com/conduktor/kafka-stack-docker-compose
+
+https://github.com/conduktor/kafka-beginners-course
+
+## Installation im STC
+
+1. Download des Kafka `curl "https://archive.apache.org/dist/kafka/3.7.0/kafka_2.13-3.7.0.tgz`
+
+# Dockerfiles Sicherung
+
+```
+docker save ...
+```
+
+# Dockerfiles Restore
+
+```
+docker image load -i <tar>
+```
+
+
+
+# Notizen STC
+
+apt install docker docker-compose
+
+1. Start läuft auf Fehler:
+
+ERROR: for zoo3 Cannot start service zoo3: OCI runtime create failed: container_linux.go:377: starting container process caused: process_linux.go:495: container init caused: process_linux.go:458: **setting cgroup config for procHooks process caused: can't load program:** function not implemented: unknown
+
+Der NdB-Kernel unterstüzt das nicht, daher gepurged und den Standardkernel hochgefahren
+
+```
+docker compose -f zk-single-kafka-multiple.yml up
+```
+
+## Ablauf
+
+1. lst02
+
+   1. Kopieren der Files via cp-Skripte
+
+   2. Auslesen und Versenden der Files per Python-Skript an die lstk1
+
+      ```
+      python3 transportv0.9.cpython-39.pyc
+      ```
+
+2. lstk1
+
+   1. den logstash starten
+
+      ```
+      /usr/share/bin/logstash -f /etc/logstash/conf.d/importLogstash.conf
+      ```
+
+      Hier werden die Daten entsprechend Forderung gefiltert
+
+   2. zookeeper starten
+
+      ```
+      /usr/share/kafka<ver>/bin/zookeeper-server-start.sh ../config/zookeeper.properties
+      ```
+
+   3. kafka starten
+
+      ```
+      /usr/share/kafka<ver>/bin/kafka-server-start.sh ../config/server.properties
+      ```
+
+      Damit Daten abgerufen werden können, muss folgender iptables-Eintrag vorgenommen werden
+
+      ```
+      iptables -I INPUT -p tcp --dport 9092 -j ACCEPT
+      ```
+
+## Nagflux.gcfg
+
+```
+[main]
+    NagiosSpoolfileFolder = "/var/spool/perfdata"
+    NagiosSpoolfileWorker = 1
+    InfluxWorker = 1
+    MaxInfluxWorker = 1
+    DumpFile = "nagflux.dump"
+    NagfluxSpoolfileFolder = "/var/spool/nagflux"
+    FieldSeparator = "&"
+    BufferSize = 10000
+    FileBufferSize = 65536
+    # If the performancedata does not have a certain target set with NAGFLUX:TARGET.
+    # The following field will define the target for this data.
+    # "all" sends the data to all Targets(every Influxdb, Elasticsearch...)
+    # a certain name will direct the data to this certain target
+    DefaultTarget = "logstashpipe"
+
+
+[Log]
+	LogFile = ""
+	MinSeverity = "INFO"
+
+[JSONFileExport "logstashpipe"]
+	Enabled = true
+	Path = /tmp/logstash_out
+	AutomaticFileRotation = "1"
+```
+
+## Bash-Skript für den Transport
+
+```
+#!/bin/bash
+
+set -x
+
+# configure network timeouts
+folder=/tmp/logstash_out
+maxtries=360	# 360 * 10s => nach 3600s = 1h = upload abbrechen, nächste Datei
+timewait=10
+
+while true; do
+	files=$(find $folder -type f -name "perfdata_*" -mmin +1 | sort)
+	for file in $files ; do
+		try=0
+		rc=0
+		until [ $try -gt $maxtries ]
+		do
+			cat $file | netcat -w1 mlsebzlstk1 8080
+			rc=$?
+			[ "$rc" == "0" ] && break
+			try=$((try+1))
+			sleep $timewait
+		done
+		
+		# remove file or rename for timeout
+		if [ "$rc" == "0" ] ; then
+			rm $file
+		else
+			mv $file $folder/timeout_$(date +%s)
+		fi
+	done
+	
+	if [ "$files" == "" ] ; then
+		echo "nothing to do, lets wait 10s"
+		sleep 10
+	fi
+done
+```
+
+## Derzeitiges Pythonskript
+
+```
+import time, os, sys, socket, shutil
+from watchdog.observers import Observer
+from watchdog.events import PatternMatchingEventHandler
+from watchdog.events import FileCreatedEvent
+from queue import Queue
+from threading import Thread
+from datetime import datetime
+
+"""
+    Prozessklasse
+"""
+
+class MyHandler(PatternMatchingEventHandler):
+    ignore_patterns = None
+    ignore_directories = False
+    case_sensitive = False 
+    patterns=['perfdata*']
+
+    def on_modified(self, event):
+        #print(f'event type: {event.event_type}  path : {event.src_path}')
+        pass
+
+        #self.queue.put(event.src_path)
+
+    def on_created(self,event):
+        print(f'event type: {event.event_type}  path : {event.src_path}')
+        watchdog_queue = Queue()
+        e = FileCreatedEvent(event.src_path)
+        watchdog_queue.put(e)
+
+    
+        worker = Thread(target=process_queue, args=(watchdog_queue,))
+        print("Thread gestartet: " + worker)
+        worker.setDaemon(True)
+        worker.start()
+
+    def on_deleted(self,event):
+        print(f'event type: {event.event_type}  path : {event.src_path}')
+
+    def on_moved(self,event):
+        print(f'event type: {event.event_type}  path : {event.src_path}')
+
+
+
+
+def sendfile(client, file_):
+    
+    f = open(file_, "r")
+    try:
+        client.connect((hostname, port))
+        try:
+        #    f = open(file_, "r")
+            data = f.read()
+#            print(data)
+            client.sendall(data.encode("utf-8"))
+            f.close()
+            os.remove(file_)
+            client.close()
+        except:
+            client.close()
+            print("Datei wurde nicht versandt: " +file_)
+            os.rename(file_  + "zzzz")
+            f.close()
+
+    except socket.error as e:
+        print ("error connecting socket: %s" %e)
+        client.close()
+        #os.rename(file_  +str(int(datetime.now().timestamp())))
+
+def process_queue(q):
+    while True:
+        if not q.empty():
+            event = q.get()
+            print("New event %s" % event)
+            modification_time = int(os.path.getmtime(event.src_path))
+            print(modification_time)
+            now = int(datetime.now().timestamp())
+            print(now-modification_time)
+            ##### hier mit while arbeiten
+            while (int(datetime.now().timestamp()) - modification_time < 10):
+                print("Ich warte")
+                time.sleep(11) # warten von 10sec
+                # nach verlassen sollte File älter als 10sec sein
+            print ("Warten verlassen")
+
+            if (int(datetime.now().timestamp())- modification_time > 10):
+                print("Datei ist älter als 10sec")
+                ## senden
+                try:
+                    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                    sendfile(client, event.src_path)
+                except:
+                    print("Datei muss gemoved werden")
+                
+
+                ## gesendet --> ja
+
+                ## fehlerhaftes senden
+                ## mv file namentlich
+        else:
+            return
+    
+
+
+
+if __name__ == "__main__":
+
+    """
+    init-Daten
+    """
+    hostname = "mlsebzlstk1"
+    port = 8080
+    watchdog_queue = Queue()
+    patterns = ['perfdata']
+    watchDir = "/tmp/logstash_out"
+    
+#    watchDir = "/tmp/test"
+
+    """
+    Einlesen des Verzeichnisses und Versenden, als eigene Threads
+    """ 
+    for file in os.listdir(watchDir):
+        filename = os.path.join(watchDir, file)
+        
+        # Erzeugen eines FileCreate Events
+        event = FileCreatedEvent(filename)
+        
+        # Einfügen in die watchdog-Queue
+        watchdog_queue.put(event)
+
+
+    """
+    Starten des Threads
+    """
+
+    worker = Thread(target=process_queue, args=(watchdog_queue,))
+#    worker.setDaemon(True)
+    worker.start()
+
+    #event_handler = FileWatchdog(watchdog_queue, patterns="perfdata*")
+
+    my_event_handler = MyHandler()
+
+
+    go_recursively = False
+    my_observer = Observer()
+    my_observer.schedule(my_event_handler, watchDir, recursive=go_recursively)
+ 
+    my_observer.start()
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        my_observer.stop()
+        my_observer.join()
+```
+
+## conf-File des logstashs auf der Empfängerseite
+
+Hier werden auf gleich die Daten an den Kafka übergeben
+
+Start: mittels systemctl oder aber zum Testen /usr/share/bin/logstash -f /etc/logstash/conf.d/importLogstash.conf
+
+```
+input {
+	tcp {
+		host => "mlsebzlstk1"
+		port => 8080
+		codec => json
+		}
+    #http {
+    #    port => 12000
+    #    additional_codecs => { "application/json" => "json_lines" }
+    #}
+}
+
+filter{
+        json {
+#				ecs_compatibility => disabled
+                source => "message"
+                target => "parsed_json"
+        }
+
+        #if [Hostname] =~ "dkr..x(skr|ssk).." or [Hostname] =~ "dpf..xivpn." or [Hostname] =~ "dha..xialg." or [Hostname] =~ "dpf..xgvpn." or [Hostname] =~ "drt..2grt.." or [Hostname] =~ "dkr..xwkr.."
+        if [Hostname] =~ "dkr..x(skr|ssk)..|dpf..xivpn.|dha..xialg." #|dpf..xgvpn.|drt..2grt..|dkr..xwkr..|dls..3wlb0.|drt..2wrt..|dls..xnsg..|dls..3elb..|dpf..xeco..|dpfe.i00015"
+        {
+                mutate
+                {
+                        add_field => {
+                                "ZGR" =>  "1"
+                        }
+                }
+
+                if [Hostname] =~ "dkr..x(skr|ssk).."
+                {
+                        mutate
+                        {
+                                add_field => {
+                                        "Dienst" => "MobZu SecuSuite"
+                                }
+                        }
+
+                        if [PerformanceLabel] =~ "eth3_traffic_(in|out)"
+                        {
+                                mutate
+                                {
+                                        add_field => ["Art", "Traffik" ]
+                      	        }
+                        }
+
+                        
+                        else if [PerformaceLabel] =~ "(ike|child)sacount"
+                        {
+                                mutate
+                                {
+                                        add_field => ["Art", "VPN Connections"]
+                                }
+                        }
+
+                        
+                        else if [PerformaceLabel] =~ "cpu_usage"
+                        {
+                                mutate
+                                {
+                                        add_field => ["Art", "CPU"]
+                                }
+                        }
+                        mkdir ~/kafka && cd ~/kafka
+                        else if [PerformaceLabel] =~ "'load-5'"
+                        {
+                                mutatemkdir ~/kafka && cd ~/kafka
+                                {
+                                        add_field => ["Art", "Load5"]
+                                }
+                        }
+                        
+                        else if [PerformaceLabel] =~ "memory_usage"
+                        {
+                                mutate
+                                {
+                                        add_field => ["Art", "Memory"]
+                                }
+                        }
+                        else
+                        {
+                                drop {}
+                        }
+                }
+
+                else if [Hostname] =~ "dpf..xivpn.|dha..xialg."
+                {
+                        mutate
+                        {
+                                add_field => {
+                                "Dienst" => "MobZu IOS"
+                                }
+                        }
+                        
+                        if [Hostname] =~ "dpf..xivpn."
+                        {
+                        	if [PerformanceLabel] =~ "em0 - .*_traffic_(in|out)"
+                        	{
+                        		mutate
+                                {
+                                        add_field => {"Art" => "Gateway Traffik" 
+                                        "Service" => "Interface: em0"
+                                        }
+                      	        }
+                        	}
+                        	else if [PerformanceLabel] =~ "VPN Connections"
+                        	{
+                        		 mutate{
+                                        add_field => {"Art" => "Gateway VPN Connections"}
+                                }
+                        	}
+                        	else if [PerformanceLabel] =~ "cpu.*usage" 
+                        	{
+                        		 mutate{
+                                        add_field => {"Art" => "Gateway CPU"}
+                                }
+                        	}
+                        	else if [PerformanceLabel] =~ "'load5'" 
+                        	{
+                                mutate{
+                                        add_field => {"Art" => "Gateway Load5"}
+                                }                        	
+                        	}
+                        	else
+                        	{
+                        		drop { }
+                        	}
+                        	
+                        }
+                        else if [Hostname] =~ "dha..xialg."
+                        {
+                        	if [PerformanceLabel] =~ "_traffic_(in|out)"
+                        	{
+                                mutate
+                                {
+                                        add_field => {"Art" => "ALG Traffik" 
+                                        "Service" => "Interface: em[01]"
+                                        }
+                      	        }
+                        	}
+                        	
+                        	else if [PerformanceLabel] =~ "cpu.*usage"
+                        	{
+                                mutate{
+                                        add_field => {"Art" => "ALG CPU"}
+                                }
+                        	
+                        	}
+                        	else if [PerformanceLabel] =~ "'load5'"
+                        	{
+                                mutate{
+                                        add_field => {"Art" => "ALG Load5"}
+                                }
+                        	}
+                        	else
+                        	{
+                        		drop { }
+                        	}
+                        }
+                }
+                else if [Hostname] =~ "dpf..xgvpn.|drt..2grt.."
+                {		
+                	mutate
+			{
+				add_field => {
+				"Dienst" => "MobZu GenuCard"}
+	               	}
+	                    if [Hostname] =~ "dpf..xgvpn."
+	                    {
+	                    	if [PerformanceLabel] =~ "em0 - .*_traffic_(in|out)"
+	                    	{
+                                mutate
+                                {
+                                        add_field => ["Art", "Traffik" ]
+                      	        }	                    	
+	                    	}
+	                    	else if [PerformanceLabel] =~ "VPN Connections"
+	                    	{
+                                mutate
+                                {
+                                        add_field => ["Art", "VPN Connections" ]
+                      	        }	  	                    	
+	                    	}
+	                    	else if [PerformanceLabel] =~ "cpu.*usage"
+	                    	{
+                                mutate
+                                {
+                                        add_field => ["Art", "CPU" ]
+                      	        }	  	                    	
+	                    	}
+	                    	else if [PerformanceLabel] =~ "load5"
+	                    	{
+                                mutate
+                                {
+                                        add_field => ["Art", "Load5" ]
+                      	        }		                    	
+	                    	}
+	                    	#else
+	                    	#{
+	                    	#	drop { }
+	                    	#}
+	                    }
+	                    else if [Hostname] =~ "drt..2grt.."
+	                    {
+	                    	if [PerformanceLabel] =~ "'Tu.* - ([a-zA-Z]+).*_traffic_(in|out)'"
+	                    	{
+                                mutate
+                                {
+                                        add_field => ["Art", "GRE Tunnel Use pro Nutzer" ]
+                      	        }		                    		                    	
+	                    	}
+	                    	#else
+	                    	#{
+	                    	#	drop { }
+	                    	#}
+	                    }
+                 }
+#                else if  [Hostname] =~ "dkr..xwkr..|dls..3wlb0.|drt..2wrt.."
+#                {
+#                	mutate
+#                	{
+#                		add_field => {
+#                                "Dienst" => "MobZu SinaWS"
+#                        }
+#                   }
+#                 }
+#                else if  [Hostname] =~ "dls..xnsg.."
+#                {
+#                	mutate
+#                	{
+#                		add_field => {
+#                                "Dienst" => "MobZu NCP"
+#                        }
+#                   }
+#                 }  
+#                else if  [Hostname] =~ "dls..3elb..|dpf..xeco..|dpfe.i00015
+#"
+#                {
+#                	mutate
+#                	{
+#                		add_field => {
+#                                "Dienst" => "MobZu ECOS"
+#                        }
+#                   }
+#                 }  
+                
+        }
+        else
+        {
+                drop  { }
+        }
+}
+	
+output{
+		stdout
+		{
+			codec => rubydebug
+		}		
+#		 kafka {
+
+#        codec => json
+#        topic_id => "DTBS"
+#      }
+
+    
+
+
+	#    http {
+    #    url => 'http://mlsebzlstr1:8080'
+    #    http_method => post
+    #    retry_non_idempotent => true
+     #   format => json_batch
+     #   http_compression => true
+    #}
+}
+
+# vim:ts=4:sw=4
+```
+

SQL.md

@@ -193,4 +193,52 @@ oder
 INSERT INTO <tabelle> (<spalte><spalte>,...) VALUES (<wert>,<wert>,...)
 
 ## Update Datensatz
-UPDATE <tabelle> set <spalte> = <wert>,  <spalte> = <wert>, ... WHERE <Bedingung>
+UPDATE <tabelle> set <spalte> = <wert>,  <spalte> = <wert>, ... WHERE <Bedingung>
+
+Anlegen eines Users mit Rechten
+
+```sql
+CREATE USER 'sammy'@'localhost' IDENTIFIED BY 'password';
+```
+
+Rechte setzen
+
+```sql
+GRANT PRIVILEGE ON database.table TO 'username'@'host';
+```
+
+- `CREATE`: Er­mög­licht es Benutzern, eine Datenbank oder Tabelle zu erstellen.
+- `SELECT`: Erlaubt Benutzern, Daten abzurufen.
+- `INSERT`: Er­mög­licht es Benutzern, neue Einträge in Tabellen hin­zu­zu­fü­gen.
+- `UPDATE`: Er­mög­licht es Benutzern, be­stehen­de Einträge in Tabellen zu ändern.
+- `DELETE`: Er­mög­licht es Benutzern, Ta­bel­len­ein­trä­ge zu löschen.
+- `DROP`: Benutzer können ganze Da­ten­bank­ta­bel­len löschen.
+
+Somit also
+
+```sql
+GRANT SELECT, CREATE  ON database.table TO 'username'@'host';
+```
+
+Einlesen der Berechtigungstabellen
+
+Aktivieren mit 
+FLUSH PRIVILEGES;
+
+
+
+Entziehen von Rechten
+
+REVOKE type_of_permission ON database_name.table_name FROM 'username'@'host';
+
+Anzeigen der aktuellen Berechtigungen
+
+```sql
+SHOW GRANTS FOR 'username'@'host';
+```
+
+User löschen
+
+```sql
+DROP USER 'username'@'localhost';
+```