Grunnleggende Docker og DevOps · leksjon

Håndtering av Secrets og RBAC

Lær avanserte strategier for å håndtere sensitive data og implementere Role-Based Access Control (RBAC) i containermiljøer.

Leksjon 3 av 412 trinn

Håndtering av Secrets og RBAC er en gratis leksjon i Grunnleggende Docker og DevOps på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Grunnleggende Docker og DevOps, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Grunnleggende Docker og DevOps inneholder totalt 4 leksjoner.

Sikre containermiljøet ditt

Velkommen! I denne leksjonen går vi gjennom viktige sikkerhetspraksiser for containeriserte applikasjoner: håndtering av hemmeligheter og rollebasert tilgangskontroll (RBAC).

Disse konseptene er avgjørende for å beskytte sensitive data og sikre at bare autoriserte entiteter kan utføre bestemte handlinger i containermiljøene dine.

Håndtering av Secrets og RBAC — illustrasjon 1

Faren ved hardkodede hemmeligheter

Det er en stor sikkerhetsrisiko å legge sensitiv informasjon som API-nøkler, databasepassord eller private sertifikater direkte inn i applikasjonskoden eller Dockerfiles.

Eksponering: Alle som har tilgang til kodelageret eller det bygde imaget, kan enkelt se dem.
Manglende kontroll: Hvis en hemmelighet skal endres, må hele applikasjonen bygges og distribueres på nytt.
Problemer med samsvar: Det bryter med mange beste praksiser for sikkerhet og regulatoriske krav.

Miljøvariabler (med forsiktighet)

En vanlig, men ikke alltid sikker, måte å sende hemmeligheter på er via miljøvariabler. Docker lar deg sende dem med flagget -e, og applikasjoner kan lese dem.

Miljøvariabler kan imidlertid enkelt inspiseres (f.eks. med docker inspect) og kan bli liggende i skallhistorikken eller logger. For virkelig sensitive data finnes det bedre løsninger.

Docker Secrets i praksis

Docker Secrets lar deg lagre og overføre sensitive data til containere på en sikker måte. Når en hemmelighet knyttes til en container, monteres den som en midlertidig fil i /run/secrets/.

Først oppretter du en hemmelighet (f.eks. echo "my_secure_pass" | docker secret create app_secret -). Deretter kan applikasjonen lese den:

import os

def main():
    secret_path = "/run/secrets/app_secret"
    try:
        with open(secret_path, 'r') as f:
            secret_value = f.read().strip()
        print(f"Secret read: {secret_value}")
    except FileNotFoundError:
        print("Secret file not found. Make sure it's mounted.")
    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    main()

Oversikt over Kubernetes Secrets

I likhet med Docker Secrets har Kubernetes sitt eget objekt kalt «Secrets» for lagring og håndtering av sensitiv informasjon. Disse hemmelighetene kan monteres som filer i Pods eller eksponeres som miljøvariabler.

Viktig: Kubernetes Secrets er base64-kodet, ikke kryptert som standard. Det betyr at de enkelt kan dekodes. For ekte kryptering ved lagring trenger du ytterligere konfigurasjon (f.eks. KMS-integrasjon).

Distribusjon med K8s Secrets

La oss se på et eksempel på hvordan en Kubernetes Secret defineres og deretter brukes i en Pod. Du kan definere secrets i YAML eller opprette dem ved hjelp av kubectl-kommandoer.

Når den er opprettet, kan en Pod referere til secreten for å montere den som et volum eller sette verdiene inn som miljøvariabler.

apiVersion: v1
kind: Pod
metadata:
  name: my-secret-pod
spec:
  containers:
  - name: my-app-container
    image: busybox
    command: ["sh", "-c", "echo Username: $(cat /etc/secrets/username) Password: $(cat /etc/secrets/password)"]
    volumeMounts:
    - name: secret-volume
      mountPath: "/etc/secrets"
      readOnly: true
  volumes:
  - name: secret-volume
    secret:
      secretName: my-k8s-secret

Eksterne hvelv for secrets

For svært sensitive data, eller når secrets skal håndteres på tvers av flere klynger og miljøer, tilbyr eksterne verktøy for secret-håndtering avanserte funksjoner som:

Sentralisert lagring: Én felles kilde til sannheten for alle secrets.
Kryptering ved lagring og overføring: Sterkere sikkerhetsgarantier.
Dynamiske secrets: Automatisk genererte, kortvarige påloggingsopplysninger.
Revisjon og tilgangskontroll: Finkornede tillatelser og omfattende logging.

Populære alternativer inkluderer HashiCorp Vault, AWS Secrets Manager og Azure Key Vault.

Hva er RBAC?

Rollebasert tilgangskontroll (RBAC) er en metode for å begrense systemtilgang til autoriserte brukere. I stedet for å tildele tillatelser direkte til enkeltbrukere grupperes tillatelsene i «roller», og brukerne tildeles disse rollene.

I containerorkestrering sørger RBAC for at brukere, applikasjoner eller tjenester bare har de nødvendige tillatelsene til å samhandle med ressurser (som Pods, Deployments og Secrets).

Byggeklosser i K8s RBAC

Kubernetes RBAC bruker noen viktige ressurstyper:

Role: Definerer tillatelser i et bestemt namespace (f.eks. «kan vise pods» i namespace-et «dev»).
ClusterRole: Definerer tillatelser i hele klyngen (f.eks. «kan vise alle pods» eller «kan administrere noder»).
RoleBinding: Tildeler tillatelsene som er definert i en Role, til en bruker, gruppe eller servicekonto i et namespace.
ClusterRoleBinding: Tildeler tillatelsene som er definert i en ClusterRole, til en bruker, gruppe eller servicekonto i hele klyngen.

RBAC-eksempel: Begrense tilgang

La oss se på et eksempel på hvordan en bestemt servicekonto får tillatelse til bare å liste opp og hente pods i et bestemt namespace. Dette håndhever prinsippet om minste privilegium.

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""] # "" indicates the core API group
  resources: ["pods"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods-binding
  namespace: default
subjects:
- kind: ServiceAccount
  name: pod-viewer-sa # Name of the ServiceAccount to bind to
  namespace: default
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Kontroller forståelsen din

Du har lært om sikring av sensitive data og kontroll av tilgang. På tide med en rask kontroll!

Besvar den i den interaktive leksjonen

Oppsummering: Sikre applikasjonene dine

Godt jobbet! I denne leksjonen har du lært om to kritiske grunnpilarer innen containersikkerhet:

Håndtering av secrets: Beskyttelse av sensitive data ved hjelp av Docker Secrets og Kubernetes Secrets, samt forståelse av styrkene og begrensningene deres.
Rollebasert tilgangskontroll (RBAC): Implementering av finkornede tillatelser i Kubernetes for å sikre prinsippet om minste privilegium.

Ved å mestre dette bygger du mer robuste og sikre containeriserte applikasjoner!

Gratis å komme i gang

Lær deg Grunnleggende Docker og DevOps med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Håndtering av Secrets og RBAC» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Grunnleggende Docker og DevOps, inkludert «Håndtering av Secrets og RBAC», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Grunnleggende Docker og DevOps inneholder totalt 4 leksjoner.

Hva lærer jeg i «Håndtering av Secrets og RBAC»?

Lær avanserte strategier for å håndtere sensitive data og implementere Role-Based Access Control (RBAC) i containermiljøer. Du øver på Grunnleggende Docker og DevOps med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Grunnleggende Docker og DevOps?

Ingen tidligere erfaring er nødvendig. Grunnleggende Docker og DevOps på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Håndtering av Secrets og RBAC»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Grunnleggende Docker og DevOps-leksjonen?

Ja. Alle Grunnleggende Docker og DevOps-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Sikkerhetsskanning av containerbilder
Containersikkerhet under kjøring
Håndtering av Secrets og RBAC
Nettverkspolicyer og nettverk med minste privilegium

← Tilbake til Grunnleggende Docker og DevOps