Transcrições
1. Introdução ao pipeline: Ei, olha aqui, defenda o campeão,
defenda o campeão. Para você realmente
chegar aqui, você é um campeão absoluto. Você conseguiu
concluir a primeira aula, que é o
módulo principal que ela apresenta, e agora está
aqui para entender o pipeline do CICD e
ver como tudo
acontecerá de ponta a ponta Observe que
analisaremos o CICD central, o
que ele envolve, coisas como Injetando variáveis de ambiente, injetando segredos,
usando ações personalizadas, armazenamento e download de
artefatos, destruindo imagens do Docker ou fazendo login e enviando
para o DockerHub, tudo isso você encontrará nesta mesma classe. Eu vou
te levar antes de tudo, você passará por
uma situação muito agnóstica Essa é uma etapa agnóstica modulítica
. Nós simplesmente queremos dizer. Isso é bom
para bebês, na verdade. Simplesmente queremos dizer que vou levar isso a sério
pelo pipeline, sem favorecer nenhuma
linguagem de programação ou qualquer aplicativo Em seguida, personalizamos
as coisas ou as trazemos para casa para
que você veja como
aplicar ao aplicativo
modular que você criou na
primeira classe, certo Esse e muitos outros
vocês verão esse caso, que promete ser acelerado
e muito envolvente Nos vemos no próximo vídeo.
2. Ferramentas de pipeline necessárias: Oi, todo mundo.
Vamos falar sobre as
ferramentas usadas nesta aula. Muito fácil. Ainda
vamos manter nosso IDE. Não vamos usar
nada diferente. Vamos construir diretamente
dentro do Intellig. Inteligência apenas o suficiente. Estamos apenas aproveitando
o Intellig e o Github. Isso é tudo o que precisamos.
Com esse conjunto , nos vemos no próximo vídeo.
3. Fluxograma de tubulação: Oi, todo mundo. Z aqui. OK. Esta seção
se concentra principalmente em tentar automatizar
nossa imagem, mas Já entramos antes, na sessão
Do We, essa é a própria
produção. O que fizemos foi tentar
criar a imagem manualmente. Executamos o manual de
comando do Docker. Não precisamos fazer isso.
Felizmente para nós, usaremos as ações do
Git, certo? Portanto, a ideia por trás da ideia por trás do uso de um pipeline
tem tudo a ver com automação, tentando eliminar as entradas do usuário Isso é o que estamos
tentando fazer. Depois de configurá-lo, você pode ter certeza de que,
além de testado, é infalível, então
você sobrecarrega É isso que
pretendemos fazer aqui. Aproveitando isso, em primeiro lugar, vamos ter uma ideia do
que pretendemos fazer Eu vou usar Jerod Ohio. Essa é uma ferramenta gratuita, que
você também pode usar, certo? Acho que são meus projetos anteriores.
Deixe-me apenas descartar. Sim, eu
já tenho tudo pronto. Apenas assuma o controle. OK. Tudo bem. Então,
vamos aproveitar um pouco do que
pretendemos construir. O que faremos é que teremos
duas seções, certo? Nós vamos ter
essas duas seções. A primeira seção será a seção de beleza, certo? Teremos
a seção Mas. Deixe-me trazer isso.
Deixe-me escolher uma imagem. Deixe-me escolher isso, os generais acham que acho que isso
deve ser suficiente T deve ser suficiente. OK.
Então, acho que vamos ter que pegar uma mensagem. Então, vamos ter
a seção Mas. Ok, então vamos
ter duas seções. Vamos deixar as seções. Você tem duas seções,
as seções serão a seção de construção
e, em seguida, também
teremos a imagem push. Vamos chamá-la de seção push
image, certo? Precisamos entender
o que isso faz, então isso nos dá uma boa ideia do que
queremos fazer. Tudo bem. Vou tentar representar isso de forma diagramática
. Vamos começar. Sim. Então, quando você
envia seu código, certo, o que você
espera que aconteça? Envie seu código, você quer algo como um laboratório
de tubulação
automatizado para executar seu código.
Depois de executar seu código, provavelmente em um ambiente
virtual ou em um ambiente específico, tente criar suas dependências
móveis, extrair todos os detalhes, certo? Então, vamos manter isso em mente. Sempre nos referimos a esse
cara enquanto construímos. A primeira coisa é quando enviamos, então vamos rotular esse código push. Essa é a única etapa que você provavelmente precisará
executar para enviar seu código. Então, depois de inserir seu código, clique. Depois de enviar seu código, o próximo passo é que você deseja enviar
o ambiente virtual. Deixe-me rotular isso como um ambiente
virtual. Vamos escolher isso. Escolha
essa entropia Vamos chamá-lo de ambiente
virtual, vamos chamá-lo via ambiente
virtual. Vamos chamá-lo de ambientes
literais virtuais,
ambientes ou contêineres,
seja o que for, certo? É aqui que seu
código será colocado. Então, uma vez que você tem isso, a próxima coisa é o que você quer que
aconteça com esse cara? O que você quer que aconteça é
configurar seu Java,
configurar o Java Beameber
como um ambiente local,
você precisa configurar o
Java, configurar o Maven, configurar o Maven e, em seguida, extrair dependências, extrair
dependências Dependências. Eu escrevo
essas dependências Extraia dependências, certo? Quando você conseguir fazer isso, extraímos dependências que basicamente
queremos executar que queremos fazer é analisar qual é a próxima etapa que
você provavelmente deseja fazer. A próxima etapa será
extrair dependências. Depois de configurar o Java
ou o ambiente, podemos colocar dependências O que o aninhamento quer fazer? Queremos construir a imagem. Queremos construir a imagem. Vamos mover isso para
outra seção. Chame isso de imagem. Mas imagem. Vamos usar uma seta
para a dicção do fluxo. Vamos pegar essas coisas na produção de fluxo do
céu. Esse cara vem aqui.
Então temos isso. Então, também temos esse direito. Ok, então imagem de beleza.
Então é isso que acontece. Então, no momento em que você pressiona
um código para se levantar, isso acontece e, em seguida,
cria uma imagem. Depois de criar sua imagem, você constrói seu frasco. Desculpe, este deve ser um arquivo Jar de beleza, não uma imagem, um frasco.
Isso é o que eu quero dizer. Desculpe. Arquivo So But Ja. Depois de criar o arquivo Ja,
o que você quer fazer? Lembre-se de que temos um comando que
faz isso , que é o Mv no
pacote limpo. Lembre-se disso. Então é isso que vamos
usar. Em seguida, Build Jar, digamos But Jar com perfil. Lembre-se de que especificamos muitos perfis, quais são os
perfis que temos? Deixe-me verificar o custo
novamente. Esse é o módulo. Temos o Dev, o Docker. Não queremos usar o Dev, porque esse é meu ambiente
local. Provavelmente queremos
usar isso, eu diria,
vamos, mas acho que isso
será suficiente. Vamos usar esse perfil
que é Docker. Se você estiver usando o
perfil, que é o Docker. Certo? Se você estiver usando, então temos que especificar
o perfil docker Mas jarra com perfil. Eu acredito que vocês entendem o que estou
tentando trazer aqui. OK. Vamos garantir que o arquivo
Ja seja bem-sucedido. Vamos garantir que o
arquivo Ja seja bem-sucedido. Vamos fazer isso,
vamos listar o arquivo. Vamos listar os erros do arquivo. Isso nos dará uma boa ideia se tivermos amadurecido, certo? Feito a redação. Então,
vamos chamar isso, por que vamos chamá-lo de arquivos de lista. Quando digo listar arquivos, queremos listar qual é o jar que foi construído no
diretório ou algo parecido. Agora, isso é mais
parecido com o primeiro passo. No entanto, é um ambiente
virtual. Essa é a primeira etapa
da construção da imagem. Agora, queremos ir
para outra seção, essa seção será
um caso em que queremos empurrar a imagem, certo? Agora você quer criar
a imagem em si. Esse é o desejo de criar a
imagem do aplicativo, eles querem impulsionar. Então, para fazer isso, certo,
vou adicionar
mais duas etapas a isso. Você pode fazer tudo isso
de uma só vez, certo? Mas vou adicionar mais
duas etapas a isso. E o motivo é porque
eu deliberadamente quero
mostrar a vocês algumas características
sobre ações de engrenagem, certo? Então, características sobre a ação da engrenagem. Então, o que eu
faria é entrar aqui e dizer que vamos levantar o
artefato. Agora, por que isso é necessário? Isso é necessário porque sempre
podemos acionar o mesmo trabalho ou salvar nossos artefatos, mas usaremos
isso para mais tarde Eu vou dizer que
carregue artefatos. Isso é muito essencial. Quando descobrir que há uma parte em que você
pode facilmente armazenar coisas em cache, não para realmente, cara, que
veremos principalmente
nesta seção , porque
não queremos extrair as
dependências toda Queremos realmente armazenar em cache para garantir que as coisas
realmente se movam. Então, empurramos a imagem, configuramos nossos detalhes, construímos o frasco
com o perfil. Eles querem listar
os arquivos que queremos
usar e que são necessários
para criar a imagem. O arquivo que é
necessário, aparentemente, acho que precisamos
pensar sobre isso, acho que precisamos do nosso arquivo JA,
precisamos do nosso arquivo docker Esses são basicamente
os dois arquivos principais que precisamos para realmente criar nossa imagem, porque o arquivo
Docker nos dirá exatamente como
queremos criar a imagem Então, o arquivo Ja é
basicamente o guia que executamos dentro do contêiner.
Queremos fazer o upload. Deixe-me ser consistente,
faça o upload do artefato. Etapa um. Nós temos isso. Etapa dois. Etapa dois agora, o que estamos fazendo na etapa
dois? Queremos levar isso. Queremos baixar
os artefatos. Deseja baixar os
artefatos Artifacts, T no download Depois de baixar o artefato, vamos gerar o conteúdo Vamos também listar o
conteúdo que temos. Vamos listar isso. Vamos
listar o conteúdo. Vamos listar o conteúdo. Vamos listar o conteúdo. Vamos ter
certeza de que o que enviamos é o
mesmo que baixamos, certo? Vamos listar o conteúdo. Eu sei por que é bonito, mas eu
só quero explicar. Então, uma vez que tenhamos feito
isso, agora temos isso. A próxima etapa é basicamente
que queremos fazer o login. Lembre-se de que você está
usando o Docker Hub ou deseja enviar o Docker
Hub por meio de um registro privado Ou o Docker Hub é um registro
privado, você basicamente precisa fazer login, você precisa fazer login no
ambiente Para o Docker, eu faço o login do Docker. Há um comando chamado Docker login que você realmente
precisa usar, mas é uma
maneira melhor de ver Aqui dizemos que vamos fazer o login. Vou apenas dizer login do Docker. Então, vou fazer o login. Então, ao fazer login, isso realmente me
daria acesso
total ao ambiente à
minha conta do Docker Hub.
Então eu vou fazer isso. Então, tudo bem. Tudo bem, então faça o login. Lembre-se de que essas etapas
são sequenciais. Isso é eu colocá-los desta forma. Em seguida, fazemos login. Então
o que você quer fazer? Então, após o login, acho que
a próxima etapa está clara. Nós visualizamos e enviamos a imagem. Agora, deveria ser
Bute e depois empurrar, mas vou colocá-lo
junto e você verá o porquê Você verá o porquê daqui a pouco. Então
chame isso de Bute e empurre Então,
porque há algo que
vou mostrar a vocês
que é realmente incrível. Em vez de construir
um degrau e construir, temos algo como:
Ok, deixe-me tirar o
recorte da sacola. Isso é basicamente o que
veremos na
próxima seção, certo? Então, vamos criar e
enviar para o Docker Hub, certo? Então, uma vez que tenhamos feito isso, acho que nossas etapas estão
praticamente concluídas, certo? Nossas etapas estão
quase concluídas. Então, porque esse é
o objetivo principal. O objetivo principal é que,
quando enviamos a imagem, queremos
enviá-la para o Github, tenhamos um ambiente virtual
ativado automaticamente e isso realmente
criará esses detalhes Depois de criar detalhes de Java, o Mv, inserir
as dependências, eles querem pegar outro gatilho
para mais tarde . Depois fazer isso,
você cria o jar Depois de criar o jar, quero listar o arquivo e
os arquivos basicamente aqui são o Dockerfile
e o arquivo jar Eles querem fazer o upload do
artefato para usarmos mais tarde. Esse é o primeiro passo. Em seguida ,
segundo passo, você quer entrar aqui, baixar o artefato
que você carregou aqui, listar o conteúdo para ter certeza é o mesmo
que temos aqui Em seguida, fazemos login,
não compramos a imagem, não enviamos para o Docker Hub Estou usando minha conta privada. OK. Dito isso, o que vou fazer é
salvar isso e mostrar parte dos arquivos. Então, vou enviar essa
imagem
para o Github para que você possa
sempre consultar mais tarde, certo Não é por isso que é bonito, mas eu só quero que vocês tenham uma ideia do que pretendemos fazer. Então, o que vou fazer por último, vou chamar essa etapa de um Passo um, passo um, então escolha isso e
coloque aqui. Vamos chamar isso de etapa dois, certo? Etapa dois. Etapa dois. Etapa dois. Tudo bem. Agora, sabemos que tudo isso
depende um do outro. Mas, no entanto, vamos continuar
no próximo vídeo.
4. Início do gasoduto: Oi, todo mundo. Veja aqui, obrigado por
voltar comigo. No vídeo anterior,
você realmente olhou esse diagrama para ver exatamente o que
vamos construir. Você sempre pode se referir a ele. Na verdade, eu me referiria a isso toda vez, de vez em quando. Vou enviar isso para que
você possa ter certeza de encontrá-lo
no repositório quando
realmente o examinar Agora, o próximo passo para
você pensar sobre isso, se você pensar sobre isso, é você
deve executar isso em paralelo? A primeira etapa e a etapa
um
dependem uma da outra. Então
, será sequencial A resposta é que tem que
ser sequencial porque, apesar de
passarmos por isso, tudo o que queremos
fazer aqui depende A etapa dois
depende da etapa um. A segunda etapa
depende da etapa um, então precisamos esperar o upload termine
antes de
passarmos para a outra etapa para
realmente obter os detalhes. Tudo bem Hum, então isso explicou
isso totalmente explicado. Então, acho que é hora de passarmos
para algo mais concreto para vermos exatamente como planejamos
isso. Então, com isso,
exploraremos o Github. Estamos explorando o GitHub para ver
o que vamos construir. Então isso é, ok, este é
um dos meus outros cursos. Deixe-me mudar para o meu curso. Deixe-me mudar
para o outro curso. Ok, então este é o curso
Swing Modult. Ok, então nas ações do Git, desculpe, no GitHub, chamamos
ações, chamadas de ações de obtenção Então, ações, você pode
ver principalmente ações como seu pipeline
básico, certo? Tudo o que você fará com um pipeline
ajo ou com um Jenkins, um Jenkins DSL
ou um arquivo de pipeline Jenkins .
Certo? É exatamente a mesma
coisa que você faria. Agora, eles só têm uma sintaxe
diferente. Mas algumas coisas
são bem parecidas, mas você só tem uma sintaxe um
pouco diferente, que provavelmente usou para o corpo atingisse
o mesmo objetivo Então eu quero que você tenha em mente. Você não precisa
aprender tudo, mas só precisa ter
uma boa compreensão de E é por isso que estou mostrando aqueles que você
realmente pode ter. Que são ações do Git. A documentação
é muito poderosa, eu a examino e
posso dizer que não aprendi
tudo, mas ainda são muitas coisas, mas você sempre encontra
o que precisa usar, sempre tem o que
precisa usar. Exploraremos as ações do Git, e é exatamente isso que
usaremos para realmente
criar nosso pipeline Agora, poderíamos dizer
: Ok, já que temos um projeto em movimento, vamos apenas iniciar o projeto
em movimento, mas isso teria
sido iniciado. Muitas pessoas já foram
iniciadas . Eu não
quero fazer isso. Eu quero nos mostrar exatamente
como isso vai funcionar e como isso vai funcionar é que vamos entrar em nossos
projetos, certo? Vamos entrar no nosso projeto,
depois dentro do projeto. No arquivo raiz
do seu projeto, que é basicamente isso
que você deve
obter como raiz nesse
arquivo raiz do seu projeto,
então, nesta dobra raiz do nosso projeto, você cria um diretório. E um diretório deve ser
rotulado como dot Git Hub, certo? Caso contrário, chamado Dot Git Hub. Então, no momento em que você realmente
pressiona um Dot GitHub, é exatamente
isso que ele espera Você deve rotular um GitHub. Não deve ter
um nome diferente. Coloque pontos no GitHub. É assim que ele reconhece que você está
tentando promover uma ação Tudo bem? Ok. Então
, agora temos isso. Agora, qual é a próxima
etapa que precisamos fazer? Dentro desse Github. Existe algo
chamado fluxos de trabalho. O fluxo de trabalho é como
se tivéssemos vários fluxos. Você poderia ter fluxos de servidor dentro do
mesmo projeto. Você pode ter um
fluxo, você pode ter fluxos de implantação
diferentes para várias coisas para
fazer várias coisas. Mas concentre-se em um deles apenas
para implantar ou construir nossa imagem. Dentro disso, você precisa criar outro arquivo chamado fluxos de trabalho Deve ser o nome
exato, por favor, o nome exato, fluxos de trabalho Nome exato. Agora, dentro dos fluxos de trabalho, não
criamos um Yarmofle Agora, esse Yarmofle pode
ser qualquer nome. Pode ter qualquer nome, mas deve
ser um arquivo Yamal. Vou chamar isso de deploy dot Yamal. Esse é o cara que usaria. Agora, automaticamente, eu tenho que, eu tenho uma inteligência
aqui dizendo que agora você pode criar um arquivo sem que ele
precise de todas essas propriedades. Chegaremos a isso,
chegaremos a isso daqui a pouco. Eu preciso entender isso. Voltando a isso mais uma vez, eu criei, estou tentando explicar que para que sua
ação seja acionada, você precisa ter
esse arquivo em seu pacote usando
o arquivo de implantação e o arquivo deve ser usado deploy
Yamfi pode ter qualquer nome Pode ser um oleoduto ou Yarmo, não importa,
mas deve ser um inhame Ele deve estar dentro
da pasta de fluxos de trabalho
e o RoflesFolder deve ser Dt Github e o Dt github deve estar na Ok. Como temos um bom
entendimento disso, acho que é hora de
começar a começar É hora de começar a entrar. Agora, há um formulário básico
que você realmente precisa. Se você verificar a documentação, há um formulário básico
que eles realmente explicam. O número um é seu fluxo de trabalho
ou sua implantação. Precisa ter
um nome. Precisa ter um nome. Vamos
dar um nome a ele. Nós temos um nome. O nome que chamamos,
nós o chamamos, acho que estamos tentando atingir o objetivo é criar uma imagem, criar uma imagem push. Vou
chamá-lo, vamos chamá-lo build push image, seja qualquer coisa. O nome pode ser imagem push para produção ou implantação, você
quiser
chamá-la, basta dar um niname. Qualquer apelido de
fã está bem, certo Agora, depois de
dar o nome, a próxima coisa é expectativa. Como você quer que essa
ação seja acionada? Agora, existem várias maneiras,
toneladas, inúmeras maneiras pelas quais
isso pode ser acionado hoje. Como você quer que
seja acionado? Defina-o usando a palavra-chave e,
em seguida, direi que quero que
isso seja acionado no push. Agora, se você
olhar isso, veja, eu apenas pressiono P.
Você poderia fazer isso em projetos
pagos,
PogrQuest, resenhas de livros Então você deve basicamente
explorar, certo? Explorar. Você pode
basicamente explorar. Então, eu preciso realmente
ter essa ideia. Na verdade, você pode
fazer isso em problemas. Você vê? Há problemas.
Digamos que você tenha problemas. Lembre-se de que, na verdade, estávamos
trabalhando em problemas há
algum tempo, tivemos
problemas de resolução Assim, você pode resolver
problemas. Então , se for esse projeto, você
pode trabalhar nisso. Então, você poderia dizer: Ok, sobre um
problema encerrado no livro de edições, lembre-se de que tentamos encerrar vários problemas com a
chance de implantação. Então, isso nós vamos fazer. Então, eu estou dizendo que você poderia
realmente usar problemas, certo? Mas estamos nos concentrando na ação. E o que realmente nos
interessa quando pressionamos o código para subir e pressionamos o código para
desistir do push é uma ação push Então, isso no push. Então esse é o verbo
basicamente empurrar. É isso que estamos
tentando realmente atingir. Agora, mesmo que
estejamos usando o push, isso por si só
não é suficiente. Se apenas rotularmos como
empurrar, estaremos dizendo qualquer empurrão em qualquer galho, certo? Qualquer empurrão em qualquer galho. Felizmente para nós, podemos
ir um passo abaixo para dizer que quero especificar
filiais. Você vê? Você pode ignorar alguma ramificação ou usar alguma ramificação. Agora, eu não posso explicar completamente tudo o que
temos sobre G Action, mas eu só queria ter alguns. É sobre você pensar,
pensar no que você precisa fazer. Pensando bem, você
pode acessá-lo facilmente. Agora, eu poderia dizer que quero que isso
seja executado na ramificação principal da ramificação
Dev, mas
provavelmente não deve ser executada em uma ramificação de recursos. Você pode colocar a ramificação de
recursos nisso. Isso é o que quero
dizer, eu poderia dizer, meu objetivo principal é fazer com que
isso corra para a filial principal. Isso funciona para a filial principal. Então eu poderia dizer, eu quero ignorar, eu quero
ignorar,
então eu vou ignorar, provavelmente, uma ramificação de recursos, se eu tiver algo chamado ramificação de
recursos, certo? Isso não funcionará devido
a um recurso ruim. Se eu pressionar alguma coisa
para o recurso, ele nunca funcionará, certo? Eu preciso realmente
ter essa ideia, certo? Isso é basicamente. Você poderia assistir isso,
mas vou
remover isso só para que
tenhamos exatamente o que precisamos. Exatamente o que precisamos. Dessa forma, quando estivermos construindo
um projeto pessoal, saibamos
exatamente o que precisamos fazer. Tudo bem Então,
vamos fazer uma pausa chocante na construção disso , então agora vamos para algo
um pouco mais detalhado. Agora, o próximo passo é:
podemos ter Remember, temos variáveis de ambiente. Essas
variáveis de ambiente para determinar. Esses caras, na verdade, definimos todas essas variáveis de ambiente. Enquanto estamos correndo, lembre-se de
que somos um rei em ação. Não estamos mais funcionando
no meu sistema local. Como resultado, onde vai arquivar onde
esses caras serão encontrados? Esse arquivo será
encontrado em ambientes. Felizmente para nós
também, temos o que
chamamos de ambiente ENV Temos meio ambiente. Eu posso seguir em frente e definir todos
os ambientes. Exemplo para dizer meu perfil de
primavera
e perfil de primavera, lembra
que usamos o perfil de sprint Isso eu estou usando o perfil de sprint. Embora saibamos que o perfil de
sprint está ativo, perfil de
primavera é exatamente o que será lido
no arquivo Docker Lembre-se desse perfil do Docker
Spring aqui. Ou seja, estou sendo consistente. Tudo bem Eu poderia
dizer spin profile, faça isso, digamos Docker Eu digo Docker, então
provavelmente modelo o host,
o host, o host local, o
host local Mas é uma maneira melhor. Sou eu que o
defino manualmente, mas dar a ela nos dá
algo melhor para fazermos, algo melhor para definirmos onde todos os nossos
ambientes poderiam estar. É isso que
exploraremos
no próximo vídeo. Te vejo, pessoal.
5. Primeira execução do gasoduto: Ei, pessoal, estejam aqui. OK. Então, eu disse que deveria criar outro aplicativo
que seja outro aplicativo que usamos para ação e definir que vou dizer o
porquê em bits. Esse é o motivo.
Vamos duplicar isso, vamos chamá-lo de ação Estamos usando ação. Agora, por que
eu decidi fazer isso? O motivo é porque
lembre-se do nosso Dockerfile, que é o aplicativo,
o ambiente Docker, o perfil DA usa uma
ferramenta DDL, Mas não queremos isso.
Nós não queremos isso. Queremos que esse cara seja atualizado, queremos que isso seja atualizado e por que
lembrar que usamos Remember, se tivermos alguma tabela,
todas as tabelas que realmente
temos dentro
do projeto, essas tabelas, basicamente, esse cara, todo esse cara
espera que sejam criadas e, se não forem
criadas, tron exception Lembre-se, a exceção do trem Motel. Como resultado, essa tabela,
a exceção Mitron. Vamos usar a atualização dessa
forma para garantir
que as tabelas sejam
criadas automaticamente no ambiente
virtual. O membro é um ambiente
virtual. Por ser um ambiente
virtual, tudo o que fazemos a
cada momento morre,
exceto aqueles que capturamos. Se alguém que não pegamos, ele morre com o contêiner
ou você o liga novamente,
então, com o
ambiente virtual, ele é recarregado Portanto, é seguro usar atualizações
todas as vezes para isso. É por isso que decidi usar
a indução, para não acabar
modificando esse Então, como resultado, não significa que vamos
recriar tudo Criamos tudo mais uma vez? Não. Então, o que eu fiz
foi seguir em frente e criar um ambiente
chamado ação. Eu criei um
ambiente chamado action, que é exatamente a
mesma réplica disso As únicas diferenças.
A única diferença é essa. As únicas diferenças. Temos sete variáveis
e as usamos porque
adicionei um perfil. Então, esse perfil, além usar a ação, eu
vou editá-lo. Vou chamar isso de ação. Então, ação é o que
esperamos. Tudo bem, ação.
Deixe-me minimizar isso. Não, não, não, não, eu
não quero deletar. Então, eu quero ação. Ok, então variável de data. Quero minha senha. Meu código de autenticação porque ele o vê como um código confidencial, então precisamos realmente
colocar os detalhes lá. Isso é bom. Na verdade, eu já
tenho essa configuração. Então, vou apenas passar
meu código autenticador. É uma vez que não
tentamos imitar porque
não funcionará .
Notícias únicas. Tudo bem. Eu editei isso. Já temos
tudo isso disponível,
temos que secretar. O segredo e tudo
continua o mesmo. Então, para evitar confusão,
quando as pessoas realmente retornam
a este curso para ver isso e dizer:
por que você tem? Vou deletar esse
docker e deletar isso. Então, temos ação aqui. Fizemos a coisa mais básica. A primeira etapa está concluída. Agora, qual é a próxima
coisa que queremos fazer? Agora que concluímos isso, podemos voltar ao nosso arquivo,
o arquivo que estamos criando
anteriormente, esse arquivo de ação. Agora, não pretendemos mais
usar isso. Não estamos mais usando esse
ambiente. Tudo o que precisamos
fazer é que, quando tivermos empregos,
temos uma seção de construção. Vou explicar
isso daqui a pouco. Quero especificar rapidamente onde
colocamos o ambiente. Eles têm ambiente. E qual é o nome
do ambiente? Ação. Por favor,
não se confunda. A ação que eu coloquei aqui. Esta ação aqui
é um perfil de primavera. Esse ambiente é o Docker
, é o ambiente GitHub, ação do ambiente GitHub.
Onde está isso. Essa ação, essa
ação aqui, sem ação, ação ambiental
é esse ambiente. Então, o que dizer da ação
Spring Profile? A
ação do perfil da primavera é essa. Por favor, entenda
a diferença. Não se confunda
com isso também. Achei que deveria
realmente mencionar isso. Ok, ótimo. Vamos voltar. Então é aqui que você
define isso, certo? É onde você o
define agora. O que são empregos? Pense nisso, você poderia ter o que
você quer fazer, certo? O que você quer fazer? trabalhos como a mesma coisa
quando quiser executar um cron job ou
executar uma tarefa específica Vamos usar essa palavra. Você
deseja executar uma tarefa específica, e essa tarefa
é basicamente chamada de trabalhos. Então, você define
que tudo o que você quer fazer é
definido nos trabalhos. Agora, pelo nome, você
pode ver que é plural. Ninguém, no plural, o que significa
que podem ser muitos. É por isso que agora você precisa
dar um nome a cada um dos seus trabalhos. H do seu trabalho, um nome. E é por isso que você
pode notar que tudo isso está construído. Então eu estou chamando isso
de trabalho de Bute, certo? A seção de trabalhos construídos. Assim, você pode nomear qualquer nome. Dê a ele uma seção construída. Não importa,
basta dar um nome para distinguir um trabalho
do outro, certo? Então, vou deixar isso como planejado
, deixá-lo como
construído. Agora temos isso. Está bem? Então, e a outra seção que
vamos executar? A outra seção que
vamos executar será chamada
de imagem push. Vou chamá-lo de push image, certo? Seção Push Image. Chame isso de seção pushmage.
É exatamente assim. Agora, isso é reclamar
porque ele espera que eu
termine meus detalhes, que eu não fiz, mas
eu só quero mostrar a
vocês como matronar seu Então eu poderia deixar isso como
seção Mas ou
dar um nome, certo? Dê a ele um nome que o
distinga. Então, eu começaria
isso porque
voltaremos a isso, certo? Voltaremos a isso. Então, agora que temos a ação, você precisa especificar
para obter a ação qual ambiente você deseja executar o aplicativo, em qual
ambiente, certo? Em qual ambiente realmente
definir que você tem o que
chamamos de execução em execução. E é executado em
vários contêineres específicos que podem ser usados. Vou usar o Ubon até o mais tardar. Como você perguntará:
Como eu conheci
essas informações? Oh, isso é bem fácil. Então, quando você realmente acessa a ação do Gear, vamos ver
o que eu costumo fazer. Trabalho de ação do Gear. Então, esta é a nossa pesquisa usando trabalhos
no fluxo de trabalho usando trabalhos. Então, se você cair,
verá que esses são
os trabalhos que podem ser executados. Vamos dar um exemplo típico de como seu trabalho deve ser
. Você vê? Jobs, então você tem um emprego também. Eu apenas rotulo a ação mental devida. Então eu precisava que vocês
realmente vissem isso, certo? Então, agora que temos
isso, vamos voltar. Vamos analisar o uso de empregos. Se você quiser usar o
trabalho, use trabalhos
no fluxo de trabalho, certo?
Nós temos isso. Agora, temos que
configurar o executor. Isso é o que eu estava
procurando . Você escolhe um corredor, certo? É aí que
usamos as corridas. Você pode fornecer as execuções e ele informa as
variações que você pode usar. Vamos descer para
ver o que você pode. Você vê? Se você especificar uma área
de StremT one, então, por exemplo, aqui está o trabalho que executamos apenas nisso,
que é esse, certo? Então você pode explorar vários
detalhes, certo? Escolhendo corredores auto-hospedados. Então, procure o que
você realmente precisa. Eu quero rodar no Ubuntu, usei a palavra latest in. Usando a versão mais recente
do Ubuntu, certo? Usando a versão mais recente do Ubuntu. Então, essas são as versões
disponíveis. Você pode ver, essas são as versões
disponíveis. Então, vou deixar esse link,
veja esse link. Vou deixar esse link, certo? Esses links. Então, eu deixaria
esse link para vocês. Deixe-me apenas colá-lo
no meu arquivo ou colocá-lo na
seção de recursos para que vocês possam realmente acessar todos
os links que obtiverem, que realmente
usamos para navegar. Então, você vê que pode
especificar o Linux. Você pode usar um Windows,
um ambiente Windows. Se o seu trabalho, a execução do relógio
requer um Windows. Digamos que você realmente queira algum comando que nós
realmente alimentemos,
shall biz ou MAC. Então, defina
o que você quiser. Então, eu vou usar o Ubuntu,
vou usar letras do Ubuntu. Diz que o Ubuntu atualmente usa a imagem Ubuntu 22 oh
four Runner,
que é exatamente o que estou usando que é exatamente o que estou Então, está tudo bem. Isso é o que eu
vou usar. Isso é o suficiente para fazermos
o que queremos fazer. Acho que
consegui especificar. Não quero
exagerar nesse problema para que vocês sempre possam
me ligar. Vou compartilhar o link Tudo bem, vamos aqui. Agora, eu realmente disse que vou
usar o Ubuno Agora,
a próxima coisa é quanto
ao ambiente
que vou usar, o ambiente
que vou usar. Lembre-se de que não preciso definir
definindo apenas esse
ambiente. Dentro desse trabalho, que
será executado no Ubuntu. Dentro desse ambiente virtual todo esse ambiente do
Ubuntu estará disponível
por Preciso que tenha isso em mente. Tudo o que disponível
estará disponível por padrão. Agora, dito isso, a próxima pergunta é: qual é a próxima
coisa que você quer fazer? Agora temos esse ambiente.
Eu quero pegar meu código. Como faço para obter meu código? Mas, no entanto, como
você procede? A próxima etapa a seguir é
que agora você tem, em um trabalho
, uma ação, quais são as
etapas que você precisa executar. Espero que adorasse que vocês assistissem isso para que isso continue. Quais são as ações
que você deseja realizar? A ação que você
deseja realizar com isso pode ser rotulada como etapas Em cada etapa que você tem, você
pode ter várias etapas. Meme, você pode ter um emprego. Você tem vários trabalhos que fazem várias coisas. Por padrão. Por padrão, todos os trabalhos são
executados em paralelo. Acho que preciso mencionar isso. De acordo com a documentação voculy, cada trabalho é executado em paralelo Se você quiser que seja sequencial, você precisa realmente contar e há uma
maneira de saber Vou mostrar a vocês
daqui a pouco como é. Quando chegarmos à seção
push IM, mostrarei como os trabalhos são
executados sequencialmente porque o push IM
dependerá do trabalho da seção de bits Precisamos indicar a
etapa que queremos seguir e cada etapa deve ter um nome. Tudo bem, o que eu quero
fazer é ficar resfriado. Vamos pegar o frio,
resfriar a fonte. Vou chamar isso de get source cold. OK. Então, temos algo
lindo aqui, certo? Temos algo
lindo aqui. Então, como faço para obtê-lo? Agora, sem nem mesmo prosseguir, abordamos
um pouco aqui, certo? Já abordamos um pouco,
mas eu não fiz nada. Então, como
não fizemos nada, não
quero tornar
isso muito complexo. Vamos insistir nisso,
certo? Vamos enviar isso para o Github e
ver como foi Tudo o que você precisa fazer é
enviar esse arquivo. Depois de pressionar isso, isso
entrará em ação imediatamente. Portanto, qualquer mudança que aconteça no push realmente
atenderá a isso Então, estou chamando esse código-fonte
convidado, mas deixe-me
imprimir algo. Digamos que imprima alguma coisa. Então, seu passo pode ser qualquer coisa.
Acabei de imprimir alguma coisa. Vou chamar isso,
vou dizer que
poderíamos usar uma execução, existe esse comando de
execução. Eu executo o comando. Ele está disponível na
seção de etapas. Basta verificar a seção de etapas,
eu realmente a encontro. Vou mostrar isso daqui pouco, mas vamos fazer isso
rapidamente. Eu vou ecoar. Vamos
repetir outra coisa. Vamos ecoar alguma coisa.
Eu vou dizer: Ei, módulos, estou
executando alguma coisa. Estou imprimindo
algo. Alguma coisa. E isso é tudo que eu
quero fazer. Dito isso, vamos realmente agir. Vamos criar um problema para que possamos realmente
rastrear isso, certo? Eu direi que a ação começa ou
simplesmente a chamo de pipeline. Vamos chamá-lo de
pipeline, certo? Pipeline Pipeline 1. Na verdade, poderíamos seguir um
após o outro. Vou comutar isso com
esta mensagem do pipeline. Venha aqui, confirma que um CM está aqui, depois fecha, o que ele 20. Então, isso é 20. Ok, então vamos insistir nisso
e ver se funciona, depois voltaremos para ver Catali explorar mais
alguns recursos Mas essa é a
primeira coisa. Acho que é um bom lugar
para parar o vídeo. Então, vamos insistir nisso. Vou permitir que essa corrida seja executada
rapidamente. Então, vamos seguir em frente com minha
ação. O push está completo? Sim, meu impulso está completo,
vamos entrar rapidamente aqui. Agora, como você pode
ver, vamos atualizar. Você pode ver? Você vê que simplesmente
estourou de repente Não havia nada em ação antes além do que você fez. Devemos apenas escolher um padrão. Mas, como o
rotulamos da maneira que fizemos, isso já
descobriu que acabamos de enviar os
commits com esse nome
e, se você
abri-lo, poderá ver reconhece um arquivo,
que é um arquivo Você pode ver que definimos apenas
a seção mas sozinhos. Se você comprar uma
seção “mas”, o que vemos? Ele configura um trabalho para
você automaticamente. Você vê? Agora, você executa qual é o seu
sistema de colocação? Posso ver o Ubuntu? E é exatamente isso
que você usa. Essa é a imagem do corredor, certo? E não se preocupe com isso. Essas são todas as
permissões que ele atribui
ao ambiente. Para
executar a ação, a ação é
automática, certo? Então, embora não seja
totalmente automático, há algumas
coisas complexas em torno disso, mas não acho que seja
relevante para esse caso. Ok, então você vê? Acabei dizer que você deveria
rodar isso e ver, ei, Ei, Molts, eu estou
executando alguma coisa E como
não há mais nada, ele executa o trabalho e
é bem-sucedido. Vamos lá, pessoal, esse
é um bom marco. Vejo vocês
no próximo vídeo.
6. Imprimir variável env: Olá, pessoal, aqui é Z. Somos capazes de correr e
fazer a primeira coisa executando isso e
as coisas estão melhorando Eu acredito que você concorda
que as coisas estão melhorando. Agora, voltando aos nossos
detalhes, temos isso. Queremos enviar o código. Queremos enviar o código, na verdade
enviamos
o código, então não o fazemos aqui,
acho que perdi uma etapa e a etapa deveria ser:
precisamos extrair o código, vamos chamá-lo de pull code porque o push code
é a ação que fazemos. O código pull é o que
a ação do Git fará, que é o comando, a ação
do Git para puxar o código para
o ambiente, chamada de ação pull Eu acho que isso é pull code ou acho que isso é realmente
mais, isso é melhor. Vamos voltar ao nosso arquivo. O. Eu acredito que alguém pode dizer, mas você acabou de
imprimir algo. Não podemos fazer algo mais incrível do
que apenas imprimir? OK. Então, por que você não
tenta extrair o ambiente, colocar os detalhes
no ambiente Agora, como você puxa? Como você coloca os detalhes
no ambiente? Coloque os detalhes
no ambiente que você deseja usar basicamente
para extrair o ambiente. Você tem a ação EMV, que está automaticamente
disponível para você, porque está disponível para você,
você pode então inseri-la Então, na verdade, você denota o uso
disso usando o sinal de $1 para
aqueles que estão bem vamos chamar isso de, então diga programa, digamos apresentadores, certo
? Mostrar arquivo de hosts. Eu mostro ao apresentador EAV. Mostre-nos o meio ambiente.
Variável de ambiente. Acho que vai ficar tudo bem.
Variável de ambiente. Só quero mostrar a vocês que
isso também funciona bem. Variável. Só você está de distância. Então, ele realmente funcionaria, e vamos repetir algo.
Vamos repetir isso. Então eu vou chamá-lo, então use a interpolação
de strings. Em seguida, coloque-o no meio. Então vamos chamá-lo de E e V. Então qual é o nome? Qual é o nome?
Vamos verificar o nome. Vamos verificar o nome que usamos. Vou entrar aqui, verificar
meus ambientes, abrir isso e escolher um deles. Vamos escolher um
deles. Veja bem, nem tente fazer login aqui. Isso não será exibido
porque não deveria ser exibido. Se você tentar registrá-lo ou
tentar, ele não será exibido. Já existe uma regra
contra se você tentar realmente repetir isso, isso nem funcionará.
Então nem tentamos. Vamos escolher esse cara. Certo? Então, volte aqui. Na verdade, eu
realmente tenho isso para começar. Então, na verdade, a G Actions usa um correio
duplo de Cali. É assim que o Get Actions
realmente o usa. Então, vai
ser o dobro, certo? O que está caindo aqui?
Substitua por um posicionador. O que é isso? Ok, não, eu acho que está certo. Está muito bem. Acho que é inteligente me dar
essa, mas está tudo bem. Ok, então vamos ver se
isso funciona, certo? Gente, vamos ver se isso funciona. Então, eu faria isso,
vamos fazer a redução. Vou
chamá-lo de pipeline dois. Fechar isso aparentemente
deveria ser 21 21. Vou chamá-lo de pipeline dois, variável de ambiente de
impressão.
Nós vamos fazer isso. OK. Então, vamos aqui. Vamos criar outro problema. Vamos criar outro problema
e esse problema será chamado Prince inn V Variable. Vamos chamá-lo de pipeline. Sabemos o que estamos fazendo pipeline, variável de
ambiente de impressão. Vamos fazer isso. Isso será 21. Isso é 221. S tem 21 anos , veja como eu
escrevi isso. Variável. Fechar 21. Agora, o que
eu escrevi isso Imprimir O que eu estava
tentando soletrar? Ambiente de impressão?
Acho que a Columbia fez isso. Então você pode emendar com o Git
commits, da dash amend. Então, isso alteraria
seus compromissos. Ok, então algumas das mudanças, então imprimir, não imprimir, ok? Então eu posso salvar isso. Tudo bem,
então faça o Git push. Tudo bem, então enquanto
isso está acontecendo, vamos seguir os caminhos e seguir nossas ações Veja, isso
entrou em cena, certo? Vamos entrar. Está bem?
Isso passa? Isso falha ou C?
Então eu posso simplesmente entrar. Aparentemente, passou.
Vamos ver, está apontando? Nada foi apontado.
Mostra eco. Deixe-me ver. Vamos voltar aqui. Eu tentei executar isso dizendo,
mostre a variável de ambiente. Qual deles eu queria
, mas esse não funcionou e por que você não correu? Vamos ver. Vamos
ver, vamos ouvir. Onde você faz isso, eu especifico
o ambiente de ação. Estou dizendo para imprimir esse cara,
mas isso não está funcionando. Quando verificamos esse lugar, cheque esse cara, ele
tentou mostrar isso, mas ele nem está
reconhecendo Deve haver alguma coisa, deve
haver um detalhe, deve haver um detalhe. Você pode
praticamente
entrar rapidamente na configuração. Deixe-me pausar este vídeo e realmente voltar para vocês Ok, pessoal,
lendo a documentação, estou vendo se você está
usando um executor Linux, você não precisa
realmente adicionar isso Então você vai
testá-lo, certo? Você não precisa adicionar isso. Você pode simplesmente usá-lo
diretamente, certo? Então eu posso chamá-lo de
trator ActratorePoints. Pontos finais do atrator. Só queremos ver os pontos finais do
atuador. Mas está dizendo que você também pode usar porque é
a documentação, esta verificando a documentação.
Isso é variável. Quer dizer que,
além de runner, get actions permite que você
leia ou defina valores-chave, ambiente, variáveis
e conteúdos destinados ao uso
em pontos diferentes Em seguida, ele diz, por exemplo, apenas esse nome para Basell
que está no executor Linux, que você está usando o nome da
coluna ENV Em um executor do Windows.
Na maioria dos casos, você também pode usar o contexto. Diz apenas usar
contexto, propriedade de ponto. Eu suponho que isso seja um
contexto. Esse é o contexto. Pontua o nome que
realmente queremos acessar. Vamos imprimir isso para
ver como realmente funciona. Vamos fazer isso. Eu não
mudei nada, então eu simplesmente coloco isso
ao lado da mesma coisa. Eu apenas cometo com o
mesmo nome desta vez, mas não vou adicionar nenhum comentário. Não adicione nenhum commit, nenhum
ID. Vamos insistir nisso. Então, vamos empurrar. Vamos
ver como isso funciona. É bom
imprimi-lo ou descobrir. Então ele é um corredor e entra em ação.
Sim, isso está funcionando. Então, vamos ver o que
acontece? Vamos dar uma olhada
nisso. O trabalho está começando. Ok, vamos ver. OK. Execute
echo, os mesmos pontos finais do trato Isso mostra isso, mas
ainda estou perdendo essa parte, ainda estou sentindo falta dessa parte. Vou executá-lo
novamente e ver exatamente. Vou fazer o
acordo antes de voltar para ter certeza de que funciona, depois
vou voltar para vocês Aqui, pessoal. Então, tendo feito
um pouco de pesquisa. Eu descobri que estava
realmente misturando as coisas. Então, o que
devemos
dizer é que temos um ambiente em
que declaramos o ambiente legado como um
ambiente e definimos
isso como alguma variável ou
simplesmente o chamamos de alguns dados Alguns dados. Agora, isso está disponível
no nível do trabalho. Vamos fazer isso e eu
explicarei o que significa nível de trabalho. Ambiente em nível de trabalho, todo
o ambiente e nível de etapa. Na verdade, podemos saber exatamente
como usar isso. Se você quiser avaliar isso, direi alguns dados. Alguns dados podem ser avaliados com isso podem ser
avaliados com isso. AMBIENTE. Então é aqui que usamos
esse EV e depois dois S, certo? Soma. OK. Então, para
o ponto final do actu, usamos a palavra-chave verse Então eu estava estragando tudo.
Use a palavra-chave verso. Eu acho que isso é um trito.
Qual é o nome mesmo? Deixe-me verificar minhas anotações.
Atuador, ponto final exposto OK. Ponto final de reposição do atuador. Então, isso
poderá imprimir isso
enquanto isso imprimirá o que salvamos na frase, certo? Na verdade, isso o imprimirá .
Tudo bem, vamos
testar isso. Vamos testar isso.
Vamos testar isso. Ok, vamos empurrar. Tudo bem. Ok, isso já passou, então vamos dar uma olhada em nosso workshop Isso não é uma falha. Basta executar isso novamente para que seja um
gatilho, isso não é uma falha. Tão legal, começar. Conseguiu, vamos
ver o que aconteceu. Tudo bem. Vamos verificar a seção.
Vamos imprimir alguma coisa. OK. Isso é o que fizemos antes. Tudo bem, você pode ver? Consegui obter isso que
definimos para a saúde e
isso e isso
também foi possível e alguns
dados, obtivemos alguns dados. Tudo bem. Então esse
é o show do desfile Agora temos uma boa
compreensão de como isso funciona. Eu estava misturando tudo sozinho. Esse vídeo já é muito longo. Vamos voltar ao próximo
vídeo e vou explicar como o ambiente funciona
e agir. Vejo vocês no próximo vídeo.
7. Imprimir env para todos os níveis: Oi, pessoal. Z aqui. Tudo
bem, então estamos de volta aqui. Vamos falar sobre impressão. Vamos falar sobre meio ambiente. Agora, poderíamos ter
um ENV aqui, certo? Temos um ENV aqui, ambiente aqui
e temos um ENV de trabalho Vamos chamá-lo, vamos te
dar um nome. Agora, isso é um JobyNV. O que significa que esse ambiente está disponível para todos os trabalhos que serão definidos como disponíveis nele. Eu vou testá-lo,
então eu vou vir aqui. Eu farei o nome. Eu vou dizer print, print JobInv. Eu vou correr. Eu vou fazer echo Ambiente de trabalho. O que é o Jab ENV? OK. Então, eu vou escolher isso. Não faça isso em casa.
Não copie e cole. OK. Tudo bem,
então temos isso. Ok, digamos que
ativemos esta seção, terei uma etapa que será executada. Teremos uma etapa que funciona, e essa etapa queremos executar. Vamos fazer. Portanto, isso nos
espera saber em qual ambiente
você deseja construir Então, vamos rodar no
Ubunzu também, ok? Vamos rodar no Ubuntu. Então, vamos imprimir isso também, certo?
Vamos imprimir isso. Esses são totalmente.
Eu também uso isso para nos
mostrar que esse trabalho
realmente é executado em paralelo. Você vê que isso vai funcionar sem
nem mesmo esperar por isso? Então, digamos que você queira
testar esse ambiente. Agora, conseguimos
testar o nível de trabalho, certo, e podemos testá-lo. Então, vamos entrar e ver exatamente como isso realmente
acontece, certo? Então, eu também quero nos mostrar que
existe um ambiente de nível de etapas.
É um nível de degrau. É nível de degrau, ENV. Tenho certeza que vocês
estão tendo uma ideia de como isso funciona agora. Vamos chamá-la de etapa ENV. Inveja. Vocês podem ter
uma ideia de como isso funciona. Está bem? Eu virei aqui. Vou apenas para o Step
ENV. Eu processo aqui. Eu estou bem. Então coloque isso. Quero mostrar o nível do trabalho,
o nível da etapa e para que você possa ver que
tudo está disponível. Esse nível de etapa
não pode ser acessado aqui porque está dentro dele. Somente o nível do cargo estará
acessível em todos os trabalhos. O nível do trabalho aqui estará
acessível em todas essas etapas enquanto o nível da etapa
estará acessível dentro das
etapas. Vamos executar isso. Vamos executar isso. OK. Deixe-me dar
um nome melhor. Vamos dar a ele um nome melhor. Vamos emendá-lo. Vamos emendá-lo. O código está imprimindo
de forma móvel em todos os níveis. Nós temos isso. fechar
todos os níveis que
deveriam ser de trânsito, eu acredito Deixe-me copiar esse nome. Vamos para Juke Issue. Nova edição, esse salvamento. Ok, então vamos salvar esses 22. Então guarde isso. Tudo bem
, então vamos empurrar Ok, então isso está acontecendo agora, está acontecendo, vamos entrar
aqui. Vamos agir. Abrindo como não
temos nenhum erro de sintaxe. Agora, você pode ver que isso está funcionando independente disso.
É um dependente. Você vê uma flecha. Portanto
, é independente. Eu te mostrei que
os trabalhos estão funcionando paralelamente. Então, por padrão, eles estão
funcionando paralelamente. Então, vamos abrir esse cara.
Isso é uma ação push? Posso ver que somos capazes de
imprimir o ambiente de trabalho, que é SSSS, é exatamente
o que realmente dizemos aqui Vejo que o SSSS está funcionando. Vamos conferir este
que tem o nível de trabalho no EMV para que possamos validar se
o nível
do trabalho realmente é nível
do trabalho realmente Então, vou para a seção Mas. Mas uma série de seções. Você pode ver que fizemos isso antes, vamos fazer o trabalho de tela aqui Você pode ver o nível da etapa do SSSS. Tudo isso eu pude mostrar
a vocês como
realmente imprimir em todos os níveis. Eu acho que isso é bom o suficiente. Agora, vou fazer uma
limpeza e, em seguida, começaremos a
extrair o código Vejo vocês
no próximo vídeo.
8. Ações personalizadas do pipeline: Oi, todo mundo. Z aqui. Na verdade, fomos à
última sessão para realmente imprimir ambientes em todos os níveis.
Na verdade, fizemos isso. Portanto, não eliminamos
essa boa seção. Vamos mudar essa parte. Vamos mudar isso para
que possamos deixar isso. Lembre-se de que mostrei a
vocês na última seção que os trabalhos realmente
funcionam em paralelo. Na verdade, poderíamos simplesmente deixar isso aqui e
provavelmente chamá-la seção de trabalho de
amostra e apenas
chamá-la de seção de empregos de Sam. Podemos então entrar aqui e sair do que precisamos
para este projeto, certo? Então eu vou chamá-lo, mas sim, vamos chamá-lo de seção
But But drop. E isso funciona. Lembre-se de que seu
nome depende totalmente de você. Então eu poderia escolher isso
porque precisamos disso, certo? Ok. Então, isso não vai realmente detalhar
a etapa de que precisamos. Tudo bem, essa etapa
provavelmente precisa agora, o que precisamos agora é
obter o código, certo? E quando queremos
obter o código, podemos realmente fazer
algo assim, certo? Fazemos um checkout do git, então provavelmente queremos
extrair ou fazer um clone do Git e, em
seguida, colocamos essa URL completa para
realmente obter Mas
basicamente agora estamos tentando superar
a segurança, tentar ver se esse treino
é evitar essa complexidade É por isso
que o Git realmente criou coisas chamadas de ações já
criadas para você, ações que já
funcionam Então, eles são basicamente a
mesma coisa que isso. Basicamente, exatamente a
mesma coisa que isso. No entanto, eles foram
compilados onde você pode simplesmente usá-los em qualquer lugar
para realizar uma ação. E um deles é o Get code. Então, se você fosse explorar, se você analisar isso com cuidado, é
assim que o Git Action é
chamado de Git Action Marketplace Então, no Git Action Marketplace, você tem tudo, algumas
das principais coisas de que precisa Por exemplo, você
quer interagir com a AWS. Tenho certeza de que você encontrará coisas
relacionadas ao EWS aqui. Se você observar isso com cuidado, verá que esse é um gerente
secreto da AWS. Se você quiser configurar alguma CLI, se você realmente cair um pouco Eles fazem muitas
paradas, muitas paradas. Tenho certeza de que se você também
tem algo no AshiCop é Ash Cov
volt Ash Cov volte. Xícara de cinza, veja. Eu só ponho manchas novamente.
O hashi, HashikUp Como você vê, temos informações
no HashiKup sobre como
interagir com o copo Tashi versus diretamente a partir de sua ação
. Então isso realmente funciona. Eles interagem com
muitas coisas, certo? Então, basicamente, essa é a ideia. Então, o que estamos vendo hoje, enquanto eu pesquisava,
descobri que também
temos o caixa. Então, quando você vê essa marca azul, isso simplesmente significa que isso
foi verificado. Isso não quer dizer que
os outros não sejam verificados. Bem, isso simplesmente significa que eles realmente
não ficaram mais fáceis de verificar. Devo verificar o código para ver se
é exatamente o que você precisa e se não expõe nenhuma forma de seus detalhes. Para
isso, precisaremos disso Agora, vou me limitar às coisas que temos. Eu tenho esse carrapato
azul, exceto talvez explorar
outras coisas que
poderemos ver mais tarde.
Vamos entrar aqui, certo? O que isso faz? Diz: Esta ação verifica seu depósito no espaço de trabalho do
Gitub Agora, se você está
familiarizado com o Jenkins, Jenkins também tem um recurso
chamado espaço de trabalho, onde é um ambiente
vetorial em que executa seu código,
gerencia todos os seus artefatos A mesma coisa com isso.
Agora, e se você não estiver interessado,
queira
também clonar outro, confira
outro repositório que
seja diferente daquele em que você
está trabalhando atualmente É por isso que você tem esse
outro parâmetro que é o w. Ele
fornece um repositório Depois de fornecer,
você deve fornecer o pôster para fazer
o check-out e o check-in Agora, às vezes você
pode precisar do
token Git para acessar algum É por isso que você também precisa disso. É um token que já
está disponível para você. Às vezes eu preciso da chave
SSH, chave SSH. Eu pessoalmente uso
chaves SSH, ambas funcionam, tecla
H para me conectar a todos os meus detalhes
do Github. Como é o uso? Muito simples.
Vamos simplesmente descer. Tão simples quanto isso.
Apenas desconecte. Apenas usar isso sozinho é o suficiente para nós. Não
precisamos de nada extra. Isso não significa inventá-lo. Você pode simplesmente verificar
o que precisa. Eu vou entrar aqui. Tudo bem Lembre-se de que a palavra-chave é o quê? Usos. Eu não quero dizer este manual, Mark. Usos, certo? E quando eu uso a palavra usos, então eu só preciso seguir
exatamente a
mesma coisa que eles fizeram. Que é finalizar a compra.
Finalize a compra e pergunte ao V four Isso é basicamente uma necessidade
leve, certo? Isso é basicamente leve.
E isso define. O que esse cara reclamando quer dizer ao se conectar
ao seu git? Basicamente l, então eu não acho que
preciso de um extra Na verdade, descobrimos um bacalhau. Agora, lembre-se de um diagrama,
extraímos o código. Agora queremos configurar
um ambiente virtual, queremos configurar o Mv,
configurar nosso Java Mv in e Agora, alguém já
fez isso
tudo por nós. Não precisamos nos
preocupar com tudo isso, o que nos
leva a essa
ação personalizada de ação, que é a configuração do Java GDK O legal
dessa configuração Java JDK, quando descobri,
é que, se você
descer , veja a Na verdade, funciona para ambos. Ele é voltado para a
segunda série e também
para o Maven, o que torna
tudo incrível para nós É um título para Deus
e para Maven. Em seguida, ele aconselha que você realmente use o checkout primeiro lugar,
que acabamos de Então, ao mesmo tempo, você puxa e usa esse
em particular. Isso é
exatamente o que estamos usando. De qualquer forma,
eu realmente não tenho nenhum problema
em me distribuir. Pessoalmente, prefiro
usar o Coreto Amazon Coreto. Tenho certeza que você está
familiarizado com isso. Temos várias distribuições. Se subirmos, você tem
os que poderia usar. Você
adota Tamarin Zurupt, então eu prefiro Coreto,
use o que achar melhor para use o que Então, no que diz respeito à versão, a versão também indica
que você pode usar 811-16-7201 Você pode ver qual é a versão do
Java aqui. Vamos entrar
e configurar isso. Vamos começar a configurar isso. O que eu faria seria aqui. Vou chamar essa configuração de JDK, 21 Lembre-se de que usamos 21 para nosso projeto e depois
usamos a ação. A palavra-chave é
ações, não ação. Ações. Ações e, em seguida, configuração. Java, eu não preciso
realmente amontoar este. Eu não preciso
simplesmente entrar e
copiá-lo exatamente porque
suas aulas. Então, basta copiar tudo isso. Sim. Evite erros. Acabei de
entrar aqui e isso define tudo. Então, quais são os outros
detalhes que eu preciso? Então, quais são os outros
detalhes que eu preciso? Portanto, se você verificar
corretamente,
lembre-se indicar a
versão que usa. É aí que vem a palavra-chave
with. Eu te disse que a palavra-chave with
é quando você quer definir parâmetros extras, certo? Então, eu estou usando uma distribuição. Veja, há uma distribuição. E a distribuição
que estamos usando é Coret. Você não precisa se lembrar de
que não precisa amontoar isso. Você pode simplesmente voltar, eu escolho. Estou interessado em Koreto. Acabei de voltar para Coreto. Sim, basta voltar para Coreto. Então versão Java, viu? Já está disponível aqui. É por isso que
adoro usar os plug-ins que me
ajudam com tudo isso. Então eu estou usando 21. Então eu quero algo
chamado cache. Quero que esse cache
seja Maven. Vamos descobrir isso. Vamos ver exatamente
o que isso faz. Ok. Então você pode ver, você diz que essa ação de configuração de ações de
configuração Java fornece as seguintes funcionalidades
e executa, entendeu Existe uma
dependência de cache gerenciada pelo Apache Mavin, que é
uma das razões pelas quais eu
amo isso Vamos ao que interessa. Você vê que esse cache diz: o cache de configuração
rápida para
dependência é
gerenciado por meio
de um dos gerenciadores dependência é
gerenciado por meio
de um dos gerenciadores de pacotes predefinidos Pode ser um dos Maven,
gradual e SVT. Isso já vai
funcionar muito. Então, o que também construímos uma vez e, na verdade, salva nosso caso, quando executamos o mesmo trabalho novamente, há uma chave que é
atribuída automaticamente. Não precisamos nos preocupar com
todos esses detalhes de integridade. Isso está resolvido. Não importa
o que façamos é armazenar em cache. Temos que armazenar em cache manualmente, fornecer a chave e depois
recuperá-la Se for essa chave,
usamos uma palavra-chave. Se for essa chave, ela não deve
ser armazenada em cache. Se não for fundamental,
deve ser construído. Mas isso só
configura isso para nós. Uma das
coisas legais sobre isso, se você fosse
descer um pouco, é se você verificar isso. Também fornece
alguns detalhes extras. Vamos ver a
palavra-chave que está sendo usada. O que eu gosto de fazer
é
simplesmente pesquisar nesse centro e procurar a palavra-chave catch. Então isso nos dá uma
coisa boa. Agora, veja isso. Diz ação Buting para restaurar a
dependência do cache. Você vê? Restauração do cache Ele usa dois kits de cache
sob o capô. Para depender do cache, o bog requer menos configurações
e configurações Isso é
exatamente o que estou procurando. Eu queria mostrar a
vocês que há
mais uma ação que está
sendo chamada por baixo No entanto, é uma boa maneira de realmente
vermos como isso funciona. Isso o chama de cache. Cache. Então, existe esse recurso de
cache, certo? Isso também está disponível e você
pode usar manualmente, certo? Mas você não precisa se
preocupar com a chave. Há essa chave que você
precisa usar para o cache
e, em seguida, restaurar há
muitas configurações. Por isso, eu sempre recomendo
que você mesmo procure as principais
coisas de que precisa. Você não precisa fazer
essas coisas manualmente, certo? Procure a ação. A única vez em que a
ação não estiver disponível, você sabe que precisa fazer
as coisas passo a passo. Se você tem uma história de pesquisa e não consegue encontrar nenhuma ação,
é muito simples. Basta procurar a
coisa mais próxima que você deseja
fazer que provavelmente faça uma ou duas coisas
que você deseja fazer, uma ou duas etapas que você
deseja realizar e, em
seguida, defina sua
etapa uma após a outra, o que apenas poupa muito estresse. O que eu vou fazer, vamos
voltar no próximo vídeo. Vamos ver isso
e acompanhar o arquivo passo a passo para ver
como isso realmente funciona. Vejo vocês
no próximo vídeo.
9. Pipeline remove composição do docker de boot de moldura e pula teste: Oi, todo mundo. Z
aqui. Tudo bem Então, pudemos realmente
detalhar nossas ações g. Trabalhamos nisso, podemos
realmente mudar o nome,
mudamos essa coisa e,
na verdade, configuramos essa sessão. não terminamos com
isso, no entanto, vamos ver o que vai
acontecer com isso. Quero que possamos
confirmar que isso está realmente funcionando como deveria e que não temos nenhum
erro. Isso nos dará uma
boa ideia do que foi feito e do que
foi gerado, certo? Vamos testá-lo. Esse é o objetivo deste vídeo. Eu criei
um problema. Crie um problema. Então, vamos nos comprometer contra
esse problema. Por isso, nos comprometemos. Ok, então vou apertar isso, então veremos nossa ação
começar. Tudo bem Então, vamos voltar à ação. Vamos às ações. Tudo bem, então isso está chegando. Então, vamos seguir em frente. Lembre-se, isso é o que
declaramos, tudo está funcionando em
paralelo, certo? Estou mais
preocupado com essa seção, mas para ver se as coisas realmente
funcionam, então vou entrar. Tudo bem, então isso está concluído. Não recebemos nenhum erro. Oh, bom trabalho. Bom trabalho. Número um, obtenha o código. Conseguimos obtê-lo com
bastante sucesso? Vamos confirmar. Então,
verificamos corretamente. O que podemos ver aqui? Nós verificamos corretamente. Então, isso foi capaz de fazer tudo o que
queríamos fazer. Portanto, isso não nos
dá nenhum erro. Então isso significa que nosso
código
foi basicamente verificado corretamente, certo? Temos certeza? Provavelmente
gostaríamos de nos registrar para ter certeza. Mas antes disso, a melhor maneira
de realmente confirmar isso é
verificar a configuração do JDK Então você pode ver que ele
realmente executa isso. Na verdade, escolheu esse
cara onde ele está em Java 21. Incrível. Em seguida, vamos armazenar em
cache com o Maven Incrível. Então, a configuração da postagem, essa é a configuração da postagem,
isso é apenas uma limpeza digamos, erro de peça, especifique a
peça e nenhum caso Não há nenhum caso. Aparentemente, não
há nenhum caso, existe o Reason porque
não executamos nenhum comando móvel. Não executou nenhum comando móvel. Isso é uma
coisa linda que vamos
fazer neste vídeo atual. Agora, garantimos que
nenhum erro realmente tenha ocorrido. Então, vamos continuar. Qual é a
próxima coisa que você quer fazer? A próxima coisa que eu quero fazer
é gerar algumas informações. Vamos gerar algumas informações. Vamos chamar essa saída de Info. Basta chamar isso de informações sobre maconha, e
eu vou correr. Vou apenas
executar um comando LS. Isso é tudo que eu vou fazer. Vou executar um comando LS. E se você estiver
familiarizado, sabe, LS basicamente executaria
tudo o que
precisa ser e que
realmente precisa ser lançado. Assim, poderemos
ver tudo
na pasta raiz e ver se as coisas realmente
funcionam corretamente. Então, vou dar um passo
em mais um passo. Quanto menos tenho isso, menos
construa com o Maven Aparentemente, estamos construindo
com o Maven, certo? Então, como você está
construindo com o Maven, essa configuração reconhecerá
que estamos construindo com Maven e captará os detalhes
porque você reconhece que está construindo o Maven, incrível,
deixe-me armazená-lo em cache para
você Isso reduzirá nossas dependências
e coisas
do Qual é o comando que
vamos fazer? Vamos usar os
comandos simples que conhecemos. Esse será o pacote VN clean, depois D, spring boots, dots run dots profiles É assim que a mola
é executada em um perfil específico. Já descobrimos
como obter nosso perfil, que são os pontos do vaso Lembre-se de que fizemos isso em algum momento. Na verdade, usamos o vaso. Desta vez é o perfil da primavera. Lembre-se de que temos esse perfil de
primavera. Lembre-se disso, vamos embora. Se você verificar esse cara, nós verificamos esse cara,
vá para nossas configurações. Então, se você verificar
nosso ambiente lembrar da ação,
configuramos o perfil de mola,
que é ação. Vamos agora colocar isso em prática. Vou fazer isso e
ver exatamente o que aconteceu. Na verdade, acho que sou
curioso o suficiente. Vamos fazer
outra coisa. Vou fazer, vamos listar os arquivos. Se isso for verdade,
mas com sucesso, devo ser capaz de avaliar
uma pasta chamada LS targets. Você sabe, é assim que funciona em destinos para Mavings a But, é uma pasta
But, desculpe pela pasta G But,
mas para Mavings é um mas para Mavings Quero imprimir tudo
dentro dessa pasta de destino. Então, vamos em frente
e experimente isso. Vamos criar um problema.
Vamos criar um problema. Vou chamá-lo, vou chamá-lo de oleoduto, só para ter certeza de que
ainda estamos no oleoduto,
então construa um casamento comigo, cara. Eu acho que isso é legal.
Sim, tudo bem. Então, posso dizer que isso
é um aprimoramento. Sim. Não usei tudo
isso de verdade, só achei que
deveria adicioná-lo
apenas um aprimoramento.
Você pode fazer isso. Então copie isso, então eu
me comprometo contra isso. Em seguida, fecha. Então, se
tudo funcionar perfeitamente, devemos ver nosso
maven em cache, Se você perceber que as
coisas estão funcionando corretamente. Então, recebe um empurrão. Vou pegar push push. Tudo bem, então vamos entrar aqui. Vou entrar, então vou
seguir minhas ações. Vá para o meu oleoduto.
Tudo bem, lembre-se que estamos
preocupados com isso. Sim. Essa parte. Tudo bem, então as coisas
estão. As coisas estão funcionando. Agora estou na
seção de bits. Então, você pode ver? São dependências plásticas.
Você pode ver isso. Isso é incrível.
Isso é incrível. Agora, isso é sempre muito grande, então talvez você não
consiga correr com ela. Então, o que eu normalmente
faço agora, é criar os dados, tudo o que esperamos,
ou algo está falhando Incrível. Algo está falhando. Agora, você vê que foi
capaz de puxar para puxar. E essa corrida de verdade, você vê? Um perfil é, na verdade,
eu o entendi corretamente. Não, mas algo está errado. F agora é chamado do jeito que o Branco estava tentando fazer isso.
Está faltando alguma coisa. Está faltando alguma coisa,
não consegue encontrar o que é? Um login de
pontos no repositório de respostas, negado. De certa forma, isso é bom. Vamos ver o que mais estamos perdendo? O que mais
estamos perdendo? Vamos dar uma olhada nesse relatório
de avaliação. Só queremos
verificar qual é o problema, o que podemos ter,
e vamos ver isso. Lembre-se de que estamos executando um ambiente
virtual Agora você precisa ser muito detalhado ao examinar os registros para ver o que
poderia ter dado errado? O que poderia ter dado
errado? Estou olhando para isso. Ok. Portanto, temos o login do Docker Não estou interessado
no login do docker. Está bem? Por que o repositório
não existe. Veja, o repositório não existe ou pode exigir login do
Docker, ok Agora, vamos verificar nosso arquivo. Vamos verificar Vamos
verificar esse arquivo. Vamos verificar isso.
Vamos dar uma olhada nisso. Se você olhar nosso
arquivo de composição, esse é o nosso problema. Vocês estão cientes?
Esse é o nosso problema. Agora, executando isso, é
aqui que entra o problema. Já definimos isso e, se você for
específico o suficiente, se olhar para isso em particular
o suficiente, veja isso. Temos as
botas de primavera docker compose. Agora, este Spring
Boots Docker Compose está tentando avaliar um ambiente
Docker, que não fornecemos Não sei se isso
faz sentido. Estamos tentando executar o ambiente
Decker, que não fornecemos Aparentemente, isso vai quebrar. Você entende que isso vai quebrar. Qual é a maneira ideal de realmente
nos mudarmos? A maneira ideal, se pretendemos, lembre-se, estamos tentando
construir para produção agora. O composto Docker
não deve mais ser usado. O composto Docker trampolim não
deve Como resultado, precisamos
começar isso. Quando recomendarmos
isso, ele
não usará mais esse
arquivo de compostagem Tentando ver como podemos conectar
as coisas
automaticamente para nós. É isso que vou
tentar alcançar. Vamos encerrar isso.
Vamos encerrar isso. Esse é o primeiro passo. Eu quero que vocês realmente tenham
cuidado com isso. Vou explicar isso novamente. No momento, ele está usando nosso
dock porque você adicionou doenças, nós automaticamente
ainda usamos esse cara. Quando você tem um arquivo de composição, com tudo isso, ele
automaticamente procura os
módulos de seu serviço, tentando
descobrir esses detalhes, tentando obter um contêiner
que descarte pessoas, o que não temos
naquele ambiente virtual Esta não é mais minha caixa local. Prosseguimos
para desativar isso. Agora, na próxima parada, ela também
será testada. Lembre-se de que, na verdade,
usamos o Docker compose. Se você se lembra do
que fizemos aqui, dissemos que ele não deveria pular
o teste de composição do Docker Ele tentará executar o teste porque, se você observar o comando,
nós realmente os colocamos. Se você observar esse comando, ele não pulará a etapa Ele não pula o teste,
não pula o teste. O que vamos
fazer é limpar o pacote de movimentação e, em
seguida, pular os testes Em seguida, traça D neste perfil. Então, o que isso fará é pular esse teste porque
isso não é uma meta Queremos construir a
imagem. Ele quer fazer apenas essa imagem, mas
isso ainda falhará. Tenho certeza de que você percebe que
isso ainda falhará porque nem mesmo temos um ambiente pós-gás nesta parte do Docker, que é o que
exploraremos no próximo vídeo Mas antes disso,
vamos
dizer que pule o teste. Ignore o teste Vamos chamá-lo de pipeline, remover Docker compose,
spring Docker compose spring Docker compose remover Docker compose,
spring Docker compose e pular o teste.
E isso
vamos explorar. Então, vamos entrar aqui. Então,
eu avanço com isso. Mas nosso comazoe
não teve nenhuma falha pois eles estão tendo falhas
na visão principal no momento Então, vou entrar aqui,
vou criar um problema. Vou chamar esse problema.
Movemos a primavera, inicializamos o Docker Compose
e pulamos Então, isso será um
gasoduto. Pipeline. Agora, deixe-me fazer uma pergunta. Por que estamos pulando o teste? Achei que já temos
tudo detalhado. Por que estamos decidindo
pular o teste aqui agora? Então, vou explicar isso
daqui a pouco, certo? Vou explicar isso daqui a pouco. Agora, estou pulando o
teste porque se você observar a estrutura
do nosso código de como realmente
estruturamos esse código, esperamos que isso aqui,
esse Docker Se pretendemos remover isso, se pretendemos remover isso, precisamos passar essa variável de
ambiente. Precisamos transmitir isso e
nos conectar. Essa é a palavra que
devemos conectar a um banco de dados de pose grass definido dentro do contêiner de
ações do Git Então, vamos pular o teste. Vamos voltar, eu irei e corrigirei isso
no próximo vídeo. Vamos realmente fazer
isso. O que eu vou fazer é chamar isso de skip test, pipeline test skip test Então, vou copiar isso. Então, estou fazendo isso passo a passo, para que você tenha uma boa
ideia do que está fazendo, comprometa e toque nisso Em seguida, fecha. Tudo bem,
então vamos insistir nisso. Então, vamos ver o que
vai acontecer. Tudo bem Nós ainda queremos isso. Isso basicamente falhará, certo? Mas conseguimos
restringir o problema para que eu
dê um passo a passo, para que
possamos ter uma boa
ideia sobre o que
fazer a seguir e como realmente
fazer com que as coisas prossigam. Então, vamos continuar. Então,
agora estamos na seção mas. Ok. Isso geralmente leva
muito tempo, na verdade. Então, vamos tolerar isso. Porque isso não teve sucesso. Então, aparentemente, ele
não pegará nada. Apart é um sucesso, certo? Ok. Agora, veja esses
caras. Você pode ver? Isso foi executado com sucesso
e eu consigo ver o frasco. Isso é o que eu estava
tentando revelar, certo? Portanto, somos capazes de realmente
fazer isso com sucesso. Fazendo isso, agora
é bem-sucedido. Agora, isso é bem-sucedido.
É exatamente isso que estou tentando revelar.
Agora, isso é bem-sucedido. Isso não terá nenhum problema. Não está conectado
a nenhum banco de dados. Eu só estou tentando gerar um arquivo jar e ele
consegue o que eu preciso. Ele pega o que eu preciso.
Se você olhar, esses são todos os
arquivos em que listamos todos os arquivos e
geramos esse tamanho de carro. Eu gerei
um carro do tamanho de um carro novo e ele
conseguiu salvar essa chave. Essa é a chave a ser usada. Quando isso estiver executando o trabalho,
é o que ele vai usar. Dito isso, por que não
permitimos que o teste seja executado? Vamos permitir que o teste seja executado
para permitir que o teste seja executado Precisamos de um
serviço de pós-gás realmente em execução, que não está
disponível no momento. Não o temos disponível. Porque se você verificar nossa ação estamos passando a fonte de dados, todos esses
detalhes do postgaar e Na verdade, não está conectado
ao Postga, vamos ver isso. O próximo vídeo.
10. Contêineres de serviço de tubulação: Ei, pessoal, obrigado por
voltarem comigo. Tudo bem. Então, pudemos
fazer alguns detalhes. Conseguimos realmente
criar o arquivo JAR. Agora, queremos explorar
em um cenário ideal, não
queremos pular o
teste porque o teste é uma parte essencial
do aplicativo, então
não queremos pular Então, como vamos fazer isso? Então, a primeira coisa que eu recomendo
é que
temos que entrar agora, não vamos pular o teste, queremos alterar o comando
para realmente permitir o teste Mas desta vez,
vou para a pasta de ações. Eu copio tudo isso e uso
diretamente em nosso teste. Em seguida, copio os dados sur. Vamos copiar a fonte de dados. Vamos copiar os dados como. Da mesma forma,
acho que vou precisar disso. Vamos apenas copiar as atualizações. OK. Então, vamos trazer isso para dentro. Tudo bem. Tudo bem. Então, eu também quero que vocês
se lembrem de algo. Lembre-se, nós carregamos
isso como inicialização, certo? E se verificarmos nosso teste, você verifica nosso teste, é
o teste de inventário? Você já fez muita coisa? Vamos ver. Então, há uma parte que estamos
realmente carregando com alguns detalhes. Pesquisando, estamos
procurando uma lista
desse cara porque sabemos que isso já existe no banco de dados
e, na verdade, adicionamos algo a ela. Isso falhará se não nos preocuparmos em capturar os dados, esses dados inicializá-los Porque vamos colocar
esse cara lá, o que vou fazer
é escolher isso. Temos que escolher tudo isso. Tudo isso terá que
acabar. Inicialize nossos dados também dentro desse cara Inicialize-o. Para inicializá-lo para
fazer isso sempre. Então, faça isso sempre. Então, isso deve funcionar. Estamos dizendo:
Ok, você sabe o que? Corra sempre. Depois de
conectar o banco de dados, execute-o sempre. Esperamos que você esteja
usando em um
outro lugar ,
acabaremos com duplicatas Mas de qualquer forma, ainda vale a pena
tentar. Então, vamos ver isso. Então, agora conseguimos fazer isso, certo,
para poder adicionar esse detalhe, voltaria para
esse arquivo e, em
seguida, removeria o teste de salto e
não pularia mais o teste Então você não está mais pulando o
teste. O teste, lembre-se de nossos testes, não
temos nenhum perfil, então nosso teste será
executado nesse padrão, certo? Agora, que outras coisas
vamos perder? faltando um pouco de algo
muito importante, porque lembre-se que estamos usando o Doka usando
qual é o nome agora Você está usando um convidado de postagem. Precisamos ser capazes de
trazer isso também. Esse cara precisa estar presente em nosso contêiner,
caso contrário falhará. Lembre-se de que estamos
usando as poses, mesmo em nosso teste, para nos conectarmos. Portanto,
temos a mesma compostura. Também temos um recurso de serviços. Há um recurso de serviços no Git Actions.
Isso é incrível? Você tem um recurso de serviços que existiria por trabalho? Ele existe para cada trabalho. Então, eu quero que ele seja executado dentro
desse trabalho. Coloque isso aqui. Então, esse cara também estaria disponível em nosso GitHub
e nas ações do Git,
e isso, na verdade,
eu apenas copiaria Então, agora vamos ver quais são as coisas
que não são permitidas. Diz que
o nome do contêiner não é permitido,
proibido, então
não queremos isso. Aparentemente,
nem estamos usando isso. O que diz aqui? O ambiente não é permitido, Scheman não é permitido, mas precisamos adicionar
alguns ambientes. Está bem? Tudo bem. Como eu sei que
precisamos , precisamos que esse banco de dados Post
guys esteja disponível. Precisamos desse post, pessoal, DB. Vamos pesquisar na camada de
serviços para ver como podemos conectar o ambiente que realmente
exigiria. Aparentemente, não estamos
usando os vasos, os vastos usuários que padronizam Mas vamos ver
como isso realmente funciona. Sim, com isso, então
explore os serviços. Tudo bem. Então, vamos dar uma olhada nos serviços. Então, esses são contêineres de serviço. Agora, veja a definição. Você pode usar contêineres de serviço
para se conectar a bancos de dados, serviços
da Web, caches de memória e outros ao seu fluxo de trabalho.
Agora, veja essa parte. Os contêineres de serviços são contêineres do Docker que fornecem uma maneira simples e
potável de
hospedar serviços que
talvez precisem testar
a operação em seu Então, isso é basicamente
o que precisamos. Vamos ver
como isso funciona. Agora, esta é uma nota muito importante que eu quero que vocês
tenham em mente Se você estiver usando
ito hosted runner, que você está usando,
você deve usar o Bunt Se você estiver usando executores
auto-hospedados, você deve usar uma máquina Linux, e o door came deve estar instalado Você precisa realmente ter
isso em mente, certo? Você precisa basicamente
ter isso em mente, porque se você não
tiver isso em mente, isso não funcionará. Se houver um corredor auto-hospedado, você
deve cuidar disso Se você estiver usando
isso, ele está dizendo que docker pode ser instalado
. O
Docker Engine
está automaticamente disponível para nós usando executores hospedados no Git Como você faz isso?
Isso é uma amostra. Veja, eu removo
o nome do contêiner porque podemos dizer um nome aqui, podemos
declarar o nome aqui. Se você voltar, você pode
basicamente vir aqui. Coloque isso lado a lado.
O lado a lado. Está bem? Então, se você olhar para isso, diz que você pode então ligar para os serviços. Para esse serviço,
você pode vir aqui e dar um nome, o nome da
corrida que vou executar Então, vou chamar esse contêiner. Portanto, o contêiner
pode ter um nome. Qual era o nome aqui? Acho que se chama Boosre,
chame isso Então temos isso, e se você
olhar isso corretamente, felizmente
temos um
contêiner de serviço postga, o que é bom,
que é apenas uma forma predefinida conectar o postgas Vamos vir aqui. Acho que isso nos
dirá
tudo o que precisamos. A imagem que precisamos, eu preciso da imagem 16 ou duas. Foi com isso
que testamos. Agora, isso deveria ser ENV. É uma fonte de comando usando ENV. Aqui temos que usar o nome sem aspas, vamos fazer isso. Vou colocar o EQ
com uma coluna, certo? Isso também
tire isso, tire esses. Acho que posso fazer isso
com g, posso fazer isso. Retire-os e
altere-os para Alterações na coluna. Alterações na coluna. Sim, então remova
isso e isso. OK. Ok, isso
não está alinhado corretamente Portanto, há alinhamentos alinhados. Então você vê isso agora, lembre-se que não
precisamos ter um código porque você já sabe
exatamente como buscá-lo Então, basta fazer isso. Como isso é um banco de dados, certo? Isso é um banco de dados. Isso
deveria ser um modelo. Module seu nome de sublinhado
do banco de dados. Eles já têm isso. Para o nome de usuário e
a senha, a mesma coisa. Você ainda não precisa
definir isso. Oh, desculpe, isso é DB agora, esta é a senha.
Esse é o usuário. Este é o usuário poscas.
O que você coloca aqui? Vamos conferir. Eu não
misturo as coisas. Tudo bem. Usamos o que fazemos como nossos usuários. Vamos voltar ao nosso arquivo de
composição, arquivo de composição. Compose files também
modula a mesma coisa. Nome de usuário e
senha, a mesma coisa. Vamos voltar aqui para nos
posicionar, volte aqui. A mesma coisa. Assim como diz o nome.
Qual é o nome? Não é Spit como
senhas o nome, depois a senha VSA.
Isso é o que usamos. Agora, lembre-se de que
não salvamos essa atribuição. Não salvamos esse
ambiente de atribuição que recebemos, guardamos um segredo.
Como você avalia os segredos? Como você avalia os segredos. Avalie os segredos, você usa
a palavra-chave segredos. É assim que você avalia os segredos. Os segredos são avaliados com a
palavra-chave secreta, desculpe, não é isso. Segredos. Eu avaliei com isso. Acho que isso basicamente
nos dá uma ideia do que fazer. Agora, você pode ver que
essa postagem não exige que
usemos esse cara. Então colocamos isso e, na verdade,
podemos testar isso. Vamos testar isso para ver se estamos gradualmente removendo isso
para
remover o teste de salto Nós viemos
aqui para adicionar esse cara. Então, estamos vindo aqui para
adicionar o contêiner de serviço. Eu expliquei como funcionam os contêineres
de serviço. Vou compartilhar o link
para os serviços. Então, queremos executar isso. Isso não será codificação rígida. Acabamos de testar isso novamente
e podemos ver, isso
funciona? Isso funciona? Vamos. Vamos descobrir. Nós simplesmente entramos e executamos isso. Vou apenas criar o procedimento Normalmente eu crio um problema.
Vou criar um problema. Vamos chamar o pipeline de problemas
usando contêineres de serviço. Tudo bem. Então, vamos fazer isso. Então eu vou salvar
isso junto com isso. Confirma o TAM, fecha e depois pressionamos E veríamos isso
realmente chegando aqui, fecharíamos isso, e
isso entraria. Tudo bem, então vamos
expandir isso e descobrir o que
acontece. OK. Isso está funcionando.
Estamos interessados nesta seção, lembra?
Continue assistindo. Acho que podemos atualizar, você
não o viu se movendo, apenas atualizando Podemos começar a atualizar e depois entrar para
ver o que está acontecendo Algo falhou
Algo falhou. Vamos entrar para ver o que
aconteceu com um construído com M. Diz possuir realmente preenchido, inveja e não encontrado W. Mas nós apenas a VN trabalha para
nós. O que aconteceu? Se mudarmos alguma coisa, você realmente
descobrirá que V não foram encontrados. Acho que não deveriam servir
nossos contêineres, mas o Envy NV não foi encontrado, temos que voltar, ou vamos ver como
estruturamos esse cara Vamos expandir isso. Ok. Então, temos um
contêiner de serviço disponível, o que é um progresso, e isso realmente
nos dará os detalhes de que precisamos. Então vamos puxar esse cara. Então vamos embora. Ao menos puxou? Você puxou a
imagem? Vamos ver. Uma série. Então pare
e remova o poquest Isso significa que temos um contêiner
postgast, que é bom. Os contêineres estão bem. Isso é bom. Isso
é bom. Vamos ver. Eu só quero confirmar isso.
Então, para onde o Maven pulou Tivemos o Maven rodando mais cedo. Então, algo definitivamente
aconteceu dentro do trabalho. Então, vamos voltar e ver
o que pode ter acontecido. Então você mudou alguma coisa aqui? VN é o que administramos. Em seguida, o pacote, e
isso foi consistente. Usamos a palavra-chave VN
configurada no Maven, então o que mais você faria? Sim, limpamos o
pacote, listamos os arquivos. Então, idealmente, não devemos
ter nenhum problema com isso. Eu não deveria ter nenhum
problema com isso, certo? Então, não deve haver
problema com isso. Então, vamos voltar às peças. Existe uma maneira de reativar?
Vamos refazer esse trabalho Vamos correr. Quero
executar novamente esse trabalho. Executamos um C que pode escolher
esse arquivo, esse fluxo de trabalho, essa imagem B push, Bud pushimage para Esse é o nome.
Posso correr daqui? Agora, eu tenho que entrar aqui. Depois corremos, executamos
todos os trabalhos de campo. Vamos dirigir esse cara,
essa seção de beleza. Vamos ver o que acontece.
Provavelmente vamos finalizar o login. Vamos ver, talvez haja
algo que esteja faltando. Executamos isso novamente e vamos
ver como funciona. Veja a lente de vídeo
em que fazemos
isso, talvez esse 14 já
precise, vamos dar uma olhada. Então, vamos ver como isso se
desenrola, entre no código. OK. Ok, então deixe-me
pausar isso e voltar, Sarus, e pegar o
vídeo Tudo bem. Então, isso está concluído
e ainda está preenchido. Então, vamos voltar
no próximo vídeo. Como você não está encontrando Mv, talvez seja necessário
adicionar um Mv em ação para definir uma configuração
móvel Vamos fazer isso no próximo vídeo.
11. Correção de erro do Pipeline Maven: Oi, pessoal. Z aqui. Tudo bem, não
conseguimos fazer isso com sucesso no último vídeo e devido
ao fato de que não
estávamos movendo ou achando isso. O que eu tive
que fazer foi verificar, eu tinha que ir e verificar os serviços
pré-instalados. Então, quando o contêiner estiver pronto, Git Hub Git action promete
que haverá algum software específico instalado no ambiente Ubuntu Eu quero mostrar a vocês como
realmente descobrir isso. Então, se você realmente verificar isso,
ok, vamos dar uma olhada nisso. Achei que tinha puxado para cima. OK. Portanto, temos a
lista de hosts runners. Sim. OK. É isso mesmo. Vou deixar o
link. Vou deixar esse link. Garanto que, de fato
, salve-o e disponibilize-o, no link desses links. Agora, se você olhar para
isso, essas são as imagens disponíveis. Agora estamos usando o Ubon duas camadas. Boon to latest se referiria a
22 em quatro e diria que este é
um software incluído Vamos clicar aqui para ver o software incluído.
Vamos descer. Assim, você pode ver
facilmente para não precisar instalar
o software que já
está disponível, certo? Agora, vemos que essa é a imagem, então
o software é o idioma que está
disponível por padrão. Não temos Java aqui. Foi por isso que
realmente tivemos um Java. Em seguida, gerenciamento de pacotes,
temos PP PPPx, vamos lá. Então, se você verificar as
ferramentas que estão disponíveis. Veja o gerenciamento de projetos. Temos Maving três.88. Supõe-se que o Maving de três pontos e oito esteja disponível. No entanto, tentamos ver que não estamos
recebendo esse recurso. Eu me disse que algo está errado ou que algo realmente o
alterou Quando verificamos isso,
acho que não
fizemos nada errado ao trazer isso aqui porque configuramos
o ambiente Java. Isso teria
funcionado basicamente, mas por algum motivo, na
verdade falhou. O que eu vou fazer, listando isso, vamos também fazer isso. Também podemos adicionar sob comando. Vamos fazer uma versão do VN Dash. Vamos ver se isso
realmente é instalado. No Ubuntu, na maioria das vezes
temos essa parte. Na verdade, o caminho é
chamado de slash OPT, Apache. Vamos fazer um LS sobre
isso. Vamos fazer isso. Vamos fazer um L S sobre
isso neste caminho. Vamos ver se esse caminho está disponível e, se estiver disponível, vamos ver o que está disponível
nesse diretório. Você vai executar
isso agora. Vou executar isso para ver. Eu vou dizer
impressão de versão móvel,
chamada de versão de impressão Mv Eles só vêm aqui com problemas. Quando não a encontrarmos, vá em frente e inclua uma ação, uma ação personalizada que apenas configura o Mving diretamente. Isso é o que
vamos fazer. Tudo bem. Vamos entrar
aqui, basta dizer gasoduto. Pipeline. Então, digamos que imprima. Detalhes da mudança. Vamos salvar
isso. Vamos copiar isso. Vamos ver o código, a
menos que recebamos commits. Então vamos fechar isso.
Acho que não copiei tudo. Isso é 27, 27. Vamos fazer isso. Vamos pegar um empurrão. Vamos prosseguir.
Vamos voltar aqui, conferir nossas ações. Aparentemente, isso é
enfatizado nesta seção, exceto empregos. Então, vamos executar isso. Vamos verificar. Ok, os continuadores
estão inicializando. Então, não precisamos ter medo. Se você olhar para os contêineres, não
podemos nos ater criticamente. Então, isso é realmente fazer você dar uma olhada,
após o recipiente de gás. Portanto, temos certeza de que está até mesmo puxando uma ou
duas postes de gás. Portanto, temos certeza de que nosso posto está disponível. Então, essa
é muito boa. Isso é uma coisa boa. Isso
é bom para nós, certo? Portanto, sabemos que o gás postal foi
instalado com sucesso. Deixe-me fechar esses
continuadores inicializados. Código G. Acho que executamos get code. Este é o
campo do Pará. Vamos ver. Isso é configuração.
Não conseguimos encontrá-lo. Estamos tentando imprimir isso e o que você
descobriu? Vamos ver. Diz uma versão móvel,
uma versão em movimento. Isso acabou, você
não tem nada, certo? Ah, então ENV Aparentemente, não estamos
vendo o que precisamos. Essa é a CyndiPa porque esse filme é a versão
que eu deveria ter Essa parte que eu deveria ter, mas não
está encontrando VN, não foi encontrada O VN não foi encontrado. Eu não tentei imprimir isso,
provavelmente eu deveria ter impresso isso antes,
a outra parte deveria ter impresso isso
antes. Vamos verificar isso. Mas ao invés de fazer isso
, não fica muito tempo com o
vídeo por isso. Vamos ao
mercado e
procurar , vamos
ao mercado. Vamos ao mercado
aqui. Vamos escolher isso. Vamos usar esse plugin de movimentação, essa movimentação temos essa ação de
movimento, ação personalizada. Vamos trazer isso
e vamos embora. O que eu vou
fazer é colocar isso imediatamente depois disso. Nós vamos fazer
isso. Então vamos resolver isso com. Se você não tiver certeza,
também podemos instalar manualmente. Se você verificar, podemos instalar
manualmente. Se você mover um patcher, um patch de maven.
Então você faz o Ubuntu. Então, para instalar o Pache Mav no
Ubuntu, como instalar o Pat? Portanto, você tem vários
links para realmente mostrar como
instalar um Pach em um Bunto Então esse é o primeiro passo. Temos uma variável de
ambiente Java. Isso já está configurado para
nós. Nós temos isso disponível. Então, para instalar agora,
poderíamos realmente obter isso. Veja, isso está disponível.
Você pode simplesmente escolher isso e ver que há muitas etapas,
muitas etapas. Decidi usar
a ação personalizada, mas, no entanto, você
poderia simplesmente escolher isso e
usá-la diretamente, certo? Você só precisa nos mostrar para que
possamos ver isso funcionar. Então, vamos tentar a primeira opção. Se você ainda está
tendo problemas
, certo, teremos que fazer
isso sozinhos Nós movemos esse nível baixo, o
adicionamos ao passe e fazemos as
coisas sozinhos Eu pensei que ela
realmente mencionou isso. Vamos voltar ao código. Agora que temos esse salvamento
, fazemos git commits. Eu CM, então direi que adicionei uma ação de movimento
personalizada. Diga isso. Foi adicionada ação de
movimento personalizada. Então você pode
fechar isso. Tudo bem. OK. Então, vamos ver. Isso realmente faz o trabalho. Tudo bem, então
vamos às ações. Então isso é Building. Vou
relaxar e refrescar isso Então, vamos entrar. Tudo bem. Então isso é Building. Vamos
atualizar isso mais uma vez Então isso é Building. Eu só
quero ver o bar se mexer. Certo? S inicialize Ok, então comecei.
Segundo salto. Então, a configuração
foi feita diretamente. Então, mais perto de Mvn
configurando o Maving. Então você está
tentando configurar o Maven. Sim. Tudo bem. Então, vamos ver porque
isso me dá detalhes agora. Tudo bem. Então você vê que isso foi realmente
impresso com sucesso. O Maving foi
impresso nesta versão VN, e o arquivo OPT nos deu
todos esses detalhes OK. Então, podemos ver que o
Mavin está funcionando agora, então conseguimos
resolver esse problema Então, vamos descer.
Vamos esperar por isso. Acho que você vê
erros aqui, vamos permitir que termine, então podemos realmente depurar para
ver qual é o erro agora Este trabalho falhou, vamos
verificar. Eu só verifico. Basicamente, alguns dos problemas
que você encontra em seu funil. Algumas coisas que estavam funcionando
antes de pararmos de funcionar, você quer depurar para ver o que aconteceu com o tempo.
Você pode ver como
realmente resolver isso, ok Então, uma vez que você desce, esse é o teste. Agora, sim, ótimo, ótimo.
Esse é o teste. Então, qual é o problema
com o teste? Então diz que não há um
ponteiro, é SQL, certo? Está falando sobre, oh,
não está conectado. Veja, ele não está
conectado ao banco de dados. Esse é o problema aqui. Não está conectando
o banco de dados, ok? Então, aparentemente,
esse é o problema. Não está conectado
ao banco de dados. Sim, não está
conectando o banco de dados. Então, confira isso novamente. Sim, começando, você
vê que o pool de transporte iniciando não conseguiu obter
conexão, aparentemente. O teste não está se conectando. Esse é basicamente
o problema. Conseguimos
chegar a esse estágio. Tudo bem, pessoal. Vejo
vocês no próximo vídeo. Nós avançamos mais rápido em uma etapa
de movimentação de um problema. Agora, na verdade, continuamos com o banco de dados sem
conexão, e isso será corrigido no próximo
vídeo. Te vejo, pessoal.
12. Pipeline explica mudanças de construção: Oi, todo mundo. Z aqui, certo. No último vídeo, na verdade, usamos a ação personalizada e,
usando isso,
usamos a
ação personalizada e aplicamos usamos a
ação personalizada e aplicamos a ação personalizada usando
essa parte específica aqui. Então, podemos apresentar isso. Então, o que eu percebi é que
alguns dos recursos realmente prometidos
no Ubuntu runner basicamente não
estavam funcionando
como deveriam, certo? Então, passamos
a ter
uma configuração de movimentação personalizada, e isso foi capaz de trazer
o comando de movimentação. Em seguida,
colocamos alguns detalhes. Tudo bem, então o que eu
fiz foi testar alguns testes
para ter que executar o
teste de movimentação, o teste de
maving e a compilação.
Descobri que algumas
coisas estavam E o que estava
falhando foi que eu vi que as variáveis de ambiente
que definimos não estavam sendo injetadas Eles não estavam sendo injetados. Olhando para a configuração, eu tenho que olhar
a documentação mais uma vez. Analisando a configuração
, ela me deu algumas ideias sobre basicamente como
fazer isso. E foi assim que consegui realmente
fazer isso. Se eu voltar aqui, esse é
o que usamos para nos mudar. Então, vamos entrar em ação. Então, vou postar contêineres de serviço de
contêineres de gás. Vou chamá-lo de serviços gtconcion. Obtenha serviços de ação.
Esse serviço continua. Foi aqui que tive a
ideia que eu realmente uso. Indo para postar o recipiente de gás. Eu vi que quando eles estavam tentando executar isso nesta
etapa, eles ainda adicionaram uma variável de
ambiente para adicionar o ambiente, o que eles queriam usar
dentro do aplicativo. Eu fui em frente e fiz exatamente
a mesma coisa. É por isso que
, em primeiro lugar, mostrei ao ambiente a
certeza de que ele está realmente chegando, porque eu não tinha
mais certeza de que estava
recebendo tantos erros. Se você verificasse a
ação, mas desse projeto, veria que
existem vários números porque eu fiz muitos testes
e não queria fazer isso ao vivo em vídeo para
poder obter a precisão
antes de voltar para vocês. Então, tendo feito isso, fui em frente e
separei o teste. Lembre-se de que, antes, estávamos fazendo uma mudança de pacote limpo, não
tínhamos o teste de pular O ideal é que,
em um pipeline, você queira separar
seu teste para ter certeza de que todos os
testes
sejam executados com sucesso. É por isso que eu apenas executo o teste de movimento diretamente com
este teste de movimento limpo Isso executará todos os
testes que temos. Em seguida, separei isso para fazer a construção e depois
mover o pacote limpo. Como fizemos o teste aqui,
posso pular o teste aqui. E aqui eu estava
apresentando aquela primavera que , na verdade,
usaria nosso arquivo Docker Isso é basicamente o que eu fiz aqui e as coisas
realmente funcionam com sucesso, o que é muito bom,
é muito bom. Sim. Qual é a próxima etapa? Quais são as coisas realmente
alteradas para fazer isso funcionar? Em primeiro lugar,
lembre-se de que estamos usando os Springboks Agora, isso definitivamente
causaria problemas aqui. Lembre-se de que, no
aspecto de você ter um motor Docker funcionando e
ele estar
tentando realmente interromper parte da cura pós-gás sozinho,
haverá Primeiro,
entrei e removi o springboard docker compose
e, removendo o
springboard docker compose ,
automaticamente, tive que
remover essa propriedade,
que é o Docker
compose skpping test, que o springboard docker compose
e, removendo o
springboard docker compose,
automaticamente, tive que
remover essa propriedade,
que é o Docker
compose skpping test, que usamos anteriormente no vídeo. Acho que esse segundo
ou terceiro vídeo também. Tive que remover isso para que
não tivéssemos distúrbios, Sim, para que eu fosse capaz de fazer. Em segundo lugar, lembre-se de que
lembramos que tínhamos esse script, além de injetar
o inventário Portanto, injetar o
inventário também
falhará para nós, porque
a propriedade que
definimos nesta parte é
para você executar atualizações, então isso
provavelmente nunca deveria acontecer, certo? Mas quando estamos executando nosso teste , temos que definir isso para nunca. Dissemos isso para nunca porque
injetamos apenas uma vez, depois estamos executando o
teste repetidamente. Mas agora que está automatizado, preciso encontrar uma maneira de,
quando cada
concurso de teste estiver sendo executado, ele sempre tente não inicializar ou
tentemos inicializar Lembre-se de que, ao fazer o teste, cada teste carrega
o teste de botas de primavera. Este é um teste de bota de primavera. O que significa simplesmente que ele
abrirá o concurso
todas as vezes. E mencionar o
concurso toda vez tem uma vantagem ou
devo chamar de desvantagem agora Se você sempre
tentar executar seu script, se definir isso como sempre que estiver lá
para continuar apresentando o erro dizendo que essa propriedade
provavelmente
já existe no banco de dados ou empreendimento que já contém essa palavra-chave,
ele continuará falhando Além disso, o que eu tive
que fazer foi criar um esquema. Eu pego o
esquema diretamente de. Como eu consegui que isso fosse muito simples? Então, dependendo do
cliente ou dois que você está usando, eu poderia ter
isso diretamente. Você pode, se estiver usando o Intelligent Ultimate,
como eu Data Grip ou alguns outros
clientes ou corretores, basicamente
gerar o DDL Então, o que eu tenho que fazer é quando entrei aqui, você
vê, então eu tenho isso. Acabei de gerá-lo diretamente. Então foi isso que eu fiz.
Acabei de gerá-lo. E para o gerador eu
acabei de copiar e que eu
realmente coloquei aqui Então, vou repassar isso de
novo, rápido. Eu só clico, vou para SQR
Scripts e depois para o gerador. Uma vez que você vá para o gerador, isso realmente o
geraria. Eu acabei de copiá-lo. Eu não precisava disso.
Eu pego isso e pego isso e é isso
que você tem aqui. Você pode ver que eu tenho
o índice de criação, eu tenho isso
exatamente como nós temos. Qual é a ideia agora? A ideia é que, se você
olhar para nossa propriedade, dissemos: qual é
a propriedade agora? Dissemos que deveria
adiar a inicialização. Não estou criando a tabela de
inventário. Estou criando manualmente a tabela de
inventário. Isso é para favorecer nosso teste. Isso é basicamente o que
eu fiz. Ao entrar aqui, isso dispara, isso dispara. Tirei isso. Eu adicionei isso, quero
dizer, adicionei isso, estou descartando a tabela
toda vez, se ela existir Eu o solto, eu recrio e depois insiro. Isso
fará a inserção. Então, a criação
é a inserção. Assim, toda vez que o concurso de
teste realmente surgir, isso eliminará a
tabela, se existir. Uma vez que isso acontece, então inserimos. Você não saberia se
a chave já existisse.
A chave já existe. Lembre-se de que tudo isso
é a
favor de termos que construir a imagem. Então você pode realmente mover
as coisas, certo? Mas, idealmente, quando eu
vou para a produção, você teria um banco de dados de
produção, que você
nem deveria usar o DD ello DD
yellow também, certo? Este é o amarelo também.
Você o configura como nulo ou nu, em vez de
movê-lo totalmente, certo? Acho que mencionei isso
algum tempo antes nos vídeos. Então, o que você deve
fazer é carregar o
script da mesma forma
que você tem esse script aqui, como
você tem esse script aqui. Você basicamente gera esse
script para todas as outras tabelas. Então você vai, você o entrega para o pessoal do
seu DBA e o executa
diretamente no banco de dados, de dentro
das
propriedades para null Mas ainda está
bem. Como você está realmente criando
isso no pipeline ainda é
possível mover as coisas para ver se as coisas realmente
funcionam com precisão. Ah, sim. Então eu fui capaz de fazer. Vou revisar as mudanças
novamente, temos uma visão geral. Então, se você está realmente
acompanhando este projeto e está
tentando codificar, então você sabe exatamente o que fazer. Quando você chega a esse
estágio, o que você precisa
fazer é desativar esse cara, que é o trampolim do
Docker Compose, depois entrar para executar o script, apenas mostrando como você
pode Lembre-se, não se esqueça
desta tabela de empregos. Não se esqueça desta tabela de empregos. Tudo será
comprometido como está, para que eu possa realmente
usá-lo diretamente. Então eu tenho isso e sabemos que estou usando essa ação. Mas se você está muito curioso
para saber, veja isso, enquanto eu estou fazendo o teste, você pode ver que eu não passei. Eu não passei nessa parte. Eu não passei em nenhum perfil. Estou dizendo para usar qualquer perfil
padrão que você vê. Na verdade,
isso usaria esse perfil padrão. E esse
perfil padrão sempre
terá isso como atualizações e removerá esse cara
e isso eu consegui fazer. Lembre-se, eu tive que adicionar todas essas propriedades,
essa propriedade, todas essas propriedades
que você vê aqui. Então, cada propriedade
um, dois, três, quatro, cinco, se você ver, se você perder uma delas,
você tem erros. Este não deveria ser
o cronograma de uso porque acredito que
uma vez que você
o conecta nas configurações e nos define o
que você faz no Github,
quero dizer, esta parte aqui Estou neste pacote. Entendo por que isso está aqui,
nesse ambiente. Nesse ambiente
aqui, tudo realmente
deveria ser
injetado automaticamente Mas descobri
que quando você chega às etapas, as coisas não estão funcionando como estão. E, por favor, observe aqui que
espera-se que usemos
Pogues e nenhum host local Então, o que você usou como
nome do contêiner, certo? Tudo o que você colocou no
nome do contêiner deve ser seu anfitrião, certo? Porque eu tentei um host local. host local estava cheio e isso me causou alguns
problemas com a depuração Então, quando mudei para
isso, funcionou, e tive a
ideia de usar essa parte. Nesta parte,
adicionando o host como Postgest, consegui realmente
fazer isso funcionar, certo? Tudo bem, então eu acho que
isso foi feito. Enquanto fazemos o teste com vocês agora, vocês veem
exatamente como funciona. Eu provavelmente mudo mais
uma coisa. Agora que construímos isso,
temos uma seção de amostra, temos uma seção construída. Agora é hora de focar nisso. Mas antes de tudo, queremos ver o que foi
listado no arquivo. Vamos explorar isso para
ver o que foi listado. Mas vou
adicionar uma propriedade Ns. Vou adicionar uma
propriedade, que é needs, e basicamente precisamos de
uma construção. Qual é o nome
desta seção? Seção é o que? Seção de construção. Essas necessidades, você
pode realmente adicioná-las à medida que as adiciona dessa forma. Funciona. Você provavelmente
adiciona essa forma como uma lista. Se você tem sete empregos,
esse trabalho depende. Mas se for só
porque é apenas um, posso simplesmente
adicioná-lo como um único trabalho. Agora, o
que significa isso ? Lembre-se da implementação
padrão, o comportamento padrão é que os trabalhos são paralelos,
eles são executados em paralelo. Mas adicionando isso,
você o está forçando a dizer:
Ei, essa seção de imagens push é totalmente
dependente desse cara Você verá que isso é totalmente dependente depois de
executá-lo agora. Vou postar que vou
parar esse vídeo
aqui para que possamos realmente assistir
ao próximo vídeo e exibi-lo, porque já são cerca de
10 minutos. Vejo vocês no próximo vídeo.
13. Artefato de upload do pipeline: Oi, todo mundo. Z aqui. Tudo bem. Então, agora temos esta seção em
que precisamos executar isso. Vou fazer uma
rápida recapitulação porque gosto do amigo e acredito que isso ajuda a manter as
informações Eu tive problemas aqui ao tentar executar este
teste, o teste. Separei o teste
da compilação principal
e, você pode ver, estou apenas fazendo um teste
limpo aqui, mas aqui, não vou
pular o teste Portanto, o ideal é que seu teste seja
executado antes da compilação principal. Basicamente, é assim que o pipeline deve funcionar para garantir que você não tenha nenhum teste que falhe Eu tive que trazer todas
essas propriedades, que na verdade foram
declaradas nesta aplicação
do inhame, e esse Yamil
é totalmente para o teste Você pode ver que está
no teste. Diz, como trazer todas
essas propriedades. Agora, isso deveria ter
sido conectado diretamente porque o definimos
nas configurações Na verdade,
configuramos as configurações, mas descobri que
não traz nada. Então, como trazer
manualmente o ambiente Tirei a ideia dessas partes. Eu vi a documentação em que
eles tiveram que trazer para o
teste as propriedades. Então, eu consegui fazer
isso realmente funcionou. No momento, o que
estamos testando é que
adicionei esse recurso
que é Needs. Necessidades significa o que quer que você coloque lá, isso também
pode ser uma lista. Eu mostrei isso no último vídeo. Isso significa que isso será executado primeiro
antes de realmente ser executado. Então, isso é suficiente e, ao mesmo tempo em que
exploramos esse arquivo de destino para conhecer os arquivos
e o que armazenar em cache , podemos seguir
em frente com o que enviar. Sempre que eu quiser fazer o upload,
quero baixar algumas coisas. Assim que eu realmente fizer isso,
poderemos realmente
entrar na seção. Tudo bem. Vamos fazer isso. Vou cometer isso, vá aqui. Aqui, eu realmente
confirmo essa chamada
configurada, digamos , desse pipeline
para manter o contexto. Eu diria que execute o trabalho em sequência. Isso mostra que você poderá realmente seguir com
a trabalhos em execução, basta chamá-la de Run
Job is sequence. Vou copiar isso, depois
vou entrar aqui. Então, vou cometer
isso contra esse Git,
confirma isso e fecha Então eu empurro. Você empurra. Ok, então vamos seguir essa
viagem. Então, isso acabou. Vamos entrar aqui. E
vamos às nossas ações. Essa é a parte que eu estava
mencionando. Se você olhar para isso, há
vários pelos. Eu tinha vários philos, certo? Enquanto eu estava
tentando testar tudo
isso, consegui realmente
trabalhar aqui. Vamos acompanhar isso. Você pode ver porque eu o
executo em sequência, você pode ver isso porque
eu tinha a palavra-chave bacana Veja, agora isso está
esperando que isso executado antes que todos
funcionassem de forma independente, mas agora isso está
esperando, o que é muito legal, isso é muito legal. Agora sabemos como executar o sequa.
Vamos continuar com isso espero que não
cometa nenhum erro e possamos passar
para a próxima parte Vamos esperar por isso. OK.
Então, isso está acontecendo. Vou apenas postar o
vídeo. Eu voltarei quando esse trabalho estiver totalmente executado. Não importa, o trabalho está próximo de 30, mas o trabalho executado é 40. Eu vou ter 40 anos, então eu vou
voltar quando isso for feito. Então, eu não quero atrasar. OK. Tudo bem, pessoal,
o trabalho está feito. Como você pode ver,
isso foi um sucesso. Fiquei muito feliz com o
sucesso porque, na verdade,
passei por muitos
problemas para conseguir E você pode ver que isso também funciona. Então, temos as coisas
realmente funcionando. Então, estamos interessados nos
arquivos que foram listados. Lembre-se de que queremos fazer o download, queremos realmente mover arquivos da seção Mas para
a seção push Min. Poderíamos ter feito
tudo em uma única etapa, mas eu só quero usar
a ideia para mostrar vocês como realmente fazer
upload de artefatos Essa parte está realmente aí
e como baixá-la. Essa é basicamente a outra coisa que você poderia ter feito
tudo de uma vez. Certo? Eu também queria mostrar
a vocês que uma etapa de uma tarefa pode depender outra tarefa e como
realmente configurar. Sim, então essa é a ideia toda. Tudo bem, então vamos listar o arquivo. OK. Tudo bem. Então,
listando os arquivos, pudemos ver que temos um arquivo
JR, que é um script. Então,
olhando para baixo, olhando para isso, temos praticamente
todos esses detalhes. Esses arquivos estão realmente
em execução, são o Yamofle, o arquivo Do, o aplicativo dock
do Yamil e similares Então,
na verdade, temos tudo em belos trabalhos. Isso
funciona. Tudo bem. Então, a ideia agora é quais são as coisas que
queremos enviar? Precisamos especificar quais são as coisas que você
deseja enviar. Agora, lembre-se de que isso está disponível dentro
dos alvos, certo? Isso está disponível
dentro do alvo. Então, se você verificar esse caminho, lembre-se de que fora do
arquivo de destino, temos a composição Quero dizer que temos o
arquivo Docker. Lembre-se, vamos
dar uma olhada na estrutura e no projeto para que
possamos ter alguns. Então, nós temos isso. Isso é uma estrutura.
Temos um arquivo Docker externo e, dentro da pasta de destino é onde basicamente temos
o arquivo JAR depois que ele é criado Então, vamos manter isso em mente. Então, isso está
basicamente fora da raiz
e, na verdade, dentro
da pasta de destino. Então, vamos agora adicionar. Agora vamos adicionar os
arquivos que queremos enviar. Então, para fazer upload de arquivos, vamos
ao mercado e ver se há mais alguma coisa
relacionada ao upload. Na verdade, existe, mas
eu quero mostrar para vocês. Então, vamos usar Gits,
ação, marketplace. Venha aqui, vamos
pesquisar o upload. Então, vamos fazer o upload. OK. Se você observar,
carregamos um artefato de construção, o artefato Upload a Bed,
como ele é usado Acabei de descer. Use. Você usa Ações, carrega artefatos em V quatro Então, como carregamos os
arquivos que queremos inserir? Para baixo. Vamos descer. Veja, existe essa
parte chamada Caminho. Primeiro, podemos lhe dar o nome, o nome. Esse nome é muito importante. Esse nome é muito importante.
Precisamos desse nome para que esse nome seja o que usamos,
na verdade, depois de carregado, é usar esse nome basicamente como uma chave e, quando
estivermos fazendo o ping,
possamos
realmente buscá-lo possamos
realmente buscá-lo Uh, partes dos arquivos
que você realmente deseja enviar. Você vê que diz se não
há arquivos. Basicamente, é assim que se usa. Vamos se você
nos der mais exemplos. Ótimo. Como você vê, você pode adicionar o arquivo que deseja usar Então, podemos fazer upload de
vários arquivos? Porque você quer fazer
o upload do download, Ah, sim. Consegue ver isso?
Pode fazer o upload disso. Agora, na verdade, o que é isso aqui? E isso significa que você deseja
executar um comando de várias linhas. Um comando de várias linhas ou na verdade, escolha esse caminho
em linhas separadas Embora todas sejam registradas
como linhas separadas, e é exatamente isso que
você vai usar Vou adicionar
essa documentação que eu realmente compartilho para
que vocês saibam exatamente como examiná-la. Sim, vamos voltar
ao nosso projeto. Então, como vamos fazer isso? Vamos voltar.
Vou escolher esse caminho. Queremos usar isso.
Interessado nisso, vou apenas copiar isso como está. Sim. Sim, eu quero algo assim, quero
algo assim. Ok Ok, então queremos fazer o upload de algumas
caudas. Eu vou entrar aqui. Ligando para Ning. Vamos fazer upload
de artefatos Tudo bem. Então isso é legal. Em seguida, use. Isso é o que eu copio para que
fique alinhado Eu não preciso mais disso. Nós temos isso. Então,
basicamente, é disso que precisamos. Em seguida, queremos entrar em
nossa pasta de destino, nossa pasta de destino para escolher o arquivo que realmente
queremos usar. Então, eu vou dizer alvos. Lembre-se de que isso estará nos destinos e na barra do arquivo
raiz. Não sei se isso
aceita um curinga ou
vamos testá-lo
que aceita um curinga Então, dentro disso, você também
deseja escolher o Dockerfile. Agora ele também tem outro recurso que eu
só quero mostrar, digamos que você não queira manter esse arquivo porque ele é
confidencial no GitHuFever Havia algo
chamado sobrescrever. Você pode sobrescrever. Dizendo que toda
vez que você gera esse arquivo, sempre
seus sites estão prontos para existir Porque se você não fizer isso,
eu uso a mesma palavra-chave, eu uso o mesmo nome. Desculpe, desculpe. Eu estraguei tudo. Deveria ser um cachimbo. Então, sim. Então vamos chamá-lo spring mood leith e, em seguida,
swing modula artefatos Ok, então temos que definir isso, então temos que definir para também
possamos definir
os dias de retenção. Então, essas partes, então
o que está dizendo é que, se isso já existe, se isso já existe e
geralmente sabemos que você substitui
os arquivos que temos aqui Então, também queremos os dias
de retenção, certo? Retenção, eles dizem, eu quero,
digamos que vamos mantê-la
por dez dias, certo? É em dias, você diz, guarde por cinco dias, ok? Mas isso substitui esse cara, isso sempre
substituirá esse Está bem?
Conseguimos fazer isso. Então, vamos experimentar. Não sei se o
Wildcard funciona ou então teríamos que
escolher o nome inteiro, mas vamos explorar Vamos explorar.
Você usa um curinga Digamos que você possa usar isso
, então vamos ver. Ok, acho que o
curinga funciona. Eu acho que isso seria
legal. Isso seria legal se o curinga
realmente funcionasse Portanto, não precisamos
procurar o
nome completo do arquivo spring. Tudo bem. Então, vamos salvar isso. Então, vou
chamar isso de vamos resolver
um problema. Portanto, crie um problema. Vou chamá-lo de upload de
ClesPipeline,
para fins de cometa, pipeline . Carregando artefatos. Ok, então vamos escolher
isso e ver. As crianças também se comprometem. Tudo bem,
então faça isso, então vamos insistir Vamos empurrar. OK. Isso está parecendo bom. Isso
está parecendo bom. Tudo bem. Então, vamos seguir em frente e ver se isso realmente acontece como
esperamos. Então, nós recarregamos isso. Vou pausar este
vídeo e mostrar que terminem essa construção finalizada antes de
eu voltar para vocês
para atrasar
o vídeo por mais tempo Deixe-me pausar isso novamente. Ok, pessoal, estamos de volta. Então, na verdade,
tudo isso é bem-sucedido. Então, vamos explorar
rapidamente. Dessa forma, fazendo o upload dos
artefatos, entre aqui. Enviando artefato, dois arquivos. Haverá o upload de dois arquivos. Sim, isso é tudo. O
nome do artefato é válido aqui. Então, se você passar
e disser Cool, diga Cool. Isso é legal. Não
exibe os artefatos namais Está carregando. Aparentemente, mas sabemos
exatamente o que está carregado. Então, o que estamos escolhendo é imprimir qualquer coisa que realmente
comece com qualquer nome, mas que termine com uma jarra de pontos Temos apenas um arquivo que
termina com o frasco de pontos. Basicamente, é isso que
estamos procurando. E sim, eu também estou escolhendo este documento e também
escolhendo este arquivo docker Na verdade, isso vai carregar dois. Vamos ter certeza de que isso
realmente aconteceu e agora como vamos ser mostrados? Vamos
descobrir no próximo vídeo. Vejo vocês no próximo vídeo.
14. Conteúdo de download do pipeline: Oi, todo mundo. Z aqui. Ok. Lembre-se de que
conseguimos fazer o upload com sucesso e como
confirmamos os arquivos que realmente
enviamos? Vamos fazer isso e ver exatamente nisso que vamos nos
concentrar neste vídeo. Como podemos realmente
validar tudo muito simples? Como você está fazendo o upload,
devemos conseguir fazer o download e é
exatamente isso que estamos fazendo aqui Lembre-se de que esse outro trabalho
depende desse trabalho. Em seguida,
entramos aqui e já imprimimos
algo aqui. Vamos entrar aqui
e fazer o download. Vamos chamar isso de
download. O nome. Chame isso de download. Chame isso download, Artifact.
Baixe o artefato Agora, queremos ver se
há um upload, temos 100% de certeza de que também
haverá um download. Vamos entrar aqui. Vamos ao mercado
e vamos fazer o download. Ok. Então, já que há um upload
que diz download, certo? Eles trabalham
lado a lado, certo? Eles trabalham lado a lado.
Se você for para o uso, é simplesmente semelhante, da mesma forma. Semelhante ao uso em
que acabamos de colocar isso
, temos que o
nome do nome é muito importante. O nome do artifa a ser baixado. Lembre-se de que, na verdade, adicionamos
esse nome, então devemos poder usar o mesmo nome.
Acho que é mais ou menos isso. Não precisamos de mais
nada, exceto que você provavelmente deseja
configurar alguma realidade, mas acho que é
basicamente disso que precisamos. Eu só vou entrar aqui. Vou apenas usar isso. Acho que posso simplesmente copiar isso diretamente. Vou copiar isso com
o W e vou descer aqui e
testar isso aqui, certo? Não precisamos mais disso. Estamos prontos,
basta organizar isso. Com então nome. Aparentemente, então
qual é o nome? Devemos usar exatamente o mesmo nome para evitar qualquer problema,
exatamente o mesmo nome. São basicamente vocês. É assim que se faz isso.
Nós não temos nenhum. Vamos produzir o conteúdo. Vamos produzir o conteúdo. Lembrem-se, pessoal, lembrem-se, pessoal, cada amigo tem um corredor Portanto, esta seção de amostra
usa um executor Ubuntu, uma vez concluída, ela fecha Isso usa um executor
diferente do Ubuntu, então eles não são o mesmo ambiente
virtual, você deve estar
ciente disso, certo? Você deve estar ciente de
que esse servidor que foi realmente criado é
diferente do que está aqui Então, uma vez que isso é
realmente carregado, uma vez que você enviou
nossos detalhes aqui, nós os enviamos aqui, acabei de enviar para um cache em
algum lugar no armazenamento do Github
Github Então, uma vez que você realmente o
baixa,
parece que é o mesmo
trabalho que está sendo executado
no mesmo contexto
do custo fringmd que é de minha propriedade Nesse caso, ele
procura esse nome e faz
o download do conteúdo. Então, eu precisava ressaltar isso. Portanto, não pense que
você verá esses detalhes
extras que
imprimimos aqui quando
chegarmos aqui porque são dois trabalhos separados e
executam dois contextos diferentes Ok, eu queria explicar isso. Então, vamos produzir. Vamos às saídas Vamos sair, vamos
chamá-lo de saídas. Conteúdo baixado, conteúdo
baixado.
Então, eu vou correr. Acabei de executar um LS. Vamos LS. Então são esses caras. Tudo bem Então esse cara, então vamos ligar
isso, vamos chamar isso. Vamos criar um problema para isso. Vou chamar isso de pipeline, baixar e gerar conteúdo. Pipeline. Baixe e produza
conteúdos. Nós temos isso. Eu posso simplesmente copiar isso.
Então vem aqui, depois confirma EM, depois
usa aqui e depois fecha Vamos pressionar Tudo bem,
vamos continuar. Vamos acompanhar isso. Acho que
isso já passou. Sim, já
passou. Isso deveria ter ido para as ações. Então, encerrado isso,
vamos para as ações. Vemos que isso
começou, começou . Está pronto para começar. Tudo
bem, então começou. Assim como antes, vou postar
esse vídeo e
voltarei assim que a compilação estiver concluída. Tudo bem
Te vejo, pessoal. Tudo bem, pessoal, isso está feito. Podemos ver a compilação concluída com sucesso no pipeline e a ação ou
seção push da imagem concluída.
Vamos explorar. Vamos explorar isso. É aqui que estamos baixando artefatos Então, ele conseguiu baixar
um único artefato, preparar-se para fazer o download e
conseguiu realmente encontrar o
artefato, um artefato Lembre-se, você pode estar se perguntando por que estamos vendo
um artefato aqui? Acho que não consegui explicar
isso no último vídeo. Vamos para a
seção Mas, a seção Mas. Se você for para onde
realmente enviamos, se você for para onde
realmente enviamos, se você olhar para baixo, verá
que estava
compactando tudo Tudo estava compactado, então só
temos um arquivo. Para o Zip two, temos
apenas um arquivo, certo? Porque estávamos carregando dois
arquivos, mas ele estava compactado. Acho que faz sentido. Eu
disse que os arquivos não estão espalhados ou
provavelmente estão gerenciados Então, quando
chegamos a essa parte, vimos que tudo está baixando
apenas um artefato Eu queria ressaltar isso.
Digamos que conteúdo gerado. Então, um total de um
artefato baixado. Vamos ver o conteúdo.
Você pode ver? Isso funciona. Isso está trazendo o alvo, o Docker e o alvo Oh, não queremos
o arquivo de destino. Na verdade, queríamos a
primavera, qual é o nome agora? seguida, o arquivo JA.
Estamos entendendo isso. Basicamente, precisamos
analisar exatamente o que deve ser feito. Vamos entrar e ver
o que está faltando, certo? É isso que
estamos perdendo. Tudo bem Então, vamos entrar aqui. Sim, verificando
se quero explorar esse
artefato de download novamente. Carregue o artefato. Acho que
quero duplicar isso, vamos duplicar essa guia Deixe-me baixar os artefatos de
upload, acho que o curinga
não está funcionando conforme Vamos dar uma olhada na placa W. Está dizendo carregar um
arquivo individual em um diretório inteiro. Essa é a parte que ele estava escolhendo. Basicamente escolhendo tudo isso. Mas queríamos um padrão de cartão W. Dizendo que queremos
que você escolha um caminho. Comece então vamos ver. Comece a estudar caminhos alvos, acho que
devemos usar isso, certo? Eu deveria usar isso. Um arquivo com qualquer dieta intermediária e, em
seguida, qualquer arquivo termina com.
Vamos experimentar isso. Vamos experimentar isso. Isso
deve ser analisado, então isso é negativo. Isso é uma exclusão. No entanto, isso é uma entrada, o que temos, que
corresponde a isso. Vou escolher isso
com o imposto de excreção. Então, vou tentar
isso para ver se isso realmente funciona como
deveria. Isso estará aqui. Essa será a estrela
alvo, depois o jarro de pontos estelares. Então, mostramos que está diretamente
abaixo da meta de da. Então, visto que qualquer caminho
intermediário não há caminhos, basta procurar o
arquivo Ja. Vamos tentar isso. Vamos tentar isso. Eu esperava que
isso funcionasse de qualquer maneira. Vamos ver como
isso se desenrola. Eu não cometeria isso.
Vou executá-lo diretamente. Não vou cometer
nenhum problema, apenas
faço o upload dos testes de pipeline. Upload de teste. Vamos ver como
isso realmente acontece. Tudo bem, para ver se foi realmente carregado com sucesso. Vou pausar
esse vídeo, como de costume. Voltarei assim que
o Mas estiver pronto, para poder ver se isso
realmente funciona corretamente. Caso contrário, se não
descobrirmos isso,
vou continuar. Vou usar a viagem completa, e isso basicamente deve
resolver esse problema. Te vejo
quando isso for feito. Ok pessoal, isso está
feito, então vamos verificar. Tudo bem, então estamos
preocupados com isso. Então, vamos ver o conteúdo
de saída. Ainda estamos recebendo
a mesma coisa. Ainda estamos recebendo
a mesma coisa. Estou esperando apenas
os outros arquivos, fornecendo todo o arquivo de destino E não precisamos do arquivo de destino
inteiro. Isso é muita
informação. O que vamos fazer é entrar e trazer apenas
esse arquivo.
O que nós fazemos Vamos entrar aqui rapidamente. Eu irei para a seção Mas. Vamos produzir. Vamos verificar se enviamos os
arquivos que listamos. Temos esse arquivo chamado
spring modulate, então acredito
que esse seja o nome spring Modulate Case que deve
seguir esse padrão Se você acessar este arquivo, siga este padrão, que é o curso de módulo de primavera então você deve anexá-lo e depois ao
jar Isso é basicamente
o que deveria acontecer. Então, eu quero essas
divisões e gravações. Então eu virei aqui,
vou colocar isso aqui, tudo bem. Então você deve ter um 001. Vamos trazer
esse apêndice. Então eu acho que deveria ser
hífen, então não fale. Deixe-me confirmar. Então, nós
vamos vir aqui. É uma mola, causamos o
hífen aqui, você pode ver que combina São fósforos, certo?
O que é bom. Então, aqui, vamos notar. Tudo bem, então vamos
entrar aqui e eu vou postar esse vídeo e quando estiver
pronto, eu voltarei, certo? Tudo bem Isso está
feito. Vamos verificar se esse vídeo
já tem mais de 10 minutos, então vamos ver
o que enviamos. Então, enviamos dois arquivos. Ótimo. Vamos dar uma olhada nisso. Então, nosso objetivo é isso. Vamos acessar a seção Imagem e ver se isso realmente
baixou o amadurecimento Uma ou duas saídas planas. Me dê a pasta de destino. Acho que sei
exatamente o que é. Voltarei no próximo
vídeo e
verei por que isso está realmente
escolhendo a pasta de destino Vejo vocês
no próximo vídeo.
15. Login no docker do pipeline: Oi, todo mundo. Z aqui. O que eu tinha que fazer foi entrar
e não mudei nada. Acabei de dizer, deixe-me fazer um LS e fazer um L S
do que está no arquivo, essa pasta de destino. Isso
é o que eu descobri. Quando verifiquei, pude ver que
temos apenas um
arquivo, que é este. Pensando nisso,
pessoal, acho que isso funciona no nosso freeboo.
Você pode se perguntar como. Agora, lembre-se do nosso arquivo Docker executando esse arquivo Docker, o que pretendemos. Esse arquivo
Docker
basicamente aparecerá na pasta de Acho que não quero mudar isso, quero
mudar outra coisa. Temos que alterar
esse arquivo Docker para agora apontar exatamente para o arquivo
JAR Isso não é exatamente o que queremos. Acho que isso funciona em nosso feboo , então não precisamos
mudar Basta deixar no ts e
isso funcionará diretamente. Eu só quero ressaltar
isso. Isso funciona. Então, o que temos atualmente funciona. Então, qual é a próxima etapa? O próximo passo é empurrar a imagem. Vamos empurrar a imagem. Mas, para enviar a
imagem, lembre-se que precisamos avaliar o Docker
Hub. Estou usando o Docker Hub Como estou usando o Docker Hub, se você prestar atenção
ao motivo pelo qual estamos fazendo o push do Docker,
tínhamos o push do Docker,
tínhamos uma seção que na verdade
chamávamos de seção,
que, se eu me lembrasse
corretamente agora, o nome da seção,
deixe-me divulgá-la Acho que são recursos
prontos para produção, se eu estiver errado, recursos
prontos para produção, certo? Sim. Acho que é um recurso pronto para
produção. Temos uma seção chamada recursos prontos para
produção. Sim, está correto. Isso está
correto. Eu pesquisei. Lembre-se de que tivemos que fazer
login porque eu
já estava logado, então tive que pressionar para Fazer A mesma coisa
aconteceu aqui. Lembre-se de que,
depois de
listar o conteúdo,
precisamos fazer login neste diagrama que,
depois de
listar o conteúdo, ,
criar e enviar. A mesma coisa que
vamos fazer aqui. Então, como você faz isso? Vamos primeiro
chamar isso de login do Docker. Login do Docker. Como
eu quero fazer login, estou logado para perder meu tempo. Portanto, há outra
ação para o login do docker. Vamos descobrir. Tudo bem. Então terminamos com isso, então
eu não preciso mais disso. Vamos voltar aqui. Vamos voltar aqui e
procurar o login do Docker. Temos algo
parecido com o login do Docker? Login do Docker com configuração.
É o que eu estou procurando. Vamos chamar isso de
login. Diga Docker. Vamos chamá-lo de Docker. Acho que precisa da
ação que estou procurando, sei o nome da
ação porque o nome da ação
é logar em ação. Esse foi o que eu
usei fisicamente. Faça login em ação, certo? uma ação de login, ação de login
do Docker Deixe-me colocar
o nome exato. Faça a ação de login. Faça login em ação. Docker log em ação, acho
que está errado. Vamos dar uma olhada nisso. Isso não
está definido corretamente. Vamos conferir
esse. Login do Docker Isso é Dal Login. Oh, incrível. Sim,
é isso. É isso mesmo. Então, basta fazer login,
passar seu nome de usuário, passar sua senha e tudo ficará bem. Então
, basicamente, é isso. Passe o nome de usuário, passe a senha e
tudo ficará bem. Então, isso é viscalmente. Então, vamos embora. Agora, lembre-se, ele está esperando um token Git up do Github Então, usar sua senha diretamente
pode não funcionar, certo? Usar sua senha
sutilmente pode não funcionar. Vamos tentar
os dois, e eu vou te dizer exatamente o que vai
funcionar. Então, vamos começar. Vamos começar. Então,
eu vou escolher isso. Eu já o
copiei em algum lugar. Vou copiar isso e
depois entrar aqui. Entre aqui, então eu
vou clicar aqui. É exatamente assim que
devemos parecer? Sim. Tudo bem. Então, a
próxima coisa que precisamos fazer, a próxima coisa que
precisamos fazer é adicionar isso
aos segredos. Isso precisa ser
adicionado para ser um segredo. Eu sei meu nome de usuário, meu nome de usuário
está bem aberto agora. Chama-se Eikoz, mas a
senha está realmente esquentada. Vou entrar e adicionar minha senha e
depois voltarei. O que eu vou fazer é
copiar isso para esse cara. Eu sei que o
primeiro é o nome de usuário, o primeiro é a senha, entre nas brigas aqui, vamos para
as configurações do Dispat, segredos Então eu vou para o meio ambiente.
A mesma ação. Então temos que conectar C. Então temos que
conectar o ambiente Lembre-se de que precisamos conectar
um ambiente
para poder detectar o que
realmente faz o uniforme. Eu vou entrar aqui.
Então isso é ação. Próximos segredos secretos.
Ela é o segredo. Nome de usuário, pacote. Vou postar isso e
voltarei assim que tiver feito
o upload. Acabei de postar isso e deixe-me adicionar
rapidamente meu. Tudo bem. Eu o adicionei. Então, muito legal. Como você o adiciona quando
está no Docker Hub? O que você precisa fazer depois
de adicionar no Docker Hub, basta ir para o lado direito, acessar as configurações da conta, outras configurações conta e
ir para a segurança E sob segurança, você pode
gerar seu token SSiS. Então ele gera,
coloca o nome. Então, uma vez gerado, você recebe o token. Depois de obter o token, basta copiar o
token e usá-lo diretamente. Então foi isso que eu fiz. Eu fiz isso
por esse token Aces modulado Então, eu o adicionei à variável de
ambiente aqui. Eu o adicionei, então você
não poderá vê-lo. Então, podemos usá-lo diretamente. Ok, então acho
que é disso que precisamos. Sim, então estamos aqui.
Então, vamos ter certeza. Na verdade, eles
funcionam com sucesso. Então, temos que ter
certeza se você realmente fez login com sucesso, certo? Então, se não funcionar, esse erro de tendência,
mas se funcionar, basicamente funcionaria
diretamente. Então, vamos ficar de fora. Então, vamos
chamar isso,
vamos chamar isso de login,
pipeline, do login. Então, chame esse pipeline do login. Tudo bem. Então, faça o login do pipe e do
Doc. Então,
vou fechar isso. Basta receber confirmações. Como faço para receber push? OK. Assim como antes, vou
postar esse vídeo. Quando o pipeline estiver pronto, voltarei para mostrar a vocês como ele
realmente funcionou. Então, vamos ver o que aconteceu. Te vejo
quando isso for feito. Tudo isso está feito. Voltando aqui, vejo que
estamos tendo o mesmo problema, login do
Docker e
representante de pacotes, mas eu o forneci Então, o que provavelmente aconteceu é o mesmo caso que estamos
vivenciando aqui. O mesmo caso que
experimentamos em que tive que adicionar
isso manualmente. Então, o que eu vou fazer, vou
voltar aqui para fazer isso também. O que eu vou fazer, eu vou entrar aqui. Então, como isso está correto, nome de usuário
Docker Undersco, E corresponde ao que realmente
temos nas configurações,
verificaremos o ambiente. Para o meio ambiente,
verifique a ação. Oh, tudo bem. Então, isso pode não funcionar, na verdade, porque eu não especifiquei essa ação. Então isso
pode não funcionar. Eu não especifiquei
o ambiente, então acho que esse erro
pode ser para mim. Então, deixe-me
fazer isso rapidamente. Portanto, você precisa especificar o
ambiente em que está sendo executado. Então, eu estou comandando esse cara. Veja, nós não
adicionamos um ambiente, então eu estou executando esse cara
na ação ambiental. Ok, então deixe-me insistir
dizendo que se compromete. Isso é então pipeline. Pipeline e, em seguida,
adicionou ambientes para enviar a seção de imagens. Então, isso basicamente fecha 34, embora eu ainda não o tenha criado Então eu vou chamar isso de fazer isso. Eu vou fazer isso, então
eu vou pular aqui. Então eu vou criar um problema, fazer isso, colocar isso aqui, depois enviar e
isso é 34, certo? Sim, são 34. Então,
podemos começar isso Então eu posso empurrar, eu posso empurrar. Deixe-me
passar isso rapidamente e eu
voltarei assim que isso
for feito, você fez. Tudo bem pessoal, isso está
feito, deixe-me ir. Esses devem ser os últimos
134. Lembre-se, 34. Essa é a identificação que usamos. Em seguida, entraremos
e verificaremos a
seção push me e faremos um
login. Veja o sucesso. Sim. Isso nos leva
à última fase. Se você observar isso
corretamente, isso é bem-sucedido. Sessão de envio de imagens, bem-sucedida. Isso nos leva à última
fase, à última fase. O que vamos
fazer é
simplesmente empurrar a imagem. Isso é tudo o que sobrou. Só precisamos empurrar a imagem. Chamamos isso de pista, depois Octo cd essa imagem push É isso que precisamos
fazer, enviar imagem. Em seguida, continuamos dizendo
que adicionamos para empurrar a imagem. O legal é que
temos mais um login. Você tem outro. Isso
funciona exatamente da mesma maneira. Então eu já tenho isso
copiado em algum lugar. Então, basta procurá-lo. É chamada de ação push
image, certo? É a ação push image. Então, a pressão.
Acho que é isso. Impulsão por pressão. A última que
usei foi a versão cinco. Agora é a versão seis. Acho que agora é a versão seis. OK. Seis é o que eu uso. Entendo, esse é o nome? Não, não, isso é isso. Vamos dar uma olhada
nessa promoção de apostas do Docker. Aparentemente, agora
esse é Scott Docker. Compor a imagem push do serviço. É Docker, mas empurre. Uma vez que existem muitas
opções no momento. Acho difícil
ver exatamente o mesmo. Não, não, não. Vamos procurar isso. O que é tentar isso, Appaly, não isso. Acho que já tentei isso,
experimente esta pequena conserva C. Fora, eu já sei o exato para usar.
Eu fiz uma pesquisa. Eu pesquisei um pouco. Vamos
tentar isso, vamos tentar isso. Aparentemente, não isso também.
Pesquisei um pouco, então sei exatamente o que é. Então deveria ser,
deveria ser esse cara. Eu faço isso em todo o resto. Vou apenas empurrar. Acabei de adicioná-lo aqui. Eu apenas adiciono e
explicarei os detalhes. Isso seria um uso, é
a conversão cinco. Esses vídeos são muito longos. Vou postar o
vídeo aqui e vejo vocês
no próximo vídeo.
16. imagem de push do docker do pipeline: Ei, pessoal, aqui. Consegui localizar a
ação que realmente precisávamos. Esse é o nome da ação. Acho que, na verdade
, achei isso difícil
, porque agora está na versão seis e eu estava usando a versão cinco. O que vou fazer é
mudar para a
versão seis para que possamos
realmente ver como ela funciona. É exatamente
assim que parece e espera que você
use uma configuração Dux Isso é muito importante, você faz login
e curtidas, mas
já concluímos esta etapa em relação ao login e curtidas. Esta é a ação push que
concluímos. Esta é a parte que você
deve usar agora, que na verdade nos foi
dada como o problema. Então, ele também espera
que você use um Bx, esse Brex para configurar uma seção
Bex Na verdade,
são alguns detalhes, mas na verdade eu modifiquei isso para
fazer isso funcionar. Acho que executei os
projetos que realmente fizeram isso. Então é assim que
deveria funcionar. Você acabou de ajustar o buder
e configurar o Bex. Então eu preciso ter certeza de
que essas etapas, o Brex, realmente existem, certo? Nessas etapas, os construtores
realmente existem. Então é exatamente isso que
vamos usar. Então, a seção Bex é o que você
realmente vai passar aqui Então, a saída é o nome. Então, isso seria basicamente
o resultado desse cara. Então, vou ver se esse contexto existe e o
Builder existe ou se o arquivo
existe na versão seis, você pode brincar com a versão seis. Então é isso que eu
vou fazer. Então, eu gosto de usar as
atualizações mais recentes porque isso significa que elas provavelmente fizeram algum trabalho
que não conhecemos. Então, vou para a seção de
arquivos, então. Então, espero um
contexto contextual aqui. Sim, há um contexto.
Um arquivo eri está localizado. Então, há um arquivo ou
sim, há um arquivo. Então é um construtor? Ah,
sim, isso é um construtor. Ok. Então eu acho que
é disso que precisamos. Sim, isso é basicamente
o que precisamos. Então, essa parte é
o que precisamos agora. Se você observar essa compilação, se
você observar isso corretamente, é seguir as etapas, o nome do ponto BDexoPuts E isso realmente parece estar
dentro de um desses arquivos. Então é bom
descobrir isso. Então, deixe-me
mudar isso para uma versão seis. Por favor, então desative
esta versão. Ok, então isso
deveria estar lá. Então eu vou em frente e mudo. Isso é de um dos
meus projetos anteriores. Então, o que estamos usando
são módulos. Então, ao substituir o que já
temos, lembre-se de que, se você estiver enviando, precisará inserir seu nome de usuário e, seguida,
cortar Ok. Então, isso
fará toda a construção e enviará para o Docker Hop, certo? Então, deixe-me comentar isso. Vou confirmar que chamaremos
isso de push pipeline push. Espero que não tenhamos erros. Então chame isso de pipeline push
docker bead and push. Isso seria 35, eu acredito, porque a última
vez foi 34, seja 35. Eu vou copiar isso. Então, é um grande problema.
Saia de um problema. Senhor, acho que vou dar uma olhada no
projeto Quate como um problema, então ele está aqui Pare de falar, isso é 35. Então já tem isso aqui. Vou colar isso. Empurrar. Apertem, pessoal, vou
postar o vídeo aqui. Eu voltarei com vocês
assim que isso for feito, então não precisamos esperar
enquanto isso é carregado. Tudo bem, até
mais. Gente, isso está feito e isso é
concluído com sucesso. Ótimo é ótimo. O que fazemos
é acessar o Docker Hub, vou confirmar e atualizar E você pode ver que isso foi
enviado há 1 minuto. Nós temos nossa imagem. Isso
é totalmente automatizado. Isso é totalmente automatizado.
Mais uma mudança que eu quero fazer. Eu estava usando a versão
cinco aqui, onde vimos a versão
seis disponível. Vamos experimentar a versão seis.
Vamos experimentar a versão seis. O que vou fazer é deixar
como está, todas as outras configurações
e simplesmente apertar. Vou só apertar Pipe e
Lou empurrar a versão seis, depois fecho 36, certo 36. Então, vamos copiar isso. Eu só quero ver se a
versão seis está funcionando. Se não estiver funcionando,
basta reverter. Tudo bem, então deixe-me ir. Vamos pegar isso.
Vamos pegar uma edição, uma nova edição, menos do que colar. Um pouco mais de seis. Está bem? Tudo bem, então vamos omitir isso. Então, venha aqui e empurre. Ok. Tudo bem Então, pessoal, eu quero assistir
ao vídeo mais uma vez
se vocês estiverem confusos. Quanto a esse membro do grupo, tive que adicionar meu token
aqui além da senha normal do Der,
preciso mencionar isso. Isso será executado. Vamos ver. Empurrado com sucesso, vá para Eu vou para minhas ações.
Então isso começou. Vou postar o vídeo quando
estiver pronto. Eu vou
voltar para vocês. Vamos ver se a versão seis funciona. Ok, pessoal. Sim, isso está feito. Vemos tudo
concluído com sucesso. Então, vamos dar uma olhada na imagem
push novamente, certo? Então você pode ver, como de costume, que está usando Emas Koreto Ele está usando nosso arquivo Docker. Está construindo e tudo funciona como deveria. Você
pode simplesmente confirmar isso. Isso foi há 1 minuto,
vamos atualizar isso. Ok, então isso é com
1 minuto para o fim. Isso é muito recente. Ok, então conseguimos
realmente concluir isso e isso é basicamente o que você quer fazer para
criar sua imagem. Qualquer etapa extra que você queira
fazer provavelmente extrairá a imagem do Docker Hub e depois
moverá para outro registro Você pode adicionar mais
etapas a isso, adicionar mais etapas ou
adicionar mais trabalhos que estão sendo executados em sequência a isso. Você pode fazer o upload da imagem,
puxar o upload da imagem. Você pode basicamente fazer qualquer coisa. Agora, a ideia
é fazer você entender que o pipeline
é algo difícil, ou melhor, apenas
ter em
mente que tudo gira em
torno das etapas manuais de automação que você está executando. Provavelmente, só quero
automatizar e
usamos o Gear Action para
realmente conseguir isso e tudo funcionou
como realmente esperamos Examinar esse arquivo de
uma só vez pode parecer assustador. Mas, passo a passo, conforme explicamos em todos
os vídeos, tenho certeza de que isso
realmente funcionaria. Basicamente, você deve realmente
seguir em frente. Obrigada, pessoal. Então, há uma última
coisa que eu quero mencionar. Lembre-se de que tivemos que adicionar
essa mudança de configuração enquanto a movimentação
padrão embutida no contêiner Bunto não
estava em Portanto, você pode perceber ,
como resultado, esse cache
não está sendo ativado Por alguma razão estranha,
não está funcionando. Minha analogia realmente mostrou que isso é porque você
realmente adicionou isso Provavelmente, antes de adicionar isso, execute isso
diretamente. É possível. O filme pode começar
. Talvez haja apenas alguns problemas padrão e talvez você não
precise realmente adicioná-los. Feito isso, agradeço a
vocês que ficam comigo. Agradeço muito o tempo e nos
vemos no próximo vídeo.
17. Segredos do ambiente de tubulação: Oi, todo mundo. Z aqui. Ok, então estamos de volta. paramos com isso e estamos tentando definir todas as variáveis de
ambiente. Lembre-se de que paramos de
criar nosso arquivo de ação. Dizendo que queremos definir
essa variável de ambiente. Agora, você pode ver várias
ações lá fora, onde elas definem
todas as variáveis, mas tudo bem. Isso funciona. Funciona com precisão. Bem, então isso significa que se eu realmente preciso
mudar alguma variável, certo? Se eu precisar alterar
alguma variável, teria que renomeá-la aqui, entrar
aqui, alterá-la e enviar para o GitHub E é isso que eu
faço. Isso é o que eu faço. Na verdade, o GitHub nos
oferece ofertas onde
podemos realmente salvar todas
as nossas variáveis
junto com nossos segredos, certo? Vilas, quais são os segredos? Segredos são como seu nome de usuário, sua senha, dados confidenciais que não devem ser
abertos a ninguém. Se você entende, esses são segredos e essas são suas variáveis de
ambiente. Então, segredos variáveis, vamos
explorar isso agora, certo? Então, vamos entrar no
Github. Isso é o GitHub. Agora, estou dizendo que é
aqui que
temos nossas ações. Nossas ações estão disponíveis aqui. Agora, estou dizendo que dentro do curso
Spring Modulate, o que é útil
porque vamos
às configurações .
Deixe-me ver as manchas. Agora olhe aqui embaixo,
você pode ver que há um ambiente. Aí está
o meio ambiente. Vamos ao meio ambiente. Agora, diz que
não há ambiente. Aparentemente, não
há ambiente. Vamos rotular qual ambiente
você deseja ter agora. Pense em ambientes
como o seu perfil, certo? Pense no seu perfil. Lembre-se de que você poderia
realmente ter coisas como uma produção de Dev UAT para seu aplicativo,
o aplicativo de propriedades Yao, certo Então, vamos pensar sobre isso, pensar sobre isso, certo? Então, você poderia realmente ter um
ambiente Dev , um ambiente
Docker. Então, vou rotular isso porque Dev estava no meu
sistema local, tudo estava estranho Estou mais interessado
no meu
ambiente docker porque é
aqui que
temos alguns detalhes que precisamos para realmente conectar as
variáveis e os segredos Eu vou entrar aqui,
vou chamar isso, qual é o nome dos
meus ambientes? Vou chamar meu ambiente de Docer. Vamos configurar meu ambiente. Esse é o meu ambiente. Assim,
você pode definir regras. Se existe uma
organização, você sabe, Github é um recurso
organizacional em que você pode ter
colaboradores, certo Você poderia realmente fazer isso e começar a definir suas opiniões,
mas esse não é o objetivo. Vou começar com
o que precisamos. Então, o que precisamos é que
tenhamos segredos e variáveis de
ambiente. Então é isso que
vamos definir aqui em nosso Docker Lembre-se do ambiente Docker. Portanto, isso será definido
no ambiente Docker. Então, se você tem uma produção, isso significa que você cria
outro ambiente, então você vem aqui. Agora você cria mais um
ambiente desta vez, provavelmente de nome ou produção. Certifique-se de especificar esse ambiente
de produção em seu arquivo de ação
e de que você está pronto. Queremos explorar
isso. Primeiro de tudo, vamos definir nossas variáveis. Quais são nossas variáveis? Na verdade, eu descrevi
alguns deles aqui. Deixe-me vir aqui. Então, esses são variáveis. Prossegui separando
cada um deles, separando cada um deles. Portanto, temos coisas como os modos em que temos o nome de usuário
modulado, a senha Eu disse, configure a variável de
ambiente. Então, qualquer pessoa que você veja que eu coloco
um V aqui é uma variável, qualquer pessoa que eu toque um S é um segredo. Esses dois podem ser
rotulados como segredos e todos podem ser
rotulados como Então, é uma escolha. Você pode
decidir qual deseja colocar como segundo ou qual
colocar em um ambiente. Se você tem um IP que
eu quero que você não queira expor, você não quer que
ninguém veja fisicamente, no entanto, é um segredo Você pode simplesmente colocar
, por exemplo , o IP do host. Coloque isso em segredo,
eu só quero mostrar a
vocês que vocês têm essas
opções para realmente explorar. Deixe-me ver se eu poderia
dividir se eu pudesse juntar minhas duas telas.
Então, vamos fazer isso. Ok. Eu vou entrar aqui e
eu vou dizer, eu vou escolher isso. Eu quero a variável. Desculpe.
Eu escolho a variável. Eu quero a
variável spring, o que estou fazendo? Então, minha variável e eu
troquei o Docker. Lembre-se de que é Docker. Lembre-se de que é
exatamente isso que passamos para o perfil de rotação mencionado anteriormente no arquivo
Docker, certo? Então eu adiciono a variável.
Legal. Agora temos isso. Vamos adicionar mais, certo? Vamos adicionar mais. Vamos adicionar
outra variável. Na próxima, eu vou
escolher o anfitrião. Meu anfitrião foi trocado de postagem local
. Substantivos é uma publicação local Legal. Vamos escolher os
próximos potes. Ah, são as panelas? Oi 43, dois, quatro, três, dois. Legal. O que vem a seguir
é o nome do banco de dados. Módulo Spring. Agora, o que acontece se
isso não estiver disponível? Simples Se isso não
estiver disponível, você pode facilmente
vir aqui para verificar, você verá que há uma edição embutida aqui. Você vem aqui e edita. Você vem aqui e
edita rapidamente. Essa é a vantagem. Assim, você não precisa
reimplantar seu arquivo de ação. Também temos uma propriedade chamada
taxa de exclusão de eventos, que você usa agora que estamos
publicando os eventos com falha. Na verdade, usamos 4.000.
Vamos pressionar isso aqui. Legal. Então temos outro chamado pontos finais do atuador,
os pontos finais que você deseja expor, 10.1 para
expor Esse é o valor que
será colocado no módulo. Legal. Então, pudemos realmente
configurar isso agora para o segredo. Também configure o sequit, que
é o nome de usuário do modulit, que é modulits e depois Vamos definir essa senha múltipla. Também é o mesmo módulo. Tudo bem Ok. Agora
isso é incrível. Na verdade, temos isso, e
acho que isso é bom o suficiente,
certo? Isso é bom o suficiente. Gente, vamos configurar isso. Vejo vocês
no próximo vídeo enquanto continuamos o processo. Vejo vocês no próximo vídeo.
18. Encerramento da pipena: Sim, defenda
o campeão,
defenda o campeão Olha quem está aqui, o campeão. Estou me referindo a
você para que você possa acessar esta
seção do curso, além de
entender o módulo, agora você sabe como
construir o pipeline do CICD Você pode simplesmente pegar
o conhecimento e
aplicá-lo em qualquer lugar e em qualquer plataforma. Funciona exatamente da
mesma maneira, certo? Meu trabalho ou meu propósito é transmitir esse conhecimento que você
acumulou agora que pertence a você Por que você não sai e
mostra essas habilidades. Está bem? Agora você pode desenvolver
o pipeline do CICD Agora você sabe como
usar um pipeline CICD. Não é mais um mistério, agora você pode desmistificá-lo ação de Gill é apenas
mergulhar no Azure, mergulhar em qualquer outra plataforma Lembre-se de que o segredo principal é saber o que você deseja alcançar, defina passo a passo. Tudo usa
o mesmo processo. Eles usam conceitos como
trabalhos, conceitos como etapas
e similares, e você também pode injetar segredos e variáveis de
ambiente Estou tão feliz que você estava aqui, agora você foi
capaz de realmente sobreviver. No entanto, como eu disse, como mencionei no último
resumo da primeira aula, há mais uma seção,
que é a seção final,
que é Kubernetis Alguns chamam isso de Kubernetis KHS. Essa é uma plataforma muito
interessante. Tenho certeza de que você já
ouviu falar do Kubernetis. Essa é uma oportunidade
para você realmente
mergulhar no Kubernetis e
será incrível Posso garantir que
vai ser maravilhoso. Vou começar passo a
passo, vou começar do zero e vou passo a passo. Não precisa se preocupar, não
sei exatamente
o que isso significa. Você vai realmente se
tornar muito familiar. E torne-se um mestre
em pouco tempo, você pode
aplicar esse conhecimento. Espero ver você
na próxima aula. Lembre-se, verifique o Asap. Verifique o sobre a banheira. Vou te
deixar um link aí, leve-o para a próxima aula. Espero que você
realmente venha comigo. Nos vemos na próxima aula.