Get started

Install Fable with

dotnet new --install Fable.Template

Create an new App

dotnet new fable

Prepare environment

dotnet tool restore

Fix NodeJS SSL Error

$ENV:NODE_OPTIONS="--openssl-legacy-provider"

Install dependencies and run app

npm install

npm start

Error Message: ERR_OSSL_EVP_UNSUPPORTED

Solution

$ENV:NODE_OPTIONS="--openssl-legacy-provider"

Error: Resource busy or locked

When starting storybook with npm run storybook, you always get the error EBUSY: resource busy or locked

Solution: modify .storybook/main.js

You can fix this by adding the following to the file .storybook/main.js

module.exports = {
  ...
  managerWebpack: (config, options) => {
    options.cache.set = () => Promise.resolve();
    return config;
  }
}

Info about Content

Total number of pages in the /articles/ section: {{ len (where .Site.RegularPages "Section" "==" "articles") }}.

Tipps und Tricks im Internet

https://cloud.google.com/sdk/docs/cheatsheet

https://medium.com/google-cloud/7-gcloud-tricks-you-probably-didnt-know-7f64a16869e7

https://github.com/dennyzhang/cheatsheet-gcp-A4

https://gist.github.com/pydevops/cffbd3c694d599c6ca18342d3625af97

Big Query – SQL

SELECT – exclude special fields

select * except(title, comment) from publicdata.samples.wikipedia limit 10

You could use select-except or select-replace. Maybe you have to change the sql dialect.

Authentication

JWT Token

Try https://jwt.io to decode/check the token

Allgemein / Vorbereitung

Um in einem Django-Projekt mit mehreren Anwendungen die HTML-Templates zu konfigurieren sind mehrere Schritte notwendig.

Ausgangsbasis ist die nachfolgende Verzeichnisstruktur (ein Projekt mit 2 Anwendungen).

Basisprojekt einrichten

➜ pipenv --python 3.10
➜ pipenv shell

➜ pip install django

➜ djangop-admin startproject project

➜ cd project
➜ mkdir apps

➜ mkdir apps\core
➜ django-admin startapp core apps\core

➜ mkdir apps\frontend
➜ django-admin startapp frontend apps\frontend

Dies ergibt die folgende Verzeichnisstruktur:

Hinweis: der Befehl startproject erstellt einen Ordner project, indem er einen weiteren Ordner project erstellt. Der erste Ordner dient dazu, sowohl das Django-Projekt, als auch die erstellten Anwendungen an einer gemeinsame Stelle zu speichern.

Der zweite Ordner project ist das Django-Projekt, in dem sich alle für das Projekt notwendigen Dateien befinden.

Wird in den nachfolgenden Beschreibungen vom dem Ordner project gesprochen, so ist immer der zweite gemeint (project/project)

➜ python manage.py migrate

➜ python manage.py createsuperuser --email admin@localhost --username admin
Password:
Password (again):
Superuser created successfully.

Anwendungen hinzufügen

Im nächsten Schritt werden die beiden erstellten Anwendungen (Core und Frontend) dem Django-Projekt hinzugefügt. Da sie in einem Unterverzeichnis (apps) liegen, muss ihre Konfiguration angepasst werden.

In dere Datei apps.py der jeweiligen Anwendung (apps/core/apps.py und apps/frontend/apps.py) wirr der Name angepasst:

Hinweis: Ohne diese Anpassung würde beim Start des Servers eine Fehlermeldung angezeigt

django.core.exceptions.ImproperlyConfigured: Cannot import 'frontend'. Check that 'apps.frontend.apps.FrontendConfig.name' is correct.

Im Anschluss daran werden die beiden Anwendungen dem Projekt hinzugefügt. Dies erfolgt in der Datei project/settings.py:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    'apps.core',
    'apps.frontend'
]

Einfache Views erstellen

Ein Template ist die Basis eines Views.

Daher richten wir für jede Anwendung einen einfachen View ein: in apps/core/views.py und apps/frontend/views.py:

from django.shortcuts import render
from django.views import generic

class IndexView(generic.TemplateView):
    """
    IndexView:
    """
    module = 'indexView'
    template_name = 'core/index.html'

URLs für die Anwendungen hinzufügen

Im letzten Vorbereitungsschritt konfigurieren wir die URLs für unsere Anwendungen bzw die beiden eingerichteten Views:

from django.contrib import admin
from django.urls import path

import apps.core.views as core
import apps.frontend.views as frontend

urlpatterns = [
    path('admin/', admin.site.urls),
    path('frontend/', frontend.IndexView.as_view(), name='index'),
    path('core', core.IndexView.as_view(), name='index'),

]

Als Ergebnis sollten wir bei beiden URLs einen Fehler sehen.

Dies was zu erwarten, da wir die notwendigen Templates ja erst jetzt einrichten werden:

Template hinzufügen

Erstellen eines Templates für die Anwendung core: apps/core/templates/core/index.html

Der Verzeichnispfad des Templates setzt sich auch mehreren Teilen zusammen

Erstellen Sie die Daten apps/core/templates/core/index.html und öffnen Sie dann den Browser:

http://localhost:8000/core

Zum Vergleich öffen wir die URL für unsere zweite Anwendung: frontend

http://localhost:8000/frontend

Im unteren Teil der Fehlermeldung findet sich aber eine hilfreiche Information:

Als erstes wir uns mitgeteilt, das ein gewünschtes Template in der nachfolgenden Reihenfolge gesucht wird. Es werden als (wir oben bereits erwähnt) mehrere Verzeichnisse durchsucht, um ein passendes Template zu finden.

Template-loader postmortem
Django tried loading these templates, in this order:

Using engine django:

Als erstes werden Verzeichnisse der Django-Installation durchsucht. Hierunter liegen z. B. die Templates für die Administration oder die Anmeldung.

django.template.loaders.app_directories.Loader: 
...\lib\site-packages\django\contrib\admin\templates\frontend\index.html (Source does not exist)

django.template.loaders.app_directories.Loader: 
...\lib\site-packages\django\contrib\auth\templates\frontend\index.html (Source does not exist)

Im Anschluss werden dann die Verzeichnisse unserer Anwendungen durchsucht.

django.template.loaders.app_directories.Loader: ...\project\apps\core\templates\frontend\index.html (Source does not exist)

django.template.loaders.app_directories.Loader: ...\project\apps\frontend\templates\frontend\index.html (Source does not exist)

Um nun ein gewünschtes Template zu finden, werden zwei Informationen benötigt:

• der Name des Template
• das Verzeichnis

Name des Templates

Der Name des Templates wird im View angegeben: apps/core/views.py:

class IndexView(generic.TemplateView):
    module = 'indexView'
    template_name = 'core/index.html'

Verzeichnis

Das Verzeichnis selbst wird über die Suchreihenfolge der zu verwendenden Template-Verzeichnisse ermittelt. Das erste Verzeichnis, dass das gewünschte Template beinhaltet, wird verwendet.

Ermitteln des Verzeichnisses

Im Falle unserer Anwendung frontend werden die nachfolgenden Verzeichnisse durchsucht, ob sie das Template core/index.html beinhalten:

Template hinzufügen

Erstellen eines Templates für die Anwendung frontend: apps/frontend/templates/frontend/index.html

Weiteres Beispiel: Suchen des passenden Templates

Richten sie einen Neuen View in der Anwendung frontend ein: apps/frontend/views.py

class BaseView(generic.TemplateView):
    module = 'baseView'
    template_name = 'base.html' 

Erstellen Sie eine URL für diesen View in project/urls.py

urlpatterns = [
    path('admin/',      admin.site.urls),
    path('core',        core.IndexView.as_view(),      name='index'),
    path('frontend/',   frontend.IndexView.as_view(),  name='index'),
    path('base/',       frontend.BaseView.as_view(),   name='base'),
]

Öffnen Sie den Browser um diese URL anzuzeigen;

http://localhost:8000/base

Wie zu erwarten war, wird das Template nicht gefunden:

In keinem der bekannten Verzeichnisse gibt es ein Template base.html.

Gemeinsame Templates für alle Anwendungen

Um Templates einzurichten, die von mehreren Anwendungen verwendet werden, empfiehlt es sich, ein Verzeichnis templates auf der gleichen Ebene, wie die Anwendungen, einzurichten

In der Datei project/settings.py wird dieses Verzeichnis dem Django-Projekt hinzugefügt.

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        ....

Öffnen Sie den Browser um diese URL anzuzeigen;

http://localhost:8000/base

Das zusätzliche Verzeichnis wird nun auch durchsucht:

Template-loader postmortem
Django tried loading these templates, in this order:

Using engine django:

django.template.loaders.filesystem.Loader: ...\project\templates\base.html (Source does not exist)

django.template.loaders.app_directories.Loader: ...\.venv\lib\site-packages\django\contrib\admin\templates\base.html (Source does not exist)
django.template.loaders.app_directories.Loader: ...\.venv\lib\site-packages\django\contrib\auth\templates\base.html (Source does not exist)
django.template.loaders.app_directories.Loader: ...\project\apps\core\templates\base.html (Source does not exist)
django.template.loaders.app_directories.Loader: ...\project\apps\frontend\templates\base.html (Source does not exist)

Erstellen Sie nun in diesem Verzeichnis (templates) das Template base.html

Öffnen Sie den Browser um diese URL anzuzeigen;

http://localhost:8000/base

Pipenv: Python-Entwicklungsworkflow für Menschen

Pipenv ist ein Tool, das darauf abzielt, das Beste aller Verpackungswelten (Bündel, Composer, NPM, Cargo, Garn usw.) in die Python-Welt zu bringen. Windows ist in unserer Welt ein erstklassiger Bürger.

Es erstellt und verwaltet automatisch eine virtuelle Umgebung für Ihre Projekte und fügt Pakete zu Ihrer Pipfile hinzu/entfernt sie, während Sie Pakete installieren/deinstallieren. Es generiert auch das immer wichtige Pipfile.lock, das verwendet wird, um deterministische Builds zu erstellen.

Die Probleme, die Pipenv zu lösen versucht, sind vielschichtig:

• Sie müssen pip und virtualenv nicht mehr separat verwenden. Sie arbeiten zusammen.
• Die Verwaltung einer Requirements.txt-Datei kann problematisch sein, daher verwendet Pipenv Pipfile und Pipfile.lock, um abstrakte Abhängigkeitsdeklarationen von der zuletzt getesteten Kombination zu trennen.
• Hashes werden immer und überall verwendet. Sicherheit. Sicherheitslücken automatisch aufdecken.
• Empfehlen Sie dringend die Verwendung der neuesten Versionen von Abhängigkeiten, um Sicherheitsrisiken durch veraltete Komponenten zu minimieren.
• Geben Sie Einblick in Ihr Abhängigkeitsdiagramm (z. B. pipenv graph).
• Optimieren Sie den Entwicklungsworkflow durch Laden von .env-Dateien.

Installation

Installieren Sie pipenv über das Kommando pip

pip install pipenv

Beispiele

Virtuelle Umgebungmit Python 3.9 erstellen

E:\> pipenv --python 3.9

E:\> type .\Pipfile
[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]

[dev-packages]

[requires]
python_version = "3.9"

Verzeichnisse der virtuellen Umgebung anzeigen

E:\> pipenv --where
E:\
E:\> pipenv --venv
C:\Users\workshop.virtualenvs\pipenv-python39-FzfGexFj

E:\> get-command python

CommandType     Name                                               Version    Source
-----------     ----                                               -------    ------
Application     python.exe                                         3.9.6150.… C:\Users\workshop\.virtualenvs\pipenv-python39-FzfGexFj\Scripts\python.exe

Die virtuelle Umgebung wird im Verzeichnis des Benutzer erstellt, im Unterordner .virtualenv.

Sollte ihr Projekt die Anforderung haben, das die virtuelle Umgebung im Projektordner erstellt wird, dann gibt es hierfür zwei Möglichkeiten:

• Erstellen Sie im Projektordner einen Unterordner .venv
• Verwenden Sie die Umgebungsvariable PIPENV_VENV_IN_PROJECT.

 E:\> $ENV:PIPENV_VENV_IN_PROJECT=1 && pipenv --python 3.9
Creating a virtualenv for this project...
Pipfile: E:\Pipfile
Using D:/Python/3.9.6/python.exe (3.9.6) to create virtualenv...
[=== ] Creating virtual environment...created virtual environment CPython3.9.6.final.0-64 in 262969ms
  creator CPython3Windows(dest=E:\.venv, clear=False, no_vcs_ignore=False, global=False)
  seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=C:\Users\rg\AppData\Local\pypa\virtualenv)
    added seed packages: pip==21.1.3, setuptools==57.1.0, wheel==0.36.2
  activators BashActivator,BatchActivator,FishActivator,PowerShellActivator,PythonActivator,XonshActivator

Successfully created virtual environment!

Um für alle zu Erstellenden virtuellen Umgebungen das Verzeichnis anzupassen, kann die Umgebungsvariable WORKON_HOME verwendet werden.

Wechseln in die virtuelle Umgebung

E:\> pipenv shell
Launching subshell in virtual environment...
PowerShell 7.2.0-preview.6
Copyright (c) Microsoft Corporation.

Virtuelle Umgebung verlassen

Verlassen Sie die virtuelle Umgebung einfach, indem sie die neu gestartete Subshell beenden

E:\> exit

Prüfen, ob man in einer virtuellen Umgebung arbeitet

Prüfen Sie, welches Python Version verwendet wird

E:\> Get-Command python

CommandType     Name                Version    Source
-----------     ----                -------    ------
Application     python.exe          3.9.6150.… E:\.venv\Scripts\python.exe

Prüfen sie, welche PIP Version verwendet wird:

E:\> pip -V
pip 21.1.3 from E:\.venv\lib\site-packages\pip (python 3.9)

Prüfen Sie die Umgebungsvariable PIPENV_ACTIVE

E:\>$ENV:PIPENV_ACTIVE
1

Löschen einer virtuellen Umgebung im aktuellen Verzeichnis

E:\> pipenv --rm
Removing virtualenv (C:\Users\workshop\.virtualenvs\pipenv-python39-FzfGexFj)...

Installieren eines Paketes

E:\> pipenv install fastapi
Installing fastapi...
Adding fastapi to Pipfile's [packages]...
Installation Succeeded
Pipfile.lock (16c839) out of date, updating to (4f56a0)...
Locking [dev-packages] dependencies...
Locking [packages] dependencies...
           Building requirements...
Resolving dependencies...
Success!
Updated Pipfile.lock (4f56a0)!
Installing dependencies from Pipfile.lock (4f56a0)...
  ================================ 0/0 - 00:00:00
To activate this project's virtualenv, run pipenv shell.
Alternatively, run a command inside the virtualenv with pipenv run.

Der neue Inhalt der Konfigurationsdatei Pipfile:

E:\> type Pipfile
[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]
fastapi = "*"

[dev-packages]

[requires]
python_version = "3.9"

Install all dependencies for a project (including dev)

E:\> pipenv install --dev
Pipfile.lock not found, creating...
Locking [dev-packages] dependencies...
Locking [packages] dependencies...
Updated Pipfile.lock (16c839)!
Installing dependencies from Pipfile.lock (16c839)...
  ================================ 0/0 - 00:00:00
To activate this project's virtualenv, run pipenv shell.
Alternatively, run a command inside the virtualenv with pipenv run.

Erstellen einer Lockdatei Pipenv.lock mit den aktuell installierten Releases

E:\> pipenv lock --pre
Locking [dev-packages] dependencies...
Locking [packages] dependencies...
Updated Pipfile.lock (16c839)!

Show a graph of your installed dependencies:

E:\> pipenv graph
fastapi==0.68.0
  - pydantic [required: >=1.6.2,<2.0.0,!=1.8.1,!=1.8,!=1.7.3,!=1.7.2,!=1.7.1,!=1.7, installed: 1.8.2]
    - typing-extensions [required: >=3.7.4.3, installed: 3.10.0.0]
  - starlette [required: ==0.14.2, installed: 0.14.2]

Oder mit dem Ausgabeformat JSON

 E:\> pipenv graph --json-tree

Überprüfen der installierten Abhängigkeiten auf Sicherheitslücken

E:\> pipenv check
Checking PEP 508 requirements...
Passed!
Checking installed package safety...
All good!

Ausführen eines Kommandos in der virtuellen Umgebung

E:\> pipenv run pip -V
pip 21.1.3 from C:\Users\rg.virtualenvs\app-pipenv-tgP0nh4t\lib\site-packages\pip (python 3.9)

Ausführen eines Pip-Kommandos

E:\> pipenv run pip freeze
fastapi==0.68.0
pydantic==1.8.2
starlette==0.14.2
typing-extensions==3.10.0.0

Kommandozeile

Optionen

--where            Output project home information.
--venv             Output virtualenv information.
--py               Output Python interpreter information.
--envs             Output Environment Variable options.
--rm               Remove the virtualenv.
--bare             Minimal output.
--completion       Output completion (to be executed by the shell).

--man              Display manpage.
--support          Output diagnostic information for use in GitHub issues.

--site-packages / --no-site-packages
                   Enable site-packages for the virtualenv.
                   env var: PIPENV_SITE_PACKAGES]

--python TEXT      Specify which version of Python virtualenv should use.

--three / --two    Use Python 3/2 when creating virtualenv.
--clear            Clears caches (pipenv, pip, and pip-tools).
                   env var: PIPENV_CLEAR]

-v, --verbose      Verbose mode.
--pypi-mirror TEXT Specify a PyPI mirror.
--version          Show the version and exit.
-h, --help         Show this message and exit.

Einleitung

Anforderungen

CORS

app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"]
)

Starlette

Templates

Template erstellen

...

    
...

Template verwenden

    ...
    <main>....</main>




Links



CSS



<link href="{{ url_for('static', path='/css/bootstrap.min.css') }}"
      rel="stylesheet"
>
JavaScript
<script src="{{ url_for('static', path='/js/jquery.min.js') }}"></script>

TL;DR

Das Repository zu diesem Blog finden sie hier.

Voraussetzung

Für die Durchführung dieses Tutorials benötigen Sie Visual Studio Code, sowie Docker.

Docker

Installieren Sie Docker, indem Sie die Anwendung Docker Desktop herunterladen. Sie finden den Download hier: https://www.docker.com/products/docker-desktop

Eine Installationsbeschreibung finden Sie hier

Visual Studio Code

Installieren Sie Visual Studio Code mit Hilfe des Zip-Archiv. Sie können es von hier herunterladen: https://code.visualstudio.com/#alt-downloads

Hinweis: https://code.visualstudio.com, danach den Link Other platforms

Speichern Sie das Zip-Archiv und packen Sie es im gewünschten Programmverzeichnis aus.

Im Programmverzeichnis von Visual Studio Code erstellen Sie den Order data.

Damit wird der portable Mode aktiviert. In diesem Mode werden alle Einstellungen innerhalb dieser Installation gespeichert.

Notwendigen Erweiterungen

• Windows Subsystem for Linux (WLS) (ms-vscode-remote.remote-wsl)
• Remote Containers (ms-vscode-remote.remote-containers)
• Docker (ms-azuretools.vscode-docker)
• Python (ms-python.python)

Umgebung für unser Tutorial

Wir wollen alle in diesem Tutorials verwendeten Dateien in einem eigenen Ordner ablegen, z. B. FastAPI-Tutorial

Am Ende des Tutorials hat der Ordner diesen Inhalt

Docker-Umgebung

Visual Studio Code Remote Containers arbeiten mit Hilfe von Docker, um eine virtuelle Umgebung bereitzustellen.

Hierfür benötigen wie eine Reihe von Docker Konfigurationsdateien

Dockerfile

FROM ubuntu:21.04

LABEL MAINTAINER="Ralph Göstenmeier"

# set environment variables
ENV TZ 'Europe/Berlin'

RUN    apt-get update

RUN echo $TZ > /etc/timezone 

RUN    apt-get install -y tzdata \
    && rm /etc/localtime \
    && ln -snf /usr/share/zoneinfo/$TZ /etc/localtime \
    && dpkg-reconfigure -f noninteractive tzdata \
    && apt-get clean

RUN apt-get install --yes build-essential lsb-release curl sudo git vim
RUN apt-get install --yes python3-pip python3-venv

RUN groupadd work -g 1000
RUN adduser user --uid 1000 --gid 1000 --home /home/user --disabled-password --gecos User

RUN echo 

EXPOSE 5000

ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

#
USER user

VOLUME [ "/workspace" ]

COPY requirements.txt /workspace/requirements.txt
WORKDIR /workspace
RUN pip install -r requirements.txt

CMD ["bash", "-l"]

docker-compose.yml

version: "3.8"

services:
    app:
        build:
            context: .
            dockerfile: Dockerfile

        container_name: fastapi-tutorial

        volumes:
            - ./workspace:/workspace

        ports:
            - 5000:5000

        environment:
            - FASTAPI_ENV=development

        command: /bin/sh -c "while sleep 1000; do :; done"

requirements.txt

Für unsere Beispielanwendung benötigen wir eine Reihe von Python-Paketen. Diese werden mit Hilfe der Datei requirements.txt beim Bauen des Docker Images installiert.

asgiref==3.4.1
certifi==2021.5.30
charset-normalizer==2.0.3
click==8.0.1
fastapi==0.67.0
h11==0.12.0
idna==3.2
pydantic==1.8.2
requests==2.26.0
starlette==0.14.2
typing-extensions==3.10.0.0
urllib3==1.26.6
uvicorn==0.14.0

Visual Studio Code Umgebung

Verzeichnisstruktur

Die aktuelle Verzeichnisstruktur beinhaltet 2 Dateien.

Ordner in einem Container öffnen

Wir wollen nun diese Ordner in einem Container öffnen.

Klicken Sie hierzu in der Statusleiste links unten auf das grüne Symbol (Open a Remote Window)

Wählen Sie dann dein Eintrag Reopen in Container

Um anzugeben, wie der Container initial konfiguriert werden soll, wählen Sie den Eintrag From 'docker-compose.yml'

Anschließen wird der Container erstellt und geöffnet. Als erstes wird das Docker Image erstellt und gestartet

Umgebung im Container

Visual Studio Code hat nun den Container geöffnet und Sie befinden sich innerhalb des Docker Image.

Fehler beim Erstellen der Umbung

Tritt beim Erstellen der Umgebung ein Fehler auf, dann kann es an den Einstellungen in der Datei docker-compose.yml liegen

Die Fehlermeldung besagt, das wir den Namen für unseren “Service” (also die Anwendung, die wir erstellen wollen) noch anpassen müssen.

Schließen Sie das Fenster und öffnen sie den Ordner wieder lokal.

Öffnen sie dann die Datei .devcontainer/docker-compose.yml.

Ändern se den Namen des Servier von your-service-name-here nach app.

Öffnen sie danach den Ordner wieder als Container (Reopen in Container)

Prüfen der Umgebung

Dieses Docker Image würde basierend auf der Linux Distribution Ubuntu erstellt.

Erkunden Sie einfach mal die Umgebung.

DevContainer-Umgebung anpassen

Als nächstes passen wir die Umgebung des DevContainer an. Wir wollen z. B. nur die Dateien unserer Anwendung sehen und nicht die Docker Konfigurationsdateien

Hierzu erstellen wir einen Unterordner workspace und legen diesen als Startverzeichnis fest.

.devcontainer/devcontainer.json

{
	"name": "FastAPI Tutorial",

	"dockerComposeFile": [
		"../docker-compose.yml",
		"docker-compose.yml"
	],

	"service": "app",

	"workspaceFolder": "/workspace",

	"settings": {},
	"extensions": []
}

.devcontainer/docker-compose.yml

version: '3.8'
services:
  app:
    
    volumes:
      - ./workspace:/workspace:cached

      command: /bin/sh -c "while sleep 1000; do :; done"
 

Arbeitsordner erstellen

mkdir workspace

Container neu erstellen

Startverzeichnis im Container

Da wir ein neuen workspaceFolder eingestellt haben, ist das Startverzeichnis in Visual Studio Code leer:

Erste Anwendung erstellen

Basisdatei für die Anwendung erstellen

Nennen Sie die neue Ddatei main.py

Verwenden Sie dann den nachfolgende Code für die Datei

from fastapi import FastAPI

app =FastAPI()

@app.get('/')
def home():
	return { 'name': 'FastAPI Tutorial' }

Öffnen Sie dann ein Terminal (falls noch keines geöffnet ist)

Starten Sie dann den Webserver mit dem nachfolgenden Kommando:

uvicorn main:app --reload --port 5000 --host 0.0.0.0

Öffnen Sie einen Browser mit dem Link localhost:5000

Find out location of command

npm -g install which

Working with local repositories

npm -g install npm_lazy

npm_lazy --init >npm_lazy.js

npm_lazy --config npm_lazy.js

npm config set registry http://localhost:8080/