Anta att någon tar tag i din API-nyckel. Plötsligt har de tillgång till allt inom dina interna microservices - gratis roaming, inga frågor ställs. När du ens inser att något är fel, har de redan siffrat av data, utövat alla tillstånd du aldrig tänkt att ge, och lämnade dig med en tuff faktura och en ännu svårare uppgift: återuppbyggnad av kundförtroende. Det beror till stor del på att de flesta mikrotjänster antar att de kan lita på varandra helt enkelt för att de sitter på samma nätverk. In simple terms: 
 
 En läckt tillförlitlig nyckel blir tjuvens pass. En läckt tillförlitlig nyckel blir tjuvens pass. Tidigare, med en enda applikation och en enda datalagring, samt en enda nätverksomkrets, var säkerhet mycket enklare, eftersom allt kördes på plats med ett lokalt datacenter. Nu har du många (dussintals) applikationer/tjänster, hundratals API:er och många olika team släpper kod varje dag.Dessutom kommer de flesta tjänster att kommunicera med andra tjänster och anta att eftersom de kommunicerar över ett gemensamt nätverk, bör de kunna lita på varje tjänst. Ditt arkitektoniska design har vuxit och utvecklats, men ditt "säkerhets" tänkande har inte.Ditt hem ser nu ut som det är öppet.Vem som helst som kan få en nyckel till ytterdörren kan gå in i varje rum, öppna varje låda och låsa upp varje säker låda i byggnaden. The Philosophy That Changed The Way Of Thinking About Architecture: Zero Trust Filosofin som förändrade sättet att tänka på arkitektur: noll förtroende Zero Trust är en förändring i hur du tänker på förtroende, inte en förbättring av säkerhetstrender. Det brukade vara, "Tro utan verifiera." Det är inte längre. Denna princip kan sammanfattas helt enkelt som, "Tro aldrig; alltid verifiera." Alla anslutningar (användare, tjänst och internt nätverk) måste identifiera sig själva, ange vad de kan göra och säga om anslutningen är säker. I grund och botten såg det ut så här för microservices Mutual TLS hela vägen: All kommunikation av en tjänsteanslutning bekräftas av användningen av mutual TLS (mTLS) innan någon av parterna kan kommunicera med varandra. API-baserade behörigheter ersätter brandväggbaserade behörigheter. Varje samtal/transaktion verifieras inloggning. Vi har varit tvungna att ompröva hur vi bygger och hur vi litar på allt inom vår arkitektur för att uppfylla Zero Trust-principerna - men genom att göra det har vi hamnat med ett mycket säkrare system. 
 
 Våra system är nu mycket säkrare tack vare Zero Trust, och det har förändrat hur vi designar, kommunicerar och litar på andra tjänster i vår arkitektur, oavsett om de är interna eller externa. Våra system är nu mycket säkrare tack vare Zero Trust, och det har förändrat hur vi designar, kommunicerar och litar på andra tjänster i vår arkitektur, oavsett om de är interna eller externa. Zero Trust: Not Optional — Not Anymore Nollförtroende: Inte valfritt – inte längre Kör du microservices utan Zero Trust? Om du väntar för länge kommer ditt företag inte bara att falla bakom – det kan slå en vägg. Nu är det dags att starta, långt innan dina system stannar. Vår egen utbyggnad var inte felfri. Vi hanterade avbrott, pressade igenom utvecklare motstånd och lärde sig några tuffa lektioner längs vägen. Men efter sex månader levererade vi det – och visade att säkerhet inte är något du stötte på. Solution/Tools Här är några av de tekniker vi använde för att övergå vår förtroendemodell, som bygger på nätverk, till en identitetsbaserad förtroendemodell: 
 
 
 
 
 
 
 För tjänsteidentitet: SPIFFE/SPIRE Service mesh/service-to-service krypterad kommunikation: Istio mTLS Kod för policy: Open Policy Agent (openpolicyagent.org) Aktiv sekretesshantering, Dynamisk sekretesshantering: HashiCorp Vault Dynamisk hotanalys: Falco Rate-Limiting, Revisionsloggning, OAuth2: Kong API Gateway Optimization 
 
 
 
 Beslut som fattas av OPA cachas (Redis / Koffein). Anslutningspooling för mTLS Revisionsloggarna för Kafka skrivs om asynkroniskt. Därefter kommer jag att beskriva implementeringen av en Zero Trust-modell för mina Java-baserade mikrotjänstprogram, inklusive hur identiteter verifieras, mTLS används och hemligheter roteras inom applikationen, samt ge verkliga exempel på kod och konfigurationer som används. JWT använder Identity Service Vi genererar och undertecknar en JWT med hjälp av RSA-256 nycklar. package com.zero.trust.common;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import java.security.*;
import java.security.interfaces.*;
import java.util.*;
public class IdentityServiceManager {

    private final String serviceName;
    private final Algorithm algorithm;

    public IdentityServiceManager(String serviceName) {
        this.serviceName = serviceName;
        try {
            KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");
            gen.initialize(2048);
            KeyPair pair = gen.generateKeyPair();
            this.algorithm = Algorithm.RSA256(
                    (RSAPublicKey) pair.getPublic(),
                    (RSAPrivateKey) pair.getPrivate());
        } catch (Exception e) {
            throw new RuntimeException("KeyPair creation failed", e);
        }
    }

    public String generateTokenData() {
        return JWT.create()
                .withIssuer(serviceName)
                .withClaim("service", serviceName)
                .withExpiresAt(new Date(System.currentTimeMillis() + 3600_000))
                .sign(algorithm);
    }

    public boolean verifyTokenData(String token) {
        try { JWT.require(algorithm).build().verify(token); return true; }
        catch (Exception e) { return false; }
    }
}
 Service Auth med SpringSecuirty Filter Varje begäran valideras för att kontrollera om token är giltig eller inte. Ingen token / ogiltig token: det är 401. package com.zero.trust.demo.config;
 import org.springframework.web.filter.OncePerRequestFilter;
 import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.*;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 //few importing missing refer git hub as i am getting error to copy the all imports 
 
@Configuration
public class ZeroTrustSecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf(AbstractHttpConfigurer::disable)
                .authorizeHttpRequests(req -> req
                        .requestMatchers("/health").permitAll()
                        .anyRequest().authenticated())
                .addFilterBefore((Filter) new TokenFilter(), UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }

    static class TokenFilter extends OncePerRequestFilter {
        @Override
        protected void doFilterInternal(HttpServletRequest req,
                                        HttpServletResponse res,
                                        FilterChain chain)
                throws ServletException, IOException {

            String auth = req.getHeader("Authorization");
            if (auth == null || !auth.startsWith("Bearer ")) {
                res.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Missing token");
                return;
            }
            String jwt = auth.substring(7);
            IdentityServiceManager manager = new IdentityServiceManager("user-service");
            if (!manager.verifyTokenData(jwt)) {
                res.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Invalid token");
                return;
            }
            Authentication a = new UsernamePasswordAuthenticationToken("service", null, List.of());
            SecurityContextHolder.getContext().setAuthentication(a);
            chain.doFilter(req, res);
        }
    }
}
 Dynamiska hemligheter med Vault Simulator I den verkliga världen kommer vi att använda HashiCorp Vault. Men lokalt simulerar vi roterande DB-uppgifter i minnet varje minut. package com.zero.trust.valut;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.UUID;

@Component
public class VaultServ {
    private String username = "dbuser";
    private String password = UUID.randomUUID().toString();

    @Scheduled(fixedRate = 60000)
    public void rotate() {
        password = UUID.randomUUID().toString();
        System.out.println("[VaultSim] Rotated password -> " + password);
    }

    public String getUsername() { return username; }
    public String getPassword() { return password; }
}
 Gateway kod Gateway genererar en JWT med sin egen identitet och ansluter till användartjänsten via ömsesidig TLS. Användartjänsten autentiserar sedan både token och certifikatet – vilket säkerställer att endast betrodda, verifierade tjänster kan kommunicera. package com.damu;

import com.zero.trust.common.IdentityServiceManager;
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
import org.springframework.http.*;

@SpringBootApplication
@RestController
public class Main {

    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }

    @Bean
    public RestTemplate restTemplate() { return new RestTemplate(); }

    private final IdentityServiceManager identity = new IdentityServiceManager("gateway-service");
    private final RestTemplate rest = new RestTemplate();

    @GetMapping("/gatewaytest")
    public String test() {
        String token = identity.generateTokenData();
        HttpHeaders h = new HttpHeaders();
        h.set("Authorization","Bearer "+token);
        HttpEntity<Void> entity = new HttpEntity<>(h);
        ResponseEntity<String> res = rest.exchange(
                "https://localhost:8443/api/users/1",
                HttpMethod.GET, entity, String.class);
        return "Gateway → " + res.getBody();
    }
}
 Kolla in vår för ett mer detaljerat flöde. GitHub 
 
 Denna end-to-end demo kommer att visa dig hur du implementerar detta med ren Java och Spring Boot. Denna end-to-end demo kommer att visa dig hur du implementerar detta med ren java och spring boot. Denna end-to-end demo kommer att visa dig hur du implementerar detta med ren Java och Spring Boot. Denna end-to-end demo kommer att visa dig hur du implementerar detta med ren java och spring boot.

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Read My Stories

Det här ljudet är producerat på berättelsens originalspråk!

Säkerställa Java Microservices med Zero Trust Architecture

About Author

KOMMENTARER

HÄNG TAGGAR

DENNA ARTIKEL PRESENTERAS I

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps