ABP微服務系列學習-搭建自己的微服務結構（三）

飯勺oO發表於2023-03-01

上一篇我們基礎服務初步搭建完畢，接下來我們整一下認證和閘道器。

搭建認證服務

認證服務的話，ABP CLI生成的所有模板都包括了一個AuthServer。我們直接生成模板然後微調一下就可以直接用了。

abp new FunShow -t app --tiered

使用命令建立模板後，我們可以找到一個AuthServer。把專案移動到Apps目錄下，然後我們開始改造一下這個專案。
首先修改專案檔案的引用配置
修改EFCore專案引用為AdministrationService.EntityFrameworkCore和IdentityService.EntityFrameworkCore，
然後新增Shared.Localization和Shared.Hosting.AspNetCore專案引用，別的基本不用怎麼修改，完整專案配置為：

<Project Sdk="Microsoft.NET.Sdk.Web">

  <Import Project="..\..\..\..\common.props" />

  <PropertyGroup>
    <TargetFramework>net7.0</TargetFramework>
    <UserSecretsId>b83bc18b-a6ca-4e2d-a827-26ffaff35dce</UserSecretsId>
    <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
    <DockerfileContext>..\..\..\..</DockerfileContext>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.DataProtection.StackExchangeRedis" Version="6.0.5" />
    <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.17.0" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Volo.Abp.Caching.StackExchangeRedis" Version="7.0.0" />
    <PackageReference Include="Volo.Abp.EventBus.RabbitMQ" Version="7.0.0" />
    <PackageReference Include="Volo.Abp.BackgroundJobs.RabbitMQ" Version="7.0.0" />
    <PackageReference Include="Volo.Abp.Account.Web.OpenIddict" Version="7.0.0" />
    <PackageReference Include="Volo.Abp.Account.Application" Version="7.0.0" />
    <PackageReference Include="Volo.Abp.Account.HttpApi" Version="7.0.0" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\..\..\services\administration\src\FunShow.AdministrationService.EntityFrameworkCore\FunShow.AdministrationService.EntityFrameworkCore.csproj" />
    <ProjectReference Include="..\..\..\..\services\identity\src\FunShow.IdentityService.EntityFrameworkCore\FunShow.IdentityService.EntityFrameworkCore.csproj" />
    <ProjectReference Include="..\..\..\..\shared\FunShow.Shared.Hosting.AspNetCore\FunShow.Shared.Hosting.AspNetCore.csproj" />
    <ProjectReference Include="..\..\..\..\shared\FunShow.Shared.Localization\FunShow.Shared.Localization.csproj" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Volo.Abp.AspNetCore.Mvc.UI.Theme.LeptonXLite" Version="2.0.0-*" />
  </ItemGroup>

  <ItemGroup>
    <Compile Remove="Logs\**" />
    <Content Remove="Logs\**" />
    <EmbeddedResource Remove="Logs\**" />
    <None Remove="Logs\**" />
  </ItemGroup>

</Project>

然後修改Program檔案，主要是日誌配置修改一下，別的不用改動

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using FunShow.Shared.Hosting.AspNetCore;
using Serilog;

namespace FunShow.AuthServer;

public class Program
{
    public async static Task<int> Main(string[] args)
    {
        var assemblyName = typeof(Program).Assembly.GetName().Name;

        SerilogConfigurationHelper.Configure(assemblyName);

        try
        {
            Log.Information($"Starting {assemblyName}.");
            var builder = WebApplication.CreateBuilder(args);
            builder.Host
                .AddAppSettingsSecretsJson()
                .UseAutofac()
                .UseSerilog();
            await builder.AddApplicationAsync<FunShowAuthServerModule>();
            var app = builder.Build();
            await app.InitializeApplicationAsync();
            await app.RunAsync();
            return 0;
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, $"{assemblyName} terminated unexpectedly!");
            return 1;
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }
}

修改module.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.DataProtection;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Hosting;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using FunShow.AdministrationService.EntityFrameworkCore;
using FunShow.IdentityService.EntityFrameworkCore;
using FunShow.Shared.Hosting.AspNetCore;
using Prometheus;
using StackExchange.Redis;
using Volo.Abp;
using Volo.Abp.Account;
using Volo.Abp.Account.Web;
using Volo.Abp.AspNetCore.Mvc.UI.Bundling;
using Volo.Abp.AspNetCore.Mvc.UI.Theme.LeptonXLite;
using Volo.Abp.AspNetCore.Mvc.UI.Theme.LeptonXLite.Bundling;
using Volo.Abp.AspNetCore.Mvc.UI.Theme.Shared;
using Volo.Abp.Auditing;
using Volo.Abp.BackgroundJobs.RabbitMQ;
using Volo.Abp.Caching;
using Volo.Abp.Caching.StackExchangeRedis;
using Volo.Abp.Emailing;
using Volo.Abp.EventBus.RabbitMq;
using Volo.Abp.Modularity;
using Volo.Abp.MultiTenancy;
using Volo.Abp.OpenIddict;
using Volo.Abp.UI.Navigation.Urls;
using Volo.Abp.VirtualFileSystem;
using Microsoft.AspNetCore.HttpOverrides;
using FunShow.Shared.Localization;

namespace FunShow.AuthServer;

[DependsOn(
    typeof(AbpCachingStackExchangeRedisModule),
    typeof(AbpEventBusRabbitMqModule),
    typeof(AbpBackgroundJobsRabbitMqModule),
    typeof(AbpAspNetCoreMvcUiLeptonXLiteThemeModule),
    typeof(AbpAccountWebOpenIddictModule),
    typeof(AbpAccountApplicationModule),
    typeof(AbpAccountHttpApiModule),
    typeof(AdministrationServiceEntityFrameworkCoreModule),
    typeof(IdentityServiceEntityFrameworkCoreModule),
    typeof(FunShowSharedHostingAspNetCoreModule),
    typeof(FunShowSharedLocalizationModule)
)]
public class FunShowAuthServerModule : AbpModule
{
    public override void PreConfigureServices(ServiceConfigurationContext context)
    {
        var hostingEnvironment = context.Services.GetHostingEnvironment();
        var configuration = context.Services.GetConfiguration();
    
    PreConfigure<OpenIddictBuilder>(builder =>
    {
    	builder.AddValidation(options =>
    {
    options.AddAudiences("AccountService");
    options.UseLocalServer();
    options.UseAspNetCore();
    });
    });
    if (!hostingEnvironment.IsDevelopment())
    {
    	PreConfigure<AbpOpenIddictAspNetCoreOptions>(options =>
    	{
    	options.AddDevelopmentEncryptionAndSigningCertificate = false;
    	});
    
        PreConfigure<OpenIddictServerBuilder>(builder =>
        {
            builder.AddSigningCertificate(GetSigningCertificate(hostingEnvironment, configuration));
            builder.AddEncryptionCertificate(GetSigningCertificate(hostingEnvironment, configuration));
            });
        }
    }
    
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
    //You can disable this setting in production to avoid any potential security risks.
        Microsoft.IdentityModel.Logging.IdentityModelEventSource.ShowPII = true;
        
        var hostingEnvironment = context.Services.GetHostingEnvironment();
        var configuration = context.Services.GetConfiguration();
        
        ConfigureBundles();
        ConfigureSwagger(context, configuration);
        ConfigureSameSiteCookiePolicy(context);
        ConfigureExternalProviders(context);
        
        Configure<AbpMultiTenancyOptions>(options =>
        {
        	options.IsEnabled = true;
        });
        
        Configure<AbpAuditingOptions>(options =>
        {
            options.ApplicationName = "AuthServer";
        });
        
        Configure<AppUrlOptions>(options =>
        {
            options.Applications["MVC"].RootUrl = configuration["App:SelfUrl"];
            options.RedirectAllowedUrls.AddRange(configuration["App:RedirectAllowedUrls"].Split(','));
        });
        
        Configure<AbpDistributedCacheOptions>(options =>
        {
        	options.KeyPrefix = "FunShow:";
        });
        
        var dataProtectionBuilder = context.Services.AddDataProtection().SetApplicationName("FunShow");
        var redis = ConnectionMultiplexer.Connect(configuration["Redis:Configuration"]);
        dataProtectionBuilder.PersistKeysToStackExchangeRedis(redis, "FunShow-Protection-Keys");
        
        context.Services.AddCors(options =>
        {
        	options.AddDefaultPolicy(builder =>
            {
            builder
            .WithOrigins(
            configuration["App:CorsOrigins"]
            .Split(",", StringSplitOptions.RemoveEmptyEntries)
            .Select(o => o.Trim().RemovePostFix("/"))
            .ToArray()
            )
            .WithAbpExposedHeaders()
            .SetIsOriginAllowedToAllowWildcardSubdomains()
            .AllowAnyHeader()
            .AllowAnyMethod()
            .AllowCredentials();
            });
        });
        
        #if DEBUG
        context.Services.Replace(ServiceDescriptor.Singleton<IEmailSender, NullEmailSender>());
        #endif
        
        if (hostingEnvironment.IsDevelopment())
        {
            Configure<AbpVirtualFileSystemOptions>(options =>
            {
            options.FileSets.ReplaceEmbeddedByPhysical<FunShowSharedLocalizationModule>(Path.Combine(
            hostingEnvironment.ContentRootPath,
            $"..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}shared{Path.DirectorySeparatorChar}FunShow.Shared.Localization"));
            });
        }
    }
    
    public override void OnApplicationInitialization(ApplicationInitializationContext context)
    {
        var app = context.GetApplicationBuilder();
        var env = context.GetEnvironment();
        
        var configuration = context.ServiceProvider.GetRequiredService<IConfiguration>();
        
        if (env.IsDevelopment())
        {
        	app.UseDeveloperExceptionPage();
        }
    
        app.UseAbpRequestLocalization();
        
        if (!env.IsDevelopment())
        {
        	app.UseErrorPage();
        }
        var forwardOptions = new ForwardedHeadersOptions
        {
            ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto,
            RequireHeaderSymmetry = false
        };
    
        forwardOptions.KnownNetworks.Clear();
        forwardOptions.KnownProxies.Clear();
        
    // ref: https://github.com/aspnet/Docs/issues/2384
        app.UseForwardedHeaders(forwardOptions);
        
        app.UseCorrelationId();
        app.UseAbpSecurityHeaders();
        app.UseStaticFiles();
        app.UseRouting();
        app.UseCors();
        app.UseCookiePolicy();
        app.UseHttpMetrics();
        app.UseAuthentication();
        app.UseAbpOpenIddictValidation();
        app.UseAbpSerilogEnrichers();
        app.UseUnitOfWork();
        app.UseAuthorization();
        app.UseSwagger();
        app.UseAbpSwaggerUI(options =>
        {
            options.SwaggerEndpoint("/swagger/v1/swagger.json", "Account Service API");
            options.OAuthClientId(configuration["AuthServer:SwaggerClientId"]);
        });
        	app.UseAuditing();
        	app.UseConfiguredEndpoints(endpoints =>
            {
            	endpoints.MapMetrics();
            });
    }
    
    private void ConfigureBundles()
    {
        Configure<AbpBundlingOptions>(options =>
        {
            options.StyleBundles.Configure(
            LeptonXLiteThemeBundles.Styles.Global,
            bundle =>
            {
            	bundle.AddFiles("/global-styles.css");
            }
        );
        });
    }
    
    private void ConfigureExternalProviders(ServiceConfigurationContext context)
    {
    	context.Services.AddAuthentication();
    }
    
    private X509Certificate2 GetSigningCertificate(IWebHostEnvironment hostingEnv, IConfiguration configuration)
    {
        var fileName = "authserver.pfx";
        var passPhrase = "2D7AA457-5D33-48D6-936F-C48E5EF468ED";
        var file = Path.Combine(hostingEnv.ContentRootPath, fileName);
        
        if (!File.Exists(file))
        {
        	throw new FileNotFoundException($"Signing Certificate couldn't found: {file}");
        }
    
    	return new X509Certificate2(file, passPhrase);
    }
    
    private void ConfigureSwagger(ServiceConfigurationContext context, IConfiguration configuration)
    {
        SwaggerConfigurationHelper.ConfigureWithAuth(
        context: context,
        authority: configuration["AuthServer:Authority"],
        scopes: new Dictionary<string, string> {
        /* Requested scopes for authorization code request and descriptions for swagger UI only */
        { "AccountService", "Account Service API" }
        },
        apiTitle: "Account Service API"
        );
    }
    
    private void ConfigureSameSiteCookiePolicy(ServiceConfigurationContext context)
    {
    	context.Services.AddSameSiteCookiePolicy();
    }
}

最後修改配置檔案

{
  "App": {
    "SelfUrl": "https://localhost:44322",
    "CorsOrigins": "http://localhost:4200,http://localhost:9527,https://localhost:44307,https://localhost:44325,https://localhost:44353,https://localhost:44367,https://localhost:44388,https://localhost:44381,https://localhost:44361",
    "RedirectAllowedUrls": "http://localhost:4200,https://localhost:44307,https://localhost:44321,http://localhost:9527"
  },
  "AuthServer": {
    "Authority": "https://localhost:44322",
    "RequireHttpsMetadata": "true",
    "SwaggerClientId": "WebGateway_Swagger"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "AdministrationService": "Host=localhost;Port=5432;User ID=postgres;password=myPassw0rd;Pooling=true;Database=FunShow_Administration;",
    "IdentityService": "Host=localhost;Port=5432;User ID=postgres;password=myPassw0rd;Pooling=true;Database=FunShow_Identity;"
  },
  "StringEncryption": {
    "DefaultPassPhrase": "fCrJICTG3WoyissG"
  },
  "Redis": {
    "Configuration": "localhost:6379"
  },
  "RabbitMQ": {
    "Connections": {
      "Default": {
        "HostName": "localhost"
      }
    },
    "EventBus": {
      "ClientName": "FunShow_AuthServer",
      "ExchangeName": "FunShow"
    }
  },
  "ElasticSearch": {
    "Url": "http://localhost:9200"
  }
}

這樣我們認證服務即修改完成。

搭建閘道器服務

閘道器服務我們直接新建一個空asp.net core專案。
然後只需要新增一個我們的Shared.Hosting.Gateways專案引用即可。

<Project Sdk="Microsoft.NET.Sdk.Web">

  <Import Project="..\..\..\..\common.props" />

  <PropertyGroup>
    <TargetFramework>net7.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\..\..\shared\FunShow.Shared.Hosting.Gateways\FunShow.Shared.Hosting.Gateways.csproj" />
  </ItemGroup>

  <ItemGroup>
    <Compile Remove="Logs\**" />
    <Content Remove="Logs\**" />
    <EmbeddedResource Remove="Logs\**" />
    <None Remove="Logs\**" />
  </ItemGroup>

</Project>

修改Program.cs

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using FunShow.Shared.Hosting.AspNetCore;
using Serilog;

namespace FunShow.WebGateway;

public class Program
{
    public async static Task<int> Main(string[] args)
    {
        var assemblyName = typeof(Program).Assembly.GetName().Name;

        SerilogConfigurationHelper.Configure(assemblyName);

        try
        {
            Log.Information($"Starting {assemblyName}.");
            var builder = WebApplication.CreateBuilder(args);
            builder.Host
                .AddAppSettingsSecretsJson()
                .AddYarpJson()
                .UseAutofac()
                .UseSerilog();
            await builder.AddApplicationAsync<FunShowWebGatewayModule>();
            var app = builder.Build();
            await app.InitializeApplicationAsync();
            await app.RunAsync();
            return 0;
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, $"{assemblyName} terminated unexpectedly!");
            return 1;
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }
}

這裡和認證服務基本一致，就是多了一個AddYarpJson()來新增我們的yarp的配置檔案。
在目錄下新建yarp.json檔案，新增我們的yarp配置內容。配置叢集和路由如下：

{
  "ReverseProxy": {
    "Routes": {
      "Account Service": {
        "ClusterId": "accountCluster",
        "Match": {
          "Path": "/api/account/{**everything}"
        }
      },
      "Identity Service": {
        "ClusterId": "identityCluster",
        "Match": {
          "Path": "/api/identity/{**everything}"
        }
      },
      "Administration Service": {
        "ClusterId": "administrationCluster",
        "Match": {
          "Path": "/api/abp/{**everything}"
        }
      },
      "Logging Service": {
        "ClusterId": "loggingCluster",
        "Match": {
          "Path": "/api/LoggingService/{**everything}"
        }
      },
      "feature-management-route": {
        "ClusterId": "feature-management-cluster",
        "Match": {
          "Path": "/api/feature-management/{**everything}"
        }
      },
      "permission-management-route": {
        "ClusterId": "permission-management-cluster",
        "Match": {
          "Path": "/api/permission-management/{**everything}"
        }
      },
      "setting-management-route": {
        "ClusterId": "setting-management-cluster",
        "Match": {
          "Path": "/api/setting-management/{**everything}"
        }
      }
    },
    "Clusters": {
      "accountCluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://localhost:44322"
          }
        }
      },
      "identityCluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://localhost:44388"
          }
        }
      },
      "administrationCluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://localhost:44367"
          }
        }
      },
      "loggingCluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://localhost:45124"
          }
        }
      },
      "feature-management-cluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://localhost:44367"
          }
        }
      },
      "permission-management-cluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://localhost:44367"
          }
        }
      },
      "setting-management-cluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://localhost:44367"
          }
        }
      }
    }
  }
}

在appsettings.json檔案新增我們認證服務的地址

{
  "App": {
    "SelfUrl": "https://localhost:44325",
    "CorsOrigins": "http://localhost:4200,https://localhost:44307,http://localhost:9527"
  },
  "AuthServer": {
    "Authority": "https://localhost:44322",
    "RequireHttpsMetadata": "true",
    "SwaggerClientId": "WebGateway_Swagger"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "Redis": {
    "Configuration": "localhost:6379"
  },
  "ElasticSearch": {
    "Url": "http://localhost:9200"
  }
}

最後我們新增FunShowWebGatewayModule檔案。配置我們yarp的服務。

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.Rewrite;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using FunShow.Shared.Hosting.AspNetCore;
using FunShow.Shared.Hosting.Gateways;
using Volo.Abp;
using Volo.Abp.Modularity;

namespace FunShow.WebGateway;

[DependsOn(
    typeof(FunShowSharedHostingGatewaysModule)
)]
public class FunShowWebGatewayModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        // Enable if you need hosting environment
        // var hostingEnvironment = context.Services.GetHostingEnvironment();
        var configuration = context.Services.GetConfiguration();
        var hostingEnvironment = context.Services.GetHostingEnvironment();
        
        SwaggerConfigurationHelper.ConfigureWithAuth(
            context: context,
            authority: configuration["AuthServer:Authority"],
            scopes: new
            Dictionary<string, string> /* Requested scopes for authorization code request and descriptions for swagger UI only */ {
            { "AccountService", "Account Service API" },
            { "IdentityService", "Identity Service API" },
            { "AdministrationService", "Administration Service API" },
            { "LoggingService", "Logging Service API" }
            },
            apiTitle: "Web Gateway API"
        );
        
        context.Services.AddCors(options =>
        {
        	options.AddDefaultPolicy(builder =>
        {
        builder
            .WithOrigins(
                configuration["App:CorsOrigins"]
                .Split(",", StringSplitOptions.RemoveEmptyEntries)
                .Select(o => o.Trim().RemovePostFix("/"))
                .ToArray()
            )
            .WithAbpExposedHeaders()
            .SetIsOriginAllowedToAllowWildcardSubdomains()
            .AllowAnyHeader()
            .AllowAnyMethod()
            .AllowCredentials();
            });
        });
    }

    public override void OnApplicationInitialization(ApplicationInitializationContext context)
    {
        var app = context.GetApplicationBuilder();
        var env = context.GetEnvironment();
        
        if (env.IsDevelopment())
        {
        	app.UseDeveloperExceptionPage();
        }
        app.UseCorrelationId();
        app.UseAbpSerilogEnrichers();
        app.UseCors();
        app.UseSwaggerUIWithYarp(context);
        
        app.UseRewriter(new RewriteOptions()
            // Regex for "", "/" and "" (whitespace)
            .AddRedirect("^(|\\|\\s+)$", "/swagger"));
            
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
        	endpoints.MapReverseProxy();
        });
    }
}

UseSwaggerUIWithYarp是從我們Yarp配置檔案中讀取服務資訊去構造swagger路由配置。
好了，到這我們認證服務和閘道器服務也搭建完畢，下一篇我們開始遷移資料庫。

ABP微服務系列學習-搭建自己的微服務結構（一）
2023-02-28
微服務
ABP微服務系列學習-使用Tye啟動微服務
2023-03-02
微服務
ABP微服務系列學習-對接前端介面
2023-03-03
微服務前端
ABP微服務系列學習-對接Apollo配置中心
2023-03-08
微服務
微服務學習系列篇
2019-05-20
微服務
三、微服務環境搭建
2020-11-30
微服務
go微服務系列之三
2017-10-25
Go微服務
構建微服務的三種重要模式 - DZone微服務
2019-08-18
微服務模式
學習微服務三-SpringBoot
2020-12-23
微服務Spring Boot
微服務學習與思考(03)：微服務總體架構圖解
2020-07-13
微服務架構圖解
go微服務系列(三) - 服務呼叫(http)
2020-08-10
Go微服務HTTP
微服務架構學習與思考(05)：微服務架構適用場景分析
2020-10-02
微服務架構
微服務2：微服務全景架構
2021-12-28
微服務架構
微服務Consul系列之服務部署、搭建、使用
2019-03-30
微服務
微服務實戰（三）：深入微服務架構的程式間通訊
2017-09-28
微服務架構
微服務學習與思考(04)：微服務技術體系
2020-07-14
微服務
學習筆記 - 微服務
2018-10-27
筆記微服務
快速搭建微服務架構的關鍵
2018-02-08
微服務架構
微服務架構：構建PHP微服務生態
2019-08-28
微服務架構PHP
微服務系列教程
2018-05-01
微服務
學習Spring Cloud與微服務之路三
2020-09-25
SpringCloud微服務
微服務設計學習（一）關於微服務和如何建模服務
2019-10-07
微服務
微服務Consul系列之叢集搭建
2019-04-07
微服務
ABP微服務學習系列-修復System.Text.Json不支援序列化Exception
2023-03-02
微服務JSONException
微服務架構(一)：什麼是微服務
2018-08-08
微服務架構
構建自己的簡單微服務架構（開源）
2019-05-22
微服務架構
微服務架構
2017-10-28
微服務架構
小墨學習記--微服務
2020-08-24
微服務
Go微服務架構系列--gin框架(上)
2020-08-25
Go微服務架構框架
SpringCloudAlibaba 微服務講解（二）微服務環境搭建
2022-03-23
SpringGCCloud微服務
微服務元件 Sentinel（三）
2022-08-06
微服務元件
微服務架構和設計模式 - DZone微服務
2019-07-27
微服務架構設計模式
微服務開發攻略之淺析微服務架構
2018-11-07
微服務架構
SpringCloud(1) ——回顧微服務和微服務架構
2020-10-11
SpringGCCloud微服務架構
[雲原生微服務架構]（十）微服務架構的基礎知識
2022-09-14
微服務架構
微服務系列 2：微服務化框架的模型和治理能力設計
2023-01-03
微服務框架模型
微服務實戰（一）：微服務架構的優勢與不足
2017-09-28
微服務架構
微服務架構初探
2018-08-08
微服務架構

ABP微服務系列學習-搭建自己的微服務結構（三）

搭建認證服務

搭建閘道器服務

相關文章