DevOps

Vad är DevOps?

DevOps är en sammanslagning av Development och Operations. Begreppet syftar på ett arbetssätt där utveckling och drift av system förenas, så att applikationer kan släppas snabbare, mer stabilt och utan att vara alltför beroende av manuella steg.

Innan DevOps blev populärt jobbade utvecklings- och driftteam ofta åtskilt. Resultatet blev långsamma releaseprocesser, förvirrande överlämningar mellan team och, när något gick fel, mest letande efter syndabockar.

Några vanliga problem som uppstår utan bra DevOps-praxis:

Långsam deploy - Releaser kan ta veckor eller månader
Dålig kommunikation - Dev- och ops-team arbetar i separata spår
Återkommande manuella processer - Rutinuppgifter blir lätt bortglömda eller felaktiga
Ojämn kvalitet - Testning och deployment fungerar olika i varje miljö

DevOps grundprinciper

1. Samarbete

Utvecklings- och driftteam arbetar närmare varandra och delar ansvaret för applikationens hela livscykel.

2. Automation

Återkommande uppgifter som build, test, deployment och provisionering bör automatiseras.

3. Kontinuerlig förbättring

Processen utvärderas löpande. Uppstår en flaskhals ska processen förbättras, inte bara lappas ihop.

4. Fokus på användaren

Målet är inte bara snabbare releaser, utan att leverera värde till användarna på ett sätt som förblir säkert och mätbart.

5. Lär av incidenter

Fel och incidenter kommer att inträffa. Det viktiga är att teamet lär sig av orsaken och förbättrar processen så att samma sak inte upprepas.

DevOps livscykel

1. Plan

Planera funktioner och förändringar utifrån produktbehov och användarfeedback.

Verktyg: Jira, Trello, Azure Boards, Linear

2. Code

Utvecklaren skriver kod och sparar den i versionshantering.

Verktyg: Git, GitHub, GitLab, Bitbucket

3. Build

Koden kompileras eller paketeras till en artefakt som är redo att testas eller köras.

Verktyg: Maven, Gradle, npm, webpack

4. Test

Automatiserad testning hjälper till att upptäcka om en ny ändring har brutit befintligt beteende.

Verktyg: Jest, Pytest, JUnit, Selenium, Cypress

// Exempel på automatiserat test
describe('User API', () => {
  test('should create new user', async () => {
    const response = await api.post('/users', {
      name: 'Anna',
      email: 'anna@example.com'
    });
    expect(response.status).toBe(201);
  });
});

5. Release

Applikationen förbereds för leverans till målmiljön, komplett med byggartefakter och nödvändig konfiguration.

Verktyg: Docker, Helm, Artifactory

6. Deploy

Den nya versionen av applikationen släpps till staging eller produktion.

Verktyg: Kubernetes, AWS, smbCloud, Ansible

# Exempel på deployment till smbCloud
$ git push smb main
# Triggar automatiskt build och deploy

7. Operate

En applikation som redan körs behöver skötas: resurser, tillgänglighet, incidenter och daglig drift.

Verktyg: Prometheus, Grafana, Datadog, New Relic

8. Monitor

Teamet övervakar prestanda, fel, loggar och systemets beteende efter release.

Verktyg: ELK Stack, Sentry, LogRocket

CI/CD: en viktig del av DevOps

Continuous Integration (CI)

Utvecklare slår ihop kodändringar till huvudgrenen regelbundet. Varje ändring triggar vanligtvis en automatisk build- och testprocess.

# Exempel på GitHub Actions CI
name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm test
      - name: Run linter
        run: npm run lint

Continuous Delivery (CD)

Efter godkänt test förbereds koden för release till nästa miljö, vanligtvis staging eller produktion.

# Exempel på CD-pipeline
deploy:
  runs-on: ubuntu-latest
  needs: test
  if: github.ref == 'refs/heads/main'
  steps:
    - name: Deploy to production
      run: |
        curl -X POST https://api.smbcloud.com/deploy \
          -H "Authorization: Bearer ${{ secrets.SMB_TOKEN }}" \
          -d '{"app": "myapp", "branch": "main"}'

Infrastructure as Code (IaC)

Infrastructure as Code innebär att infrastrukturen hanteras via konfigurationsfiler i stället för manuella klick i en dashboard.

Terraform-exempel

# Definiera infrastruktur som kod
resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  
  tags = {
    Name = "WebServer"
    Environment = "Production"
  }
}

Docker-exempel

# Dockerfile för Node.js-app
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

DevOps verktygsekosystem

Versionshantering

Git - Distribuerat versionshanteringssystem
GitHub/GitLab - Plattform för kodhosting och samarbete

CI/CD-plattformar

GitHub Actions - CI/CD integrerat med GitHub
GitLab CI - Inbyggd CI/CD i GitLab
Jenkins - Automation server med öppen källkod
CircleCI - Molnbaserad CI/CD-plattform

Containerisering

Docker - Containerplattform för att paketera applikationer
Podman - Ett alternativ till Docker

Orkestrering

Kubernetes - Plattform för containerorkestrering
Docker Swarm - Dockers inbyggda orkestreringsalternativ

Molnplattformar

AWS - Amazon Web Services
Google Cloud - Google Cloud Platform
Azure - Microsofts molnplattform
smbCloud - Molnplattform för utvecklare

Övervakning och loggning

Prometheus - Insamling av mätvärden och larm
Grafana - Dashboard och visualisering
ELK Stack - Elasticsearch, Logstash, Kibana
Datadog - Integrerad övervakning

Konfigurationshantering

Ansible - Automation av IT-drift
Puppet - Konfigurationshantering
Chef - Infrastrukturautomation

DevOps bästa praxis

1. Börja i liten skala

Du behöver inte anamma allt på en gång. Många team börjar med:

Ordnad versionshantering
Enkel CI
Automatiserad deployment för en enda miljö

2. Automatisera det som verkligen behövs

Manuella processer som upprepas ofta är oftast värda att automatisera, till exempel:

Testning
Deployment
Provisionering av infrastruktur
Grundläggande larm

3. Mät processen i stället för att bara gissa

Några mätvärden som ofta används:

Deployment frequency - Hur ofta applikationen släpps
Lead time - Tiden från kodändring till att den är live
MTTR - Återställningstid vid en incident
Change failure rate - Andel deploys som leder till problem

4. Använd feature flags vid behov

Feature flags hjälper teamet att släppa kod utan att direkt behöva aktivera alla funktioner för alla användare.

if (featureFlags.isEnabled('new-checkout')) {
  // Nytt kassaflöde
} else {
  // Gammalt kassaflöde
}

5. Bygg in säkerhet från början

Detta angreppssätt kallas ofta DevSecOps. Principen är enkel: säkerhet skjuts inte upp till slutet, utan granskas genom hela processen från build till deploy.

DevOps-kultur: den ofta svåra delen

Skuldfria efteranalyser (blameless post-mortems)

När en incident inträffar bör huvudfokus vara att förstå vad som hände och hur liknande händelser kan förhindras, inte att hitta en syndabock.

Vad hände? - Händelseförloppet
Varför hände det? - Grundorsaksanalys
Vad behöver ändras? - Åtgärder som faktiskt går att genomföra

Delat ansvar

Principen "you build it, you run it" uppstår ur behovet av att teamet som bygger applikationen också förstår dess operativa konsekvenser i produktion.

Kontinuerligt lärande

DevOps-praxis mognar vanligtvis genom experiment, utvärdering och vanan att förbättra processen steg för steg.

DevOps för mindre bolag och startups

Utmaningar

Begränsade resurser - Små team får ofta axla många roller samtidigt
Kompetensgap - Inte alla team har en dedikerad DevOps-ingenjör
Komplex verktygsflora - Många valmöjligheter, men inte alla är relevanta i tidiga skeden

Lösning med smbCloud

smbCloud hjälper team som vill ha ett smidigare deploy- och driftflöde utan att behöva sätta upp alla komponenter själva.

# Ingen komplicerad setup behövs
$ npx smb init
$ git add .
$ git commit -m "Initial commit"
$ git push smb main

Auto CI/CD configured
SSL certificate provisioned
Monitoring enabled
Live at https://myapp.smbcloud.app

Fördelar:

Lättare operativ setup
Auto-skalning ingår som en plattformsfunktion
Grundläggande övervakning är redan på plats
Kostnaden är lättare att förutse för mindre team

Viktiga DevOps-mått

DORA-mätvärden

(DevOps Research and Assessment)

Deployment Frequency
- Elite: Flera deploys per dag
- High: En gång per dag till en gång per vecka
- Medium: En gång per vecka till en gång per månad
- Low: Mindre än en gång per månad
Lead Time for Changes
- Elite: Mindre än 1 timme
- High: 1 dag till 1 vecka
- Medium: 1 vecka till 1 månad
- Low: Mer än 1 månad
Mean Time to Recover (MTTR)
- Elite: Mindre än 1 timme
- High: Mindre än 1 dag
- Medium: 1 dag till 1 vecka
- Low: Mer än 1 vecka
Change Failure Rate
- Elite: 0-15%
- High: 16-30%
- Medium: 31-45%
- Low: 46-60%

Vägen till att bli DevOps-ingenjör

Nivå 1: Grunderna (3-6 månader)

Grundläggande Linux och kommandoraden
Git och versionshantering
Grundläggande nätverk (DNS, HTTP, TCP/IP)
Programmering eller skriptspråk (Python, Bash, JavaScript)

Nivå 2: DevOps-kärnan (6-12 månader)

CI/CD med GitHub Actions eller GitLab CI
Docker och containerisering
Grundläggande Kubernetes
Infrastructure as Code (Terraform)
Övervakning och loggning

Nivå 3: Avancerat (12+ månader)

Avancerad Kubernetes (Helm, Operators)
Service mesh (Istio, Linkerd)
Avancerat nätverk och säkerhet
Multi-cloud-strategier
Chaos engineering

Vanliga misstag inom DevOps

För stort fokus på verktyg - Verktyg är viktiga, men teamets arbetssätt är fortfarande avgörande
Att skapa en ny silo kallad "DevOps-teamet" - Om allt läggs på ett enda team är samarbetsproblemet inte löst
Att automatisera en process som fortfarande är rörig - Städa upp processen först, automatisera sedan
Att bortse från säkerhet - Att lägga till det i efterhand blir oftast dyrare och krångligare
Deploy utan övervakning - Svårt att åtgärda ett system om du inte vet vad som pågår

Slutsats

DevOps är inte bara en samling verktyg. Kärnan handlar om att bygga ett smidigare arbetsflöde mellan kodning, testning, deployment och drift av applikationen.

Om du precis har börjat räcker det att fokusera på grunderna: disciplinerad versionshantering, automatiserade tester, upprepningsbar deployment och rimlig övervakning. Lägg sedan till fler verktyg och processer efter teamets behov.