Bootcamp i backendudvikling med Node.js · Lektion

Rollebaseret adgangskontrol

Udvikl middleware til autorisation, så adgangen til API-routes begrænses ud fra brugerroller og tilladelser.

Lektion 5 af 611 trin

Rollebaseret adgangskontrol er en gratis Bootcamp i backendudvikling med Node.js-lektion på CoddyKit. Dette er lektion 5 af 6. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Bootcamp i backendudvikling med Node.js, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i backendudvikling med Node.js-kurset indeholder 6 lektioner i alt.

Introduktion til rollebaseret adgangskontrol

Velkommen! I denne lektion går vi i dybden med rollebaseret adgangskontrol (RBAC). RBAC er en metode til at begrænse systemadgang baseret på de roller, som enkelte brugere har i en organisation.

Tænk på det som et sæt nøgler: Hver nøgle (rolle) giver adgang til bestemte døre (ressourcer eller handlinger). I stedet for at give hver person en nøgle til alle døre giver du dem en nøglebundt baseret på deres arbejde.

Betydningen af RBAC

RBAC er afgørende for at opbygge sikre og skalerbare programmer. Det giver flere fordele:

Forbedret sikkerhed: Brugere får kun adgang til det, de har brug for.
Forenklet administration: Det er nemmere at administrere tilladelser for grupper end for enkeltpersoner.
Færre fejl: Der er mindre risiko for at give forkert adgang.
Bedre overholdelse af regler: Hjælper med at opfylde lovkrav til adgang til data.

Uden RBAC bliver administration af tilladelser i et voksende program et mareridt!

Roller og tilladelser defineret

Det er vigtigt at forstå forskellen mellem roller og tilladelser:

Rolle: En samling tilladelser. Eksempler: Admin, Editor, Viewer, Guest.
Tilladelse: En bestemt handling, som en bruger kan udføre. Eksempler: read:post, write:post, delete:user.

En bruger tildeles en eller flere roller, og hver rolle har et sæt definerede tilladelser. Denne struktur gør adgangskontrollen fleksibel.

Sådan gemmer du brugerroller

Når en bruger registrerer sig eller logger ind, skal de tildelte roller gemmes. Almindelige måder at gøre det på omfatter:

Databasefelt: En tekststreng (f.eks. "admin", "user") eller et array af tekststrenge (f.eks. ["admin", "editor"]) i brugerens dokument eller post.
JWT-payload: Inkluder rollerne direkte i JSON Web Tokenet (JWT) under login. Så er de nemt tilgængelige ved hver forespørgsel.

I vores eksempler antager vi, at rollerne er tilgængelige på objektet req.user, som ville blive udfyldt af en forudgående godkendelses-middleware (f.eks. en fra en tidligere lektion).

Forløbet for autorisations-middleware

I Express.js er middleware-funktioner perfekte til autorisation. En autorisations-middleware ligger mellem forespørgslen og rutebehandleren.

Sådan fungerer det:

Der kommer en forespørgsel til en beskyttet rute.
Vores autorisations-middleware kører.
Den kontrollerer, om den godkendte bruger har de nødvendige roller.
Hvis ja, kalder den next() for at give kontrollen videre til rutebehandleren.
Hvis nej, sender den et fejl-svar (f.eks. 403 Forbidden).

Definér middleware til rollekontrol

Vi opretter en genanvendelig middleware-funktion, der kontrollerer, om en godkendt bruger har en bestemt rolle. Funktionen modtager requiredRole som argument og returnerer en anden middleware-funktion.

Et rigtigt program ville først have en godkendelses-middleware, der udfylder req.user.

function authorizeRoles(requiredRole) {
  return (req, res, next) => {
    // Assume req.user is populated by auth middleware
    // e.g., req.user = { id: 'abc', roles: ['user', 'editor'] }
    if (!req.user || !req.user.roles || !req.user.roles.includes(requiredRole)) {
      console.log(`Access Denied: Missing role '${requiredRole}'`);
      return res.status(403).send('Forbidden: Insufficient role');
    }
    console.log(`Access Granted for role '${requiredRole}'`);
    next(); // User has the required role, proceed
  };
}

// To make it runnable for demonstration, let's wrap it in a mock Express-like setup
const mockReq = { user: { id: '123', roles: ['user', 'admin'] } };
const mockRes = {
  status: function(code) { this.statusCode = code; return this; },
  send: function(msg) { console.log(`Response Status: ${this.statusCode}, Message: ${msg}`); }
};
const mockNext = () => console.log('Next middleware/route handler called.');

console.log('--- Testing authorizeRoles("admin") ---');
const adminAuth = authorizeRoles('admin');
adminAuth(mockReq, mockRes, mockNext);

console.log('\n--- Testing authorizeRoles("guest") ---');
const guestAuth = authorizeRoles('guest');
guestAuth(mockReq, mockRes, mockNext);

Beskyttelse af ruter med RBAC

Lad os nu se, hvordan vi anvender vores authorizeRoles-middleware til at beskytte bestemte ruter i et Express.js-program.

Vi kan give middleware-funktionen direkte videre til en rutedefinition. Alle forespørgsler til denne rute går først gennem autorisationskontrollen.

const express = require('express');
const app = express();

// Mock authentication middleware (from previous lessons)
app.use((req, res, next) => {
  // In a real app, this would verify a JWT and populate req.user
  req.user = { id: 'user123', roles: ['user', 'viewer'] };
  next();
});

// Our authorization middleware
function authorizeRoles(requiredRole) {
  return (req, res, next) => {
    if (!req.user || !req.user.roles.includes(requiredRole)) {
      return res.status(403).send('Forbidden: Insufficient role');
    }
    next();
  };
}

// Route accessible only by 'admin'
app.get('/admin-panel', authorizeRoles('admin'), (req, res) => {
  res.send('Welcome to the Admin Panel!');
});

// Route accessible by 'user' or 'viewer' (since req.user has 'user', 'viewer')
app.get('/my-profile', authorizeRoles('user'), (req, res) => {
  res.send(`Hello ${req.user.id}, this is your profile.`);
});

app.listen(3000, () => {
  console.log('Server running on port 3000. Try accessing /admin-panel or /my-profile');
});

Håndtering af flere nødvendige roller

Nogle gange kan en rute være tilgængelig for mere end én rolle (f.eks. en Editor eller en Admin). Vi kan udvide vores middleware, så den accepterer flere nødvendige roller.

Brugeren skal blot have *mindst én* af de angivne roller for at få adgang.

const express = require('express');
const app = express();

// Mock authentication middleware
app.use((req, res, next) => {
  req.user = { id: 'editor456', roles: ['user', 'editor'] };
  next();
});

// Middleware to check for multiple roles
function authorizeAnyRole(requiredRoles) {
  return (req, res, next) => {
    if (!req.user || !req.user.roles) {
      return res.status(403).send('Forbidden: User roles not found');
    }
    const hasRequiredRole = req.user.roles.some(role =>
      requiredRoles.includes(role)
    );
    if (!hasRequiredRole) {
      return res.status(403).send('Forbidden: Insufficient role(s)');
    }
    next();
  };
}

// Route accessible by 'admin' OR 'editor'
app.get('/edit-content', authorizeAnyRole(['admin', 'editor']), (req, res) => {
  res.send('You can edit content!');
});

// Route accessible by 'admin' only
app.get('/delete-all', authorizeAnyRole(['admin']), (req, res) => {
  res.send('Danger Zone: All data deleted!');
});

app.listen(3000, () => {
  console.log('Server running on port 3000. Try /edit-content or /delete-all');
});

Ud over roller: Detaljerede tilladelser

Roller er gode til at gruppere tilladelser, men nogle gange har du brug for mere detaljeret kontrol. Her kommer eksplicitte tilladelser ind i billedet.

I stedet for authorizeRoles('admin') kan du f.eks. have authorizePermission('delete:user').
Dit brugerobjekt kan derefter gemme et array med bestemte tilladelser (f.eks. ['read:post', 'update:post', 'delete:comment']).

Denne tilgang giver maksimal fleksibilitet, men kan gøre administrationen af tilladelser mere kompleks.

Test din forståelse

Se på følgende Express-ruteopsætning:

// ... (assume authorizeRoles function is defined as in lesson)
app.use((req, res, next) => {
  req.user = { id: 'testUser', roles: ['user', 'moderator'] };
  next();
});

app.get('/moderate', authorizeRoles('moderator'), (req, res) => {
  res.send('Moderator access granted.');
});

app.get('/admin-only', authorizeRoles('admin'), (req, res) => {
  res.send('Admin access granted.');
});

Besvar den i den interaktive lektion

Opsummering og næste trin

Godt gået! Du har lært at implementere rollebaseret adgangskontrol i dine Node.js-programmer med Express.js-middleware.

RBAC begrænser adgangen baseret på brugerroller.
Middleware-funktioner er ideelle til at kontrollere roller før adgang til en rute.
Du kan kontrollere én eller flere roller.
Avancerede scenarier kan indebære direkte kontrol af tilladelser.

Korrekt autorisation er afgørende for at sikre din API. Bliv ved med at øve dig, så du bliver fortrolig med disse begreber!

Gratis at komme i gang

Lær JavaScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 22
Lektioner: 92

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Rollebaseret adgangskontrol” gratis?

Ja — hele teksten til “Rollebaseret adgangskontrol” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Bootcamp i backendudvikling med Node.js-kurset, skal du opgradere til CoddyKit PRO. Bootcamp i backendudvikling med Node.js-kurset indeholder 6 lektioner i alt.

Hvad lærer jeg i “Rollebaseret adgangskontrol”?

Udvikl middleware til autorisation, så adgangen til API-routes begrænses ud fra brugerroller og tilladelser. Du øver dig i Bootcamp i backendudvikling med Node.js med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Bootcamp i backendudvikling med Node.js?

Der kræves ingen tidligere erfaring. Bootcamp i backendudvikling med Node.js på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 5 af 6.

Hvor lang tid tager lektionen “Rollebaseret adgangskontrol”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Bootcamp i backendudvikling med Node.js-lektion?

Ja. Alle Bootcamp i backendudvikling med Node.js-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Bootcamp i backendudvikling med Node.js