Katakanlah seseorang mendapat kunci API anda.Tiba-tiba, mereka mempunyai akses kepada segala-galanya di dalam microservices dalaman anda – roaming percuma, tiada soalan yang ditanyakan.Pada masa anda menyedari sesuatu yang salah, mereka telah mengetepikan data, menggunakan setiap kebenaran yang anda tidak pernah bermaksud untuk memberikan, dan meninggalkan anda dengan bil yang berat dan tugas yang lebih berat: membina semula kepercayaan pelanggan. Jadi bagaimana jenis pelanggaran ini berlaku? Sebahagian besarnya, ia adalah kerana kebanyakan microservices menganggap mereka boleh mempercayai satu sama lain hanya kerana mereka duduk di rangkaian yang sama. In simple terms: 
 
 Kunci dipercayai yang bocor menjadi pasport pencuri. Kunci dipercayai yang bocor menjadi pasport pencuri. Di masa lalu, dengan satu aplikasi dan satu gudang data, serta perimeter rangkaian tunggal, keselamatan jauh lebih mudah, kerana segala-galanya dijalankan di premis dengan pusat data tempatan. Walau bagaimanapun, apabila anda bertukar kepada microservices, semua ini berubah.Sekarang anda mempunyai banyak (puluhan) aplikasi / perkhidmatan, beratus-ratus API, dan banyak pasukan yang berbeza mengeluarkan kod setiap hari.Selain itu, kebanyakan perkhidmatan akan berkomunikasi dengan perkhidmatan lain dan menganggap bahawa kerana mereka berkomunikasi melalui rangkaian biasa, mereka harus dapat mempercayai setiap perkhidmatan. Reka bentuk seni bina anda telah berkembang dan berkembang; bagaimanapun, pemikiran "keselamatan" anda tidak. rumah anda kini kelihatan seperti ia terbuka luas.Siapa sahaja yang boleh mendapatkan kunci untuk pintu depan boleh masuk ke dalam setiap bilik, membuka setiap lemari, dan membuka setiap lemari keselamatan di dalam bangunan. The Philosophy That Changed The Way Of Thinking About Architecture: Zero Trust Filsafat yang mengubah cara berpikir tentang seni bina: Zero Trust Zero Trust ialah perubahan dalam cara anda berfikir tentang kepercayaan, bukan peningkatan dalam trend keselamatan. Awalnya ia bermaksud, "Percayalah tetapi Verifikasi."Ia tidak lagi. Prinsip ini boleh disimpulkan semata-mata sebagai, "Jangan pernah mempercayai; sentiasa mengesahkan." Semua sambungan (pengguna, perkhidmatan dan rangkaian dalaman) mesti mengenal pasti diri mereka sendiri, menyatakan apa yang boleh mereka lakukan, dan mengatakan sama ada sambungan itu selamat. Pada asasnya, ia kelihatan seperti ini untuk microservices Mutual TLS sepanjang jalan: Semua komunikasi sambungan perkhidmatan dikonfirmasi oleh penggunaan mutual TLS (mTLS) sebelum mana-mana pihak boleh berkomunikasi satu sama lain. Keizinan berasaskan API menggantikan keizinan berasaskan firewall. Setiap panggilan / transaksi sedang disahkan log masuk. Kami terpaksa memikirkan semula bagaimana kami membina dan bagaimana kami mempercayai apa-apa dalam seni bina kami untuk memenuhi prinsip Zero Trust - tetapi dengan melakukannya, kami telah berakhir dengan sistem yang jauh lebih selamat. 
 
 Sistem kami kini jauh lebih selamat kerana Zero Trust, dan ia telah mengubah cara kami merancang, berkomunikasi, dan mempercayai perkhidmatan lain dalam seni bina kami, sama ada dalaman atau luaran. Sistem kami kini jauh lebih selamat kerana Zero Trust, dan ia telah mengubah cara kami merancang, berkomunikasi, dan mempercayai perkhidmatan lain dalam seni bina kami, sama ada dalaman atau luaran. Zero Trust: Not Optional — Not Anymore Zero Trust: Bukan Pilihan - Bukan Lagi Adakah anda menjalankan microservices tanpa Zero Trust? Jika anda menunggu terlalu lama, perniagaan anda tidak hanya akan terlepas – ia mungkin menjejaskan dinding. Sekarang adalah masa untuk memulakan, lama sebelum sistem anda terjejas. Pelancaran kami sendiri bukan tanpa kesilapan. Kami menangani gangguan, mendorong melalui rintangan pengembang, dan mempelajari beberapa pelajaran yang sukar di sepanjang jalan. Tetapi selepas enam bulan, kami menghantarnya – dan membuktikan bahawa keselamatan bukan sesuatu yang anda terjatuh ke. Ia adalah sesuatu yang anda direka untuk, dengan sengaja, dari hari pertama. Solution/Tools Berikut ialah beberapa teknologi yang kami gunakan untuk menukar model kepercayaan kami, yang berasaskan rangkaian, kepada model kepercayaan berasaskan identiti: 
 
 
 
 
 
 
 Untuk Identiti Perkhidmatan: SPIFFE/SPIRE Perkhidmatan mesh / perkhidmatan-ke-perkhidmatan yang disulitkan komunikasi: Istio mTLS Kod dasar: Agen Kebijakan Terbuka (openpolicyagent.org) Pengurusan Rahsia Aktif, Pengurusan Rahsia Dinamis: HashiCorp Vault Analisis ancaman dinamik: Falco. Rate-Limiting, Log Audit, OAuth2: Gateway API Kong Optimization 
 
 
 
 Keputusan yang dibuat oleh OPA disimpan dalam cache (Redis / Caffeine). Sambungan untuk mTLS Log audit Kafka ditulis semula secara asynchronous. Seterusnya, saya akan menerangkan pelaksanaan model Zero Trust untuk aplikasi microservice berasaskan Java saya, termasuk bagaimana identiti disahkan, mTLS digunakan, dan rahsia berputar dalam aplikasi, serta menyediakan contoh dunia sebenar kod dan konfigurasi yang digunakan. JWT Menggunakan Perkhidmatan Identiti Setiap perkhidmatan memperoleh identiti sendiri. kami mencipta dan menandatangani JWT menggunakan kunci RSA-256. 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; }
    }
}
 Perkhidmatan Auth menggunakan SpringSecuirty Filter Setiap permintaan disahkan untuk memeriksa sama ada token itu sah atau tidak. Tiada token / token tidak sah: ia adalah 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);
        }
    }
}
 Menggunakan Vault Simulator Dalam dunia sebenar, kami akan menggunakan HashiCorp Vault. tetapi secara tempatan, kami mensimulasikan rotating DB credentials dalam memori setiap minit. 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; }
}
 Kod Gateway Gateway menjana JWT dengan identiti sendiri dan menyambung ke Perkhidmatan Pengguna melalui TLS bersama.Perkh Pengguna kemudian mengesahkan token dan sijil - memastikan bahawa hanya perkhidmatan yang dipercayai dan disahkan boleh berkomunikasi. 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();
    }
}
 Periksa kami untuk aliran yang lebih terperinci. GitHub 
 
 Zero-Trust bukan trend semasa, melainkan sikap. demo end-to-end ini akan menunjukkan kepada anda bagaimana untuk melaksanakan ini dengan Java murni dan Spring Boot. demo end-to-end ini akan menunjukkan kepada anda bagaimana untuk melaksanakan ini dengan java murni dan spring boot. Zero-Trust bukan trend semasa, melainkan sikap. demo end-to-end ini akan menunjukkan kepada anda bagaimana untuk melaksanakan ini dengan Java murni dan Spring Boot. demo end-to-end ini akan menunjukkan kepada anda bagaimana untuk melaksanakan ini dengan java murni dan 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

Audio ini dihasilkan dalam bahasa asal cerita!

Perkhidmatan Microservices Java dengan Zero Trust Architecture

About Author

KOMEN

GANTUNG TANDA

ARTIKEL INI DIBENTANGKAN DALAM

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps