Categorías
Python

Primeros pasos con Python IDLE

 

Tabla de Contenidos

  • flujo de trabajo
  • Por qué Docker? Configuración
  • acoplable
  • crear una nueva máquina
  • Componer arriba!
  • generar y ejecutar
  • próximos pasos
  • acoplable HubDocker Hub de CI
  • acoplable Hub de CI
  • CircleCISetupFeature Branch WorkflowCreate la BranchUpdate Característica del AppIssue un tirón Solicitud
  • Configuración
  • de ramas de características de flujo de trabajo
  • crear la operación Branch
  • actualizar la aplicación
  • Emitir un tirón Solicitud
  • Conclusión
  • acoplable Hub para la instalación IC
  • de ramas de características de flujo de trabajo
  • crear la operación Branch
  • actualizar la aplicación
  • Emitir un tirón Solicitud

con acoplable que puede implementar fácilmente una aplicación web, junto con sus dependencias, las variables de entorno y los valores de configuración – todo lo necesario para recrear su entorno de forma rápida y eficiente.

este tutorial mira precisamente eso.

Vamos a empezar por crear un contenedor acoplable para el funcionamiento de una aplicación Python frasco. A partir de ahí, vamos a ver un desarrollo buen flujo de trabajo para gestionar el desarrollo local de una aplicación, así como la integración continua y la entrega, paso a paso …

I (Michael Herman) presentó originalmente este flujo de trabajo en PyTennessee el 8 de febrero, 2015. puede ver las diapositivas aquí, si está interesado.

Actualizado 04/04/2019 : Mejorado Docker (v18.09.2), acoplable Componer (v1.23.2), acoplable Máquina (v0.16.1), Python (v3.7.3), y CircleCI (v2). Gracias Florian Dahlitz!

Actualizado 02/28/2015 : Agregado acoplable Componer y actualizado del estibador y boot2docker a las últimas versiones.

flujo de trabajo

Este tutorial es para usuarios de Mac OS X, y vamos a estar utilizando las siguientes herramientas / tecnologías v3.7.3 – Python, v1.0.2 Frasco, v18.09.2 estibador, acoplable Componer v1.23.2 , acoplable máquina 0.16.1, obtener de Redis v5.0.4

Vamos a ello …

en primer lugar, algunos términos específicos acoplable:

  • un Dockerfile es un archivo que contiene un conjunto de instrucciones que se utilizan para crear una imagen. Una imagen
  • se utiliza para construir y guardar instantáneas (el Estado) de un entorno.
  • Un contenedor es una imagen en directo instancia que ejecuta un conjunto de procesos.

Asegúrese de revisar la documentación del estibador para obtener más información sobre Dockerfiles, imágenes y contenedores.

Por qué estibador?

que realmente puede imitar su entorno de producción en la máquina local. Ya no tendrá que errores específicos de depuración del entorno o preocuparse de que su aplicación se realice de manera diferente en la producción. Configuración

acoplable

Para poder ejecutar los contenedores Docker en nuestro sistema Mac OS X que necesitamos para instalar acoplable Desktop para Mac.If está utilizando un sistema Windows, asegúrese de que la caja acoplable Desktop para Windows.If está utilizando mayores versiones de Mac OS X o Windows, usted debe tratar importa acoplable Caja de herramientas instead.No cuya instalación se recogen basado en su sistema operativo, el resultado final será tener las tres principales herramientas acoplables instalados: Docker (CLI), acoplable componer y acoplable máquina.

Ahora vamos a comprobar su instalación acoplable:

$ docker --version
Docker version 18.09.2, build 6247962
$ docker-compose --version
docker-compose version 1.23.2, build 1110ad01
$ docker-machine --version
docker-machine version 0.16.1, build cce350d7

crear una nueva máquina

Antes de poder empezar a desarrollar, tenemos que crear una nueva ventana acoplable machine.As queremos desarrollar algo, vamos a llamar a la nueva dev máquina:

$ docker-machine create -d virtualbox dev;
Creating CA: /Users/realpython/.docker/machine/certs/ca.pem
Creating client certificate: /Users/realpython/.docker/machine/certs/cert.pem
Running pre-create checks...
(dev) Image cache directory does not exist, creating it at /Users/realpython/.docker/machine/cache...
(dev) No default Boot2Docker ISO found locally, downloading the latest release...
(dev) Latest release for github.com/boot2docker/boot2docker is v18.09.3
(dev) Downloading /Users/realpython/.docker/machine/cache/boot2docker.iso from https://github.com/boot2docker/boot2docker/releases/download/v18.09.3/boot2docker.iso...
(dev) 0%....10%....20%....30%....40%....50%....60%....70%....80%....90%....100%
Creating machine...
(dev) Copying /Users/realpython/.docker/machine/cache/boot2docker.iso to /Users/realpython/.docker/machine/machines/dev/boot2docker.iso...
(dev) Creating VirtualBox VM...
(dev) Creating SSH key...
(dev) Starting the VM...
(dev) Check network to re-create if needed...
(dev) Found a new host-only adapter: "vboxnet0"
(dev) Waiting for an IP...
Waiting for machine to be running, this may take a few minutes...
Detecting operating system of created instance...
Waiting for SSH to be available...
Detecting the provisioner...
Provisioning with boot2docker...
Copying certs to the local machine directory...
Copying certs to the remote machine...
Setting Docker configuration on the remote daemon...
Checking connection to Docker...
Docker is up and running!
To see how to connect your Docker Client to the Docker Engine running on this virtual machine, run: docker-machine env dev

dejar que el punto de cliente acoplable a la nueva máquina a través de:

$ eval $(docker-machine env dev)

Ejecutar el siguiente comando para ver las máquinas actualmente en ejecución:

$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
dev * virtualbox Running tcp://192.168.99.100:2376 v18.09.3

Componer arriba!

acoplable Componer es un marco de orquestación que se encarga de la construcción y explotación de servicios múltiples (a través de recipientes separados) usando un simple .yml file.It hace que sea muy fácil de ejecutar los servicios de enlace juntos en diferentes contenedores.

inicio clonando el repositorio de GitHub usando git:

$ git clone https://github.com/realpython/fitter-happier-docker
$ cd fitter-happier-docker
$ tree .
.
├── article.md
├── circle.yml
├── docker-compose.yml
├── presentation
│ ├── images
│ │ ├── circleci.png
│ │ ├── docker-logo.jpg
│ │ ├── fig.png
│ │ ├── figup.png
│ │ ├── heart.jpg
│ │ ├── holy-grail.jpg
│ │ ├── oh-my.jpg
│ │ ├── rp_logo_color_small.png
│ │ └── steps.jpg
│ └── presentation.md
├── readme.md
└── web
├── Dockerfile
├── app.py
├── requirements.txt
└── tests.py

3 directories, 18 files

Ahora vamos a nuestra aplicación Frasco en funcionamiento junto con Redis. de

Let echar un vistazo a la ventana acoplable -compose.yml en el directorio raíz:

version: '3'

services:
web:
build: ./web
volumes:
- ./web:/code
ports:
- "80:5000"
links:
- redis:redis
command: python app.py
redis:
image: redis:5.0.4
ports:
- "6379:6379"
volumes:
- db-data:/data

volumes:
db-data:

Aquí añadir los servicios que componen nuestra pila:?

¿Se notaron los Dockerfile en el directorio “web” Este archivo se utiliza para construir nuestra imagen, a partir de una imagen base oficial de Python, las dependencias requeridas están instaladas y la aplicación se construye.

generar y ejecutar

Con un simple comando podemos construir la imagen y ejecutar el contenedor:

$ docker-compose up --build

Este comando construye una imagen de nuestra aplicación Frasco, tira de la imagen Redis, y luego empieza todo.

tomar una taza de café. O dos. Esto tomará algún tiempo la primera vez que genere el contenedor. Dicho esto, ya que almacena en caché acoplable cada paso (o capa ) del proceso de construcción de la Dockerfile, la reconstrucción va a pasar mucho más rápido, ya que sólo las medidas que se cambiaron desde la última construcción se reconstruyen.

Si cambia una línea / paso / capa de la Dockerfile, se recrean / a reconstruir todo lo que a partir de esa línea – así que ser conscientes de esto cuando la estructura de su Dockerfile.

acoplable Componer trae cada contenedor hasta a la vez en paralelo. Cada contenedor también tiene un nombre único y cada proceso dentro de la traza de la pila / log es un código de colores para facilitar la lectura.

listo para la prueba?

Abra su navegador Web y vaya a la dirección IP asociada a la variable DOCKER_HOST – es decir, http://192.168.99.100/, en este ejemplo. (Run ventana acoplable-máquina ip dev para obtener la dirección.)

Debería ver el texto “¡Hola! Esta página ha sido visto 1 veces “. en su navegador:

Actualizar. El contador de páginas debería haber incrementado.

Kill los procesos (Ctrl + C), y a continuación, ejecutar el siguiente comando para ejecutar el proceso en el fondo.

$ docker-compose up -d

No necesitamos para fijar la bandera –build como las imágenes ya fueron construidos.

desea ver los procesos actualmente en ejecución?

$ docker-compose ps
Name Command State Ports
-----------------------------------------------------------------------------------------------
fitter-happier-docker_redis_1 docker-entrypoint.sh redis ... Up 0.0.0.0:6379->6379cp
fitter-happier-docker_web_1 python app.py Up 0.0.0.0:80->5000cp

Ambos procesos se están ejecutando en un recipiente diferente, conectado a través del estibador Componer!

próximos pasos

Una vez hecho esto, matar a los procesos a través de abajo de composición del cargador de muelle. Confirmar los cambios a nivel local, y luego empujar a Github.

Así que, ¿qué podemos lograr?

Establecemos el medio ambiente local, detallando el proceso básico de la construcción de una imagen de un Dockerfile y luego la creación de una instancia de la imagen llama un contenedor .We atado todo junto con acoplable Componer para construir y conectar diferentes contenedores s tanto para la aplicación y el proceso Frasco Redis.

Ahora, Echemos un vistazo a una buena integración continua del flujo de trabajo impulsado por CircleCI .

acoplable Hub

Hasta ahora hemos trabajado con Dockerfiles, imágenes y contenedores (abstraídos por acoplable Componer, por supuesto).

¿Está familiarizado con el flujo de trabajo Git? Las imágenes son como repositorios Git mientras que los contenedores son similares a un repository.Sticking clonado con esa metáfora, acoplable Hub, que es repositorio de imágenes Docker, es similar a Github.

Una vez añadido, esto dará lugar a la generación inicial. Asegúrese de que la construcción es exitosa.

acoplable Hub de CI

acoplable Hub, en sí mismo, actúa como un servidor de integración continua ya que se puede configurar para crear una construcción automática cada vez que se coloca un nuevo comprometen a Github.In otras palabras, se asegura que no causan una regresión que rompe por completo el proceso de construcción cuando se actualiza la base de código.

Hay algunas desventajas de este enfoque – a saber, que no se puede empujar (a través de empuje ventana acoplable) actualizada imágenes directamente a acoplable Hub.Docker concentrador debe traer cambios desde tu repositorio y crear las propias imágenes para asegurarse de que su son sin errors.Keep esto en mente a medida que avanza a través de esta documentación workflow.The Docker no es clara con respecto a este asunto. La prueba de

Let esto. Añadir una aserción que el conjunto de pruebas:

self.assertNotEqual(four, 102)

Commit y empujar a Github para generar una nueva construcción en acoplable Hub.Success?

Línea de fondo: buena de para saber que si un commit tenga como consecuencia una regresión que acoplable Hub atraparlo, pero ya que esta es la última línea de defensa antes de desplegar (ya sea de ensayo o de producción) que idealmente se desea capturar los saltos antes de generar una nueva construcción en acoplable Hub.Plus, también quieren hacer funcionar su unidad y pruebas de integración de un servidor de integración continua cierto – que es exactamente donde CircleCI entra en juego.

CircleCI

CircleCI es una integración continua y la plataforma de entrega de que los soportes de pruebas dentro de Docker containers.Given un Dockerfile, CircleCI construye una imagen, se inicia un nuevo contenedor, y a continuación, ejecuta las pruebas dentro de ese contenedor.

Recuerde que el flujo de trabajo que queremos? Enlace.

vamos a echar un vistazo a cómo lograr que …

Configuración

El mejor lugar para comenzar es la excelente guía de Introducción a CircleCI …

sesión con su cuenta de Github, a continuación, añadir el Github repositorios para crear un nuevo project.This añadirá automáticamente una web hook para el repositorio de manera que en cualquier momento se presiona a Github una nueva construcción es triggered.You debe recibir un correo electrónico una vez que se añade el gancho. archivo de configuración

El CircleCI está situado en la década de .circleci directory.Let echar un vistazo a la config.yml :

version: 2
jobs:
build:
docker:
- image: circleci/python:3.7.3

working_directory: ~/repo

steps:
- checkout

- setup_remote_docker:
docker_layer_caching: true
version: 18.06.0-ce

- run:
name: Install Docker client
command: |
set -x
VER="17.03.0-ce"
curl -L -o mp/docker-$VER.tgz https://download.docker.com/linux/static/stable/x86_64/docker-$VER.tgz
tar -xz -C mp -f mp/docker-$VER.tgz
sudo mv mp/docker/* /usr/bin

- run:
name: run tests
command: |
docker image build -t fitter-happier-docker web
docker container run -d fitter-happier-docker python -m unittest discover web

- store_artifacts:
path: test-reports
destination: test-reports

publish-image:
machine: true
steps:
- checkout

- deploy:
name: Publish application to Docker Hub
command: |
docker login -u $DOCKER_HUB_USER_ID -p $DOCKER_HUB_PWD
docker image build -t fitter-happier-docker web
docker tag fitter-happier-docker $DOCKER_HUB_USER_ID/fitter-happier-docker:$CIRCLE_SHA1
docker tag fitter-happier-docker $DOCKER_HUB_USER_ID/fitter-happier-docker:latest
docker push $DOCKER_HUB_USER_ID/fitter-happier-docker:$CIRCLE_SHA1
docker push $DOCKER_HUB_USER_ID/fitter-happier-docker:latest

workflows:
version: 2
build-master:
jobs:
- build
- publish-image:
requires:
- build
filters:
branches:
only: master

Básicamente, se definen dos jobs.First, hemos creado nuestro entorno estibador, construir la imagen y ejecutar el tests.Second, hacemos uso de la imagen para acoplable concentradores.

Por otra parte, se define un flujo de trabajo .¿Por qué necesitamos un flujo de trabajo ? Como se puede ver, el trabajo acumulación siempre se ejecuta mientras que la publicar la imagen trabajo solamente se ejecuta en maestra como que don’ t desea publicar una nueva imagen al abrir una nueva solicitud de extracción.

Puede establecer las variables de entorno y DOCKER_HUB_USER_ID DOCKER_HUB_PWD en la configuración del proyecto de CircleCI.

Con el archivo config.yml creado, empujar los cambios en Github para desencadenar una nueva construcción. Recuerde: esto también dará lugar a una nueva construcción en acoplable concentradores.

éxito?

Antes de continuar, tenemos que cambiar nuestro flujo de trabajo ya que no estará empujando directamente a la rama principal más.

de ramas de características de flujo de trabajo

Por estas familiarizado con el flujo de trabajo de ramas de características, echa un vistazo a este excelente introducción. plazo de

Vamos a través de un ejemplo rápido …

crear la operación Branch

$ git checkout -b circle-test master
Switched to a new branch 'circle-test'

actualizar la aplicación

Añadir un nuevo aserción en tests.py :

self.assertNotEqual(four, 60)

Emitir una Solicitud de tracción

$ git add webests.py
$ git commit -m "circle-test"
$ git push origin circle-test

Incluso antes de crear el actual solicitud de extracción, CircleCI empieza a crear la build.Go adelante y crear la solicitud de extracción, a continuación, una vez que las pruebas pasan en CircleCI, pulse el Combinar button.Once fusionó, la acumulación se activa el estibador de concentradores.

Conclusión

Así, fuimos más de un flujo de trabajo de desarrollo agradable que incluye la creación de un entorno local junto con la integración continua a través de CircleCI (pasos 1 a 6):

¿Qué pasa con la pieza final – la entrega de esta aplicación para el entorno de producción ( paso 7)? En realidad se puede seguir a otro de mis entradas de blog acoplables para extender este flujo de trabajo para incluir la entrega.

comentario a continuación si tiene alguna pregunta. Coge el código final aquí. ¡Salud!

Si usted tiene un flujo de trabajo de su cuenta, por favor sepamos. Actualmente estoy experimentando con sal, así como a una mejor orquestación Tutum mango y la entrega a Océano Digital y Linode.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *