Hope This Helps

Problem : Man benötigt bei einem Webserver hinter einem AWS Application Loadbalancer die RemoteIP des Clients. Das Vorgehen ist eigentlich für alle LBs gültig.

Lösung : Ich verwende hier Debian auf anderen Distries sollte es ähnlich sein.
Es wird das Modul remoteip_module benötigt.

a2enmod remoteip

Dann legt man eine neue config an und aktiviert diese.

vi /etc/apache2/conf-available/loadbalancer_remoteip.conf

dort diesen Inhalt einfügen

# Settings for mod_remoteip:
# the Header X-Forwarded-For comes from AWS Application Loadbalancer
RemoteIPHeader X-Forwarded-For
RemoteIPInternalProxy xxx.xxx.xxx.xxx # 1.Loadbalancer IP Intern
RemoteIPInternalProxy xxx.xxx.xxx.xxx # 2.Loadbalancer IP Intern usw.
# dont log healthy checks
SetEnvIf User-Agent ELB-HealthChecker nolog

die config aktiviert man mit

a2enconf loadbalancer_remoteip

dann anpassen der apache2.conf

# mod_remoteip LogFormat
LogFormat "%a %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" combined

in der VHost der Website dann das CustomLog anpassen bzw. eintragen

CustomLog "/var/log/apache2/site/access.log" combined env=!nolog

jetzt kann man mal testen ob die config so läuft

apache2ctl configtest

der output sollte lauten

root@xxx.xxx.xxx.xxx:/> apache2ctl configtest
Syntax OK

dann den Apache neu starten und überprüfen ob alles so läuft wie es soll

systemctl restart apache2
less +F -S /var/log/apache2/site/access.log

Ist jetzt zwar kein Hexenwerk aber hier ein kleiner Portscanner in Python3

#!/usr/bin/env python3
import argparse , socket , sys , logging
from datetime import datetime

SOCKET_STATES = {
    0: "open",
    11: "firewalled",
    111: "closed",
}

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("hostname", metavar="HOSTNAME",
                        help="define the hostname to be checked")
    parser.add_argument("start_port", type=int, metavar="START_PORT",
                        help="define the start port")
    parser.add_argument("end_port", type=int, metavar="END_PORT",
                        help="define the end port")
    parser.add_argument("-a", "--all-ports", action="store_true",
                        help="shows all (default is show only open ports)")
    parser.add_argument("-l", "--logfile", type=str, 
    					help="if set i will write an logfile (you have to set an logfile incl path)")
    parser.add_argument("-t", "--timeout", type=int, default=3, 
    					help=("set the TIMEOUT for socket operations (default is 3 seconds)"))
    parser.add_argument("-v", "--verbose", action="store_true",
                        help="set debug mode (set --all-ports)")
    args = parser.parse_args()
    
    if args.end_port < args.start_port:
    	sys.exit("END_PORT must be higher then START_PORT")

    if 0 < args.start_port <= 65535 and 0 < args.end_port <= 65535:
        return args
    else:
        sys.exit("The Portrange must between 1-65535")

def get_ip_address(hostname):
    try:
        return socket.gethostbyname(hostname)
    except socket.error as err:
        # print (str(err))
        print ('Hostname could not be resolved. Exiting')
        sys.exit(4)

def check_port(ip, port):
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            result = s.connect_ex((ip, port))
            return SOCKET_STATES.get(result, result)
    except KeyboardInterrupt:
    	sys.exit(1)
    except socket.gaierror:
        print ('Hostname could not be resolved. Exiting')
        sys.exit(3)
    except socket.error:
        print ("Couldn't connect to server")
        sys.exit(2)

def write_log(entry,state):
	if state in ['info', 'warning', 'critical','error']:
		log_method = getattr(logging,state)
		log_method(str(entry))

def scan_ports(remote_host, start_port, end_port, logfile , debug=False, show_all=False):
    ip = get_ip_address(remote_host)
    # Print Banner
    print ("-" * 90)
    print ("please wait, scanning remote host {0} , takes some time !".format(ip))
    print ("-" * 90)
    print ("\n")

    t_start = datetime.now()
    for port in range(start_port, end_port + 1):
        if debug:
            print ("\n--> check port {0} on ip {1}\n".format(port, ip))
        port_state = check_port(ip, port)
        if logfile:
        	write_log ("--> check port {0} on ip {1} its {2}".format(port, ip, port_state),"info")
        if port_state == "open" or show_all or debug:
            print ("Port {0: >5}: {1: >10}".format(port, port_state))
    duration = datetime.now() - t_start

    print ("\n")
    print ("-" * 90)
    print ("scanning completed in : {0}".format(duration))

if __name__ == '__main__':
    args = parse_args()
    socket.setdefaulttimeout(int(args.timeout))
    logging.basicConfig(format='%(asctime)s | %(levelname)s | %(message)s',filename=args.logfile,filemode='w',level=logging.DEBUG)
    scan_ports(remote_host=args.hostname,
               start_port=args.start_port, end_port=args.end_port,
               debug=args.verbose, show_all=args.all_ports,logfile=args.logfile)

Überprüfen ob ein Remote File vorhanden ist oder nicht.

if ssh USER@HOST "test -e DATEI_INCL_PFAD"; then
    echo "remote file ist DATEI_INCL_PFAD vorhanden"
else
    echo "remote file DATEI_INCL_PFAD ist NICHT vorhanden"
fi

Problem : Wir arbeiten hier auf einem Server mit mehreren Usern, es kommt immer wieder vor das jemand die known_hosts überschreibt. Den Schuldigen haben wir noch nicht gefunden Also verwenden wir jetzt in unseren Skripts eigene known_hosts files.

Lösung :
Ich habe mir angewöhnt im Skript Ordner einen Ordner ssh anzulegen in dem dann die known_hosts liegt.
Somit bin ich unabhängig von anderen.
Setzen einer Variable im Skript

SSH_KNOWN_HOST="-o ConnectTimeout=30 -o UserKnownHostsFile=$(dirname $(readlink -f ${0}))/ssh/known_hosts"

Im Skript selbst kann man das so verwenden.

ssh ${SSH_KNOWN_HOST} USER@HOSTNAME

Da sftp und ssh die selben Parameter kennen kann man diese Variable beim Aufruf von ssh und sftp verwenden.