Data-integratie & engineering op Google Cloud
Gebouwd om data te laten stromen
Elke organisatie komt op het punt dat de systemen echt met elkaar moeten praten. Wij beginnen bij de systemen die je al hebt: we ontwerpen en bouwen de pijplijnen en koppelingen op Google Cloud die ze verbinden, maken eenduidig wat eruit komt, en zorgen dat het blijft lopen als een bronsysteem eronder verandert.
Praat met een expertBekijk wat we bouwen
- 20+ jaar op Google Cloud
- Google Cloud Premier Partner
- 50+ certificeringen
- ISO 27001:2022
Hoe silo's ontstaan
Niemand bouwt met opzet een silo. Ze stapelen zich op uit een reeks redelijke besluiten: een snel scriptje om twee systemen te laten praten, een geplande export omdat de API lastig was, een spreadsheet omdat het vrijdag was.
Eén koppeling per probleem
Elke koppeling is gebouwd voor de twee systemen die er op dat moment lagen. Het tiende systeem erbij betekent negen nieuwe koppelingen schrijven, en degene die de eerste drie schreef werkt hier niet meer.
Het breekt als de bron verandert
Een veld wordt bovenstrooms hernoemd, een API-limiet gaat omlaag, en de pijplijn valt 's nachts stil om. Dat merk je meestal doordat iemand ziet dat een getal er vreemd uitziet.
Dezelfde bewerking, vijf keer geschreven
Valuta omrekenen, dubbelingen eruit halen, datums verwerken: in elke pijplijn net iets anders gebouwd. Zo komt het dat twee rapporten het oneens zijn over dezelfde order.
Van losse koppelingen naar een platform
De omslag is van elke keer een koppeling schrijven naar één plek waar koppelingen thuishoren: herbruikbare patronen, beheerde diensten die zelf meeschalen, en monitoring die je een storing meldt vóórdat een collega dat doet.
Voor
- Een eigen koppeling per paar systemen
- Inlezen, bewerken en controleren met de hand
- Pijplijnen die stil omvallen als een schema verandert
- Capaciteit vooraf gepland, en meestal verkeerd
- Elke nieuwe toepassing begint bij nul
Na
- Eén orkestratielaag die je systemen verbindt
- Inlezen, bewerken en controleren geautomatiseerd
- Koppelingen die API-limieten en schemawijzigingen overleven
- Serverloze diensten die meeschalen zonder capaciteitsplanning
- Herbruikbare patronen en templates, dus de volgende is goedkoper
Watch
Waarom er nóg een koppeling bij plakken zelden helpt, en hoe één samenhangende architectuur op Google Cloud er in plaats daarvan uitziet.
Beheerde diensten, minder bewegende delen
Application Integration, Dataflow, Pub/Sub en Apigee zijn allemaal dingen die je anders zelf zou moeten bouwen én draaien. Ze gebruiken betekent dat de onderdelen die meestal om drie uur 's nachts stukgaan — meeschalen, opnieuw proberen, tegendruk opvangen — het probleem van iemand anders zijn.
Het houdt de integratielaag ook in dezelfde omgeving als het warehouse dat hij voedt, en dat haalt een hele categorie vragen weg over netwerk, identiteit en waar je data staat.
20+
Jaar bouwen op Google Cloud, van voordat het meeste een naam had
50+
Google Cloud-certificeringen in het team
Premier
Google Cloud Premier Partner, met specialisaties in data en infrastructuur
Wat we verbinden
Een traject begint meestal met het landschap en de eisen in kaart brengen, en gaat dan verder via architectuur, het bouwen van de pijplijnen, en de governance die het draaiend houdt.
De low-code iPaaS van Google Cloud als orkestratielaag voor je klantdata, met afrekenen naar gebruik en standaardkoppelingen voor Salesforce Marketing Cloud, Dynamics 365 en de rest van de platformen die de meeste organisaties al hebben.
Eén orkestratielaag
Eén plek waar koppelingen thuishoren, in plaats van een koppeling die je schrijft elke keer dat twee systemen elkaar nodig hebben.
Standaardkoppelingen
Salesforce Marketing Cloud, Dynamics 365 en de rest: instellen in plaats van vanaf nul schrijven.
Low-code flows
Koppelingslogica die ook iemand anders dan de schrijver kan lezen. Over drie jaar telt dat zwaarder dan in week één.
Afrekenen naar gebruik
Kosten die volgen wat je werkelijk draait, en niet een licentie op maat van een volume dat je nog niet haalt.
API's & streaming
Voor de gevallen waarin een geplande batch niet genoeg is: API's netjes publiceren en beheren, en gebeurtenissen doorgeven op het moment dat ze plaatsvinden in plaats van 's nachts.
API-beheer met Apigee
API's publiceren, beveiligen en monitoren door de hele organisatie, met zicht op wie wat aanroept.
Inlezen met Pub/Sub
Inlezen en doorgeven in real time, dat elastisch meeschaalt — zodat een actie de pijplijn niet plat legt.
Dataflow-pijplijnen
Volledig beheerde, serverloze verwerking die automatisch meeschaalt, voor bewerkingen die te zwaar zijn voor een flow.
Het deel dat bepaalt of het bovenstaande er over een jaar nog staat: infrastructure as code, monitoring die het eerder ziet dan een gebruiker, en iemand die op de kosten let.
Infrastructure as code
Omgevingen vastgelegd in een repository, zodat een wijziging te beoordelen, te herhalen en terug te draaien is.
Monitoring
Storingen met genoeg context om er iets aan te doen, in plaats van een rood bolletje op een dashboard waar niemand naar kijkt.
Sneller maken
De pijplijnen zo snel dat mensen er niet meer omheen gaan plannen.
Kosten in de hand
Aandacht voor wat elke pijplijn kost om te draaien. Dat is het getal dat geruisloos groeit zolang niemand het bezit.
Een platformmigratie, in drie maanden
Een e-commercebedrijf naar een nieuw platform brengen is vooral een koppelingsvraagstuk met een andere jas aan.
Body&Fit · sportvoeding
Shopify verbinden met alles wat erachter zit
Body&Fit had een nieuwe Shopify-winkel nodig, gekoppeld aan het warehousebeheer, contact services, e-mailmarketing en BI, zowel voor de verkoop aan consumenten als aan winkels. Wij gebruikten Google Cloud Application Integration als orkestratielaag in plaats van eigen pijplijnen te schrijven. Twee nieuwe externe systemen waren binnen twee maanden gekoppeld, en in de derde maand stond het geheel in productie.
Lees het klantenverhaal (Engels) →
Voordat je nog een script schrijft
Onze koppelingen werken. Waarom zouden we ze veranderen?
Zijn ze stabiel en begrijpt iemand ze, dan meestal niet. De reden om te veranderen komt doorgaans als het aantal groter wordt dan één persoon kan overzien, als storingen niet meer snel opvallen, of als een nieuw platform betekent dat de helft toch herschreven moet worden.
Is iPaaS niet gewoon weer een licentie?
Google Cloud Application Integration rekent af naar wat je draait en niet per gebruiker of per koppeling, en dat verandert de rekensom flink ten opzichte van een enterprise-iPaaS. Voor stabiele flows met weinig volume kan een lichte eigen laag nog goedkoper zijn, en we zeggen aan welke kant van die streep je staat.
Wat als een bronsysteem zijn API verandert?
Dat gebeurt, en vrij regelmatig. Onze koppelingen zijn gebouwd om limieten en schemawijzigingen op te vangen in plaats van aan te nemen dat ze niet komen, en de monitoring zorgt dat een storing opvalt vóórdat een rapport er vreemd uitziet.
Kan ons eigen team dit onderhouden?
Dat is de bedoeling. Low-code flows zijn te lezen door mensen die ze niet geschreven hebben, de infrastructuur staat in jouw repository, en documenteren hoort bij het werk in plaats van dat het aan het eind wordt beloofd.
Hoe gaan jullie om met beveiliging tussen systemen?
Koppelen betekent meestal dat de sleutels van meerdere systemen op één plek liggen, dus toegang en het omgaan met geheimen zitten vanaf het begin in het ontwerp. Wij zijn ISO 27001:2022-gecertificeerd, en voor klanten in een gereguleerde sector werken we volgens het raamwerk dat daar geldt.
Volgende stap
Wil je dat de systemen echt samenwerken?
Ga je naar een nieuw platform, of is het aantal koppelingen groter geworden dan iemand kan overzien? We kijken graag wat er staat en wat het kost om het samen te brengen.