Maven_super_29 - itnett/FTD02H-N GitHub Wiki

Kommunikasjon mellom ulike programgrensesnitt handler om hvordan forskjellige applikasjoner eller tjenester kan utveksle data og samarbeide. Dette er spesielt viktig i moderne programvareutvikling, der systemer ofte må integreres med hverandre på tvers av plattformer og teknologier. Her skal vi dekke flere metoder og teknikker for kommunikasjon mellom ulike programgrensesnitt, inkludert APIer, webtjenester, og meldingskøer.

Et API (Application Programming Interface) er en definert måte for programmer å kommunisere med hverandre. APIer gjør det mulig for applikasjoner å sende og motta data over et nettverk (f.eks. internett).

REST (Representational State Transfer) er en populær arkitekturstil for APIer. RESTful APIer bruker HTTP-metoder som GET, POST, PUT, DELETE for å utføre operasjoner på ressurser, som ofte er representert i JSON-format.

Eksempel: Enkel RESTful API i Flask

from flask import Flask, jsonify, request

app = Flask(__name__)

data = [
    {"id": 1, "navn": "Anna", "alder": 25},
    {"id": 2, "navn": "Bob", "alder": 30}
]

@app.route('/personer', methods=['GET'])
def get_personer():
    return jsonify(data)

@app.route('/personer/<int:id>', methods=['GET'])
def get_person(id):
    person = next((p for p in data if p['id'] == id), None)
    return jsonify(person) if person else ('', 404)

@app.route('/personer', methods=['POST'])
def add_person():
    ny_person = request.json
    data.append(ny_person)
    return jsonify(ny_person), 201

@app.route('/personer/<int:id>', methods=['PUT'])
def update_person(id):
    person = next((p for p in data if p['id'] == id), None)
    if person:
        person.update(request.json)
        return jsonify(person)
    return ('', 404)

@app.route('/personer/<int:id>', methods=['DELETE'])
def delete_person(id):
    global data
    data = [p for p in data if p['id'] != id]
    return ('', 204)

if __name__ == '__main__':
    app.run(debug=True)

Forklaring:

• GET /personer: Henter en liste over personer.
• GET /personer/: Henter informasjon om en spesifikk person.
• POST /personer: Legger til en ny person.
• PUT /personer/: Oppdaterer informasjon om en spesifikk person.
• DELETE /personer/: Sletter en spesifikk person.

Klienter kan kommunisere med APIer ved å sende HTTP-forespørsler. Dette kan gjøres med verktøy som Postman eller ved å bruke biblioteker som requests i Python.

Eksempel: Kommunisere med et API ved hjelp av requests

import requests

# Hente alle personer
response = requests.get('http://localhost:5000/personer')
if response.status_code == 200:
    personer = response.json()
    print(personer)

# Legge til en ny person
ny_person = {"id": 3, "navn": "Charlie", "alder": 22}
response = requests.post('http://localhost:5000/personer', json=ny_person)
if response.status_code == 201:
    print("Ny person lagt til:", response.json())

# Oppdatere en person
oppdatert_person = {"navn": "Charlie", "alder": 23}
response = requests.put('http://localhost:5000/personer/3', json=oppdatert_person)
if response.status_code == 200:
    print("Person oppdatert:", response.json())

# Slette en person
response = requests.delete('http://localhost:5000/personer/3')
if response.status_code == 204:
    print("Person slettet.")

SOAP (Simple Object Access Protocol) er en annen protokoll for kommunikasjon mellom applikasjoner. Den er mer kompleks enn REST og bruker XML for meldingsformat.

SOAP-tjenester defineres ofte ved hjelp av WSDL (Web Services Description Language). La oss se på et eksempel ved hjelp av zeep, et Python-bibliotek for SOAP-tjenester.

Eksempel: SOAP-klient med zeep

from zeep import Client

# Koble til en SOAP-tjeneste
wsdl = 'http://www.dneonline.com/calculator.asmx?WSDL'
client = Client(wsdl=wsdl)

# Utføre en operasjon (f.eks. addisjon)
result = client.service.Add(intA=10, intB=20)
print("Resultat av addisjon:", result)

Meldingskøer brukes til asynkron kommunikasjon mellom applikasjoner. De tillater at meldinger sendes og behandles senere, noe som gjør dem ideelle for systemer som trenger å håndtere høyt volum eller trenger å være desentralisert.

RabbitMQ er en populær meldingskø for asynkron kommunikasjon.

Eksempel: Sender og mottar meldinger med RabbitMQ

import pika

# Koble til RabbitMQ-serveren
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# Opprett en kø
channel.queue_declare(queue='hello')

# Publiser en melding
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')
print(" [x] Sent 'Hello World!'")

# Mottar en melding
def callback(ch, method, properties, body):
    print(f" [x] Received {body}")

channel.basic_consume(queue='hello',
                      on_message_callback=callback,
                      auto_ack=True)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

Mikrotjenester er en arkitekturstil der en applikasjon er bygget opp av flere mindre, selvstendige tjenester som kommuniserer med hverandre over nettverket. Dette kan gjøres via RESTful APIer, meldingskøer, eller andre protokoller.

• Skalerbarhet: Hver tjeneste kan skaleres uavhengig.
• Fleksibilitet: Tjenester kan utvikles i forskjellige språk og teknologier.
• Feilisolering: Feil i en tjeneste påvirker ikke nødvendigvis de andre.

Kommunikasjonen i en mikrotjenestearkitektur kan skje på flere måter:

• Synkron kommunikasjon: Ved hjelp av RESTful APIer eller gRPC.
• Asynkron kommunikasjon: Ved hjelp av meldingskøer som RabbitMQ eller Kafka.

Når du kommuniserer mellom ulike programgrensesnitt, er sikkerhet en kritisk faktor. Dette kan inkludere:

• Autentisering og autorisasjon: Sikre at bare autoriserte applikasjoner kan få tilgang til tjenestene.
• Kryptering: Bruk av HTTPS for å sikre at data som sendes over nettverket er kryptert.
• API-nøkler og tokens: Bruk av API-nøkler, OAuth, eller JWT for å autentisere API-forespørsler.

• Timeouts: Håndtere situasjoner der forespørsler tar for lang tid å svare.
• Retries: Implementere logikk for å forsøke forespørsler på nytt hvis de feiler.
• Circuit Breakers: Beskytte systemer ved å stoppe forespørsler til en tjeneste som feiler gjentatte ganger.

• Opprett et RESTful API som håndterer brukerdata (CRUD-operasjoner) og kommuniser med det ved hjelp av requests-biblioteket i Python.
• Utforsk SOAP-tjenester ved å opprette en klient for en offentlig tilgjengelig SOAP-tjeneste, som f.eks. en valutakalkulator.
• Implementer asynkron kommunikasjon mellom to Python-skript ved hjelp av RabbitMQ.
• Bygg en enkel mikrotjenestebasert applikasjon der hver tjeneste er ansvarlig for en spesifikk del av funksjonaliteten, og la disse tjenestene kommunisere med hverandre.

Ved å mestre kommunikasjon mellom ulike programgrensesnitt kan du utvikle komplekse, skalerbare og robuste applikasjoner som integrerer forskjellige systemer på en sikker og effektiv måte. Hvis du har flere spørsmål eller trenger hjelp med å implementere disse teknikkene, er jeg her for å hjelpe!