Welkom bij het eerste in een serie van vier artikelen over de containerisatie en cloud-native beweging die wordt geleid door Docker, Google en een groeiend ecosysteem van traditionele en nieuwe spelers. In deze serie wagen we ons aan het definiëren en bespreken van deze opkomende en opwindende ruimte in een poging organisaties te helpen er beter doorheen te navigeren. Terwijl dit eerste artikel zich richt op het definiëren van "cloud native" en enkele gerelateerde bewegende delen, zullen we in toekomstige artikelen de belangrijke lagen en gerelateerde uitdagingen met netwerken, opslag en containerorkestratie onderzoeken om u een completer beeld te geven... maar laten we eerst beginnen bij het begin.
In het begin waren er Free BSD en Solaris, die een meesterlijke basis legden voor wat nu wordt beschouwd als moderne containerisatietechnologieën met mogelijkheden die respectievelijk FreeBSD Jails en Solaris Zones worden genoemd. Google heeft geholpen om containers naar Linux te brengen door cgroups toe te voegen aan de Linux Kernel. In combinatie met namespaces en chroot werd de technische basis gelegd. Docker maakte containers verder toegankelijker door een eenvoudige workflow rond containerafbeeldingen te creëren en zich te concentreren op een gemakkelijke ontwikkelaarservaring.
De beste manier om de ruimte te definiëren is waarschijnlijk door een aantal fundamentele vragen te beantwoorden en een aantal gastexperts te vragen om deze te beantwoorden. (zie hoe ik werk uitbesteed aan andere mensen die meer gekwalificeerd zijn!?)
Wat is een container?
Gastbijdrager Cameron Brunner, hoofdarchitect Navops
Met containers kunnen applicaties betrouwbaar van de ene computeromgeving naar de andere worden verplaatst. Dit kan van de laptop van een ontwikkelaar zijn, tot de QA-omgeving tot productie on-premise of in de cloud. Afhankelijkheden van de softwarestack van de applicatie die in de container draait, zoals het besturingssysteem of andere softwarecomponenten en bibliotheken, kunnen grotendeels in een container worden ingebed, waardoor deze losgekoppeld kan worden van de details van de onderliggende IT-omgeving. Containers zijn oorspronkelijk ontworpen om isolatie te bieden tussen applicaties die op een besturingssysteem draaien. Ze bieden een combinatie van resourcecontroles en grensscheiding die helpt om de uitvoering van code binnen de container te isoleren van andere activiteiten en andere containers die op die machine/het besturingssysteem draaien. Containers bereiken deze isolatie door gebruik te maken van besturingssysteemfuncties zoals cgroups en naamruimten.
Wat is Docker?
Docker is zowel een bedrijf als een commerciële/open source-implementatie van containers. Containers bestonden al een lange tijd vóór Docker met vroege implementaties zoals FreeBSD Jails (2000) en Solaris Zones (2004) en Docker heeft fantastisch werk geleverd door containers bruikbaar te maken voor de massa door het creatie- en uitvoeringsproces aanzienlijk te vereenvoudigen. Hoewel Docker hard op weg is om het defacto standaard containerformaat te worden, heeft het bedrijf verdere stappen gezet in de richting van openheid en samenwerking door het Open Container Initiative (OCI) op te richten onder de Linux Foundation. OCI betrekt een aantal branchedeelnemers en werkt aan industriestandaarden voor containerformaten en looptijden. (Zie www.opencontainers.org/)
Dus wat is Cloud Native Computing?
Gastbijdrager Joe Beda, oprichter en medewerker van zowel Google Compute Engine als Kubernetes
Cloud Native is een van de vele nieuwe manieren van denken over het bouwen en beheren van applicaties op schaal. In de basis structureert Cloud Native teams, cultuur en technologie om automatisering en architecturen te gebruiken om complexiteit te beheren en snelheid te ontsluiten.
Terwijl containers en containerbeheer vaak deel uitmaken van het 'Cloud Native'-denken, hebben organisaties zoals Netflix deze manier van denken beroemd toegepast met VM's en VM-images. Bovendien hoeft u niet in de cloud te werken om enkele voordelen van deze verschuiving in denken te realiseren. Applicaties en teams kunnen beter worden beheerd terwijl applicaties op locatie worden geïmplementeerd.
Er zijn geen vaste regels voor wat Cloud Native is. Er zijn echter enkele thema's die naar voren komen.
- DevOps en Ops-automatisering: Ingenieurs die de pet van applicatie-ontwikkelaar dragen, spelen een actieve rol om ervoor te zorgen dat applicaties betrouwbaar kunnen werken in productie. Evenzo zorgen degenen die de operationele rol vervullen ervoor dat ervaringen worden teruggevoerd naar ontwikkeling. Automatisering is essentieel voor het beheer van veel bewegende stukken.
- Containers: Containers bieden een handige manier om een inzetbaar build-artefact te maken dat kan worden getest en gevalideerd. Dit zorgt ervoor dat implementaties voorspelbaar zijn.
- Rekenclusters: een API-gestuurd rekencluster en planningssysteem stelt een klein aantal technici in staat om een groot aantal werklasten te beheren. Daarnaast zorgt het ervoor dat die workloads efficiënt in nodes kunnen worden verpakt om de bezettingsgraad te verhogen. Ten slotte vermindert een goed beheerd cluster de operationele last voor applicatieteams.
- Microservices: Microservices splitsen applicaties op in kleinere inzetbare eenheden, zodat ontwikkelteams snel en wendbaar kunnen zijn. Deze ideeën zijn niet noodzakelijkerwijs nieuw, maar worden toegepast in combinatie met tools om schaalbaar beheer mogelijk te maken. We zullen hier hieronder meer over vertellen.
- Diepe zichtbaarheid: Cloud Native impliceert diepere inzichten in hoe services draaien. Gedistribueerde tracering, het verzamelen en indexeren van logboeken en diepgaande applicatiemonitoring helpen allemaal om een licht te werpen op wat er werkelijk gebeurt in een applicatie.
Wat is een op microservices gebaseerde architectuur?
Gastbijdrager Joe Beda, oprichter en medewerker van zowel Google Compute Engine als Kubernetes
Microservices is een nieuwe naam voor een concept dat al heel lang bestaat. In feite is het een manier om een grote applicatie op te splitsen in kleinere stukjes, zodat ze onafhankelijk kunnen worden ontwikkeld en beheerd. Laten we eens kijken naar enkele van de belangrijkste aspecten hier:
- Sterke en duidelijke interfaces. Nauwe koppeling tussen diensten moet worden vermeden. Gedocumenteerde en versiebeheerde interfaces helpen om dat contract te verstevigen en een zekere mate van vrijheid te behouden voor zowel de consumenten als de producenten van deze diensten.
- Zelfstandig ingezet en beheerd. Het moet mogelijk zijn om een enkele microservice te updaten zonder te synchroniseren met alle andere services. Ook is het wenselijk om een versie van een microservice eenvoudig terug te kunnen draaien. Dit betekent dat de binaire bestanden die worden geïmplementeerd zowel voorwaarts als achterwaarts compatibel moeten zijn, zowel wat betreft API als eventuele gegevensschema's. Dit kan de samenwerkings- en communicatiemechanismen tussen de juiste ops- en dev-teams testen.
- Veerkracht ingebouwd. Microservices moeten worden gebouwd en getest om onafhankelijk veerkrachtig te zijn. Code die een service gebruikt, moet ernaar streven om te blijven werken en iets redelijks te doen in het geval dat de gebruikte service niet werkt of zich misdraagt. Evenzo moet elke dienst die wordt aangeboden enige verdediging hebben met betrekking tot onverwachte belasting en slechte input.
- Microservices gaan meer over mensen dan over technologie. Kleine teams zijn wendbaarder. Jeff Bezos staat erom bekend dat hij voorstelt om vergaderingen en teams klein genoeg te houden zodat ze kunnen worden gevoed met 2 pizza's. Door een groot project te structureren als een reeks kleinere teams en vervolgens uit de weg te gaan, kunnen die teams samensmelten en eigenaar worden van dat deel van het project.
We kijken uit naar de volgende artikelen waarin we enkele van de belangrijke lagen van de cloud-native stack zullen bespreken.
Rob Lalonde is vicepresident en algemeen directeur van Navops . Hij is actief betrokken bij diverse open source-initiatieven, waaronder de Cloud Native Computing Foundation (CNCF), de Open Container Initiative (OCI) en de Linux Foundation. Rob heeft leidinggevende functies bekleed bij meerdere succesvolle hightechbedrijven en startups. Hij heeft een MBA-opleiding afgerond aan de Schulich School of Business van York University en een bachelordiploma in computerwetenschappen van Laurentian University.
Amazon