Tegyük fel, hogy valaki megragadja az API-kulcsot. Hirtelen hozzáférhetnek mindenhez a belső mikroszolgáltatásain belül - ingyenes barangolás, kérdések nem merülnek fel. Abban az időben, amikor észreveszed, hogy valami nincs rendben, már kikapcsolták az adatokat, minden engedélyt gyakoroltak, amit soha nem szándékoztak megadni, és egy kemény számlát és egy még nehezebb feladatot hagytak maguk mögött: az ügyfelek bizalmának helyreállítását. Ez nagyrészt azért van, mert a legtöbb mikroszolgáltatás feltételezi, hogy megbízhatnak egymásban egyszerűen azért, mert ugyanazon a hálózaton ülnek. In simple terms: 
 
 A szivárgott kulcs a tolvaj útlevelévé válik. A szivárgott kulcs a tolvaj útlevelévé válik. A múltban egyetlen alkalmazással és egyetlen adattárral, valamint egyetlen hálózati periméterrel a biztonság sokkal egyszerűbb volt, mivel minden helyi adatközponttal futott. Azonban miután átváltott a mikroszolgáltatásokra, mindez megváltozott.Most már sok (tíz) alkalmazás/szolgáltatás, több száz API és sok különböző csapat kiadja a kódot minden nap.Ezen túlmenően a legtöbb szolgáltatás kommunikál más szolgáltatásokkal, és feltételezi, hogy mivel közös hálózaton keresztül kommunikálnak, minden egyes szolgáltatást megbízhat. Az építészeti tervezésed nőtt és fejlődött; azonban a „biztonsági” gondolkodásod nem. Az otthonod most úgy néz ki, mintha széles körben nyitva lenne. Bárki, aki megkapja az ajtó kulcsát, bejuthat minden szobába, megnyithat minden fiókot, és feloldhatja az épület minden biztonságos szekrényét. The Philosophy That Changed The Way Of Thinking About Architecture: Zero Trust A filozófia, amely megváltoztatta az építészeti gondolkodásmódot: nulla bizalom A zéró bizalom a bizalomról való gondolkodásmód megváltoztatása, nem pedig a biztonsági trendek javulása. Ezt az elvet egyszerűen úgy lehet összefoglalni, mint: „Soha ne bízzon, mindig ellenőrizze.” Minden kapcsolatnak (felhasználó, szolgáltatás és belső hálózat) azonosítania kell magát, meg kell határoznia, hogy mit tehet, és meg kell mondania, hogy a kapcsolat biztonságos-e. Alapvetően a mikroszolgáltatások esetében a Mutual TLS így nézett ki: A szolgáltatási kapcsolat minden kommunikációját a kölcsönös TLS (mTLS) használatával erősítik meg, mielőtt bármelyik fél kommunikálhat egymással. Az API-alapú engedélyek helyettesítik a tűzfal alapú engedélyeket. Minden hívást/tranzakciót hitelesítenek. Újra kellett gondolkodnunk arról, hogyan építünk, és hogyan bízunk bármiben az építészetünkben, hogy megfeleljünk a Zero Trust elveinek – de ezzel egy sokkal biztonságosabb rendszert hoztunk létre. 
 
 Rendszereink most sokkal biztonságosabbak a Zero Trustnak köszönhetően, és megváltoztatta azt a módot, ahogyan belső vagy külső szolgáltatásainkat tervezzük, kommunikálunk és bízunk más szolgáltatásokban. Rendszereink most sokkal biztonságosabbak a Zero Trustnak köszönhetően, és megváltoztatta azt a módot, ahogyan belső vagy külső szolgáltatásainkat tervezzük, kommunikálunk és bízunk más szolgáltatásokban. Zero Trust: Not Optional — Not Anymore Zéró bizalom: nem opcionális – nem többé Mikroszolgáltatásokat futtatsz Zero Trust nélkül? Ha túl sokáig vársz, az üzleted nem fog lemaradni – talán egy falra ütközik. Most itt az ideje elkezdeni, jóval a rendszered leállása előtt. Saját bevezetése nem volt hibátlan. Megoldottuk a leállásokat, a fejlesztők ellenállását, és megtanultunk néhány nehéz leckét az út mentén. De hat hónap elteltével kiszállítottuk - és bebizonyítottuk, hogy a biztonság nem valami, amibe beleeshetsz. Ez valami, amit szándékosan tervezel az első naptól. Solution/Tools Íme néhány olyan technológia, amelyet a hálózatokon alapuló bizalmi modellünknek az identitásalapú bizalmi modellre való átállásához használtunk: 
 
 
 
 
 
 
 Szolgáltatási azonosító: SPIFFE/SPIRE Service mesh/service-to-service titkosított kommunikáció: Istio mTLS Politikai kódex: Nyílt Politika Ügynök (openpolicyagent.org) Aktív titokkezelés, dinamikus titokkezelés: HashiCorp Vault Dinamikus fenyegetés elemzés: Falco. Rate-Limiting, Audit Logging, OAuth2: Kong API átjáró Optimization 
 
 
 
 Az OPA által hozott határozatok gyorsítótárban vannak tárolva (Redis / Koffein). Csatlakoztatás az mTLS-hez Kafka könyvvizsgálati naplói aszinkron újraírásra kerülnek. Ezután leírom a Zero Trust modell megvalósítását a Java-alapú mikroszolgáltatási alkalmazásokhoz, beleértve az identitások ellenőrzését, az mTLS használatát és a titkok forgatását az alkalmazásban, valamint a használt kódok és konfigurációk valós példáit. JWT Identity Service használata Minden szolgáltatás megszerzi a saját személyazonosságát. létrehozunk és aláírunk egy JWT-t az RSA-256 kulcsokkal. 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 a SpringSecuirty Filter használatával Minden kérést érvényesítenek annak ellenőrzésére, hogy a token érvényes-e vagy sem. Nincs token / érvénytelen token: ez 401. Csak érvényes JWT-k folytatódnak. 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);
        }
    }
}
 Dinamikus titkok a Vault Simulator segítségével A valós világban HashiCorp Vaultot fogunk használni, de helyi szinten minden percben szimuláljuk a forgó DB azonosítókat a memóriában. 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 kód A Gateway egy JWT-t hoz létre saját személyazonosságával, és kölcsönös TLS-en keresztül csatlakozik a Felhasználói Szolgáltatáshoz.A Felhasználói Szolgáltatás ezután mind a tokent, mind a tanúsítványt hitelesíti – biztosítva, hogy csak megbízható, hitelesített szolgáltatások tudjanak kommunikálni. 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();
    }
}
 Nézze meg a mi A részletesebb áramlás érdekében. GitHub szolgáltatás 
 
 Ez a végső demo megmutatja, hogyan kell végrehajtani ezt a tiszta Java és Spring Boot. Ez a végső demo megmutatja, hogyan kell végrehajtani ezt a tiszta java és tavaszi boot. Ez a végső demo megmutatja, hogyan kell végrehajtani ezt a tiszta Java és Spring Boot. Ez a végső demo megmutatja, hogyan kell végrehajtani ezt a tiszta java és tavaszi 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

Ez a hanganyag a történet eredeti nyelvén készült!

A Java Microservices biztonsága a Zero Trust architektúrával

About Author

HOZZÁSZÓLÁSOK

HANG TAGOK

EZT A CIKKET BEMUTATTA

Related Stories

Hubble Protocol, a DeFi project on Solana Raises $10 Million Led By Crypto.com Capital, DCG and CMS

Of The First and Last Things: Part 3

INTRODUCTION

From Desk to HackerNoon: Your Ultimate Guide on How to Publish a Story

Hubble Protocol, a DeFi project on Solana Raises $10 Million Led By Crypto.com Capital, DCG and CMS

Of The First and Last Things: Part 3

INTRODUCTION

From Desk to HackerNoon: Your Ultimate Guide on How to Publish a Story

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps