Parece que é assim? Conectamos o fabric8-maven-plugin ao projeto e vamos: construindo, executando o aplicativo no OpenShift. Mas, quando estudei, queria entender melhor esse processo e, em seguida, queria ter mais controle e liberdade sobre o processo de criação e implantação do aplicativo no OpenShift. Portanto, o cenário a seguir resultou com esses recursos.- Eu mesmo construo o artefato, com minha ferramenta (maven, gradle etc.)
- Eu controlo a criação do Docker Image através do Dockerfile
- O processo de compilação e implantação no Openshift está configurado no modelo, ou seja, qualquer especificação de contêiner, o pod é personalizável.
- Assim, o próprio processo pode ser transferido para um conjunto externo, sistema de implantação
Obviamente, para isso, uso os recursos disponíveis do próprio OpenShift, que são abundantes.E assim eu tenho um artefato java preparado, então eu preparo um Dockerfile com as características e funcionalidades necessáriasDockerfile
FROM openjdk
MAINTAINER Rylkov Alexander <arylkov@.>
COPY demo.springboot.mvn-0.0.1-SNAPSHOT.jar /deployments/app.jar
ENV JAVA_OPTS="$JAVA_OPTS -Xms500m -Xmx1024m"
EXPOSE 8080
EXPOSE 5005
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar /deployments/app.jar" ]
Assim, haverá dois arquivos na pasta: o artefato e o Dockerfile.A
composição dos arquivos é condicional, se, por exemplo, no Dockerfile forem necessários arquivos adicionais para a imagem do Dockerfile, os adicionaremos aqui. Agora, a imagem java básica e meu aplicativo de inicialização Spring são especificados no Dockerfile, duas portas estão abertas etc.Nesta etapa, temos a opção / liberdade na ferramenta para criar o aplicativo e montar a imagem do Docker.Em seguida, eu preparo o modelo OpenShift para o aplicativo; essa operação pode ser única, só precisa ser parametrizada. Como ele pode conter todo o possível para criar, iniciar e operar o aplicativo, gerenciaremos esses processos por meio dele. Será bem simples para mim e consistirá nas três configurações mais necessárias- Imagestream
- Buildconfig
- DeploymentConfig
Modelo java-app-samplekind: Template
apiVersion: v1
metadata:
labels:
app: java-app-sample
name: java-app-sample
annotations:
description: >-
This example shows how to create a simple Java application in openshift
tags: java
parameters:
- name: APP_NAME
description: application name
value: app-sample
required: true
objects:
- kind: ImageStream
apiVersion: v1
metadata:
name: "${APP_NAME}"
spec:
tags:
- from:
kind: DockerImage
name: 172.30.1.1:5000/myproject/${APP_NAME}:latest
name: latest
- kind: BuildConfig
apiVersion: v1
metadata:
name: "${APP_NAME}"
labels:
name: "${APP_NAME}"
spec:
source:
binary: {}
type: Binary
strategy:
type: Docker
output:
to:
kind: DockerImage
name: 172.30.1.1:5000/myproject/${APP_NAME}:latest
postCommit: {}
resources: {}
- kind: DeploymentConfig
apiVersion: v1
metadata:
name: "${APP_NAME}"
spec:
strategy:
type: Rolling
rollingParams:
updatePeriodSeconds: 1
intervalSeconds: 1
timeoutSeconds: 120
resources: {}
replicas: 1
selector:
app: "${APP_NAME}"
template:
metadata:
labels:
app: "${APP_NAME}"
spec:
containers:
- name: "${APP_NAME}"
image: 172.30.1.1:5000/myproject/${APP_NAME}:latest
ports:
- containerPort: 8080
protocol: TCP
- containerPort: 5005
protocol: TCP
env:
- name: TZ
value: Europe/Moscow
resources:
limits:
cpu: '0.5'
memory: 1000Mi
requests:
cpu: '0.2'
memory: 500Mi
imagePullPolicy: Always
restartPolicy: Always
dnsPolicy: ClusterFirst
triggers:
- type: ConfigChange
imageChangeParams:
automatic: true
containerNames:
- "${APP_NAME}"
from:
kind: ImageStreamTag
name: 172.30.1.1:5000/myproject/${APP_NAME}:latest
- type: ImageChange
status: {}
Alguns parâmetros do contêiner são indicados no modelo como um exemplo, por exemplo, recursos / limites, variável de ambiente TZ, um parâmetro do modelo é especificado - nome do aplicativo (APP_NAME). O endereço da janela de encaixe do registro é especificado para a versão minishift (eu o uso localmente para o desenvolvimento 172.30.1.1►000 / myproject /) e outros.Mas, no meu cenário, a coisa mais importante é indicada aqui - kind: BuildConfig
spec:
source:
binary: {}
type: Binary
strategy:
type: Docker
O BuildConfig diz que a fonte será o (s) arquivo (s) binário (s) e para gerenciar a estratégia de preparação da imagem do docker - Dockerfile (tipo: Docker)Vamos criar este modelo no OpenShift oc create -f template.yaml
Este modelo aparecerá no diretório de modelos (será possível organizar o processo no console da interface da web, mas não aqui).
Usando este modelo, criaremos um aplicativo (na verdade, isso é apenas um nome e não mais)oc new-app java-app-sample -p APP_NAME=app-sample
especifique o nome do modelo e o parâmetro do nome do aplicativo
Três de minhas configurações foram criadas.Iniciamos o processo de montagem e implantação do aplicativo no contêiner.>oc start-build app-sample --from-dir . --follow
É importante executar a partir da pasta em que o arquivo binário e o Dockerfile estão especificados, apenas o parâmetro --from-dir indica que toda a pasta estará preparada para carregar no OpenShift para criar e implantar imagens no registro da janela de encaixe. Existem outros parâmetros desse comando, por exemplo, do arquivo morto.
Vimos que o conteúdo da pasta foi carregado no OpenShift, que iniciou o processo do Docker para preparar a Imagem para o Dockerfile e finalmente colocou a imagem no registro da janela de encaixe.O aplicativo foi iniciado
no console da Web OpenShift. Os parâmetros do contêiner especificados na configuração são
especificados. A variável de ambiente especificada na configuração é
registrada.
Assim, sem plug-ins adicionais, com controle máximo e liberdade de escolha, conseguimos colocar o aplicativo no OpenShift.MateriaisInstalando o Minishiftpara aprender sobre o OpenShift, eu recomendo começar com o Minishift