Vorwort
Im Folgenden finden Sie ein Beispiel für die Integration von Kubernetes in den CDN-Service Edgio Delivery für erfahrene Kubernetes-Praktizierende. Es setzt Kenntnisse in Kubernetes und Kenntnisse über Standard-Internetprotokolle wie TCP, DNS und HTTP/HTTPS voraus. Das letzte Ziel besteht darin, eine Möglichkeit zu demonstrieren, wie der Edgio Delivery CDN-Service als Standard-Eingangsleistung angezeigt wird. Der Kubernetes-Benutzer kann die Eingangskonfiguration in vertrauten Systemen wie Portainer oder Terraform beibehalten .
Kubernetes
Kubernetes.io definiert Kubernetes als „ein Open-Source-System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen“. Es gibt mehrere Möglichkeiten, einen Cluster zu öffnen. Die schnellste und einfachste Möglichkeit besteht darin, einen der vielen Cloud-Anbieter zu nutzen, die Bereitstellungen mit nur einem Klick ermöglichen.
Kubernetes-Cluster enthalten viele Teile. In der Demo konzentrieren wir uns auf eine Teilmenge der Gesamtsumme.
Kubernetes Teile
- Knoten: Maschine oder VM, die die Workloads und Services hostet.
- Workload: Anwendung einfach oder komplex
- Pod: Container, in denen die Anwendungssoftware ausgeführt wird. Ein oder mehrere Pods stellen eine Arbeitslast dar.
- Service: Ein Mechanismus, der eine Workload anderen Workloads oder Eingängen zugänglich macht
- Ingress: Ein Mechanismus, um Dienstleistungen der Außenwelt zugänglich zu machen
Edgio
Edgio macht Connected Living schneller, sicherer und einfacher zu verwalten, indem wir unübertroffene Geschwindigkeit, Sicherheit und Einfachheit an der Peripherie mit unseren nahtlos integrierten Bereitstellungs-, Anwendungs- und Streaming-Lösungen bereitstellen. Unsere weltweit skalierte Technologie und unsere Expertenservices verleihen den weltweit führenden Marken die Fähigkeit, jedem Nutzer die schnellsten, dynamischsten und reibungslosesten Bildungs-, Unterhaltungs-, Event- und Anwendungsprogramme zu bieten. Edgio ist ein Partner erster Wahl, der den weltweiten Internetverkehr fördert, um die beliebtesten Shows, Filme, Sport, Spiele und Musik zu unterstützen und Websites sofort zu laden.
Architektur
Edgio Delivery CDN
Für diese Demo verwenden wir das Edgio Python SDK bei GitHub – llnw/llnw-sdk-python: Limelight Networks Python SDK. Die Basiskonfiguration wird einfach gehalten.
Beim Konfigurieren des CDN sind die folgenden Daten (außer der Authentifizierung) erforderlich.
- SHORTNAME: Eine eindeutige ID innerhalb des Edgio Delivery CDN, die CDN-Regeln enthält.
- Veröffentlichter Hostname: Der Hostname, der vom CDN aus auf das Internet gerichtet ist. Im Fall dieser Demo wurde der Hostname cstradtman.s.llnwi.net bereits konfiguriert.
- Veröffentlichter URL-Pfad: Der Pfad, der der betreffenden Regel zugeordnet ist.
- Quell-Hostname: Der Hostname des Ursprungs. In diesem Fall weist ein Round-robin-Rekord auf den Kubernetes-Cluster hin.
- Quell-URL-Pfad: Der Zielpfad, der mit dem Hostnamen verknüpft ist. In diesem Fall ist es leer, da wir es später in diesem Dokument beschreiben. In dieser Demo werden Workloads nach Portnummer und nicht nach Pfad unterschieden.
DNS
Die Demo verwendet die Vultr DNS-API. Das Konfigurieren des CDN mit IP-Adressen als Ursprung ist keine bewährte Vorgehensweise. Die Demo verwendet eine API zum Erstellen oder Ändern eines Round-robin-Datensatzes, der auf die Clusterknoten verweist.
Cluster
Die Demo befindet sich in Vultr auf einem Cluster mit drei Knoten.
Namespaces
Die Demo wird unter dem Standard-Namespace vorhanden sein, da sie das einzige Element ist, das auf diesem Cluster ausgeführt wird
Knoten
- VKE-Cluster – je 3 Knoten mit
- 4G-Zylinder
- 80G-Festplatte
- 2 vCPU
- 1 G-Netzwerk
Workloads
Die Workload ist ein einfaches Python-Programm, das grundlegende Informationen über die HTTP-Verbindung zurückgibt. Wir stellen diese Demo inline bereit, was keine typische Bereitstellungsmethode ist. Sie ermöglicht es jedoch, dass die Demo vollständig in sich geschlossen ist, anstatt externe Abhängigkeiten zum Erstellen und Speichern der Container zu haben. Der Quellcode befindet sich in Anhang 1. Der tatsächliche Python-Code wird kursiv dargestellt, der YAML-Code, der das Deployment beschreibt, ist dies nicht. Die Workload verwendet TCP-Port 8000.
Services
Es stehen mehrere Servicetypen zur Verfügung. Wir verwenden den Servicetyp „NodePort“. Der Dienst wird auf den externen IP-Adressen des Clusters auf einer zufällig ausgewählten hohen Portnummer angegeben. Kubernetes kümmert sich um die Verbindung zu einem Knoten, auf dem die Workload ausgeführt wird.
Eindringen
Kubernetes Ingress ist ein Softwareobjekt, das das Verhalten einer Sammlung von Ressourcen beschreibt, die einen Kubernetes-Service außerhalb des Clusters verfügbar machen.
Ein Eingangssteuergerät kombiniert Software und/oder Hardware, die das Eingangssoftware-Objekt instanziiert.
Ein CDN ist ein funktionsreicher verteilter Reverse-Proxy. Neben der Reverse-Proxy-Funktion verfügen CDNs normalerweise über flexible Cache-Algorithmen, geografische Vielfalt, Sicherheitsfunktionen (ACLs (GEO, Method, regex), Webanwendungen Firewalls, Wasserzeichen und andere erweiterte Funktionen, die in einfachen Reverse-Proxys nicht zu finden sind.
Die APIs für die Kubernetes-Objektüberwachung sind gut definiert, und eine Reihe von HTTP-Reverse-Proxys und Load Balancer wurden erweitert, um als Eingangscontroller zu arbeiten. NGINX und HAProxy sind beispielsweise Proxys der alten Schule, die als Eingangsregler erweitert wurden, und solche wie Traefik und Itsio wurden parallel zu Kubernetes entwickelt. Ein CDN ist eine natürliche nächste Progression von einfachen Reverse Proxys. Im Fall dieser Demo erstellen wir einen benutzerdefinierten Eingangscontroller, der das Edgio Delivery CDN steuert. Die Daten, die normalerweise zur Beschreibung eines Eingangs erforderlich sind, sind
- Öffentlicher Hostname: Der Hostname, auf dem der Kubernetes-Service verfügbar ist
- Öffentlicher Pfad: Der Pfad, der mit dem öffentlichen Hostnamen verknüpft ist, auf dem die Kubernetes-Dienste verfügbar sind
- Backend Service-Name: Service-Name, der von einer Kubernetes-Service-Stanz definiert wird
- Backend-Port: Ein Name, der mit der Portbeschreibung in der Servicebeschreibung übereinstimmt
Edgio Delivery CDN-Asset-Zuordnungen:
|
Kubernetes |
Edgio Delivery CDN |
|
Öffentlicher Hostname |
Veröffentlichter Hostname |
|
Öffentlicher Pfad |
Veröffentlichter URL-Pfad |
|
Backend Service-Name Einzigartig innerhalb des Kubernetes-Clusters Nicht bekannt/für die Außenwelt verfügbar |
Hostname der Quelle Vollständig angegebener Domainname Nicht wirklich eins zu eins |
Die Logik dahinter ist:
- Auf Namespace-Eingangsereignis aus dem Cluster horchen
- Wenn der Ereignistyp „hinzugefügt“ ist.
- Ruft die IP-Adresse der Knoten im Cluster ab
- DNS-Datensatz in vultr erstellen
- Erstellen Sie CDN-Regeln in Edgio CDN, die auf die erstellten DNS-Datensätze und den vom NodePort-Service zugewiesenen Port verweisen.
- Wenn der Ereignistyp „geändert“ ist.
- Suchen Sie CDN-Regeln in Edgio CDN, die mit dem vorhandenen Eingang übereinstimmen
- Ändern Sie die Regeln in Edgio CDN, um neue Daten im Ereignis wiederzugeben
- Wenn der Ereignistyp „gelöscht“ ist.
- Suchen Sie CDN-Regeln in Edgio CDN, die mit entferntem Eingang übereinstimmen
- Entfernen Sie DNS-Datensätze in Vultr, die mit diesem Eingang verknüpft sind
- Entfernen Sie die CDN-Regeln in Edgio, die mit dem entfernten Eingang übereinstimmen
Konfiguration
Objekte
Kubernetes-Objekte werden in YAML-Dateien beschrieben. In Kubernetes ist jede Konfiguration ein Objekt. Sie können alle Deployment-Konfigurationen in einer einzigen Datei ablegen. Es ist gängige Praxis, sie nach dem Teil der Bereitstellung aufzuteilen, den sie beschreiben.
Bereitstellung
In Anhang 1 befindet sich eine große YAML-Datei, die eine Kombination aus Python-Code und YAML ist. Alles nach „spec.template.spec.containers.command”“ ist der Python-Code, der während der Bereitstellung in einen Container umgewandelt wird. Aus Sicht des Kubernetes-Objekts sind für uns folgende Zeilen wichtig:
- Art: Deployment – beschreibt das Objekt als Deployment
- Metadata.name: Der Name wird vom Service-Objekt verwendet, um die Verknüpfung zwischen den beiden zu erstellen.
- Spec.selector.matchlabels.app: gibt an, auf welche Pods die Bereitstellung angewendet wird.
- Spec.template.spec.Containers.image: Zeigt auf das offizielle Bild des Docker Hub Python 3
- Spec.template.spec.containers.ports.name: Ein Label für den Port, der in diesem Fall in einem anderen Objects-Service referenziert werden soll
- Spec.template.spec.Containers.Ports.containerport: Führt den TCP-Port auf, der vom ausgeführten Container bereitgestellt wird
Service
- Art: Deployment – beschreibt das Objekt als Deployment
- Metadata.name: Der Name wird vom eingehenden Objekt verwendet, um die Verknüpfung zwischen den beiden zu erstellen.
- Spec.selector.app: verweist auf den Namen des Deployments – pywai-inline-Service, der im Deployment-Objekt genannt wird.
- Spec.selector.type: Nodeport Hiermit wird dieser Service als Typ Nodeport definiert, wie oben beschrieben
- Spec.ports.name: Das Label für den Port, der von anderen Objekten referenziert werden soll (in diesem Fall Eingang)
- Spec.ports.protocol: definiert das verwendete IP-Protokoll – TCP
- SPEC.Ports.Port: Definiert den Port, der von diesem Service angegeben wird
- SPEC.Ports.targetPort: Verweist auf den Port, der von der Bereitstellung bereitgestellt wird – in diesem Fall pywai-inline-Deployment
Eindringen
In Anhang 3 sehen Sie die YAML-Datei, die das Kubernetes-Objekt für den Edgio Ingress Controller beschreibt. Es handelt sich um folgende Objekte:
- Art: Ingress – Dies sagt Kubernetes, dass es sich um ein Ingress-Objekt handelt
- Medatdata.name – alles in Kubernetes muss einen Namen haben
- Metadaten.Labels.cdn – dieses Tag wird verwendet, um dem Eingangscontroller zu signalisieren, dass dieses Objekt für den Edgio-Eingangscontroller ist
- Spec.rules.host – öffentlicher Hostname für die Bereitstellung des Dienstes.
- Spec.rules.http.paths.path – Pfad, der mit dem Dienst verknüpft ist.
- Spec.rules.http.paths.backend.service.name – Etikett des zu entdeckenden Dienstes
- Spec.rules.http.paths.backend.service.port.name – Kennzeichnung des Ports des Dienstes, der offengelegt werden soll
Zuordnungen Konfigurieren
Geheimnisse
Kubernetes verfügt über ein integriertes Konzept von Geheimnissen für die Speicherung sensibler Daten. Diese Demo nutzt dies für die Benutzernamen und freigegebenen Schlüssel sowohl für Edgio SDK als auch für die Vultr DNS-API
Codebeispiele
Der Code für diese Demonstration, der im GIT-Repos enthalten ist
- Edgio Delivery Python SDK
- Demo-Bereitstellung von Kubernetes
- https://github.com/llnw/edgio-delivery-k8s-demo
- Hierbei handelt es sich um eine Reihe von Kubernetes-Objekten, die als yaml bezeichnet werden und zeigen, wie die Integration von Edgio Delivery bereitgestellt wird
- Edgio Delivery Ingress Controller Demo
- https://github.com/llnw/edgio-delivery-k8s-ingress-demo
- Dies ist der tatsächliche Code, der die Edgio Delivery Eingangssteuerung implementiert
- Auf lange Sicht sollte es als Service innerhalb von Kubernetes ausgeführt werden, um die Demo jedoch einfach zu halten, wird es einfach als separater Prozess ausgeführt
Zukünftige Erweiterungen und Verbesserungen des aktuellen Designs
In einem zukünftigen Beitrag zeigen wir Ihnen, wie Sie andere Edgio-Lösungen nutzen können, z. B. Anwendungen. Wir könnten den Kubernetes-Cluster als Möglichkeit verwenden, Konfigurationen zwischen mehreren Edgio CDN-Angeboten für verschiedene Workflows zu nutzen und zu synchronisieren.
Anhang 1 – pywai-inline-Deployment.yaml
ApiVersion: Apps/v1
Art: Bereitstellung
Metadaten:
Name: Pywai-inline-Deployment
Spez.:
Wahlschalter:
MatchLabels:
App: Pywai-Inline-Deployment
Replikate: 1
Vorlage:
Metadaten:
Etiketten:
App: Pywai-Inline-Deployment
Spez.:
Container:
– Name: python
Bild: python:3
Befehl:
– /Bin/sh
– „-c“
– |
Kat. > /test.py <<EOF
#!/usr/bin/env python3
“””
Sehr einfacher HTTP-Server in Python zum Protokollieren von Anforderungen
Verwendung:
./server.py [<Hafen>]
“””
Importieren Sie von http.server BaseHTTPRequestHandler, HTTPServer
Protokollierung importieren
pprint importieren
Klasse S (BaseHTTPRequestHandler):
def_Set_Response(Self):
self.send_response(200)
self.send_header(‘Content-type’, „Text/html“)
Self.end_headers()
def do_GET(Self):
logging.info(“GET Anforderung,\nPfad: %S\nHeader:\n%s\n“, str(Self.path), str(pprint.pformat(Self.Header))
Self._Set_response()
Headerinfo=pprint.pformat(self.headers.items())
clientinfo=pprint.pformat(Self.Client_address)
Lineinfo=pprint.pformat(Self.requestline)
versioninfo=pprint.pformat(Self.Request_Version)
Self.wfile.write(„<pre> {} </pre>”.Format(headerinfo).encode(‘utf-8’))
Self.wfile.write(„<pre> {} </pre>”.Format(clientinfo).encode(‘utf-8’))
Self.wfile.write(„<pre> {} </pre>”.Format(lineinfo).encode(‘utf-8’))
Self.wfile.write(„<pre> {} </pre>”.Format(versioninfo).encode(‘utf-8’))
def Run(Server_class=HTTPServer, Handler_class=S, Port=8080):
Logging.basicConfig(Level=Logging.INFO)
Server_address = (”, Port)
Httpd = Server_class(Server_address, Handler_class)
logging.info(‘Starting httpd…\n’)
Versuchen Sie es:
httpd.serve_forever()
Außer KeyboardInterrupt:
Pass
httpd.server_close()
logging.info(‘Stopping httpd…\n’)
Wenn __NAME__ == „__Main__“:
Aus SYS importieren argv
Wenn len(argv) == 2:
Run(Port=int(argv[1]))
Sonst:
Run()
EOF
exec Python /test.py 8000
Anschlüsse:
– Name: http
Containerport: 8000
Anhang 2 – pywai-inline-Service.yaml
ApiVersion: v1
Art: Service
Metadaten:
Name: Pywai-inline-Service
Spez.:
Wahlschalter:
App: Pywai-Inline-Deployment
Typ: NodePort
Anschlüsse:
– Name: http
protokoll: TCP
Hafen: 80
Zielport: 8000
Anhang 3 – pywai-edgio-ingress.yaml
ApiVersion: Networking.k8s.io/v1
Art: Eindringen
Metadaten:
Name: External-pywai-Inline-Inress
Anmerkungen:
kubernetes.io/ingress.class: Edgio
Etiketten:
cdn: Edgio
Spez.:
Regeln:
– Gastgeber: <Geben Sie den eindeutigen Kurznamen>.s.llnwi.net ein
http:
Pfade:
– Pfad: /fred
Pfadtyp: Exakt
Backend:
Service:
Name: External-pywai-inline-Service
Anschluss:
Name: Pywai-Port
