Skip to content

PyPi - Pakete ein Sicherheitsproblem?

Python3
  • Beim Lesen diesen Beitrages bekomme ich ein ungutes Gefühl. Da man ja bei Python ständig externe Pakete importiert hier ein Beispiel

    ###############################################
    # Imports
    ###############################################
    
    import json
    import locale
    from pathlib import Path
    from functools import partial
    from dataclasses import dataclass
    
    from pywebio import start_server, config
    from pywebio.pin import put_input
    from pywebio.session import info as session_info
    from pywebio.output import put_text, \
        put_table, \
        use_scope, \
        scroll_to, \
        put_markdown, \
        put_buttons, \
        put_button, \
        clear, \
        put_info, \
        put_error, \
        put_html, \
        put_tabs, \
        toast, \
        put_image, \
        put_row, \
        put_grid, \
        put_loading
    from pywebio.input import input, \
        input_group, \
        NUMBER, \
        PASSWORD, \
        TEXT, \
        URL, \
        radio
    from pywebio_battery import popup_input
    import requests as requests  # Requests for making network connections.
    
    from bs4 import BeautifulSoup  # For extracting data from HTML and XML docs.
    

    Das ist mein Import für ein kleines neues Tool, wo ich mein Portfolio mit anzeigen möchte. Ein wenig Spielerei, aber spannend und ich lerne wieder was dabei.

    In diesem Artikel, stehen auch ein paar Pakete, die ich nutze 😟
    https://blog.phylum.io/phylum-discovers-revived-crypto-wallet-address-replacement-attack

    Ich habe dann mal in der Gruppe PyDDF "Python Meeting Düsseldorf" nachgefragt, wie die Lage ist. Einer der Tipps war dann, VMs bzw. Docker zu benutzen, das ermöglicht ja eine gewisse Trennung vom Haupt-System.

    Docker läuft sowieso, dann kann ich das ja mal ausprobieren. Nach vielem Rumprobieren habe ich jetzt aktuelle eine funktionierende Lösung.

    Im Projekt gibt es ein dockerfile

    FROM python:3.10
    # Or any preferred Python version.
    ADD main.py .
    RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y locales
    RUN sed -i -e 's/# de_DE.UTF-8 UTF-8/de_DE.UTF-8 UTF-8/' /etc/locale.gen && \
        dpkg-reconfigure --frontend=noninteractive locales && \
        update-locale LANG=de_DE.UTF-8
    ENV LANG de_DE.UTF-8
    RUN pip install requests beautifulsoup4 pywebio pywebio_battery matplotlib
    CMD python ./main.py
    # Or enter the name of your unique directory and parameter set.
    

    Als nächstes brauchen wir mal folgendes

    docker build -t python-imagename .
    

    Danach dann starten mit

    docker run -d --rm --publish 7070:7070 --name portfolio python-imagename:latest
    

    Jetzt findet man die Anwendung wie gewohnt unter

    http://192.168.3.xxx:7070
    

    Die locales waren eine kleine Herausforderung, ich hoffe das passt jetzt so. Werde ich die Tage noch intensiver beobachten.

    Damit das Ganze halbwegs praktikabel ist, habe ich mir ein kleines Script geschrieben.

    scraping.sh

    #!/bin/bash
    ### BEGIN INIT INFO
    # Provides:          scraping
    # Required-Start:
    # Required-Stop:
    # Should-Start:
    # Default-Start:
    # Default-Stop:
    # Short-Description: scraping
    # Description:       scraping
    ### END INIT INFO
    
    case "$1" in
    stop)
        docker kill portfolio
        exit 0
            ;;
    
    start)
        #!/bin/bash
        cd /home/frankm/PycharmProjects/scraping/
        docker kill portfolio
        docker build -t python-portfolio .
        docker run -d --rm --publish 7070:7070 --name portfolio python-portfolio:latest
    
        exit 0
            ;;
    *)
            echo "Usage: basename $0 {start | stop}" >&2
            exit 64
            ;;
    esac
    exit 0
    

    Jetzt kann man nach einer Änderung am Code das Script schreiben. Der Docker Container wird gestoppt, falls er läuft. Danach wird das Image neu gebaut und dann gestartet.

    Zum Stoppen

    ./scraping.sh stop
    

    Zum Starten

    ./scraping.sh start
    

    Das kann man aber, in meinen Augen, nur mit fertigen Anwendungen machen. Wenn man entwickelt, braucht man ständig die Ausgaben auf der Konsole. Das fehlt einem ja dann im Container. Bin gespannt wie sich das weiter entwickelt.

    An die Docker Spezialisten draußen im Netz, wenn man das anders bzw. besser macht, bitte ich um einen Kommentar. Danke 😉

  • Python - Interessante Packages

    Python3
    1
    0 Stimmen
    1 Beiträge
    116 Aufrufe
    Niemand hat geantwortet
  • PyWebIO vs. Flask

    Python3
    2
    0 Stimmen
    2 Beiträge
    185 Aufrufe
    FrankMF
    Mist, jetzt habe ich auch noch Streamlit gefunden. Jetzt geht mir langsam die Zeit aus...
  • Portfolio - mein kleines Flask Projekt

    Python3
    5
    0 Stimmen
    5 Beiträge
    220 Aufrufe
    FrankMF
    Hab ChatGPT nochmal nach der Installation auf einem Production Server befragt. ChatGPT Certainly! Here's a short example of the steps you can follow to deploy a Flask application on a production server using Nginx and Gunicorn: Prepare your server: Set up a server (e.g., using a cloud provider like AWS, DigitalOcean, or a dedicated server) and ensure it has a clean, up-to-date installation of a Linux distribution (e.g., Ubuntu or CentOS). Install required software: Install necessary software packages on your server. You'll need Python, pip (Python package manager), Nginx, and Gunicorn. You can use your distribution's package manager (e.g., apt for Ubuntu or yum for CentOS) to install these dependencies. Deploy your Flask application: Copy your Flask application code and any required dependencies to your server. Set up a virtual environment (optional but recommended): Create a virtual environment for your Flask application to isolate its dependencies. You can use venv or virtualenv for this purpose. Install Flask and any required Python packages within your virtual environment: pip install flask Test your Flask application: Ensure your Flask application runs correctly within your server's virtual environment. Configure Gunicorn: Create a Gunicorn configuration file (e.g., gunicorn_config.py) to specify the settings for running your Flask application. Here's a simple example: workers = 4 # Number of Gunicorn worker processes bind = '0.0.0.0:8000' # The address and port Gunicorn should listen on Start Gunicorn: Start Gunicorn with your Flask application: gunicorn -c gunicorn_config.py your_app:app Configure Nginx: Create an Nginx server block (often located in /etc/nginx/sites-available) to define how Nginx should handle incoming requests. Here's a simplified example: server { listen 80; server_name your_domain.com www.your_domain.com; location / { proxy_pass http://127.0.0.1:8000; # Pass requests to Gunicorn proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; } } Enable the Nginx server block and restart Nginx: sudo ln -s /etc/nginx/sites-available/your_config /etc/nginx/sites-enabled/ sudo nginx -t # Test Nginx configuration sudo systemctl restart nginx Configure your DNS: Point your domain name to your server's IP address. Secure your server (optional but recommended): Set up SSL/TLS certificates for your domain to enable HTTPS. You can use Let's Encrypt for free SSL certificates. Monitor your application: Set up monitoring tools and logs to keep track of your application's performance and troubleshoot any issues. These are the basic steps to deploy a Flask application on a production server with Nginx and Gunicorn. Please note that this is a simplified example, and there are many additional considerations, such as database configuration, security, and optimization, depending on your specific application and requirements. It's also important to keep your server and software up to date and follow security best practices to ensure the stability and security of your production environment. Das werde ich doch mal ausprobieren
  • Redis - Datenbank Zugriff mit Python

    Redis
    3
    1
    0 Stimmen
    3 Beiträge
    185 Aufrufe
    FrankMF
    Ich bin mit der Lernkurve noch nicht so richtig zufrieden. Eine Frage die sich mir stellte, geht das einfacher? Der Ursprung meiner Datenbank Struktur liegt in einem anderen Projekt, wo ich versucht habe Daten permanent in einem File zu speichern. Dazu hatte ich damals JSON genommen. Deswegen auch diese Zeilen self.project = str(db_client.json().get('settings', '$..project')[0]) or self.project Gut, ich hatte dann mal ChatGPT gefragt, wie macht man das so 'normalerweise'? es kam eine Klasse heraus, die ich dann intensiv ausprobiert habe, ein wenig umgebaut usw. So lange, bis ich der Meinung war, ok ich habe es verstanden. Jetzt nutzte der Code auch mehr Redis Funktionen, wie self.client.hset('settings', name, json.dumps(data)) Es waren jetzt folgende Funktionen drin hset hexists hdel hget Dokumentation -> https://redis.io/commands/hset/ Beim Durchlesen des Codes hatte ich jetzt mehr das Gefühl, so muss das sein In RedisInsight sieht das dann jetzt so aus. [image: 1695479582374-393195f7-1017-4285-8fca-734ee6b4bff7-grafik.png] Klasse class PortfolioSettings: def __init__(self, host='172.17.0.2', port=6379, db=0): if args.test_mode == 1: self.client = redis.StrictRedis(host=SERVER_IP, port=port, db=TEST[0]) else: self.client = redis.StrictRedis(host=SERVER_IP, port=port, db=LIVE[0]) def set_settings(self, name, data): """Init settings if db don't exist""" if not self.client.hexists('settings', name): self.client.hset('settings', name, json.dumps(data)) return True return False def edit_setting(self, name, data): """Edit an entry in settings""" if self.client.hexists('settings', name): self.client.hset('settings', name, json.dumps(data)) return True return False def delete_setting(self, name): """Delete an entry in settings""" return self.client.hdel('settings', name) def get_setting(self, name): """Get an entry in settings""" setting = self.client.hget('settings', name) return json.loads(setting) if setting else None def get_all_settings(self): """Get all entries in settings""" settings = self.client.hgetall('settings') return {k.decode(): json.loads(v) for k, v in settings.items()} Und hier die Initialisierung settings_data = PortfolioSettings() ##################### # Will only be executed if DB is not available! ##################### if not settings_data.get_all_settings(): # Settings initialisieren print("INIT") settings_data.set_settings("project", "Portfolio") settings_data.set_settings("version", "0.0.3") settings_data.set_settings("theme", "dark") settings_data.set_settings("url_list", ["https://www.onvista.de/aktien/Deutsche-Telekom-Aktie-DE0005557508"]) settings_data.set_settings("exchange_list", ['DKB','Smartbroker','BUX']) Teile der Klasse sind [KI-generiert] Ich war zufrieden und habe die Klasse dann in mein Projekt übernommen und den Code überall entsprechend angepasst.
  • Python - Frameworks

    Python3
    2
    0 Stimmen
    2 Beiträge
    132 Aufrufe
    FrankMF
    Und mal hier parken https://www.youtube.com/watch?v=Tucr8Ta-kq4&t=1911s
  • ResticUI with PyWebIO - Repo

    PyWebIO
    1
    0 Stimmen
    1 Beiträge
    101 Aufrufe
    Niemand hat geantwortet
  • Qt 5 Designer

    Python3
    1
    4
    0 Stimmen
    1 Beiträge
    118 Aufrufe
    Niemand hat geantwortet
  • PyQt6 - QSettings

    Python3
    3
    0 Stimmen
    3 Beiträge
    383 Aufrufe
    FrankMF
    Möglichkeit 1 Das hier settings = QSettings("Frank_Mankel", "Restic_UI") erzeugt unter /home/frank/.config/Frank_Mankel/Restic_UI.conf die Konfigurationsdatei. Möglichkeit 2 Das hier settings = QSettings("Restic_UI") erzeugt unter /home/frank/.config/Restic_UI.conf die Konfigurationsdatei. Damit habe ich die grundlegenden Dinge, hoffentlich , verstanden. Für den Rest mal in die Dokumentation schauen. Sehr hilfreich war auch mal ein Blick auf die Definition der Klasse. Rechtsklick auf QSettings und dann Go to Definition class QSettings(QObject): class Scope(enum.Enum): UserScope = ... # type: QSettings.Scope SystemScope = ... # type: QSettings.Scope class Format(enum.Enum): NativeFormat = ... # type: QSettings.Format IniFormat = ... # type: QSettings.Format InvalidFormat = ... # type: QSettings.Format class Status(enum.Enum): NoError = ... # type: QSettings.Status AccessError = ... # type: QSettings.Status FormatError = ... # type: QSettings.Status [..gekürzt..]