Dies ist eine Fortsetzung der (2) Frontend-Entwicklung - Nginx + React.
Ich möchte eine Anwendung mit Djagno + React-Konfiguration entwickeln und für Google Kubernetes Engine bereitstellen Ich habe es geschrieben, weil es unwahrscheinlich war, dass es ein zusammenhängendes Tutorial geben würde.
** Ich denke, es gibt einige Punkte, die noch nicht perfekt sind **, aber ich denke, wenn Sie ein wenig Erfahrung haben, können Sie sie sofort verwenden.
Dies ist eine Aufzeichnung eines unerfahrenen Hobbyingenieurs, der mit der Bereitstellung zur Erstellung eines Portfolios zu kämpfen hat. Wenn es Mängel gibt, weisen Sie bitte darauf hin. ..
$ node --version
v12.14.1
$ npm --version
6.13.7
$ python --version
Python 3.7.4
$ docker --version
Docker version 19.03.8
OS windows10 pro
Wir werden es für Google Kubernetes Engine (GKE) bereitstellen. Ich verweise sehr auf das Offizielle Tutorial.
Melden Sie sich bei Ihrem Google-Konto an und starten Sie ein neues Projekt über die Cloud-Konsole.
Projektname: gke-django-tutorial
Ort:Keine Organisation
Referenz: https://cloud.google.com/billing/docs/how-to/modify-project?authuser=2
GCP-Ressourcen können mithilfe des Cloud SDK von Ihrem lokalen PC aus bearbeitet werden. Es wird davon ausgegangen, dass gcloud bereits installiert ist.
#gcloud-Initialisierung
$\gke-django-tutorial\gcloud init
Welcome! This command will take you through the configuration of gcloud.
Pick configuration to use:
[1] Re-initialize this configuration [xxxxxx] with new settings
[2] Create a new configuration
Please enter your numeric choice: 2
Enter configuration name. Names start with a lower case letter and
contain only lower case letters a-z, digits 0-9, and hyphens '-': gke-django-tutorial
Your current configuration has been set to: [gke-django-tutorial]
You can skip diagnostics next time by using the following flag:
gcloud init --skip-diagnostics
Network diagnostic detects and fixes local network connection issues.
Checking network connection...done.
Reachability Check passed.
Network diagnostic passed (1/1 checks passed).
Choose the account you would like to use to perform operations for
this configuration:
[1] [email protected]
[2] [email protected]
[3] Log in with a new account
Please enter your numeric choice: 1
You are logged in as: [[email protected]].
Pick cloud project to use:
[1] XXXXXXX
[2] [YOUR_PROJECT]
[3] Create a new project
Please enter numeric choice or text value (must exactly match list
item): 2
Your current project has been set to: [YOUR_PROJECT].
Not setting default zone/region (this feature makes it easier to use
[gcloud compute] by setting an appropriate default value for the
--zone and --region flag).
See https://cloud.google.com/compute/docs/gcloud-compute section on how to set
default compute region and zone manually. If you would like [gcloud init] to be
able to do this for you the next time you run it, make sure the
Compute Engine API is enabled for your project on the
https://console.developers.google.com/apis page.
Your Google Cloud SDK is configured and ready to use!
* Commands that require authentication will use [email protected] by default
* Commands will reference project `[YOUR_PROJECT]` by default
Run `gcloud help config` to learn how to change individual settings
This gcloud configuration is called [YOUR_PROJECT]. You can create additional configurations if you work with multiple accounts and/or projects.
Run `gcloud topic configurations` to learn more.
[Unten weggelassen]
Aktivieren Sie Datenspeicher-, Pub / Sub-, Cloud-Speicher-JSON-, Cloud-Protokollierungs- und Google+ APIs.
$\gke-django-tutorial\gcloud services enable sqladmin
Operation "operations/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" finished successfully.
Laden Sie Cloud SQL Proxy herunter und benennen Sie es in "cloud_sql_proxy.exe" um.
Dies wird unter $ \ gke-django-tutorial \ installiert.
Erstellen Sie eine Instanz von CloudSQL über die Cloud-Konsole.
Auswahl der Datenbank-Engine: PostgreSQL
Instanz-ID: [SQL_INSTANCE_NAME]
Passwort: [YOUR_PASSWORD]
Ort:
Region: [SQL_REGION_NAME]
Zone: [DATABASE_ZONE]
Datenbankversion: PostgreSQL 11
Überprüfen Sie den "Verbindungsnamen", um eine Verbindung zu CloudSQL mithilfe der zuvor heruntergeladenen "cloud_sql_proxy.exe" herzustellen.
#Bestätigung von connecsionName
$\gke-django-tutorial\gcloud sql instances describe [SQL_INSTANCE_NAME]
connectionName: [YOUR_PROJECT]:[SQL_REGION_NAME]:[SQL_INSTANCE_NAME]
#Instanzverbindung
$\gke-django-tutorial\gcoud_sql_proxy.exe -instances="[YOUR_PROJECT]:[SQL_REGION_NAME]:[SQL_INSTANCE_NAME]"=tcp:5432
2020/04/28 17:49:51 Listening on 127.0.0.1:5432 for gke-django-tutorial:asia-northeast1:websql
2020/04/28 17:49:51 Ready for new connections
Mit diesem Befehl konnte ich von meinem PC aus eine Verbindung zu meiner CloudSQL-Instanz herstellen. Lassen Sie die Eingabeaufforderung mit der Instanz verbunden und arbeiten Sie mit einer anderen Eingabeaufforderung.
Erstellen wir eine Datenbank über die Konsole. Sie können eine Datenbank aus einer Datenbank erstellen, indem Sie auf der Konsole "[SQL_INSTANCE_NAME]" auswählen.
Name der Datenbank: [DATABASE_NAME]
Erstellen Sie ein Datenbankbenutzerkonto über die Konsole.
Nutzername: [DATABASE_USER]
Passwort: [DATABASE_PASSWORD]
Erstellen Sie ein CloudSQl-Dienstkonto über die Konsole und laden Sie Ihren privaten Schlüssel im JSON-Format herunter.
Name des Dienstkontos: [SERVICE_ACCOUNT_NAME]
Dienstkonto-ID: [SERVICE_ACCOUNT_NAME]@BBBBBBBBB.iam.gservice
Behörde:Cloud SQL-Administrator
⇒ Wählen Sie beim Erstellen eines privaten Schlüssels das JSON-Format
⇒ privater Schlüssel im JSON-Format: ZZZZZZZZZZZZZZZ.json wird heruntergeladen
Erstellen Sie ein Verzeichnis mit dem Namen "Geheimnisse \ Cloudsql" direkt unter dem Projekt und platzieren Sie den erstellten privaten Schlüssel.
$\gke-django-tutorial\mkdir secrets
$\gke-django-tutorial\cd secrets
$\gke-django-tutorial\secrets\mkdir cloudsql
$\gke-django-tutorial\secrets\cd cloudsql
#Behalten Sie Ihren privaten Schlüssel
$\gke-django-tutorial\secrets\cloudsql\dir
ZZZZZZZZZZZZZZZ.json
Stellen Sie die Django-Datenbank auf CloudSQL ein, starten Sie sie und bereiten Sie die Verwendung von CloudSQL vor. Wie im lokalen sqlite3 werden wir die Tabelle aus der lokalen Umgebung über cloud_sql_proxy migrieren.
Fügen Sie `` DATABASE_USER und DATABASE_PASSWORDzur.env`-Datei hinzu, um sie als Umgebungsvariablen zu verwenden.
Setzen Sie kein Leerzeichen zwischen Schlüssel und Wert.
SECRET_KEY='XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
DEBUG=False
DATABASE_USER=[DATABASE_USER]
DATABASE_PASSWORD=[DATABASE_PASSWORD]
backend/config/settings.py
Ändern Sie die DATABASE-Einstellung von Django von db.sqlite3 in CloudSQL.
Sie müssen direkt auf die .env-Datei verweisen, also laden Sie sie mit python-dotenv.
# backend/config/setting.sy
import os
from dotenv import load_dotenv #hinzufügen
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
PROJECT_DIR = os.path.basename(BASE_DIR)
load_dotenv(os.path.join(BASE_DIR, '.env')) #hinzufügen
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = os.environ.get('SECRET_KEY')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = os.environ.get('DEBUG')
DATABASES = {
'default': {
# If you are using Cloud SQL for MySQL rather than PostgreSQL, set
# 'ENGINE': 'django.db.backends.mysql' instead of the following.
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'web-db',
'USER': os.getenv('DATABASE_USER'),
'PASSWORD': os.getenv('DATABASE_PASSWORD'),
'HOST': '127.0.0.1',
'PORT': '5432',
}
}
Ich habe die Datenbankeinstellungen in CloudSQL geändert und muss erneut migrieren.
(venv)$\gke-django-tutorial\backend\python manage.py migrate
Operations to perform:
Apply all migrations: admin, auth, contenttypes, sessions, todo
Running migrations:
Applying contenttypes.0001_initial... OK
Applying auth.0001_initial... OK
Applying admin.0001_initial... OK
Applying admin.0002_logentry_remove_auto_add... OK
Applying admin.0003_logentry_add_action_flag_choices... OK
Applying contenttypes.0002_remove_content_type_name... OK
Applying auth.0002_alter_permission_name_max_length... OK
Applying auth.0003_alter_user_email_max_length... OK
Applying auth.0004_alter_user_username_opts... OK
Applying auth.0005_alter_user_last_login_null... OK
Applying auth.0006_require_contenttypes_0002... OK
Applying auth.0007_alter_validators_add_error_messages... OK
Applying auth.0008_alter_user_username_max_length... OK
Applying auth.0009_alter_user_last_name_max_length... OK
Applying auth.0010_alter_group_name_max_length... OK
Applying auth.0011_update_proxy_permissions... OK
Applying sessions.0001_initial... OK
Applying todo.0001_initial... OK
Ich konnte problemlos auf CloudSQL migrieren.
Erstellen Sie einen Administratorbenutzer sowie SQLite.
(venv)$\gke-django-tutorial\backend\python manage.py createsuperuser
Nutzername(leave blank to use '[YOUR_NAME]'): [SUPERUSER_NAME]
Mail Adresse: [YOUR_EMAIL]@gmail.com
Password:
Password (again):
Superuser created successfully.
Starten wir den Entwicklungsserver und fügen ungefähr 3 Daten von der Administratorseite hinzu.
(venv)$\gke-django-tutorial\backend\python manage.py runserver
Sie können Daten in der Datenbank speichern, die in Ihrer CloudSQL-Instanz erstellt wurde, indem Sie sich auf der Administrationsseite unter "http: // localhost: 8000 / admin /" anmelden. Fügen wir ein paar Elemente hinzu.
Speichern Sie statische Dateien in Google Cloud Storage (GCS) und konfigurieren Sie Einstellungen für statische Dateien, die von GCS geliefert werden sollen.
Erstellen Sie Speicher und laden Sie statische Dateien hoch. Wenn Sie dies nicht tun, wird CSS wie der Administratorbildschirm nicht angezeigt.
#Speicher erstellen
(venv)$\gke-django-tutorial\backend\gsutil mb gs://[STORAGE_NAME]
Creating gs://gke-django-storage/...
#Veröffentlichungseinstellungen
(venv)$\gke-django-tutorial\backend\gsutil defacl set public-read gs://[STORAGE_NAME]
Setting default object ACL on gs://[STORAGE_NAME]/...
/ [1 objects]
#Sammeln Sie statische Dateien
(venv)$\gke-django-tutorial\backend\python manage.py collectstatic
#Laden Sie statische Dateien in den Cloud-Speicher hoch
(venv)$\gke-django-tutorial\backend\gsutil rsync -R staticfiles/ gs://[STORAGE_NAME]/static
Ändern Sie "STATIC_URL" in "backend / config / settings.py", um auf GCS zu verweisen.
# backend/config/settings.py
STATIC_URL = 'https://storage.googleapis.com/[STORAGE_NAME]/static/'
Wir haben ein GCP-Projekt erstellt und uns auf Cloud SQL und Cloud Storage vorbereitet.