fb
info@yenlo.com
WSO2 9 min

MockLab en WSO2 Micro Integrator

Rob Blaauboer
Rob Blaauboer
Integration Consultant & WSO2 Trainer
MockLab en WSO2 Micro Integrator

Als trainer ontwikkel ik mijn eigen trainingsmateriaal. Ik ben altijd op zoek naar manieren om het eenvoudiger te maken; eenvoudiger in de zin dat het me zo weinig mogelijk tijd kost om iets te laten werken.

Dit is een goed voorbeeld: ik gebruik nu bijvoorbeeld WireMock al een aantal jaren lokaal op onze trainingsmachines om specifieke services na te bootsen. Sommige van deze services reageren alleen met een vertraging van een bepaald aantal seconden, waardoor er een endpoint-fout op een micro integrator wordt geactiveerd.

Andere services worden nagebootst omdat ze gewoon moeten reageren met de naam van de service en het nummer, in het geval van een load balanced round Robin endpoint-definitie.

Hoewel het opzetten van WireMock niet zo’n groot probleem is, heb ik onlangs de installatie van WireMock van mijn lokale instanties verwijderd en verplaatst. Op de API-conferentie in Londen in oktober van dit jaar hoorde ik dat er een gehoste versie was met de naam MockLab, waar ik de gratis versie kon gebruiken om te zien of het waarde aan onze trainingen toevoegt.

De gratis versie biedt 1000 gratis aanroepen per maand. Als ik die overschrijdt, ik moet natuurlijk een abonnement nemen, maar over het algemeen zouden 1000 aanroepen voor mij voldoende zijn.

In deze blog laat ik je zien hoe ik MockLab gebruik om een heel eenvoudige API na te bootsen en hoe ik de Micro Integrator ga gebruiken om zowel de back-end-URL als de vereiste API-sleutel voor deze demo te verbergen.

Ik scherm alles af van de gebruiker door de API door de Micro Integrator te laten lopen voor een beetje lichtgewicht mediation, in dit geval door een APIKEY in de header toe te voegen en deze door te sturen naar de endpoint. Maar laten we aan de slag gaan met MockLab!

Installatie

Natuurlijk: die is er niet. Dit is een gehoste service, dus ik ga gewoon naar de url van MockLab, meld me aan of gebruik de login van Google of GitHub.

Mocklab inlog Google or Github

Ik gebruik GitHub en ik zal beginnen met het maken van een nieuwe mock API.

Het aanmaken is heel eenvoudig. Klik op Mock API en vul de details in.

Creating a new mock API for Github

De hostnaam is optioneel en kan worden gebruikt bij het aanroepen van de API. Daaronder staat ook een willekeurig gegenereerde code als onderdeel van een URL, zoals r1274.mocklab.io.

Daarna maken we de API (die we Blog noemen) en definiëren we een context/bron voordat we deze opslaan door op de knop “Save” te klikken.

Create new API Github

We kunnen ook de beveiliging definiëren die nodig is om toegang tot de API te krijgen. Dit kan gebruikersnaam/wachtwoord (ook wel bekend als Http Basic) of Header Match zijn.

Define security to access API

We kunnen een Header selecteren (benoemen) en de Predicate, bijvoorbeeld gelijk aan 1234.

Naming API in Mock API Security

Maar laten we dit voorlopig leeg laten en een stub maken. De stub doet een GET op /retrieve/data (gewoon een willekeurige context/bron) en geeft een statuscode 200 en een JSON-body terug, maar pas na een vertraging van 15.000 milliseconden. We voegen ook een header toe om ervoor te zorgen dat het Json-response inderdaad een bericht is met Content Type application/json. Als je dat weglaat, krijg je een bericht in octet-stream-formaat terug.

Header with Content Type application json

We hebben de time-out ingesteld op 15 seconden (15.000 ms).

set the timeout in mocklab

We kunnen het vanuit de browser testen omdat het een GET is.

mocklab test GET

Je krijgt de dummy response terug in je browservenster. Laten we een header match toevoegen als beveiliging zodat de API niet voor iedereen toegankelijk is.

add a Header mocklab

Dit kunnen we ook testen, nu vanuit SoapUI aangezien we de foutmelding dan makkelijker kunnen zien.

mocklab test from SoapUI

Wanneer we de sleutel als header toevoegen, kunnen we zien dat we de 200 en de Response krijgen.

mocklab test Soapui 200 and Response

En we krijgen de response terug in plaats van een 401-statuscode.

Verbergen

Een van de dingen die je kunt doen, is een tussenstop in de API plaatsen. Hiermee bedoel ik dat je het endpoint niet rechtstreeks gaat aanroepen, maar eerst naar een andere API gaat die bij elke aanroep de nagebootste back-end zal aanroepen. Het voordeel van een dergelijke opstelling is dat het endpoint dat we in dit geval aanroepen, dat van mock lab, niet bekend is bij de persoon die de API aanroept. Bovendien ziet deze niet dat de de API-sleutel als een header in de flow wordt toegevoegd. Dit is de oplossing die je kunt gebruiken als je zoiets als een header aan de API-flow moet toevoegen, maar dit niet in de API-definitie wilt doen of als je het adres van het daadwerkelijke aangeroepen endpoint wilt verbergen .

In dit geval moeten we dus een API maken en in een zeer eenvoudige flow de header aan de API-aanroep toevoegen Deze sturen we vervolgens door zodat hij het oorspronkelijke endpoint op MockLab aanroept.

Ik ga niet de hele opzet van de micro integrator en integration studio beschrijven, omdat dat te veel ruimte zou innemen op deze blog. Je kunt echter een van deze blogs bekijken als je vragen hebt over de installatie. Een van de dingen die ik ga beschrijven is de installatie. In dit geval ga ik integration studio 8.1 gebruiken met een ingebouwde micro integrated 4.1. Dat maakt het heel gemakkelijk, aangezien ik behalve integration studio geen extra software hoef te installeren.

Normaal gesproken zou ik dit op een Linux-omgeving installeren, maar voor deze blog zal ik Windows gebruiken. De reden is eenvoudig dat zowel de WSO2-producten als integration studio op de belangrijkste platformen draaien: Windows, Linux en Macintosh.

Integration Studio starten

Als je Integration Studio start, hoef je alleen maar op het pictogram te klikken in de map waarin je het hebt geïnstalleerd.

Starting integration studio new workspace

Ik heb een nieuwe werkruimte gemaakt (die, zoals je kunt zien, gewoon naar een map wijst) en ga een nieuw Integration Project in die map aanmaken.

new Integration Project in directory

We bevinden ons momenteel in de weergave ‘Getting Started’ van integration studio.

Getting Started view of integration studio

Als je op een nieuw integration project klikt, wordt de wizard geopend die de projectstructuur met een composite exporter voor ons maakt, maar ook een geconfigureerd project om als artifacts op te slaan. Ik ga het MockLabProject noemen.

Select modules integration studio

De wizard voegt achter de projectnaam configs en een composite exporter toe om de submappen te maken. We houden alle instellingen zoals ze zijn en klikken op finish.

Integration studio schakelt nu over naar de ESB-weergave, waar we het nieuw gemaakte project kunnen openen en de submap configs kunnen bekijken.

Integration studio switches to ESB

Hier kunnen we een nieuwe API maken. Selecteer de submap van de api, klik daar met de rechtermuisknop op en selecteer New/REST API.

create a new API and select REST API
mockAPI API artifact creation options

Houd het simpel; voer MockAPI en /mock als naam en context in. Klik op Finish.

enter MockAPI

Om het eenvoudig te maken, gaan we de broncode kopiëren en de standaard API-definitie vervangen.

copy source code and replace default API definition

Klik op Source en kopieer deze code.

<?xml version="1.0" encoding="UTF-8"?>
<api context="/mock" name="MockAPI" xmlns="http://ws.apache.org/ns/synapse">
    <resource methods="GET">
        <inSequence>
            <header name="APIKEY" scope="transport" value="1234"/>
            <call>
                <endpoint>
                    <http method="get" uri-template="https://yenloblog.mocklab.io/retrieve/data">
                        <suspendOnFailure>
                            <initialDuration>-1</initialDuration>
                            <progressionFactor>-1</progressionFactor>
                            <maximumDuration>0</maximumDuration>
                        </suspendOnFailure>
                        <markForSuspension>
                            <retriesBeforeSuspension>0</retriesBeforeSuspension>
                        </markForSuspension>
                    </http>
                </endpoint>
            </call>
            <property name="ContentType" scope="axis2" type="STRING" value="application/json"/>
            <respond/>
        </inSequence>
        <outSequence/>
        <faultSequence/>
    </resource>
</api>

Sla op CTRL-S. Schakel over naar ontwerpmodus en je ziet deze opstelling.

mocklab save code

Open de Pom van de Composite Exporter en selecteer de API. Sla op met CTRL-S.

Selecteer Window-Show View – Other…

Open the Pom of the Composite Exporter

Typ of selecteer Servers en klik op Open.

select servers in integration studio

Klik op het tabblad Server met de rechtermuisknop op Micro Integrator Server (het bovenste rechthoekige donkere vak) en selecteer Add and Remove,

Micro Integrator Server mocklab

Selecteer Add and Finish.

mocklab projects add and remove

Start de server, klik opnieuw met de rechtermuisknop op Micro Integrator Server en selecteer Start zoals weergegeven in de afbeelding hiervoor.

Start the server on Micro Integrator Server 1

De console toont de geïmplementeerde API.

console the deployed API

Open nu opnieuw het Rest Project in SoapUI. Maak een nieuw REST project op de opengestelde API ( http://localhost:8290/mock ).

Create new REST Project on exposed API in SoapUI
request new rest project

Ontbrekende header

Er moet gezegd worden dat ik bij de eerste setup vergat de header in te stellen, omdat ik aannam dat de json-body ook een correcte header bevatte. Je moet dit echter handmatig instellen, anders komt het bericht binnen als application/octet-stream in plaats van application/json (omdat we een json-response in MockLab hebben gedefinieerd).

Als tijdelijke oplossing hebben we het content-type ingesteld op application/json. Als je messageType instelt op application/json, krijg je een response als volgt: {“binary”: “eyJQYXRpZW50cyI6IjEwMSJ9”}, wat een base64-gecodeerde versie van het bovenstaande bericht is.

Dit kan natuurlijk gedecodeerd worden. In dat geval nemen we de inkomende body van het bericht

setting header in mockapi
<?xml version="1.0" encoding="UTF-8"?>
<api context="/mock" name="MockAPI" xmlns="http://ws.apache.org/ns/synapse">
    <resource methods="GET">
        <inSequence>
            <header name="APIKEY" scope="transport" value="1234"/>
            <call>
                <endpoint>
                    <http method="get" uri-template="https://yenloblog.mocklab.io/retrieve/data">
                        <suspendOnFailure>
                            <initialDuration>-1</initialDuration>
                            <progressionFactor>-1</progressionFactor>
                            <maximumDuration>0</maximumDuration>
                        </suspendOnFailure>
                        <markForSuspension>
                            <retriesBeforeSuspension>0</retriesBeforeSuspension>
                        </markForSuspension>
                    </http>
                </endpoint>
            </call>
            <property expression="$body/*" name="messageBody" scope="default" type="STRING"/>
            <payloadFactory media-type="json">
                <format>$1</format>
                <args>
                    <arg evaluator="xml" expression="base64Decode(get-property('messageBody'))"/>
                </args>
            </payloadFactory>
            <property name="messageType" scope="axis2" type="STRING" value="application/json"/>
            <respond/>
        </inSequence>
        <outSequence/>
        <faultSequence/>
    </resource>
</api>

We moeten de body naar een variabele kopiëren, aangezien de payloadFactory de body initialiseert als het een nieuwe maakt. In dat geval zie je de gedecodeerde json-payload in de response.

Samenvatting

Soms heb je gewoon een service nodig die iets nabootst Het kan zijn dat je iets wilt uitproberen, maar een service nog niet kunt ontwikkelen of dat de service niet beschikbaar is.

Bekijk in dat geval Mocklab als een snelle manier om een API te maken die je kunt gebruiken. In deze blog heb ik je laten zien hoe gemakkelijk Mocklab is door een API te definiëren en WSO2 Micro Integrator te gebruiken in combinatie met WSO2 Integration Studio om de setup te testen door middel van het sturen van een eenvoudig bericht naar de API. Zelfs het toevoegen van het vereiste om een header toe te voegen met een sleutel die Mocklab zal controleren en waarbij Mocklab alleen zal reageren als de header bestaat en correct is.

ned
Sluiten
Wij waarderen het
Delen

Selecteer een van de sociale media hier beneden om deze pagina content te delen met de wereld