通用型产品发布解决方案(基础环境搭建)

文章目录

    • 1.项目技术栈和前置技术
    • 2.创建Linux平台
        • 1.需求分析
        • 2.安装Virtual Box
          • 1.BIOS里修改设置开启虚拟化设备支持(f2 或f10)
          • 2.任务管理器 -> cpu 查看虚拟化是否开启
          • 3.卸载方式
          • 4.安装6.1.26
          • 5.管理员身份运行,选择安装位置
          • 6.一直下一步,然后点击完成
          • 7.双击软件,看到这个页面即为成功
          • 3.安装Vagrant
            • 1.基本介绍
            • 2.卸载方式
            • 3.更改安装路径
            • 4.安装之后重启机器
            • 5.进入命令行输入 vagrant,如果有以下信息则安装成功
            • 6.通过vagrant下载指定Linux系统镜像文件,并启动系统
              • 1.查看有哪些系统可以下载安装
              • 2.安装centox/7
              • 3.创建目录
              • 4.进入这个文件夹的cmd
              • 5.执行 vagrant init centos/7
              • 6.执行成功就会有一个初始化文件
              • 7.执行 vagrant up 来安装CentOS7
              • 8.打开VirtualBox查看,正在运行则成功
              • 9.回到命令行输入 vagrant ssh 进入系统,登录成功
              • 10.查看当前版本 cat /etc/centos-release
              • 11.退出远程连接 exit
              • 12.关闭linux虚拟机,退出,选择正常关机
              • 13.启动虚拟机,启动,选择无界面启动
              • 14.如果启动不起来,重启一下主机
              • 4.配置linux可以和windows主机通信
                • 1.设置 - > 网络
                • 2.查看win的ip,记下win与VirtualBox通信的ip 192.168.56.1
                • 3.修改配置文件 Vagrantfile
                • 4.将这行注释打开,修改ip与win的在同一网段56
                • 5.使用vagrant up指令重启linux,使配置文件生效
                • 6.如果启动出问题了,就任务管理器把进程关闭或者重启电脑即可
                • 7.使用 vagrant ssh 进入系统 输入 ip addr 查看ip,这里只有101,所以linux的ip就是192.168.56.101
                • 8.win与linux互相ping
                  • 1.win 输入 ping 192.168.56.101
                  • 2.查看win的ip
                  • 3.linux 输入 ping 192.168.137.1
                  • 4.解释
                  • 3.安装docker
                      • 1.基本原理
                        • 1.说明
                        • 2.示意图
                        • 2.安装步骤
                          • 1.进入官网
                          • 2.启动虚拟机
                          • 3.登录 vagrant ssh
                          • 4.卸载以前版本的docker
                          • 5.设置仓库
                          • 6.安装最新版本的docker引擎
                            • 一路输入y即可
                            • 7.启动docker
                            • 8.查看docker版本
                            • 9.查看docker的images镜像(目前是空)
                            • 10.设置docker自启动
                            • 3.配置docker阿里云镜像加速(没配)
                              • 1.基本介绍
                              • 2.找到镜像加速器
                              • 3.四句话依次执行即可
                              • 4.安装MySQL
                                  • 1.配置示意图
                                  • 2.进入docker官网查找mysql镜像
                                    • 1.官方网址
                                    • 2.选择官方镜像
                                    • 3.选择Tags,搜索5.7
                                    • 4.找到要下载的镜像
                                    • 3.拉取镜像
                                    • 4.查看本地镜像仓库
                                    • 5.进行容器目录挂载以及端口映射
                                      • 1.提前创建目录
                                      • 2.进行目录挂载和端口映射
                                      • 3.查看容器运行情况 docker ps
                                      • 6.进入容器
                                        • 1.可以登录这个mysql进行操作
                                        • 2.退出
                                          • 1.输入quit退出mysql
                                          • 2.输入exit退出容器
                                          • 7.容器常用命令
                                            • 1.首先查看所有容器
                                            • 2.启动mysql容器
                                            • 3.关闭mysql容器
                                            • 4.查看正在运行的容器
                                            • 5.删除mysql容器
                                            • 8.IDEA连接mysql容器
                                              • 1.查看linux的ip为192.168.56.101
                                              • 2.简要说明
                                              • 3.连接信息
                                              • 4.测试连接
                                              • 5.创建一个测试数据库
                                              • 6.进入docker中的mysql容器查看
                                                • 1.进入容器
                                                • 2.登录mysql
                                                • 3.查看数据库
                                                • 9.再创建一个mysql容器
                                                  • 1.提前创建目录
                                                  • 2.进行目录挂载和端口映射
                                                  • 3.查看两个mysql容器执行情况
                                                  • 4.IDEA测试mysql2的连接
                                                  • 10.注意事项
                                                    • 1.设置docker容器自启动
                                                    • 2.切换到root用户
                                                    • 5.配置Git
                                                        • 1.git-ssh配置(之前配过)
                                                          • 测试免密登录是否生效 输入 ssh -T git@gitee.com
                                                          • 2.IDEA关联Git
                                                          • 3.在Gitee创建仓库拉取到IDEA
                                                            • 1.创建仓库
                                                            • 2.新建目录
                                                            • 3.复制仓库地址
                                                            • 4.拉取到IDEA
                                                            • 5.查看Git

                                                              1.项目技术栈和前置技术

                                                              2.创建Linux平台

                                                              1.需求分析
                                                              2.安装Virtual Box
                                                              1.BIOS里修改设置开启虚拟化设备支持(f2 或f10)

                                                              启动BIOS的虚拟化设置 | 开启CPU虚拟化支持-百度经验 (baidu.com)

                                                              2.任务管理器 -> cpu 查看虚拟化是否开启
                                                              3.卸载方式
                                                              4.安装6.1.26
                                                              5.管理员身份运行,选择安装位置
                                                              6.一直下一步,然后点击完成
                                                              7.双击软件,看到这个页面即为成功
                                                              3.安装Vagrant
                                                              1.基本介绍
                                                              2.卸载方式
                                                              3.更改安装路径
                                                              4.安装之后重启机器
                                                              5.进入命令行输入 vagrant,如果有以下信息则安装成功
                                                              6.通过vagrant下载指定Linux系统镜像文件,并启动系统
                                                              1.查看有哪些系统可以下载安装

                                                              Discover Vagrant Boxes - Vagrant Cloud (vagrantup.com)

                                                              2.安装centox/7
                                                              3.创建目录
                                                              4.进入这个文件夹的cmd
                                                              5.执行 vagrant init centos/7
                                                              6.执行成功就会有一个初始化文件
                                                              7.执行 vagrant up 来安装CentOS7
                                                              8.打开VirtualBox查看,正在运行则成功
                                                              9.回到命令行输入 vagrant ssh 进入系统,登录成功
                                                              10.查看当前版本 cat /etc/centos-release
                                                              11.退出远程连接 exit
                                                              12.关闭linux虚拟机,退出,选择正常关机
                                                              13.启动虚拟机,启动,选择无界面启动
                                                              14.如果启动不起来,重启一下主机
                                                              4.配置linux可以和windows主机通信
                                                              1.设置 - > 网络
                                                              • 可以看到使用的是端口转发规则,也就是win的2222端口转发到linux的22端口
                                                              • 这样如果linux有一个mysql的3306端口那么也需要配置一下win的端口进行转发,很麻烦
                                                                2.查看win的ip,记下win与VirtualBox通信的ip 192.168.56.1
                                                                3.修改配置文件 Vagrantfile
                                                                4.将这行注释打开,修改ip与win的在同一网段56
                                                                5.使用vagrant up指令重启linux,使配置文件生效
                                                                6.如果启动出问题了,就任务管理器把进程关闭或者重启电脑即可
                                                                7.使用 vagrant ssh 进入系统 输入 ip addr 查看ip,这里只有101,所以linux的ip就是192.168.56.101
                                                                8.win与linux互相ping
                                                                1.win 输入 ping 192.168.56.101
                                                                2.查看win的ip
                                                                3.linux 输入 ping 192.168.137.1
                                                                4.解释
                                                                • win使用 VirtualBox Host-Only Network 的 192.168.56.1 与linux的 192.168.56.101 连接
                                                                • win可以ping通linux的 192.168.56.101
                                                                • linux可以ping通win的wifi的 192.168.137.1
                                                                • 这样就不需要做端口转发了

                                                                  3.安装docker

                                                                  1.基本原理
                                                                  1.说明
                                                                  2.示意图
                                                                  2.安装步骤
                                                                  1.进入官网

                                                                  Install Docker Engine on CentOS | Docker Docs

                                                                  2.启动虚拟机
                                                                  3.登录 vagrant ssh
                                                                  4.卸载以前版本的docker
                                                                  sudo yum remove docker \
                                                                                    docker-client \
                                                                                    docker-client-latest \
                                                                                    docker-common \
                                                                                    docker-latest \
                                                                                    docker-latest-logrotate \
                                                                                    docker-logrotate \
                                                                                    docker-engine
                                                                  
                                                                  5.设置仓库
                                                                   sudo yum install -y yum-utils
                                                                  
                                                                  sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
                                                                  
                                                                  6.安装最新版本的docker引擎
                                                                   sudo yum install docker-ce docker-ce-cli containerd.io
                                                                  
                                                                  一路输入y即可
                                                                  7.启动docker
                                                                  sudo systemctl start docker
                                                                  
                                                                  8.查看docker版本
                                                                  sudo docker -v
                                                                  
                                                                  9.查看docker的images镜像(目前是空)
                                                                  sudo docker images
                                                                  
                                                                  10.设置docker自启动
                                                                  sudo systemctl enable docker
                                                                  
                                                                  3.配置docker阿里云镜像加速(没配)
                                                                  1.基本介绍
                                                                  2.找到镜像加速器

                                                                  镜像加速器网址

                                                                  3.四句话依次执行即可

                                                                  4.安装MySQL

                                                                  1.配置示意图
                                                                  • 容器是独立于linux的一个环境,但是win是连接的linux,如果不配置每次访问还需要进入容器环境来访问
                                                                  • 所以就将容器挂载到linux中,直接通过win来访问linux即可
                                                                    2.进入docker官网查找mysql镜像
                                                                    1.官方网址

                                                                    docker官网

                                                                    2.选择官方镜像
                                                                    3.选择Tags,搜索5.7
                                                                    4.找到要下载的镜像
                                                                    docker pull mysql:5.7
                                                                    
                                                                    3.拉取镜像
                                                                    sudo docker pull mysql:5.7
                                                                    
                                                                    4.查看本地镜像仓库
                                                                    sudo docker images
                                                                    
                                                                    5.进行容器目录挂载以及端口映射
                                                                    1.提前创建目录
                                                                    mkdir -p /mydata/mysql/log
                                                                    mkdir -p /mydata/mysql/data
                                                                    mkdir -p /mydata/mysql/conf
                                                                    mkdir -p /mydata/mysql/conf/mysql.conf.d
                                                                    mkdir -p /mydata/mysql/conf/conf.d
                                                                    
                                                                    2.进行目录挂载和端口映射
                                                                    • 此时的容器名为mysql
                                                                    • root的密码为root
                                                                    • linux主机监听3306,映射到mysql的3306
                                                                      sudo docker run -p 3306:3306 --name mysql \
                                                                      -v /mydata/mysql/log:/var/log/mysql \
                                                                      -v /mydata/mysql/data:/var/lib/mysql \
                                                                      -v /mydata/mysql/conf:/etc/mysql \
                                                                      -e MYSQL_ROOT_PASSWORD=root \
                                                                      -d mysql:5.7
                                                                      解读
                                                                      1. sudo : 使用管理员身份执行
                                                                      2. docker run 启动某个容器/同时也创建该容器
                                                                      3. -p 3306:3306 : 将Linux 虚拟机的3306端口和启动的容器中的Mysql3306端口
                                                                      映射
                                                                      4. --name 给容器命名,由程序员指定	
                                                                      5. -v /mydata/mysql/log: /var/log/mysql :将 Mysql 容器的/var/log/mysql 挂载到
                                                                      Linux 虚拟机的 /mydata/mysql/log ,
                                                                      类似映射/快捷键方式, 这样在 Linux 虚拟机就可以管理 MySQL 容器的 文件/
                                                                      数据
                                                                      6. 后面几个 -v 含义类似
                                                                      7. -e MYSQL_ROOT_PASSWORD=root 给启动 MySQL 的 root 用户设置密码为 root
                                                                      8. -d mysql:5.7 以 daemon 方式运行 mysql5.7 镜像文件, 即启动了一个独立的容
                                                                      器
                                                                      9. d14f6.... 看到这个信息,就说明容器启动成功
                                                                      
                                                                      3.查看容器运行情况 docker ps
                                                                      6.进入容器
                                                                      sudo docker exec -it mysql /bin/bash
                                                                      
                                                                      1.可以登录这个mysql进行操作
                                                                      2.退出
                                                                      1.输入quit退出mysql
                                                                      2.输入exit退出容器
                                                                      7.容器常用命令
                                                                      1.首先查看所有容器
                                                                      • 这里可以看到我们的mysql5.7的容器名为mysql,等会启动和关闭的时候都需要使用这个名字
                                                                         docker ps -a
                                                                        
                                                                        2.启动mysql容器
                                                                        docker start mysql
                                                                        
                                                                        3.关闭mysql容器
                                                                        docker stop mysql
                                                                        
                                                                        4.查看正在运行的容器
                                                                        docker ps
                                                                        
                                                                        5.删除mysql容器
                                                                        sudo docker rm mysql
                                                                        
                                                                        8.IDEA连接mysql容器
                                                                        1.查看linux的ip为192.168.56.101
                                                                        2.简要说明
                                                                        • 此时我们通过 192.168.56.101:3306来连接mysql容器,实际上是linux映射到了docker的mysql容器
                                                                          3.连接信息
                                                                          • ip: 192.168.56.101
                                                                          • port:3306
                                                                          • username:root
                                                                          • password:root
                                                                            4.测试连接
                                                                            5.创建一个测试数据库
                                                                            6.进入docker中的mysql容器查看
                                                                            1.进入容器
                                                                            sudo docker exec -it mysql /bin/bash
                                                                            
                                                                            2.登录mysql
                                                                            mysql -u root -p
                                                                            
                                                                            3.查看数据库
                                                                            9.再创建一个mysql容器
                                                                            1.提前创建目录
                                                                            mkdir -p /mydata2/mysql/log
                                                                            mkdir -p /mydata2/mysql/data
                                                                            mkdir -p /mydata2/mysql/conf
                                                                            mkdir -p /mydata2/mysql/conf/mysql.conf.d
                                                                            mkdir -p /mydata2/mysql/conf/conf.d
                                                                            
                                                                            2.进行目录挂载和端口映射
                                                                            • 此时的容器名为mysql2
                                                                            • root的密码为root
                                                                            • linux主机监听3307,映射到mysql2的3306
                                                                              sudo docker run -p 3307:3306 --name mysql2 \
                                                                              -v /mydata2/mysql/log:/var/log/mysql \
                                                                              -v /mydata2/mysql/data:/var/lib/mysql \
                                                                              -v /mydata2/mysql/conf:/etc/mysql \
                                                                              -e MYSQL_ROOT_PASSWORD=root \
                                                                              -d mysql:5.7
                                                                              解读
                                                                              1. sudo : 使用管理员身份执行
                                                                              2. docker run 启动某个容器/同时也创建该容器
                                                                              3. -p 3306:3306 : 将Linux 虚拟机的3306端口和启动的容器中的Mysql3306端口
                                                                              映射
                                                                              4. --name 给容器命名,由程序员指定	
                                                                              5. -v /mydata/mysql/log: /var/log/mysql :将 Mysql 容器的/var/log/mysql 挂载到
                                                                              Linux 虚拟机的 /mydata/mysql/log ,
                                                                              类似映射/快捷键方式, 这样在 Linux 虚拟机就可以管理 MySQL 容器的 文件/
                                                                              数据
                                                                              6. 后面几个 -v 含义类似
                                                                              7. -e MYSQL_ROOT_PASSWORD=root 给启动 MySQL 的 root 用户设置密码为 root
                                                                              8. -d mysql:5.7 以 daemon 方式运行 mysql5.7 镜像文件, 即启动了一个独立的容
                                                                              器
                                                                              9. d14f6.... 看到这个信息,就说明容器启动成功
                                                                              
                                                                              3.查看两个mysql容器执行情况
                                                                              docker ps
                                                                              
                                                                              4.IDEA测试mysql2的连接
                                                                              10.注意事项
                                                                              1.设置docker容器自启动
                                                                              2.切换到root用户

                                                                              5.配置Git

                                                                              1.git-ssh配置(之前配过)
                                                                              测试免密登录是否生效 输入 ssh -T git@gitee.com
                                                                              2.IDEA关联Git
                                                                              3.在Gitee创建仓库拉取到IDEA
                                                                              1.创建仓库
                                                                              2.新建目录
                                                                              3.复制仓库地址
                                                                              4.拉取到IDEA
                                                                              5.查看Git