微服务之springCloud和docker-Eureka(一)

前言

   本文记录怎么搭建服务注册中心eureka,然后打包成docker镜像,用docker swarm部署eureka集群

1、环境

环境 版本及说明 参考地址
docker v1.13.1,Docker是一个能够把开发的应用程序自动部署到容器的开源引擎 http://www.cnblogs.com/520playboy/p/7910357.html
doker-compose v1.11,Docker 官方编排(Orchestration)项目之一,负责快速在集群中部署分布式应
docker swarm v1.13.1,Docker Engine 1.12或更高版本中内置了swarm(不用额外安装) http://www.cnblogs.com/520playboy/p/7873903.html
docker registry registry:latest,用于存储docker镜像的私有仓库 http://www.cnblogs.com/520playboy/p/7889647.html
spring boot 1.5.1.RELEASE,是开箱即用,提供一系列大型项目常用的非功能性特征的快速度开发工具 spring boot官网
spring cloud Camden SR5,Spring Cloud 为开发者提供了在分布式系统(如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性 Token、全局锁、决策竞选、分布式会话和集群状态)操作的开发工具集 spring cloud官网
开发工具 jdk1.8/IntelliJ idea2016/maven3.3

2、创建父空项目 microservice-spring-cloud

3、父项目的pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.2.RELEASE</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.jacky</groupId>
    <artifactId>microservice-spring-cloud</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

    <modules>
        <module>microservice-discovery-eureka-ha</module>
    </modules>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <docker.image.prefix>jacky</docker.image.prefix><!--配置镜像仓库的属性-->
        <docker.repostory>192.168.6.132:5000</docker.repostory><!--配置镜像仓库的对应的地址与端口-->
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Camden.SR3</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
        <!--添加利用maven插件构建docker镜像的插件依赖-->
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>com.spotify</groupId>
                    <artifactId>docker-maven-plugin</artifactId>
                    <version>0.4.13</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

</project>

4、创建子项目microservice-discovery-eureka-ha

5、microservice-discovery-eureka-ha工程的pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>microservice-spring-cloud</artifactId>
        <groupId>com.jacky</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microservice-discovery-eureka-ha</artifactId>
    <packaging>jar</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
        </dependency>
       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <executions>
                    <!--设置在执行maven 的install时构建镜像-->
                    <execution>
                        <id>build-image</id>
                        <phase>install</phase>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!--安装了docker的主机,并且打开了api remote接口设置-->
                    <dockerHost>http://192.168.6.130:5678</dockerHost>
                    <pushImage>true</pushImage><!--设置上传镜像到私有仓库,需要docker设置指定私有仓库地址-->
                    <!--镜像名称-->
                    <imageName>${docker.repostory}/${docker.image.prefix}/${project.artifactId}:${project.version}</imageName>
                    <!--镜像的基础版本-->
                    <baseImage>java:openjdk-8-jdk-alpine</baseImage>
                    <!--镜像启动参数-->
                    <entryPoint>["java", "-jar", "/${project.build.finalName}.jar"]</entryPoint>
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <directory>${project.build.directory}</directory>
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

5、microservice-discovery-eureka-ha工程的application.yml文件

spring:
  application:
    name: EUREKA-HA
security:
  basic:
    enabled: true
  user:
    name: jacky
    password: admin
---
server:
  port: 8761
spring:
  profiles: peer1
eureka:
  instance:
    hostname: peer1        #Eureka实例的主机名
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.cloud.client.ipAddress}:${spring.application.instance_id:${server.port}}
  client:
    serviceUrl:
      defaultZone: http://jacky:[email protected]:8762/eureka/,http://jacky:[email protected]:8763/eureka/  #Eureka节点相互注册
      register-with-eureka: true
---
server:
  port: 8762
spring:
  profiles: peer2
eureka:
  instance:
    hostname: peer2      #Eureka实例的主机名
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.cloud.client.ipAddress}:${spring.application.instance_id:${server.port}}
  client:
    serviceUrl:
      defaultZone: http://jacky:[email protected]:8761/eureka/,http://jacky:[email protected]:8763/eureka/
      register-with-eureka: true
---
server:
  port: 8763
spring:
  profiles: peer3
eureka:
  instance:
    hostname: peer3    #Eureka实例的主机名
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.cloud.client.ipAddress}:${spring.application.instance_id:${server.port}}
  client:
    serviceUrl:
      defaultZone: http://jacky:[email protected]:8761/eureka/,http://jacky:[email protected]:8762/eureka/
      register-with-eureka: true

6、创建EurekaHaApplication.java文件

package com.jacky.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaHaApplication {
  public static void main(String[] args) {
    SpringApplication.run(EurekaHaApplication.class, args);
  }
}

7、在父目录下创建docker-compose.yml文件

version: "3"
services:
  peer1:      # 默认情况下,其他服务可以使用服务名称连接到该服务。因此,对于eurekaService1的节点,它需要连接http://eurekaService2/3:951X/eureka/,因此需要配置该服务的名称是eurekaService1。
    image: 192.168.6.132:5000/jacky/microservice-discovery-eureka-ha:1.0-SNAPSHOT
    deploy:
      replicas: 1   #定义 replicated 模式的服务的复本数量
      update_config:
        parallelism: 1    #每次更新复本数量
        delay: 2s       #每次更新间隔
      restart_policy:
        condition: on-failure     #定义服务的重启条件
    networks:
      - eureka-net
    ports:
      - "8761:8761"
    environment:
      - spring.profiles.active=peer1
  peer2:    # 高可用eureka注册节点2
    image: 192.168.6.132:5000/jacky/microservice-discovery-eureka-ha:1.0-SNAPSHOT
    deploy:
      replicas: 1   #定义 replicated 模式的服务的复本数量
      update_config:
        parallelism: 1    #每次更新复本数量
        delay: 2s       #每次更新间隔
      restart_policy:
        condition: on-failure     #定义服务的重启条件
    networks:
      - eureka-net
    ports:
      - "8762:8762"
    environment:
      - spring.profiles.active=peer2
  peer3:    # 高可用eureka注册节点3
    image: 192.168.6.132:5000/jacky/microservice-discovery-eureka-ha:1.0-SNAPSHOT
    deploy:
      replicas: 1   #定义 replicated 模式的服务的复本数量
      update_config:
        parallelism: 1    #每次更新复本数量
        delay: 2s       #每次更新间隔
      restart_policy:
        condition: on-failure     #定义服务的重启条件
    networks:
      - eureka-net
    ports:
      - "8763:8763"
    environment:
      - spring.profiles.active=peer3
networks:
  eureka-net:            #网络名称
    driver: overlay

8、打包

双击install

9、在192.168.6.130机器上查看镜像

表示上传成功

10、把的docker-compose.yml文件上传到拥有swarm环境下,执行命令如下

[[email protected] docker-compose]# docker stack deploy -c docker-compose.yml eureka
Creating service eureka_peer2
Creating service eureka_peer3
Creating service eureka_peer1
[[email protected] docker-compose]# docker stack ps eureka
ID            NAME            IMAGE                                                                   NODE             DESIRED STATE  CURRENT STATE           ERROR  PORTS
njhk2gkh7b6r  eureka_peer1.1  192.168.6.132:5000/jacky/microservice-discovery-eureka-ha:1.0-SNAPSHOT  node3.jacky.com  Running        Running 55 seconds ago
y5xwabq42zx4  eureka_peer3.1  192.168.6.132:5000/jacky/microservice-discovery-eureka-ha:1.0-SNAPSHOT  node3.jacky.com  Running        Running 55 seconds ago
468xoiu6lv6l  eureka_peer2.1  192.168.6.132:5000/jacky/microservice-discovery-eureka-ha:1.0-SNAPSHOT  node2.jacky.com  Running        Running 57 seconds ago 

说明eureka集群部署成功

说明:swarm集群192.168.6.130;192.168.6.131;192.168.6.132;8761,8762,8763端口都可以访问

时间: 2024-11-08 12:05:32

微服务之springCloud和docker-Eureka(一)的相关文章

谈谈我对微服务、SpringCloud、k8s、Istio的一些杂想

一.微服务与SOA "微服务"是一个名词,没有这个名词之前也有"微服务",一个朗朗上口的名词能让大家产生一个认知共识,这对推动一个事务的发展挺重要的,不然你叫微服务他叫小服务的大家很难集中到一个点上. 业界对微服务与SOA的区别争论比较多大多都是在微观上对比他们的区别什么微服务粒度更细啊.微服务没有ESB啊.微服务通讯相比SOA采用更轻量级的协议啊等等,但是从微观谈区别本身就有悖论, 这些区别只是微服务的一种"最佳实践"而已.我个人理解微服务与S

微服务和SpringCloud入门

微服务是什么 微服务的核心是将传统的一站式应用,根据业务拆分成一个一个的服务,彻底去耦合,每个微服务提供单个业务功能的服务,一个服务做一件事情,从技术角度看就是一种小而独立的处理过程,类似进程概念,能够进行单独启动和销毁,可以拥有独立的数据库. 微服务与微服务架构的区别 微服务:它强调的事服务的大小,它关注的是某个点,是具体解决某一个问题/提供落地对应服务的一个服务应用 微服务架构:它是一种架构模式,它提成将单一应用程序划分成一组小的服务,服务之间相互配合协调,为服务提供最终价值.每个服务运行在

微服务之SpringCloud实战(二):SpringCloud Eureka服务治理

服务治理 SpringCloud Eureka是SpringCloud Netflix微服务套件的一部分,它基于Netflix Eureka做了二次封装,主要完成微服务的服务治理功能,SpringCloud通过为Eureka增加了SpringBoot自动化配置,只需要简单的依赖和配置就可完成Eureka整合搭建.   服务治理可以说是微服务中做核心的模块,主要负责服务的自动化注册与发现,在最初开始构建微服务的时候,可能服务并不会很多,我们可以通过一些静态配置进行相互调用,但是随着业务的更新迭代,

微服务架构 SpringCloud(一)组件和概念介绍

一:什么是微服务(Microservice) 微服务英文名称Microservice,Microservice架构模式就是将整个Web应用组织为一系列小的Web服务.这些小的Web服务可以独立地编译及部署,并通过各自暴露的API接口相互通讯.它们彼此相互协作,作为一个整体为用户提供功能,却可以独立地进行扩. 微服务架构需要的功能或使用场景 1:我们把整个系统根据业务拆分成几个子系统. 2:每个子系统可以部署多个应用,多个应用之间使用负载均衡. 3:需要一个服务注册中心,所有的服务都在注册中心注册

微服务框架-SpringCloud简介

前面一篇文章谈到微服务基础框架,而Netflix的多个开源组件一起正好可以提供完整的分布式微服务基础架构环境,而对于Spring Cloud正是对Netflix的多个开源组件进一步的封装而成,同时又实现了和云端平台,和Spring Boot开发框架很好的集成. Spring Cloud是一个相对比较新的微服务框架,今年(2016)才推出1.0的release版本. 虽然Spring Cloud时间最短, 但是相比Dubbo等RPC框架, Spring Cloud提供的全套的分布式系统解决方案.

升级微服务架构1:搭建Eureka Server服务中心

Spring Cloud中使用Eureka来做服务注册和发现,来统一管理微服务实例. 1.使用IDEA创建一个空的Maven项目做父模块 (也可以不用父项目,所有模块都用平行结构) 删除父模块src文件夹 可使用Spring Initializr来创建模块或者创建Maven项目手动添加依赖 2.使用Spring Initializr创建Eureka Server 选择SDK 1.8 Artifact填写对应模块的名称 依次选择Cloud Discovery->Eureka Server,Spri

微服务之SpringCloud干货(一):SpringCloud简介

什么是微服务架构 微服务架构就是系统架构设计的一种风格,它主旨将一个独立的系统,拆分成各个微服务,各个微服务独立运行,他们之间通过Http的Restful API进行通信,拆分出来的微服务是根据原系统高耦合部分进行构建(之后会单独讲解如何拆分微服务),每个微服务 都有自己的数据存储(涉及到分布式事务的处理,之后会有讲解).独立部署,由于轻量级的通讯协议,微服务可以使用不同的语言来开发. SpringCloud SpringCloud是一个基于SpringBoot实现的微服务架构开发工具,它为微服

微服务架构之spring cloud eureka

Spring Cloud Eureka是spring cloud的核心组件,负责服务治理功能,起到中心枢纽作用,其它组件都依赖eureka来获取服务,然后再根据项目需求实现自己的业务,eureka在整个微服务架构中的位置绝对是核心地位. (一)   版本说明 a)         Spring boot   2.0.6.RELEASE b)        Spring cloud  Finchley.SR2 c)         Java version   1.8 (二)   项目设置 Pom

微服务和SpringCloud

目录: 1.什么是微服务 马丁.福勒微服务架构博文:https://martinfowler.com/articles/microservices.html 译文:https://blog.csdn.net/qq_32252957/article/details/90247418 微服务架构是一种架构模式或者说是一种架构风格,它提倡将单一应用程序划分成一组小的服务,每个服务运行在其独立的进程中,服务之间相互协调.互相配合,为用户提供最终价值.服务之间采用轻量级的通信机制互相沟通(通常是基于HTT

微服务之springcloud技术栈

一.微服务架构图: 二.技术介绍:(技术选型随着代码的编写会完成) 关于技术选型,我盗了一张微服务技术栈的图,如下:原文:http://www.jianshu.com/p/2da6becfb019 我将会用到上图中的如下技术 服务注册和服务发现:consul 服务健康检查:consul 配置管理:consul.archaius 集群容错:hystrix 计数监控:codahale-metrics.java-statsd-client.hystrix-dashboard.turbine.stats