DevOps is noch een methode, noch een tool, het is een cultuur



DevOps is de praktijk van operations en development engineers die samen deelnemen aan de gehele levenscyclus, van ontwerp en ontwikkelingsproces tot productieondersteuning. Agility in het systeem brengen kan worden beschouwd als een DevOps-cultuur.

Cultuur wordt vaak genegeerd en verkeerd begrepen, maar het is een sleutelfactor die verantwoordelijk is voor de prestaties van een bedrijf. Als we onze cultuur niet beheren, zullen we uiteindelijk verkeerde praktijken toepassen die uiteindelijk onze bedrijfsdoelen zullen beïnvloeden.

Inzicht in de huidige cultuur van een organisatie

Cultuur vertelt ons over de waarden en normen binnen een groep of bedrijf. Het identificeert wat belangrijk is en hoe mensen elkaar benaderen en met elkaar samenwerken.





CULTURE = 'Hoe dingen slim kunnen worden gedaan voor succes'

Laten we het voorbeeld nemen van een klantenserviceteam. De cultuur van dat team moet zodanig zijn dat ze uiteindelijk 97-98% van de klanttevredenheid behalen.



Met het oog op de tevredenheid van de klant, moeten ze allereerst beleefd zijn, zelfs in moeilijke situaties moeten ze goed kunnen luisteren om verwarring te voorkomen, ze moeten het werk naar behoefte prioriteren.

Laten we even pauzeren en onszelf een paar vragen stellen:

  • Wat is de cultuur van mijn bedrijf nu?
  • Hoe goed is deze cultuur afgestemd op mijn bedrijfsdoelen of KRA's?
  • Welke problemen kan ik verwachten als gevolg van een verkeerde uitlijning?

Voor elke organisatie spelen de 4C's een cruciale rol



4C van organisatie

Laten we nu eens kijken naar de cultuur van een softwareontwikkelingsorganisatie. Er zijn veel teams betrokken bij het bouwen en onderhouden van één software-unit. Al deze teams hebben aparte doelen en een aparte cultuur.

big data-tutorial voor beginners

Dit proces start nadat de eisen zijn bevestigd door de klant.

Ontwikkelaars volgen de coderingsrichtlijnen die zijn gedefinieerd door hun organisatie en programmeertools zoals compilers, interpreters, debuggers enz. Worden gebruikt om de code te genereren. Er worden verschillende programmeertalen op hoog niveau gebruikt, zoals C, C ++, Pascal, Java en PHP, voor codering.

Ze verdelen het complete pakket in kleine mappen en ontwikkelen dienovereenkomstig kleine codes.

Fase 1 : Deze kleine codes worden vervolgens geknuppeld om een ​​grote eenheid te vormen. Bij het integreren van de kleinere chips moet een test op projectniveau worden uitgevoerd, ook wel integratietest genoemd.

Stage 2 : Na de succesvolle integratie wordt het geïmplementeerd in een dummy-systeem. Dit dummy-systeem heeft een vergelijkbare configuratie als die van de clientcomputer of de machine waarop dit project uiteindelijk moet worden ingezet.

Stap 3 : Ten slotte, na het testen van alle functies in een dummy-systeem, wordt het project geïmplementeerd op de productieserver of de clientcomputer.

Hoewel dit proces in woorden erg soepel en gemakkelijk lijkt, is het technisch gezien erg moeilijk te bereiken.

Laten we eens kijken met welke problemen we te maken kunnen krijgen:

Fase 1 :

De klant is altijd op zoek naar veranderingen om de kwaliteit van het product te verbeteren. Meestal wanneer de eerste iteratie is gedaan, zal de klant een paar wijzigingen voorstellen. Wanneer de ontwikkelaars de wijzigingen ontvangen, beginnen ze deze op te nemen, wat van invloed is op de integratie die leidt tot kapotte builds.

Stage 2:

Meestal zullen de testers of andere operatoren niet op de hoogte zijn van de nieuwe wijzigingen die moeten worden aangebracht. Zodra ze de code van ontwikkelaars krijgen, beginnen ze deze te testen. Aan de achterkant maken de ontwikkelaars nog steeds de wijzigingen.

Omdat ze niet genoeg tijd krijgen om nieuwe wijzigingen door te voeren, ontwikkelen ze uiteindelijk inefficiënte codes en worden ze geconfronteerd met andere netwerk- en databaseproblemen, waardoor hun leveringstijd opnieuw wordt vertraagd.

Wanneer ze de codes uiteindelijk aan het operatieteam bezorgen, hebben ze zeer weinig tijd om nieuwe testcases te maken en te implementeren. Dus slaan ze veel van de testcases over, waarvan ze later beseffen dat die hoge prioriteit hadden.

Stap 3:

Hoewel vrijwel de build klaar lijkt om in productie te gaan, zijn de resultaten volledig onverwacht. Het bouwen mislukt en er treden een aantal bugs op.

Vervolgens moeten ze voor elke opgetreden bug bijhouden waarom dat is opgetreden, waar het zich heeft voorgedaan, welke wijzigingen moeten worden aangebracht om het te verhelpen, zullen er wijzigingen zijn in de codes van anderen om het compatibel te maken met de vorige. Ten slotte moet voor al deze bugs een bugrapport worden gegenereerd.

De storing is het gevolg van systeemfouten als gevolg van de onwetendheid van de databaseontwikkelaar over de efficiëntie van code, de onwetendheid van de tester in het aantal testgevallen, enz.

Omdat de klant de deadline altijd krap houdt, concentreren de medewerkers die betrokken zijn bij het bereiken ervan zich alleen in de uiteindelijke release, zelfs als ze de algehele kwaliteit in gevaar moeten brengen.

Hoewel dit een probleem lijkt te zijn bij de coördinatie van werk, dit is eigenlijk het falen van de aangenomen cultuur.

Dit gebeurt vanwege de grote afhankelijkheid van handmatige processen. Heen en weer rennen in hetzelfde team vanwege gebrek aan kennis van een ander gebied, gebrek aan toegang of misschien gebrek aan interesse, verhoogt onze eigen last en pijn.

Het wordt hoog tijd dat we veelzijdig moeten zijn. Het is misschien moeilijk om alle processen in een systeem onder de knie te krijgen, maar we kunnen de krik van allemaal zijn en er één beheersen. Alleen dan kunnen we ons systeem automatiseren of intelligent genoeg maken om te herstellen in plaats van terugdraaien.

Nu denk je misschien waarom?

Het is omdat degene die je beheerst in hoge mate afhankelijk is van anderen. Dus om het afhankelijkheidspunt te kennen, moeten we het hele systeem begrijpen.

Laten we dus eens kijken naar een proces om de cultuur te veranderen. Heeft u daarvoor het antwoord op onderstaande vragen?

  • Waar faalt uw huidige cultuur?
  • Waarom wil je het proces wijzigen?
  • Heeft u alle vereiste wijzigingen duidelijk geïdentificeerd?
  • Heb je feedback en buy-in gekregen van alle betrokken stakeholders?
  • Heeft u de procesdiscipline, het data- en meetsysteem opnieuw gevalideerd voor de verandering?

Dus als we nu het antwoord op allemaal hebben, denken we aan een revolutie in ons systeem. Hoe zal deze revolutie plaatsvinden? Het kan alleen worden bereikt als we doden wat we nu zijn. Er wordt veel tijd verspild aan de migratie van code tussen de teams. We moeten het proces brengen waar we continue integratie en continue implementatie kunnen doen.

Dit proces van continue integratie en implementatie maakt het flexibeler. Het brengen van deze behendigheid wordt beschouwd als een DevOps-cultuur.

DevOps is de praktijk van operations en development engineers die samen deelnemen aan de gehele levenscyclus van de service, van ontwerp via het ontwikkelingsproces tot productieondersteuning.

Het is niet eenvoudig om het werkende systeem in de loop van de tijd te veranderen. Een succesvolle overgang maken is het systeem renoveren in plaats van opnieuw opbouwen.

komkommer java selenium webdriver voorbeeld

Laten we nu eens kijken hoe we dit kunnen bereiken. Er kunnen twee manieren zijn om te benaderen.

1) Van boven naar beneden

2) Bottom-up

Als we dieper in deze technieken duiken, zullen we beseffen welke het meest geschikt is voor onze organisatie.

Bij de top-down benadering kunnen we naar het hoger management gaan en hen vragen om wijzigingen aan te brengen in alle teams. Als het management dan overtuigd is, kunnen we eraan beginnen.

Maar de kans om het antwoord 'NEE' te krijgen, is vrij hoog. Het is omdat het veranderen van het systeem de organisatie tot instabiliteit kan leiden.

Ze moeten kijken naar de organisatiestructuur, de inkomsten, het belang van de klant, enz. Maar de belangrijkste factor die hen ervan weerhoudt uit het oude systeem te komen, is dat ze de grote afbeelding van wat kan worden bereikt en hoe soepel het kan worden bereikt met de nieuwere.

In dit geval kunnen we zoeken naar de tweede benadering om dit grote plaatje te krijgen.

De bottom-up benadering vraagt ​​om vrijwilligerswerk. Hier moeten we een klein team en een kleine taak nemen en deze uitvoeren in DevOps Model.

Als we naar de technische kant van dit model kijken, hebben we verschillende sets geavanceerde tools die het werk efficiënter en sneller maken. Maar tools alleen zijn niet capabel genoeg om een ​​samenwerkingsomgeving te creëren die DevOps wordt genoemd.

array sorteren c ++

Om zo'n omgeving te creëren, moet je out of the box denken, bijv. beoordelen en opnieuw afstemmen hoe mensen denken over hun teams, het bedrijf en de klanten.

Het samenstellen van een nieuwe set tools is eenvoudiger dan het veranderen van de organisatiecultuur. Door de antisociale masterontwikkelaars te promoten, inefficiënte code te laten integreren, codes in te zetten die niet goed zijn getest, elkaar de schuld te geven, het operatieteam dom beschouwen, zijn niet de beste praktijken die we volgen om het bedrijf mogelijk te maken en waarde creëren voor onze klanten.

Het zijn niet de tools, maar de mensen die ze gebruiken, die het proces complex maken. Om op een abstract niveau te zeggen in plaats van ideeën en gedragingen te verzamelen, als we ervoor openstaan, komen we op een helder pad.

Laten we beginnen met een team van zes leden en een verhaal met drie punten. Eerst moeten we het team dat we noemen als ontwikkelaars, operaties, testers, enz. Breken. We beschouwen ze allemaal als één, zeg maar 'DevOps'. Wanneer we de vereisten ontvangen, moeten we de risicozones analyseren. Rekening houdend met de diepere delen van de zee & hellip .. We beginnen met zeilen.

Nu moet u zich afvragen “wat is de x-factor van deze continue integratie en continue inzet die de kans op mislukking verkleint”.

Met de verbeterde visie en het proces kunnen we het management benaderen door een duidelijk beeld te krijgen van de resultaten, zoals hoe soepel het proces was, hoe het risico op mislukking werd verminderd, hoe de taak werd voltooid vóór de tijdlijn, enz.

Nu kunnen we duidelijk visualiseren hoe het hele proces op technisch en cultureel gebied werd geoptimaliseerd door na elke iteratie terug te kijken.

Edureka heeft speciaal samengesteld waarmee je concepten rond Puppet, Jenkins, Ansible, SaltStack en Chef onder de knie krijgt.

Heeft u een vraag voor ons? Noem ze in het opmerkingengedeelte en we nemen contact met u op.

Gerelateerde berichten: