Wat is cloud-native? Belangrijkste kenmerken en toepassingen

Cloud-native computing is een methode om applicaties te ontwerpen, maken, implementeren en uit te voeren waarbij optimaal gebruik wordt gemaakt van de mogelijkheden van een cloudplatform. Hoewel traditionele software, ook wel monolithische software genaamd, kan worden uitgevoerd in een datacenter of in een openbare cloud, kan dergelijke software niet de schaalbaarheid en kostenefficiëntie van de cloudomgeving leveren.

Dat is het moment om cloud-native computing te gaan gebruiken. Cloud-native software is niet één applicatie die op een server is geïnstalleerd, maar is samengesteld uit tientallen, honderden of zelfs duizenden kleine stukjes software. Die stukjes, microservices genaamd, worden in containers geplaatst die op cloudservers zijn geïnstalleerd. Microservices communiceren vervolgens via beveiligde snelle netwerken en werken samen om zakelijke problemen op te lossen.

Wat zijn de voordelen van deze modulaire aanpak? Er zijn vele voordelen, waar we in dit document nader op ingaan. Dit zijn de vier belangrijkste voordelen.

• Microservices kunnen onafhankelijk worden geschreven, getest en geïmplementeerd, waardoor het ontwikkelingsproces wordt versneld.
• Als een defect wordt gevonden in het ontwerp of de implementatie van een bepaalde microservice, kan de fout in die ene microservice worden opgespoord en kan de microservice worden verbeterd en vervangen zonder dat de rest van de applicatie wordt beïnvloed.
• Als een microservice wordt overbelast vanwege een onverwacht hoog gebruik, kan de container van die microservice worden gerepliceerd met een of meer identieke twins, die elk op verschillende servers worden geïnstalleerd en kan de workload daartussen worden gedeeld. Hiermee worden knelpunten in de prestaties verminderd of geëlimineerd.
• De ontwikkelaars die een bepaalde microservice maken, hebben de flexibiliteit om voor de service die ze bouwen gebruik te maken van de meest geschikte tools, processorarchitecturen en zelfs programmeertalen.

We gaan nu wat dieper in op de concepten en we introduceren de terminologie die wordt gebruikt om de specifieke kenmerken van cloud-native computing te beschrijven.

Wat is cloud-native?

De term 'cloud-native' verwijst naar het concept van het ontwerpen, bouwen, implementeren, uitvoeren en beheren van applicaties via een methode waarbij wordt geprofiteerd van gedistribueerde computing die u in de cloud aantreft. Cloud-native apps zijn zo ontworpen dat ze profiteren van de schaal, elasticiteit, veerkracht en flexibiliteit die de cloud biedt.

De Cloud Native Computing Foundation (CNCF), een onafhankelijke organisatie die veel van de open standaarden beheert waardoor cloud-native functioneert, definieert het concept op deze manier.

Met cloud-native technologieën kunnen organisaties schaalbare applicaties bouwen en uitvoeren in moderne, dynamische omgevingen zoals openbare, privé- en hybride clouds. Containers, servicemeshes, microservices, onveranderbare infrastructuur en declaratieve API's vormen een voorbeeld van deze benadering.

Door deze technieken zijn systemen met weinig afhankelijkheden mogelijk die veerkrachtig, beheerbaar en observeerbaar zijn. In combinatie met robuuste automatisering kunnen engineers regelmatig en voorspelbaar ingrijpende wijzigingen doorvoeren met minimale inspanning.

Het is de moeite waard om even dieper in te gaan op die definitie.

Schaalbare applicaties zijn applicaties die verhoogde workloads kunnen verwerken zonder dat de software moet worden herschreven of opnieuw ontworpen. De dynamische omgevingen in deze definitie zijn platforms voor cloudcomputing, zoals Oracle Cloud Infrastructure (OCI), maar ook andere openbare, privé- en hybride clouds van alle grote serviceproviders.

De technologieën in die definitie zijn de containers die individuele microservices en de servicemesh-infrastructuur bevatten die deze containers met elkaar verbindt via snelle netwerken die beveiliging, waarneembaarheid, beleidshandhaving en servicediscovery ondersteunen. Onveranderbare infrastructuur betekent dat containers na implementatie nooit worden gewijzigd. In plaats daarvan worden ze op een zorgvuldige en gecontroleerde manier vervangen. Hierdoor kan een gedistribueerde applicatie zowel voorspelbaar als repliceerbaar zijn, dat wil zeggen dat alle exemplaren van een container of een microservice precies hetzelfde zijn.

Een laatste en zeer belangrijk concept is 'met weinig afhankelijkheden'. Dat betekent dat wanneer microservices met andere microservices samenwerken, ze weten hoe ze moeten communiceren via goed gedefinieerde protocollen, declaratieve API's genaamd, waarin nauwgezet wordt beschreven wat de microservice doet, welke data de microservice nodig heeft en welke data de microservice retourneert nadat deze zijn werk heeft voltooid. Deze interne werking van die microservice is verborgen en kan op elk moment worden gewijzigd zonder dat dit invloed heeft op een ander deel van de applicatie. Daardoor is de applicatie als geheel veerkrachtig, schaalbaar en eenvoudiger bij te werken.

Cloud-native applicaties kunnen in elke cloudarchitectuur worden uitgevoerd: openbaar, privé, hybride of multicloud. Een openbare cloud is een cloud waarin data via internet wordt overgedragen tussen de cloudapplicatie en de eindgebruiker of een bedrijfsdatacenter. Bij een privécloud wordt de data volledig overgedragen binnen beveiligde netwerken, zoals een cloudservice die is ingesteld binnen een datacenter. Een hybride cloud maakt gebruik van een combinatie van openbare clouds, privéclouds en bedrijfsdatacenters. Daarnaast omvat een multicloud-implementatie meerdere commerciële cloudproviders. Een deel van de applicatie kan OCI zijn en een ander deel kan bijvoorbeeld worden uitgevoerd in Microsoft Azure.

Voornaamste conclusies

• In cloud-native worden grote applicaties opgesplitst in modulaire stukjes die microservices worden genoemd.
• Microservices kunnen vervolgens worden verpakt in containers, die eenvoudig op servers van een cloudleverancier kunnen worden geïnstalleerd.
• Met orkestratiesoftware, zoals Kubernetes, worden de implementatie en het beheer van microservices in containers geautomatiseerd.
• Microservices worden onafhankelijk van elkaar ontworpen, gecodeerd, getest, geïmplementeerd en beheerd. Hierdoor kunnen ze sneller worden gebouwd, kunnen fouten worden opgespoord en kunnen verbeteringen worden aangebracht zonder dat dit gevolgen heeft voor de rest van de applicatie.
• Omdat cloud-native applicaties beter gebruik kunnen maken van een commerciële cloudservice, worden applicaties efficiënter uitgevoerd zonder dat resources worden verspild. Hierdoor worden de bedrijfskosten van de software verlaagd.

Uitleg over cloud-native

Cloud-native applicaties zijn ontworpen als onafhankelijke microservices, verpakt in lichtgewicht, op zichzelf staande containers. Deze containers zijn goed worden verplaatst en kunnen snel worden op- of afgeschaald op basis van de vraag. Doordat microservices in containers worden ingebed, maakt cloud-native een naadloze implementatie mogelijk in een breed scala aan bedrijfsomgevingen, waaronder datacenters en commerciële cloudservices, en ze kunnen worden uitgevoerd op verschillende soorten servers zoals Linux of Windows.

In de meest voorkomende cloud-native ontwerpen wordt een applicatie zo ontworpen dat de functionaliteit ervan wordt verdeeld over tientallen, honderden of zelfs duizenden microservices, die elk zijn ontworpen om een specifieke taak uit te voeren. Nadat de microservice is geschreven, wordt deze in een containerimage geïnstalleerd, dat wil zeggen een leveringsmiddel dat op een service kan worden geladen en vervolgens kan worden uitgevoerd. De meest voorkomende standaard voor containers is Docker, een opensource-indeling van de CNCF die door vrijwel elke cloudprovider wordt ondersteund.

Een voltooide bedrijfsapplicatie kan duizenden Docker-containers hebben. Maar hoe implementeert u al die containers in een cloudservice, koppelt u deze aan de juiste beveiliging en snelle netwerken, zorgt u ervoor dat berichten van één microservice naar de juiste ontvangers worden gerouteerd en wat doet u met de schaalbaarheid en af en toe een servicefout? Dat is het moment om een opensource-Kubernetes-platform te gaan gebruiken. Net als Docker wordt Kubernetes ondersteund door de CNCF en het is de industriestandaard geworden. Zonder verder in te gaan op alle details, is het genoeg om te vermelden dat Kubernetes alle complexe sanitaire voorzieningen verwerkt en automatiseert die nodig zijn om een grote cloud-native applicatie uit te voeren, te beheren en op te schalen.

Met microservices binnen Docker-containers, en Docker-containers die door Kubernetes worden geïmplementeerd in cloudservices, beschikt u over een volledige, schaalbare en veerkrachtige cloud-native applicatie.

Traditionele applicaties versus cloud-native applicaties

Het tegenovergestelde van een cloud-native applicatie kan een traditionele of monolithische applicatie worden genoemd die als één codebase en meestal door één ontwikkelingsteam is ontworpen. De software wordt geschreven en getest door dat team en wordt vervolgens overgedragen aan een operationeel team dat software implementeert op een server. Als de software een defect heeft, spoort het ontwikkelingsteam het probleem op, reviseert de software en levert een nieuwe versie aan het operationele team. Het operationele team stopt vervolgens de oorspronkelijke software, installeert de vervanging en start deze opnieuw op. Hetzelfde proces wordt gevolgd voor het toevoegen van nieuwe functies. De hele applicatie moet worden vervangen en opnieuw worden geïnstalleerd.

Daarentegen wordt een cloud-native applicatie geschreven als een verzameling met vele microservices, die elk een afzonderlijk stukje software zijn. Die stukjes software worden onafhankelijk ontworpen, gecodeerd, getest en geïmplementeerd zonder dat dit invloed heeft op de rest van de applicatie, waardoor het revisieproces sneller en de updates soepeler verlopen. Ontwikkelaars kunnen de beste tools, waaronder programmeertalen, kiezen voor de specifieke microservice die ze bouwen.

Om een analogie te gebruiken: stel je voor dat in je huis de kraan in de gastenbadkamer begint te lekken. Als je dit zou willen repareren, zou je van Huis 4.1 moeten verhuizen naar Huis 4.2 dat geen lekkende kraan heeft, en vervolgens weer terug moeten verhuizen. Wilt u een enkele wastafel vervangen door een dubbele wastafel? Dan moet u verhuizen naar Huis 4.3. Dat is het monolithische of traditionele softwaremodel. Zou je dat doen? Natuurlijk niet. Een loodgieter zou de kraan vervangen of een aannemer zou de gastenbadkamer kunnen verbouwen zonder dat dit invloed heeft op de rest van het huis. Dat is het cloud-native model.

Belangrijkste componenten van cloud-native ontwikkeling

Met cloud-native computing worden ook een aantal nieuwe concepten en termen geïntroduceerd die van belang zijn om de voordelen van het model te begrijpen. Dit zijn:

1. Containers en containerisatie

   Kubernetes is ontworpen voor hoge beschikbaarheid. De bijbehorende automatische functies voor het repareren van defecte containers vormen de ruggengraat van cloud-native. Deze lichtgewicht, zelfstandige pakketten, die vaak worden gemaakt met Docker, bevatten alle benodigde afhankelijkheden voor consistente uitvoering van applicaties in verschillende computingomgevingen. Met containerisatie zijn applicaties verplaatsbaar en is snelle implementatie mogelijk.

   Containers bieden een gestandaardiseerde, geïsoleerde omgeving waarmee applicaties onafhankelijk kunnen worden uitgevoerd en het risico op conflicten tussen afhankelijkheden wordt verkleind. Door deze isolatie wordt de beveiliging verbeterd doordat potentiële kwetsbaarheden worden beperkt tot afzonderlijke containers. Het lichtgewicht karakter van containers draagt ook bij aan efficiënt gebruik van resources.

2. Microservices-architectuur

   Bij microservices worden complexe applicaties opgesplitst in kleinere, onafhankelijke services. Elke service is gericht op een specifieke functie, waardoor sneller kan worden ontwikkeld door gelijktijdig te werken aan verschillende services.

   De microservicearchitectuur bevordert de flexibiliteit. Elke microservice kan onafhankelijk worden ontwikkeld, geïmplementeerd en geschaald, waardoor snelle updates en nieuwe functiereleases mogelijk zijn. Met deze modulariteit wordt ook de foutisolatie verbeterd, zodat problemen in één service niet van invloed zijn op de hele applicatie.

3. Onveranderbare infrastructuur

   Onveranderbare infrastructuur is een principe waarbij geïmplementeerde resources nooit rechtstreeks worden gewijzigd. Wijzigingen worden geïmplementeerd door nieuwe instances te maken met bijgewerkte configuraties, waardoor consistentie wordt geboden en terugdraaiprocedures worden vereenvoudigd. Met Infrastructure-as-code (IaC)-tools wordt de inrichting van de infrastructuur geautomatiseerd, zodat de efficiëntie en herhaalbaarheid worden verbeterd.

   Met IaC kan de infrastructuur worden gedefinieerd als code voor beter versiebeheer, geautomatiseerde tests en consistente implementatie in alle omgevingen. Deze benadering behandelt infrastructuur als een essentiële applicatiecomponent die is onderworpen aan hetzelfde strenge beheer en controle als de codebase.

4. Automatisering en orkestratie

   Automatisering is een essentieel aspect van cloud-native, met als doel grootschalige implementaties mogelijk te maken die moeilijk handmatig zouden kunnen worden beheerd. Met containerorkestratietools, zoals Kubernetes, worden het beheer en de implementatie van containerapplicaties geautomatiseerd. Deze tools bieden een hoge beschikbaarheid, efficiënte toewijzing van resources en vereenvoudigd schalen, waardoor complexe gedistribueerde systemen beter kunnen worden beheerd.

   Automatisering en orkestratie zijn essentieel om de schaalbaarheid, fouttolerantie en zelfherstellende mogelijkheden te bereiken waardoor cloud-native systemen worden gekenmerkt. Kubernetes-cloudservices maken dynamische toewijzing van resources mogelijk, zodat applicaties kunnen worden geschaald op basis van de vraag en geautomatiseerd herstel na storingen mogelijk is.

5. Waarneembaarheid en monitoring

   Cloud-native applicaties zijn ontworpen met het oog op waarneembaarheid. Dat betekent dat ontwikkelaars meer inzicht hebben in de interne werking van hun systemen. Dit omvat het verzamelen en analyseren van metrics, logbestanden en traces om inzicht te krijgen in prestaties, resourcegebruik en potentiële problemen.

   Geavanceerde monitoringtools bieden realtime inzicht in de status en prestaties van applicaties. Met deze tools is proactieve probleemoplossing mogelijk, waardoor ontwikkelaars problemen kunnen identificeren en oplossen voordat deze gevolgen hebben voor gebruikers. Waarneembaarheids- en beheerservices zijn cruciaal voor het optimaliseren van applicatieprestaties en de toewijzing van resources.

6. Veerkracht en zelfherstellend

   Veerkracht is een belangrijk kenmerk van cloud-native systemen waardoor deze kunnen herstellen van storingen en de stabiliteit behouden blijft. Met strategieën zoals replicatie, load balancing en geautomatiseerde herstelmechanismen is dit mogelijk. Met zelfherstellende functies, zoals deze worden genoemd, worden problemen gedetecteerd en verholpen zonder handmatige interventie, met behoud van hoge beschikbaarheid.

   Cloud-native applicaties zijn zo ontworpen dat storingen correct en met een minimale uitvaltijd worden afgehandeld. Met zelfherstellende mechanismen worden problemen automatisch gedetecteerd en opgelost en wordt ervoor gezorgd dat applicaties soepel blijven draaien. Deze veerkracht is cruciaal voor kritieke bedrijfsactiviteiten en maakt een betrouwbare gebruikerservaring mogelijk.

Video: Wat is cloud-native?

Voordelen van cloud-native benaderingen

De cloud-native benadering biedt organisaties het potentieel van aanzienlijke voordelen ten opzichte van het uitvoeren van traditionele monolithische applicaties. Deze voordelen zijn onder andere:

• Schaalbaarheid en flexibiliteit. Cloud-native applicaties bieden dynamische schaalbaarheid om aan de vraag te voldoen. Met containers en microservices kan gedetailleerd worden geschaald voor efficiënt gebruik van resources en kosteneffectiviteit. Door deze flexibiliteit kunnen bedrijven zich snel aanpassen aan veranderingen in de markt.
• Flexibele ontwikkeling en snellere marktintroductietijd Met de cloud-native benadering worden ontwikkelingscycli versneld. Met een microservices-architectuur is parallelle ontwikkeling mogelijk, waardoor teams tegelijkertijd aan verschillende services kunnen werken. Dit resulteert in snellere releases, waardoor uw bedrijf een concurrentievoordeel krijgt.
• Kostenefficiëntie. Met cloud-native architectuur wordt het gebruik van resources geoptimaliseerd, wat kan leiden tot aanzienlijke kostenbesparingen. Organisaties betalen alleen voor de resources die ze gebruiken, en met geautomatiseerde processen worden de operationele kosten verlaagd doordat handmatig werk tot een minimum wordt beperkt.
• Verbeterde betrouwbaarheid en hoge beschikbaarheid. Cloud-native systemen zijn ontworpen met het oog op veerkracht voor het leveren van hoge beschikbaarheid. Dankzij redundantie-, load balancing- en zelfherstellende mechanismen blijven applicaties beschikbaar, zelfs tijdens storingen. Dit is van vitaal belang voor kritieke bedrijfsactiviteiten en software-updates kunnen worden geïmplementeerd met minimale uitvaltijd.
• DevOps en CI/CD. Cloud-native is naadloos afgestemd op de werkwijzen van DevOps en maakt efficiënte CI/CD-pijplijnen (Continuous Integration and Continuous Delivery) mogelijk. Automatisering stroomlijnt de ontwikkelingscyclus en bevordert samenwerking en efficiëntie.
• Op standaarden gebaseerde portabiliteit. Cloud-native services zijn vaak afhankelijk van opensource- en op standaarden gebaseerde technologie voor interoperabiliteit en portabiliteit van workloads. Hierdoor kan de afhankelijkheid van leveranciers worden verminderd en wereldwijd gebruik van de infrastructuur mogelijk worden gemaakt, wat kan leiden tot lagere latentie en hogere prestaties voor gebruikers over de hele wereld.
• Ontworpen voor veiligheid. Bij cloud-native is beveiliging in elke laag geïntegreerd. Containers bieden geïsoleerde omgevingen, waardoor het risico op kwetsbaarheden wordt verminderd. Geautomatiseerde beveiligingsupdates en beleidshandhaving versterken de beveiligingsstatus, waardoor cloudcomputing zelfs geschikt is voor de meest op beveiliging gerichte gebruiksscenario's.

Dit zijn enkele van de belangrijkste functies en voordelen van cloud-native computing.

Uitdagingen van cloud-native

Cloud-native computing klinkt misschien ingewikkeld. Dat is ook wel zo, vooral voor organisaties waarvoor de cloud nieuw is en die al jaren of decennia bezig zijn met het bouwen van traditionele, monolithische softwareomgevingen. Hier volgen enkele uitdagingen waarmee organisaties worden geconfronteerd wanneer ze willen overstappen op cloud-native computing.

• Complexiteit, hiaten in vaardigheden en leercurve. Cloud-native architecturen kunnen complex zijn, vooral voor grotere applicaties. Met microservices worden extra abstractielagen geïntroduceerd, waarvoor zorgvuldig ontwerp en beheer vereist zijn. Overweeg te investeren in training en bijscholing van uw werknemers om effectief met deze technologieën te werken.
• Culturele verschuiving. Het omarmen van cloud-native vereist vaak een culturele omslag. DevOps-praktijken, multifunctionele samenwerking en een verschuiving naar automatisering en flexibiliteit zijn essentieel. Hierbij kan het ook nodig zijn om gevestigde processen en organisatiestructuren te wijzigen, waarbij de betrokkenheid van alle belanghebbenden, zowel technisch als branche, vereist is.
• Beveiliging en compliance. Hoewel cloud-native de beveiliging kan verbeteren, moet ook met nieuwe dingen rekening worden gehouden. Organisaties moeten bijvoorbeeld zorgen voor veilige communicatie tussen microservices, waarvoor beveiligingscontroles en naleving van compliancevoorschriften moeten worden ingesteld en afgedwongen.
• Gedistribueerde systemen beheren. Cloudarchitecturen en de vereisten voor het gebruik van Kubernetes kunnen heel anders zijn dan de normale activiteiten van uw engineeringteam.
• Kostenbeheer. De flexibiliteit van cloud-native kan leiden tot kostenpieken bij onjuist beheer. Organisaties kunnen monitoringstrategieën implementeren en tools van cloudproviders gebruiken voor kostenoptimalisatie.

Best practices voor implementatie van cloud-native oplossingen

Geen twee organisaties volgen hetzelfde traject naar cloud-native computing. Wat u echter zult merken is dat de meesten deze zeven best practices in gedachten houden.

1. Implementeer een microservices-architectuur. Uw architecten splitsen applicaties op in onafhankelijke microservices, die elk gericht zijn op een specifieke bedrijfsfunctie. Vervolgens kunnen uw ontwikkelaars, of idealiter het DevOps-team, die microservices onafhankelijk bouwen, testen, implementeren en schalen, waardoor de flexibiliteit en veerkracht toenemen.
2. Standaardiseer met containers. Door gebruik te maken van containers (meestal Docker) om microservices in te pakken in eenvoudig te implementeren en eenvoudig te beheren eenheden, wordt de betrouwbaarheid van ontwikkeling tot aan productie gegarandeerd, vooral als u een CI/CD-pijplijn gebruikt.
3. Automatiseer implementatie en schaling. Uw DevOps-teams kunnen CI/CD gebruiken om softwarebuilds, tests en implementaties te automatiseren voor een snelle en betrouwbare levering van software. Als u bovendien een platform zoals Kubernetes gebruikt, kan uw pijplijn automatisch worden opgeschaald en wordt de kans op menselijke fouten kleiner.
4. Gebruik Infrastructure as Code (IaC) en een onveranderbare infrastructuur. Geavanceerde IaC en onveranderbare toolchains kunnen met Kubernetes werken zodat het maken van veilige snelle netwerken wordt geautomatiseerd en uw applicatie snel kan worden geïnstalleerd waar u deze nodig hebt.
5. Geef prioriteit aan waarneembaarheid en monitoring. Als u het niet kunt zien, kunt u het ook niet beheren. Leg er dus de nadruk op dat microservices zo moeten worden ontworpen dat robuuste logs kunnen worden gegenereerd en algemene waarneembaarheids- en monitoringstandaarden worden ondersteund.
6. Integreer beveiliging op elke laag. Integratie van beveiliging in elke fase van het ontwerp- en implementatieproces van applicaties is van cruciaal belang. Veel organisaties kiezen ervoor om een zero trust-benadering in te voeren.
7. Optimaliseer de kosten en het resourcegebruik. Cloudcomputing is een zakelijke OpEX-resource (operationele uitgaven): hoe meer u gebruikt, hoe hoger de rekening. In tegenstelling tot traditionele applicaties in een datacenter is er dus direct winst te behalen als de efficiëntie wordt verbeterd en de resources optimaal zijn afgestemd op de workloads.

Ontwikkeling van apps versnellen met cloud-native flexibiliteit

Oracle biedt alles wat nodig is voor het bouwen en implementeren van cloud-native applicaties, zoals tools, services en automatisering, zodat ontwikkelteams snel kunnen bouwen en tegelijkertijd het aantal operationele taken kunnen verminderen.

Cloud-native Oracle services worden uitgevoerd in OCI. Dit biedt een op standaarden gebaseerd platform met hogere prestaties en lagere kosten in vergelijking met andere cloudproviders. Door gebruik te maken van services op basis van open source en open standaarden kunnen ontwikkelaars applicaties in elke cloud- of on-premises omgeving uitvoeren zonder deze te hoeven aanpassen. Door deze flexibiliteit wordt de vrijheid geboden om te focussen op het bouwen en innoveren, zoals met behulp van krachtige generatieve AI en zelfs vooraf gebouwde AI/ML-services, om nieuwe functies en intelligence in te bouwen in uw bestaande applicaties.

Levert cloud-native applicatieontwikkeling echt apps op die zoveel beter zijn dan traditioneel ontwikkelde apps? Ja. De voordelen zijn duidelijk: cloud-native apps zijn schaalbaar omdat hun functies worden opgesplitst in microservices die individueel kunnen worden beheerd. Bovendien kunnen cloud-native apps op een zeer gedistribueerde manier draaien, waarbij ze onafhankelijk blijven en resources kunnen toewijzen op basis van de applicatiebehoeften.

Cloud-native applicaties kunnen helpen om de bedrijfsstrategie en -waarde te verhogen, omdat ze een consistente ervaring kunnen bieden in privé-, openbare en hybride clouds. Hiermee kan uw organisatie optimaal profiteren van cloudcomputing door responsieve en betrouwbare, schaalbare applicaties uit te voeren.

Veelgestelde vragen over cloud-native

Wat is het verschil tussen cloud-native architectuur en traditionele applicatiearchitecturen?

Met cloud-native architectuur worden grote, complexe bedrijfsapplicaties opgedeeld in een groot aantal microservices, die elk een bedrijfsfunctie uitvoeren. De applicatie werkt wanneer deze microservices via een snel netwerk met elkaar communiceren om aan een taak samen te werken. Elke microservice wordt afzonderlijk gedefinieerd, ontworpen, gebouwd, getest, geïmplementeerd, beheerd en geüpgraded, wat kan resulteren in snellere implementaties en een veel grotere schaalbaarheid. Wanneer een microservice bijvoorbeeld een hoge workload detecteert, kan een cloud-native applicatie automatisch een exemplaar van die microservice op een andere server maken en de workload daartussen verdelen. Een traditionele applicatiearchitectuur bestaat daarentegen uit één softwarecodebase (een monoliet) die als één geheel wordt ontworpen, gebouwd, getest en geïmplementeerd. Bugfixes of upgrades leiden tot wijzigingen in de monoliet, die vervolgens opnieuw moeten worden geïmplementeerd. Hierdoor zijn software-implementaties vaak traag. Schaalbaarheid is een uitdaging en vereist vaak het opnieuw ontwerpen (en herschrijven) van de software of het installeren ervan op een snellere, duurdere server.

Hoe kunnen bedrijven hun bestaande applicaties effectief omzetten om cloud-native te worden?

Bestaande monolithische applicaties kunnen worden herbouwd tot cloud-native applicaties. Met het proces worden delen van de code geïdentificeerd die kunnen worden opgesplitst in microservices, die vaak beginnen met de codesecties die het eenvoudigst kunnen worden gescheiden of die prestatieknelpunten veroorzaken. Door deze secties één voor één af te handelen, kan een monolithische applicatie veel van de voordelen van de cloud-native benadering realiseren.

Wat is de CNCF?

De Cloud Native Computing Foundation (CNCF) is een leveranciersneutrale opensource-organisatie die wordt gehost door de Linux Foundation. Het doel van de CNCF is om cloud-native technologieën te promoten en het biedt essentiële ondersteuning voor veel project- en branchestandaarden, zoals de Docker-containerindeling en het Kubernetes-platform voor containerautomatisering en -orkestratie. Veel cloudserviceproviders, waaronder Oracle, dragen bij aan het werk van de CNCF en hebben de standaarden ingevoerd om de interoperabiliteit tussen cloudecosystemen te bevorderen.

Wat is het verschil tussen cloud en cloud-native?

Cloud verwijst naar computerservices die worden gehost door commerciële serviceproviders zoals Oracle. Die computerservices omvatten vele soorten servers, snelle netwerken, opslagsystemen, bibliotheken met geavanceerde computingfuncties (zoals voor AI en beveiliging), en zelfs zakelijke applicaties. Bijna elke website of applicatie die u opent via een webbrowser bevindt zich geheel of gedeeltelijk in de cloud. De rest bevindt zich in bedrijfsdatacenters. Veel mobiele-telefoonapps vertrouwen ook op de cloud om essentiële functionaliteit te bieden.

Cloud-native is een aanpak voor het bouwen van bedrijfsapplicaties waarmee de applicatie wordt opgesplitst in tientallen of honderden microservices. Elke microservice omvat een belangrijk stukje van de bedrijfsfunctionaliteit. De applicatie vormt één geheel bij het oplossen van bedrijfsproblemen wanneer die microservices via veilige snelle netwerken met elkaar samenwerken, waarbij elke microservice zijn eigen stukje van de workload uitvoert. Cloud-native applicaties maken gebruik van de resources van een cloudserviceprovider zodat de applicatie schaalbaar, efficiënt en veerkrachtig wordt.