精华内容
下载资源
问答
  • //拉取Nginx镜像 $ docker pull nginx //启动Nginx容器 $ docker run -d -p 8080:80 --name hellonginx nginx
  • 在Docker容器部署Spring Boot应用

    千次阅读 2018-05-30 15:08:34
    Docker是开发者的开放平台,它是一个机制,通过将每个应用程序打包到容器中来隔离依赖关系。容器是可扩展的,可更安全...在本文中介绍如何在Docker容器部署一个简单的Spring Boot应用,通过构建、部署过程来理解Do...

    Docker是开发者的开放平台,它是一个机制,通过将每个应用程序打包到容器中来隔离依赖关系。容器是可扩展的,可更安全的使用和部署。Docker容器能够共享一个内核并共享应用程序库,因此容器比虚拟机具有更低的系统开销,只要用户愿意使用单一平台来提供共享的操作系统,容器可以更快,占用更少资源。

    在本文中介绍如何在Docker容器中部署一个简单的Spring Boot应用,通过构建、部署过程来理解Docker的一些基本概念和操作命令。

    1 Spring Boot应用

    一个简单的Hello World应用。

    1.1 Maven依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    引入spring-boot-starter-web来创建一个Web应用。

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    1.2 主应用程序

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

    1.3 服务接口

    RESTful服务接口:

    @RestController
    public class HelloController {
        @RequestMapping("/hello")
        public String hello() {
           return "Hello World";
        }
    }

    2 Docker安装

    Docker是一个基于Linux内核构建、传输和运行的轻量级容器平台。Docker默认支持Linux平台,同时还通过使用Boot2Docker来支持Mac和Windows,它们运行在Virtual Box虚拟机之上。

    本例中是在Windows系统中安装Docker。Windows环境分两种情况,一种是Windows 10 64位专业版,一种是其他版本(比如很多人仍然推崇的Win 7)。前者可以直接支持安装Docker原生版,性能最好,体验最佳;后者只能使用Docker官方提供的一种过度技术(Docker ToolBox),这种技术不得不依赖Oracle的Virtualbox以在你的系统里创建一个虚拟机用以模拟Linux运行环境。在低版本的windows上使用时你的处理器必须支持硬件虚拟化。

    安装完毕后,Docker环境的虚拟IP是192.168.99.100。

    3 部署应用

    3.1 Spring Boot应用打包

    在Spring Boot应用工程目录下执行mvn 打包命令:

    mvn package spring-boot:repackage

    工程的target目录里生成了一个jar包 firtSpringBoot-0.0.1-SNAPSHOT.jar。将jar包更名为firtSpringBoot-1.0.jar上传到Docker环境里。

    3.2 Dockerfile文件

    Dockfile原则上是一个批处理文件,包含了构建图像的命令。将这些命令放入文件中并不是绝对必要的,因为我们可以将它们传递到命令行,只是使用文件更简单一些。

    现在创建一个Dockerfile:

    FROM alpine:edge
    MAINTAINER peterwanghao.com
    RUN apk add --no-cache openjdk8
    VOLUME /tmp
    ADD  firtSpringBoot-1.0.jar firtSpringBoot.jar
    EXPOSE 8080
    ENTRYPOINT ["java","-jar","/firtSpringBoot.jar"]

    FROM:基础镜像。
    MAINTAINER:用于声明作者。
    RUN :目标系统中执行shell命令行。在这里,我们利用 Alpine Linux’s的包管理器apk安装java 8。
    VOLUME :让你的容器访问宿主机上的目录。
    ADD:ADD命令有两个参数,源和目标。它的基本作用是从源系统的文件系统上复制文件到目标容器的文件系统。
    EXPOSE :在这里我们告诉Docker,我们的应用程序使用哪个端口。当容器启动时,该端口将被发布到主机。
    ENTRYPOINT :配置容器启动后执行的命令,并且不可被 docker run 提供的参数覆盖。每个 Dockerfile 中只能有一个 ENTRYPOINT,当指定多个时,只有最后一个起效。

    3.3 创建镜像

    在Dockerfile文件目录下运行docker build命令,这将下载基镜像并一条接一条地运行Dockerfile文件中的条目。创建的镜像的名字是first,标签1.0。–rm=true,在整个构建过程成功后删除中间环节的容器。

    $docker build -t first:1.0 --rm=true .

    使用docker images命令列出所有的镜像和它们的详细信息。

    docker@default:~/first-spring-boot$ docker images
    REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
    first               1.0                 02f67d8c308d        17 hours ago        119MB
    hello-world         latest              e38bc07ac18e        6 weeks ago         1.85kB
    alpine              edge                5c4fa780951b        4 months ago        4.15MB

    3.4 运行容器

    接下来,我们将运行容器。使用下面的命令加载并运行容器。

    docker run --name=first -p 8080:8080 -t first:1.0

    使用docker ps命令列出正在运行的容器

    docker@default:~/first-spring-boot$ docker ps 
    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
    9fc3aef6e852        first:1.0           "java -jar /firtSpri   5 hours ago         Up 5 hours          0.0.0.0:8080->8080/tcp   first

    3.5 测试

    通过浏览器访问 http://192.168.99.100:8080/hello 显示“Hello World”。

    4 结论

    正如我们所看到的,我们现在能够建立自定义Docker镜像,运行一个Spring Boot应用程序在Docker容器中。有关构建文件的进一步阅读,可以参考官方的Dockerfile手册和Docker-compose.yml手册。

    展开全文
  • docker 中 单容器和多容器部署

    千次阅读 2018-07-11 01:42:39
    容器应用部署实践说明:部署一个单页面的应用 参考网址:https://github.com/docker/labs/blob/master/beginner/chapters/votingapp.md1.启动容器会自动下载dockersanples/static-site镜像 2.启动容器 3.查看...

    单容器应用部署实践

    说明:部署一个单页面的应用 
    参考网址:https://github.com/docker/labs/blob/master/beginner/chapters/votingapp.md

    1.启动容器会自动下载dockersanples/static-site镜像 
    这里写图片描述

    2.启动容器 
    这里写图片描述

    3.查看端口 
    这里写图片描述

    4.查看容器运行情况 
    这里写图片描述

    5.在浏览器中输入地址和端口号,就可以看到网页 
    这里写图片描述

    6.创建文件夹flask-app 
    这里写图片描述

    7.flask-app下有四个文件 
    这里写图片描述

    8.构建镜像 
    这里写图片描述

    9.启动容器,将虚拟机8888端口映射到容器的5000端口 
    这里写图片描述

    10.在浏览器中输入网址,查看运行效果 
    这里写图片描述

    多容器应用部署实践

    说明:用docker compose和docker deploy stack 部署 
    参考网址:https://github.com/docker/labs/blob/master/beginner/chapters/votingapp.md 
    应用说明:该应用基于以下镜像搭建 
    Python 
    Node.js 
    redis 
    .net 
    postgress

    1.下载工程 
    这里写图片描述

    2.创建Docker Swarm 
    这里写图片描述

    3.docker stack deploy是在Docker Swarm模式下docker-compose的替代 
    这里写图片描述

    4.查看启动的服务 
    这里写图片描述

    5.查看容器的运行情况 
    这里写图片描述

    6.浏览器中输入虚拟机地址,这是5000端口,是投票服务 
    这里写图片描述

    7.浏览器中输入虚拟机地址,这是5001端口,投票统计服务 
    这里写图片描述

    8.镜像更新,只需要修改虚拟机中的配置文件 
    这里写图片描述 
    9. 
    这里写图片描述

    10.重启app 
    这里写图片描述

    11.在浏览器中查看运行情况 
    这里写图片描述

    12. 
    这里写图片描述
    13. 
    这里写图片描述 
    14. 
    这里写图片描述

    展开全文
  • 在Docker容器部署Web应用

    万次阅读 2015-02-02 23:20:57
    本文直接讲解如何在Docker容器中实战部署一个Web应用程序,关于Docker相关的概念和如何安装Docker请参考相关资料完成。   第一步:工具准备 演示如何在Docker容器部署一个Java Web应用程序,需要准备的软件工具...

    本文直接讲解如何在Docker容器中实战部署一个Web应用程序,关于Docker相关的概念和如何安装Docker请参考相关资料完成。

     

    第一步:工具准备

    演示如何在Docker容器中部署一个Java Web应用程序,需要准备的软件工具包括:jre,tomcat和webapp应用。另外,为了实现在容器启动时自动启动webapp,需要编写一个脚本工具完成该工作。

    安装jre,请参考:http://www.wikihow.com/Install-Java-on-Linux

    安装tomcat,请参考:http://blog.csdn.net/williamcs/article/details/8579957

    如何在tomcat中部署webapp,请参考:

    http://tomcat.apache.org/tomcat-7.0-doc/deployer-howto.html

    http://www.cnblogs.com/zengsong-restService/archive/2013/01/04/2844568.html

     

    jre1.8.0_31.tar.gz   // 可以选择其他版本

    apache-tomcat-6.0.35.tar.gz // 可以选择其他版本

    MyWeb.war // 自己写一个web应用即可,才发现csdn不允许上传附件

    start_tomcat.sh



    第二步:制作镜像

    通过编写Dockerfile的方式制作镜像。

    需要在Dockerfile中完成如下几项工作:

    (1)安装jre

    (2)安装tomcat,并完成在tomcat中部署web应用的基本配置(为实现此功能:在制作镜像之前直接先完成tomcat的基础配置,然后直接拷贝到镜像中即可)。

    (3)对外开发8080端口(具体的端口值可以根据实际Tomcat配置参数为准)。

    $mkdir docker

    $cd docker

    $mkdir webapps

    $cp jre1.8.0_31.tar.gz .

    $tar xzvf jre1.8.0_31.tar.gz

    $cp apache-tomcat-6.0.35.tar.gz

    $tar xzvf apache-tomcat-6.0.35.tar.gz

    $cp MyWeb.war ./webapps/

    $vim apache-tomcat-6.0.35/conf/server.xml

    编辑tomcat配置文件:server.xml,在<Host>节点中添加如下配置:<Context path="myweb"docBase="/webapps/MyWeb.war" reloadable="false"workDir="/tomcat_work"/>,配置片段如下所示:

    <Host name="localhost"  appBase="webapps"

         unpackWARs="true" autoDeploy="true"

         xmlValidation="false" xmlNamespaceAware="false">

     

      <!-- SingleSignOn valve, shareauthentication between web applications

           Documentation at:/docs/config/valve.html -->

      <!--

      <Valve className="org.apache.catalina.authenticator.SingleSignOn"/>

      -->

     

      <!-- Access log processes all example.

           Documentation at:/docs/config/valve.html -->

      <!--

      <ValveclassName="org.apache.catalina.valves.AccessLogValve"directory="logs" 

            prefix="localhost_access_log." suffix=".txt"pattern="common" resolveHosts="false"/>

      -->

      <Contextpath="/myweb"docBase="/webapps/MyWeb.war"reloadable="false"workDir="/tomcat_work"/>

    </Host>

     

    $vim start_tomcat.sh

    #!/bin/bash

     

    #Date: 2015/02/02

    #Desc:

    #       Start tomcat with docker containerstart.  

     

    echo "Start Tomcat ..."

     

    # Export java path

    export PATH=$PATH:/usr/local/java/bin

    # Display container ipaddress

    ifconfig

    # Start tomcat

    bash /usr/local/tomcat/bin/catalina.sh run

    注意:启动tomcat时必须通过$TOMCAT_HOME/bin/catalina.sh实现,不能使用$TOMCAT_HOME/bin/startup.sh启动,否则脚本执行后容器立刻就退出了。

     

    编写Dockerfile

    #Build java web app container image

    FROM docker.cn/docker/ubuntu:14.04

    MAINTAINER chenchanghui<nuccch2010.163.com>

    #Make java and tomcat install directory

    RUN mkdir /usr/local/java

    RUN mkdir /usr/local/tomcat

    #Copy jre and tomcat into image

    ADD jre1.8.0_31 /usr/local/java/

    ADD apache-tomcat-6.0.35 /usr/local/tomcat/

    ADD start_tomcat.sh start_tomcat.sh

    #Expose http port

    EXPOSE 8080


    创建镜像

    $sudo docker build -t=”ubuntu/myweb:tomcat”.

    Sendingbuild context to Docker daemon 270.6 MB

    Sendingbuild context to Docker daemon

    Step 0 :FROM docker.cn/docker/ubuntu:14.04

     ---> b39b81afc8ca

    Step 1 :MAINTAINER chenchanghui <nuccch2010.163.com>

     ---> Running in cd9ba3324dae

     ---> ab45c422bdf5

    Removingintermediate container cd9ba3324dae

    Step 2 :RUN mkdir /usr/local/java

     ---> Running in f640de521691

     ---> bd94048cb633

    Removingintermediate container f640de521691

    Step 3 :RUN mkdir /usr/local/tomcat

     ---> Running in de4a392ec89d

     ---> 956ac99b8bec

    Removingintermediate container de4a392ec89d

    Step 4 :ADD jre1.8.0_31 /usr/local/java/

     ---> e3181a61f635

    Removingintermediate container b69c147f28fe

    Step 5 :ADD apache-tomcat-6.0.35 /usr/local/tomcat/

     ---> 9169a4ab9a80

    Removingintermediate container c190162d7a5c

    Step 6 :ADD start_tomcat.sh start_tomcat.sh

     ---> cf61f83dc0b0

    Removingintermediate container 3f10c2a9e374

    Step 7 :EXPOSE 8080

    --->abea02c999a2

    Removingintermediate container a3841acba123

    Successfullybuilt abea02c999a2


    第三部:启动容器

    webapp通过数据卷挂在到容器中进行部署,不需要拷贝到镜像中。

    $sudo docker run -t -i --name tomcat –v /home/$username/docker/webapps:/webapps/

    ubuntu/myweb:tomcat /bin/bash/start_tomcat.sh

    Start Tomcat ...

    eth0     Link encap:Ethernet  HWaddr02:42:ac:11:00:0c 

             inet addr:172.17.0.12 Bcast:0.0.0.0  Mask:255.255.0.0

    ……..

    Feb 02, 2015 1:38:42 PMorg.apache.catalina.core.AprLifecycleListener init

    INFO: The APR based Apache Tomcat Nativelibrary which allows optimal performance in production environments was notfound on the java.library.path:/usr/java/packages/lib/amd64:/usr/lib64:/lib64:/lib:/usr/lib

    Feb 02, 2015 1:38:42 PMorg.apache.coyote.http11.Http11Protocol init

    INFO: Initializing Coyote HTTP/1.1 onhttp-8080

    Feb 02, 2015 1:38:42 PMorg.apache.catalina.startup.Catalina load

    INFO: Initialization processed in 788 ms

    Feb 02, 2015 1:38:42 PMorg.apache.catalina.core.StandardService start

    INFO: Starting service Catalina

    Feb 02, 2015 1:38:42 PM org.apache.catalina.core.StandardEnginestart

    INFO: Starting Servlet Engine: ApacheTomcat/6.0.35

    Feb 02, 2015 1:38:42 PMorg.apache.catalina.startup.HostConfig deployDirectory

    INFO: Deploying web application directorymanager

    Feb 02, 2015 1:38:42 PM org.apache.catalina.startup.HostConfigdeployDirectory

    INFO: Deploying web application directorydocs

    Feb 02, 2015 1:38:42 PMorg.apache.catalina.startup.HostConfig deployDirectory

    INFO: Deploying web application directoryROOT

    Feb 02, 2015 1:38:42 PM org.apache.catalina.startup.HostConfigdeployDirectory

    INFO: Deploying web application directoryexamples

    Feb 02, 2015 1:38:43 PMorg.apache.catalina.startup.HostConfig deployDirectory

    INFO: Deploying web application directoryhost-manager

    Feb 02, 2015 1:38:43 PM org.apache.coyote.http11.Http11Protocolstart

    INFO: Starting Coyote HTTP/1.1 on http-8080

    Feb 02, 2015 1:38:43 PMorg.apache.jk.common.ChannelSocket init

    INFO: JK: ajp13 listening on /0.0.0.0:8009

    Feb 02, 2015 1:38:43 PMorg.apache.jk.server.JkMain start

    INFO: Jk running ID=0 time=0/27  config=null

    Feb 02, 2015 1:38:43 PMorg.apache.catalina.startup.Catalina start

    INFO: Server startup in 842 ms


    如日志所示,Docker容器已经启动,并且其中安装的tomcat已经成功启动。

    访问:http://172.17.0.12:8080/myweb/,Everything is ok!

    小技巧:启动容器时带参数-t -i和不带参数的区别:带参数-t -i时可以通过Ctrl+C停止容器运行,不带参数-t -i启动时,停止容器只能通过命令:$sudo docker stop $containerid实现。


    展开全文
  • Docker容器部署Python应用

    千次阅读 2019-07-17 07:45:00
    简介Docker是目前主流IT公司广泛接受和使用的,用于构建、管理和保护它们应用程序的工具。容器,例如Docker允许开发人员在单个操作系统上隔离和运行多个应用程序,而不...
        

    640?wx_fmt=jpeg


    简介

    640?wx_fmt=png


    Docker是目前主流IT公司广泛接受和使用的,用于构建、管理和保护它们应用程序的工具。
    容器,例如Docker允许开发人员在单个操作系统上隔离和运行多个应用程序,而不是为服务器上的每个应用程序专用一个虚拟机。使用容器更轻量级,可以降低成本、更好地使用资源和发挥更高的性能。
    本文将使用Flask开发一个简单的Python web应用程序,并为“容器化”做好准备。然后创建一个Docker镜像,并将其部署到测试和生产环境中。
    注意:请确保机器上已安装Docker,如果没有请参考Docker官方安装教程。
    Docker介绍

    640?wx_fmt=png


    Docker是一种工具,它使开发人员能够交付他们的应用程序(以及库或其他依赖项),确保他们可以使用正确的配置运行,而不受部署环境影响。
    这是通过将应用程序隔离在单独的容器中来实现的,这些应用程序虽然被容器分隔开,但是却可以共享操作系统和其他资源。
    Docker包含两部分:
    • Docker Engine:应用打包工具,用于封装应用程序。

    • Docker Hub:用于管理云上容器应用程序的工具。


    为何选择容器

    640?wx_fmt=png


    了解容器的重要性和实用性非常重要,虽然它和直接将应用部署到服务器没有多大区别,但是当涉及到比较复杂的且相当吃资源的应用,尤其是多个应用部署在同一台服务器,或是同一应用要部署到多台服务器时。容器就变得非常有用。
    在容器之前,这是通过VMWare和Hypervisor等虚拟机解决的,但是它们在效率、速度和可移植性方面已被证明并不是最佳选择。
    Docker容器是虚拟机的轻量级的替代品-与VM不同,我们不需要为它预先分配RAM、CPU或其他资源,也不需要为每个应用程序启动一个VM,仅仅只需要一个操作系统即可。
    使用容器开发人员就不需要为不同环境制定特殊版本,这样可以专注于应用程序的核心业务逻辑。
    创建Python应用

    640?wx_fmt=png


    Flask是Python的一个轻量级Web应用框架,简单易用,可以很快速地创建Web应用。我们用它来创建此demo应用。
    如果还没有安装Flask模块,可以使用下面命令安装:
    $ pip install flask

    安装成功后,新建一个应用目录,命名为FlaskDemo。并在该目录下创建应用代码文件app.py。
    在app.py中,首先引入Flask模块,然后创建一个Web应用:
    from flask import Flask	
    app = Flask(__name__)

    然后定义路由/和其对应的请求处理程序:
    @app.route("/")	
    def index():  	
      return """	
      <h1>Python Flask in Docker!</h1>	
      <p>A sample web-app for running Flask inside Docker.</p>	
      """

    最后,添加运行主程序并启动该脚本:
    if __name__ == "__main__":  	
        app.run(debug=True, host='0.0.0.0')	
    Copy	
    $ python app.py

    然后在浏览器中访问http://localhost:5000/,可以看到Dockerzing Python app using Flask这样的页面。
    640?wx_fmt=png
    Dokcer打包应用

    640?wx_fmt=png


    要在Docker上运行应用程序,首先必须构建一个容器,而且必须包含使用的所有依赖项——在我们的例子中只有Flask。因此,新建一个包含所有依赖包的 requirements.txt 文件,然后创建一个Dockerfile,该文件用来描述构建镜像过程。
    此外,当启动容器时还需要放开应用程序的HTTP端口。
    准备工作
    requirements.txt 文件非常简单,只需要填入项目的依赖包和其对应版本即可:
    Flask==1.0.2

    接下来,需要将应用程序运行所需的所有Python文件都放在顶层文件夹中,例如,名为app的目录。
    同时建议将主入口程序命名为app.py ,将脚本中创建的Flask对象命名为app是一种通常的做法,这样也可以简化部署。
    FlaskApp  	
        ├── requirements.txt	
        ├── Dockerfile	
        └── app	
            └── app.py	
            └── <other .py files>

    创建Dockerfile
    Dockerfile本质上是一个文本文件,其中明确定义了如何为我们的项目构建Docker镜像。
    接下来创建一个基于Ubuntu 16.04和Python 3.X的Dokcer镜像:
    FROM ubuntu:16.04	
    MAINTAINER jhao104 "j_hao104@163.com"	
    RUN apt-get update -y && \	
        apt-get install -y python3-pip python3-dev	
    COPY ./requirements.txt /requirements.txt	
    WORKDIR /	
    RUN pip3 install -r requirements.txt	
    COPY . /	
    ENTRYPOINT [ "python3" ]	
    CMD [ "app/app.py" ]

    Dockerfile的基本指令有十三个,上面用到了部分。
    • FROM:所有Dockerfile的第一个指令都必须是FROM ,用于指定一个构建镜像的基础源镜像,如果本地没有就会从公共库中拉取,没有指定镜像的标签会使用默认的latest标签,如果需要在一个Dockerfile中构建多个镜像,可以使用多次。

    • MAINTAINER:描述镜像的创建者,名称和邮箱。

    • RUN:RUN命令是一个常用的命令,执行完成之后会成为一个新的镜像,通常用于运行安装任务从而向镜像中添加额外的内容。在这里,我们需更新包,安装python3和pip 。在第二个RUN命令中使用pip来安装requirements.txt文件中的所有包。

    • COPY:复制本机文件或目录,添加到指定的容器目录,本例中将requirements.txt复制到镜像中。

    • WORKDIR:为RUN、CMD、ENTRYPOINT指令配置工作目录。可以使用多个WORKDIR指令,后续参数如果是相对路径,则会基于之前命令指定的路径。

    • ENTRYPOINT:在启动容器的时候提供一个默认的命令项。

    • RUN:运行app目录中的app.py。


    Docker镜像构建原理
    Docker镜像是使用Docker build命令构建的。在构建镜像时,Docker创建了所谓的“层(layers)”。每一层都记录了Dockerfile中的命令所导致的更改,以及运行命令后镜像的状态。
    Docker在内部缓存这些层,这样在重新构建镜像时只需要重新创建已更改的层。例如,这里使用了ubuntu:16.04的基础镜像,相同容器的所有后续构建都可以重用它,因为它不会改变。但是,因为项目修改,在下次重新构建过程中app目录的内容可能会有所不同,因此只会重新构建这一层。
    需要注意的是,每当重新构建某一层时,Dockerfile中紧随其后的所有层也都需要重新构建。例如,我们首先复制requirements.txt文件,然后再复制应用程序的其余部分。这样之前安装的依赖项只要没有新的依赖关系,即使应用程序中的其他文件发生了更改,也不需要重新构建这一层。这一点在创建Dockerfiles时一定要注意。
    因此,通过将pip安装与应用程序其余部分的部署分离,可以优化容器的构建过程。
    构建Docker镜像
    现在Dockerfile已经准备好了,而且也了解了Docker的构建过程,接下来为我们的应用程序创建Docker镜像:
    docker build -t docker-flask:0.1 .

    调试模式运行
    根据前面讲到的容器化的优点,开发的应用程序通过容器部署,这从一开始就确保了应用程序构建的环境是干净的,从而消除了交付过程中的意外情况。
    但是呢,在开发应用程序的过程中,更重要的是要快速重新构建和测试,以检查验证过程中的每个中间步骤。为此,Web应用程序的开发人员需要依赖于Flask等框架提供的自动重启功能(Debug模式下,修改代码自动重启)。而这一功能也可以在容器中使用。
    为了启用自动重启,在启动Docker容器时将主机中的开发目录映射到容器中的app目录。这样Flask就可以监听主机中的文件变化(通过映射)来发现代码更改,并在检测到更改时自动重启应用程序。
    此外,还需要将应用程序的端口从容器转发到主机。这是为了能够让主机上的浏览器访问应用程序。
    因此,启动Docker容器时需要使用volume-mapping和port-forwarding选项:
    docker run --name flask_app -v $PWD/app:/app -p 5000:5000 docker-flask:0.1

    改命令将会执行以下操作:
    • 基于之前构建的docker-flask镜像启动一个容器;

    • 这个容器的名称被设置为flask_app 。如果没有——name选项,Docker将为容器生成一个名称。显式指定名称可以帮助我们定位容器(用来停止等操作);

    • -v选项将主机的app目录挂载到容器;

    • -p选项将容器的端口映射到主机。


    现在可以通过http://localhost:5000或者http://0.0.0.0:5000 访问到应用:
    640?wx_fmt=png
    如果我们在容器运行的时候,修改应用程序代码,Flask会检测到更改并重新启动应用程序。
    640?wx_fmt=gif
    要停止容器的话,可以使用Ctrl + C,并运行docker rm flask_app移除容器。
    生产模式运行
    虽然直接使用Flask裸跑运行应用程序对于开发来说已经足够好了,但是我们需要在生产中使用更健壮的部署方法。
    目前主流的部署方案是Nginx + uWSGI,下面我们将介绍如何为生产环境部署Web应用程序。Nginx是一个开源Web服务器,uWSGI是一个快速、自我修复、开发人员和系统管理员友好的服务器。
    首先,我们创建一个入口脚本,用来控制以开发模式还是生产模式启动我们的应用程序,这两者区别是选择直接运行Python还是Nginx模式。
    然后再写一个简单shell启动脚本entry-point.sh:
    #!/bin/bash	
    if [ ! -f /debug0 ]; then  	
      touch /debug0	
      while getopts 'hd:' flag; do	
        case "${flag}" in	
          h)	
            echo "options:"	
            echo "-h        show brief help"	
            echo "-d        debug mode, no nginx or uwsgi, direct start with 'python3 app/app.py'"	
            exit 0	
            ;;	
          d)	
            touch /debug1	
            ;;	
          *)	
            break	
            ;;	
        esac	
      done	
    fi	
    if [ -e /debug1 ]; then  	
      echo "Running app in debug mode!"	
      python3 app/app.py	
    else  	
      echo "Running app in production mode!"	
      nginx && uwsgi --ini /app.ini	
    fi  	
    Copy

    然后创建uWSGI配置文件app.ini:
    [uwsgi]	
    plugins = /usr/lib/uwsgi/plugins/python3	
    chdir = /app	
    module = app:app	
    uid = nginx	
    gid = nginx	
    socket = /run/uwsgiApp.sock	
    pidfile = /run/.pid	
    processes = 4  	
    threads = 2

    和Nginx配置文件nginx.conf:
    user nginx;	
    worker_processes  4;	
    pid /run/nginx.pid;	
    events {	
        worker_connections  20000;	
    }	
    http {	
        include    mime.types;	
        sendfile on;	
        keepalive_timeout  65;	
        gzip off;	
        server {	
            listen 80;	
            access_log off;	
            error_log off;	
            location / { try_files $uri @flaskApp; }	
            location @flaskApp {	
                include uwsgi_params;	
                uwsgi_pass unix:/run/uwsgiApp.sock;	
            }	
        }	
    }

    最后,修改Dockerfile将Nginx和uWSGI安装到镜像,将配置文件复制到镜像中,并设置运行Nginx所需的用户权限:
    FROM ubuntu:16.04	
    MAINTAINER jhao104 "j_hao104@163.com"	
    RUN apt-get update -y && \	
        apt-get install -y python3-pip python3-dev && \	
        apt-get install -y nginx uwsgi uwsgi-plugin-python3	
    COPY ./requirements.txt /requirements.txt	
    COPY ./nginx.conf /etc/nginx/nginx.conf	
    WORKDIR /	
    RUN pip3 install -r requirements.txt	
    COPY . /	
    RUN adduser --disabled-password --gecos '' nginx\	
      && chown -R nginx:nginx /app \	
      && chmod 777 /run/ -R \	
      && chmod 777 /root/ -R	
    ENTRYPOINT [ "/bin/bash", "/entry-point.sh"]

    然后重新打包镜像:
    docker build -t docker-flask:0.1 .

    然后使用Nginx启动应用程序:
    docker run -d --name flaskapp --restart=always -p 8091:80 docker-flask:0.1

    该镜像包含Python、Nginx、uWSGI完整环境,只需要在部署时指定端口映射便可以自动部署应用。要停止并删除此容器,请运行下面命令:
    docker stop flaskapp && docker rm flaskapp

    此外,如果我们仍然需要上面调试功能或修改部分代码,也可以像上面一样以调试模式运行容器:
    docker run -it --name flaskapp -p 5000:5000 -v $PWD/app:/app docker-flask:0.1 -d debug

    管理外部依赖

    640?wx_fmt=png


    如果将应用程序作为容器交付时,需要记住的一个关键事项是,开发人员管理依赖项的责任增加了。除了识别和指定正确的依赖项和版本之外,还需要负责在容器环境中安装和设置这些依赖项。
    在Python项目中管理安装依赖比较容易,可以使用requirements.txt指定依赖项和对应版本,然后通过pip安装。
    需要重申的是是,无论何时修改requirements.txt文件,都需要重新构建Docker镜像。
    启动时安装依赖项
    可能在某次版本更新时需要安装额外的依赖项。比如,在开发过程中使用了一个新的包。如果不希望每次都重新构建Docker镜像,或者希望在启动时使用最新的可用版本。可以通过修改启动程序在应用程序启动时运行安装程序来实现这一点。
    同样,我们也可以安装额外的系统级包依赖项。修改entry-point.sh:
    #!/bin/bash	
    if [ ! -f debug0 ]; then	
      touch debug0	
      if [ -e requirements_os.txt ]; then	
        apt-get install -y $(cat requirements_os.txt)	
       fi	
       if [-e requirements.txt ]; then	
        pip3 install -r requirements.txt	
       fi	
      while getopts 'hd:' flag; do	
        case "${flag}" in	
          h)	
            echo "options:"	
            echo "-h        show brief help"	
            echo "-d        debug mode, no nginx or uwsgi, direct start with 'python3 app/app.py'"	
            exit 0	
            ;;	
          d)	
            touch debug1	
            ;;	
          *)	
            break	
            ;;	
        esac	
      done	
    fi	
    if [ -e debug1 ]; then	
      echo "Running app in debug mode!"	
      python3 app/app.py	
    else	
      echo "Running app in production mode!"	
      nginx && uwsgi --ini /app.ini	
    fi

    这样我们可以在requirements_os.txt中指定将要安装的系统软件包名称,这些包名以空格分隔放在同一行。他们将和requirements.txt中的Python依赖库一样在应用程序启动之前安装。
    尽管这样对应用的迭代开发期间提供了便利,但是出于几个原因,在启动时安装依赖项不是一个好的实践:
    • 它破坏了容器化的目标之一,即修复和测试由于部署环境的变化而不会改变的依赖关系;

    • 增加了应用程序启动的额外开销,这将增加容器的启动时间;

    • 每次启动应用程序时需要安装依赖项,这样对网络资源有要求。


    原文链接:http://www.spiderpy.cn/blog/detail/46
    基于Kubernetes的DevOps实战培训

    640?


    基于Kubernetes的DevOps战培训将于2019年7月26日在上海开课,3天时间带你系统掌握Kubernetes,学习效果不好可以继续学习。本次培训包括:容器特性、镜像、网络;Kubernetes架构、核心组件、基本功能;Kubernetes设计理念、架构设计、基本功能、常用对象、设计原则;Kubernetes的数据库、运行时、网络、插件已经落地经验;微服务架构、组件、监控方案等,点击下方图片或者阅读原文链接查看详情
    640?wx_fmt=jpeg
    展开全文
  • 作者 | sitin来源 | 涛哥聊Python(ID:programmer100)周末,在一个技术群里面有同学在问Django开发部署,所以今天给大家分享一下基于Doc...
  • 在Docker容器部署相互依赖的应用

    千次阅读 2018-06-01 16:22:21
    在上一篇文章中介绍了如何在Docker中部署单独的Spring Boot应用。使用Docker命令和Dockerfile文件特别适合创建单独的容器。但如果你想在相互孤立的应用中建立网络通信互相调用,容器管理将很快变得非常混乱。为解决...
  • 在 CentOS 7 中安装 Docker 和创建 Tomcat 容器部署Web应用 一般部署Web应用都需要安装数据库,比如 MySQL 和 Redis,MySQL 和 Redis 属于多个Web应用公用的系统,所以就不需要安装到 Docker 里了,直接在操作...
  • docker运行的每个容器都是隔离的,redis默认不允许外部连接,因此想要部署在docker容器内的应用连接上redis,需要修改redis默认配置,这里我们以配置文件运行redis即可。 拉取redis容器 docker pull redis 指定版本...
  • Docker 多容器复杂应用部署

    千次阅读 2018-05-04 20:29:26
    1.在某个文件中放入一个python flask项目...由于需要redis,我们将redis单独作为一个容器,创建redis容器:docker run -d --name redis redis4.将项目build成一个镜像:docker build -t 15091302@qq.com/flask-redis...
  • SpringBoot应用部署于外置Tomcat容器

    万次阅读 2018-06-05 07:18:26
    0x01. 概述 SpringBoot平时我们用的爽歪歪,爽到它自己连Tomcat都自集成了,我们可以直接编写SBT...此时我们需要剥离掉SBT应用内置的Tomcat服务器,进而将应用发布并部署到外置的Tomcat容器之中,本文就实践一下这...
  • 利用Amazon ECR和ECS部署容器应用

    千次阅读 2019-09-02 12:44:19
    众所周知现在容器的技术越来越火,很多企业已经将整个业务架构容器化,利用容器的灵活性、可移植性、轻量等优势为企业开发和运维带来很大的优势,目前整个容器编排服务中最吃香的当然是Kubernetes (简称K8S),...
  • Docker 容器化技术介绍(一) 之 虚拟化技术 Docker 容器化技术介绍(二) 之 Docker 简介 Docker 容器化技术介绍(三) 之 Docker 组件 Docker 容器化技术介绍(四) 之 Docker的安装与启动 Docker 容器化技术...
  • 本文的范围是比较可用于我们的应用程序部署用例的各种部署模型。本文假设读者将具备虚拟机,容器和管理程序的基本知识。 1.简介 有一系列技术可用于将应用程序部署到生产环境,选择正确的策略是特定用例的重要决策...
  • linux下使用docker容器部署web应用

    千次阅读 2020-01-19 13:31:14
    Docker 是一个开源的应用容器引擎,基于 Go 语言 并遵从 Apache2.0 协议开源。 Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中,然后发布到任何流行的 Linux 机器上,也可以实现虚拟化。...
  • Spring Boot 应用服务部署有两种, 一种是传统的部署方式(没试验,暂时不清楚), 一种是使用Spring Boot内嵌的容器(tomcat 或者 jetty),本文介绍本文介绍的是基于内嵌的tomcat容器进行部署

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 237,981
精华内容 95,192
关键字:

容器应用部署