GitHub ක්‍රියා සහිත නිරයේ කව (ජාවා ව්‍යාපෘතියක් සඳහා CI/CD නල මාර්ගයක් තැනීම)

ජාවා වල ගොඩනැගිලි ව්‍යාපෘති සඳහා මට බොහෝ විට නල මාර්ගයක් තැනීමට සිදුවේ. සමහර විට එය විවෘත මූලාශ්ර වේ, සමහර විට එය නොවේ. Travis-CI සහ TeamCity වෙතින් GitHub ක්‍රියා වෙත මගේ ගබඩාවන් කිහිපයක් ගෙන යාමට උත්සාහ කිරීමට මම මෑතකදී තීරණය කළ අතර, එයින් පිටතට පැමිණියේ මෙයයි.

අපි ස්වයංක්‍රීය කරන්නේ කුමක්ද?

පළමුව, අපට ස්වයංක්‍රීය කරන ව්‍යාපෘතියක් අවශ්‍ය වේ, අපි Spring boot / Java 11 / Maven හි කුඩා යෙදුමක් කරමු. මෙම ලිපියේ අරමුණු සඳහා, අපි යෙදුම් තර්කනය ගැන කිසිසේත් උනන්දු නොවනු ඇත; යෙදුම වටා ඇති යටිතල පහසුකම් අපට වැදගත් වේ, එබැවින් සරල REST API පාලකයක් අපට ප්‍රමාණවත් වේ.

ඔබට මෙහි මූලාශ්‍ර නැරඹිය හැක: github.com/antkorwin/github-actions නල මාර්ගයක් තැනීමේ සියලු අදියරයන් මෙම ව්යාපෘතිය සඳහා ඇදීමේ ඉල්ලීම් වලින් පිළිබිඹු වේ.

JIRA සහ සැලසුම් කිරීම

අපි සාමාන්‍යයෙන් JIRA ගැටළු ට්‍රැකර් එකක් ලෙස භාවිතා කරන බව පැවසීම වටී, එබැවින් අපි මෙම ව්‍යාපෘතිය සඳහා වෙනම පුවරුවක් සාදා එහි පළමු ගැටළු එකතු කරමු:

මඳ වේලාවකට පසුව අපි JIRA සහ GitHub ඒකාබද්ධව ඉදිරිපත් කළ හැකි රසවත් දේවල් වෙත ආපසු යමු.

අපි ව්යාපෘතියේ එකලස් කිරීම ස්වයංක්රීය කරන්නෙමු

අපගේ පරීක්ෂණ ව්‍යාපෘතිය Maven හරහා ගොඩනගා ඇත, එබැවින් එය සෑදීම තරමක් සරල ය, අපට අවශ්‍ය වන්නේ mvn පිරිසිදු පැකේජය පමණි.

Github ක්‍රියා භාවිතයෙන් මෙය සිදු කිරීම සඳහා, අපට අපගේ කාර්ය ප්‍රවාහය විස්තර කරන ගොනුවක් ගබඩාවේ සෑදිය යුතුය, මෙය සාමාන්‍ය yml ගොනුවකින් කළ හැකිය, මම “yml ක්‍රමලේඛනයට” කැමති යැයි මට පැවසිය නොහැක, නමුත් අපට කුමක් කළ හැකිද - අපි එය කරන්නේ .github/ directory workflow/ file build.yml හි ප්‍රධාන ශාඛාව ගොඩනඟන විට අපි ක්‍රියා විස්තර කරන්නෙමු:

name: Build

on:
  pull_request:
    branches:
      - '*'
  push:
    branches:
      - 'master'

jobs:
  build:
    runs-on: ubuntu-18.04
    steps:
      - uses: actions/checkout@v1
      - name: set up JDK 11
        uses: actions/setup-java@v1
        with:
          java-version: 1.11
      - name: Maven Package
        run: mvn -B clean package -DskipTests

on — මෙය අපගේ ස්ක්‍රිප්ට් දියත් කෙරෙන සිදුවීම පිළිබඳ විස්තරයකි.

මත: pull_request/push — මාස්ටර් වෙත තල්ලුවක් සිදු කර ඇදීමේ ඉල්ලීම් සාදන සෑම අවස්ථාවකම මෙම කාර්ය ප්‍රවාහය දියත් කළ යුතු බව පෙන්නුම් කරයි.

පහත දැක්වෙන්නේ කාර්යයන් පිළිබඳ විස්තරයකි (රැකියා) සහ ක්රියාත්මක කිරීමේ පියවර (පියවර) එක් එක් කාර්යය සඳහා.

දුවන - මෙහිදී අපට ඉලක්කගත මෙහෙයුම් පද්ධතිය තෝරා ගත හැකිය, පුදුමයට කරුණක් නම්, ඔබට Mac OS පවා තෝරා ගත හැකිය, නමුත් පුද්ගලික ගබඩාවල මෙය තරමක් මිල අධිකය (ලිනක්ස් හා සසඳන විට).

භාවිතා ඔබට වෙනත් ක්‍රියා නැවත භාවිතා කිරීමට ඉඩ සලසයි, උදාහරණයක් ලෙස, අපි Java 11 සඳහා පරිසරය ස්ථාපනය කරන actions/setup-java action භාවිතයෙන්.

සහාය ඇතිව සමග අපි ක්‍රියාව දියත් කරන පරාමිතීන් අපට නියම කළ හැකිය, අවශ්‍යයෙන්ම මේවා ක්‍රියාවට යවනු ලබන තර්ක වේ.

ඉතිරිව ඇත්තේ Maven හි ව්‍යාපෘති ගොඩනැගීම ක්‍රියාත්මක කිරීම පමණි: run: mvn -B clean package ධජය -B අපට අන්තර් ක්‍රියාකාරී නොවන මාදිලියක් අවශ්‍ය බව පවසයි, එවිට මේවන් හදිසියේම අපෙන් යමක් ඇසීමට අවශ්‍ය නැත

මහා! දැන්, ඔබ මාස්ටර් වෙත කැපවන සෑම අවස්ථාවකම, ව්‍යාපෘති ගොඩනැගීම ආරම්භ වේ.

පරීක්ෂණ දියත් කිරීම් ස්වයංක්‍රීය කිරීම

එකලස් කිරීම හොඳයි, නමුත් යථාර්ථයේ දී, ව්යාපෘතියක් ආරක්ෂිතව එකලස් කළ හැකි නමුත් ක්රියා නොකරයි. එබැවින්, ඊළඟ පියවර වන්නේ පරීක්ෂණ ධාවනය ස්වයංක්රීය කිරීමයි. ඊට අමතරව, ඔබ PR සමාලෝචනයක් කරන විට පරීක්ෂණ සමත් වීමේ ප්‍රති results ල දෙස බැලීම තරමක් පහසුය - පරීක්ෂණ සමත් වන බව ඔබ නිසැකවම දන්නා අතර ඒකාබද්ධ කිරීමක් කිරීමට පෙර කිසිවෙකුට ඔවුන්ගේ ශාඛාව ක්‍රියාත්මක කිරීමට අමතක වී නැත.

ඇදීමේ ඉල්ලීමක් නිර්මාණය කිරීමේදී අපි පරීක්ෂණ ක්‍රියාත්මක කර ප්‍රධානියාට ඒකාබද්ධ කරන අතර ඒ සමඟම අපි කේත ආවරණය පිළිබඳ වාර්තාවක් නිර්මාණය කරන්නෙමු.

name: Build

on:
  pull_request:
    branches:
      - '*'
  push:
    branches:
      - 'master'

jobs:
  build:
    runs-on: ubuntu-18.04
    steps:
      - uses: actions/checkout@v1
      - name: set up JDK 11
        uses: actions/setup-java@v1
        with:
          java-version: 1.11
      - name: Maven Verify
        run: mvn -B clean verify
      - name: Test Coverage
        uses: codecov/codecov-action@v1
        with:
          token: ${{ secrets.CODECOV_TOKEN }}

පරීක්ෂණ ආවරණය කිරීම සඳහා, මම jacoco ප්ලගිනය සමඟ එක්ව codecov භාවිතා කරමි. codecov හට තමන්ගේම ක්‍රියාවක් ඇත, නමුත් එයට අපගේ ඇදීමේ ඉල්ලීම සමඟ වැඩ කිරීමට ටෝකනයක් අවශ්‍ය වේ:

${{ secrets.CODECOV_TOKEN }} — අපි මෙම ඉදිකිරීම එක් වරකට වඩා දකිනු ඇත, රහස් යනු GitHub හි රහස් ගබඩා කිරීමේ යාන්ත්‍රණයකි, අපට එහි මුරපද / ටෝකන / සත්කාරක / url සහ ගබඩා කේත පදනමට ඇතුළත් නොකළ යුතු වෙනත් දත්ත ලිවිය හැකිය.

ඔබට GitHub හි ගබඩා සැකසුම් තුළ රහස් වලට විචල්‍යයක් එක් කළ හැක:

ඔබට ටෝකනයක් ලබා ගත හැක codecov.io GitHub හරහා අවසර දීමෙන් පසු, පොදු ව්‍යාපෘතියක් එක් කිරීමට ඔබට මෙවැනි සබැඳියක් අනුගමනය කිරීමට අවශ්‍ය වේ: GitHub පරිශීලක නාමය/[repo නම]. පුද්ගලික ගබඩාවක් ද එකතු කළ හැකිය; මෙය සිදු කිරීම සඳහා, ඔබ Github හි යෙදුමට codecov හිමිකම් ලබා දිය යුතුය.

POM ගොනුවට jacoco ප්ලගිනය එක් කරන්න:

<plugin>
	<groupId>org.jacoco</groupId>
	<artifactId>jacoco-maven-plugin</artifactId>
	<version>0.8.4</version>
	<executions>
		<execution>
			<goals>
				<goal>prepare-agent</goal>
			</goals>
		</execution>
		<!-- attached to Maven test phase -->
		<execution>
			<id>report</id>
			<phase>test</phase>
			<goals>
				<goal>report</goal>
			</goals>
		</execution>
	</executions>
</plugin>
<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-surefire-plugin</artifactId>
	<version>2.22.2</version>
	<configuration>
		<reportFormat>plain</reportFormat>
		<includes>
			<include>**/*Test*.java</include>
			<include>**/*IT*.java</include>
		</includes>
	</configuration>
</plugin>

දැන් codecov bot අපගේ එක් එක් ඇදීමේ ඉල්ලීම් ඇතුළත් කර ආවරණ වෙනස් කිරීමේ ප්‍රස්තාරයක් එක් කරයි:

අපි ස්ථිතික විශ්ලේෂකයක් එකතු කරමු

මගේ බොහෝ විවෘත මූලාශ්‍ර ව්‍යාපෘතිවල මම ස්ථිතික කේත විශ්ලේෂණය සඳහා සෝනා වලාකුළු භාවිතා කරමි, ට්‍රැවිස්-සී වෙත සම්බන්ධ වීම තරමක් පහසුය. එබැවින් GitHub ක්‍රියා වෙත සංක්‍රමණය වන විට එයම කිරීම තාර්කික පියවරකි. ක්‍රියාදාම වෙළඳපොල හොඳ දෙයක්, නමුත් මේ වතාවේ එය මාව ටිකක් පහත් කළා, මොකද පුරුද්දෙන් මම මට අවශ්‍ය ක්‍රියාව සොයාගෙන එය කාර්ය ප්‍රවාහයට එකතු කළා. නමුත් සෝනාර් මේවන් හෝ ග්‍රැඩ්ල් මත ව්‍යාපෘති විශ්ලේෂණය කිරීමේ ක්‍රියාවක් හරහා වැඩ කිරීමට සහාය නොදක්වන බව පෙනී ගියේය. ඇත්ත වශයෙන්ම, මෙය ලේඛනයේ ලියා ඇත, නමුත් එය කියවන්නේ කවුද?!

ක්‍රියාවක් හරහා එය කළ නොහැක, එබැවින් අපි එය mvn ප්ලගිනය හරහා කරන්නෙමු:

name: SonarCloud

on:
  push:
    branches:
      - master
  pull_request:
    types: [opened, synchronize, reopened]

jobs:
  sonarcloud:
    runs-on: ubuntu-16.04
    steps:
      - uses: actions/checkout@v1
      - name: Set up JDK
        uses: actions/setup-java@v1
        with:
          java-version: 1.11
      - name: Analyze with SonarCloud
#       set environment variables:
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
#       run sonar maven plugin:
        run: mvn -B verify sonar:sonar -Dsonar.projectKey=antkorwin_github-actions -Dsonar.organization=antkorwin-github -Dsonar.host.url=https://sonarcloud.io -Dsonar.login=$SONAR_TOKEN -Dsonar.coverage.jacoco.xmlReportPaths=./target/site/jacoco/jacoco.xml

SONAR_TOKEN - දී ලබා ගත හැක sonarcloud.io ඔබ එය රහසිගතව ලියාපදිංචි කළ යුතුය. GITHUB_TOKEN - මෙය GitHub උත්පාදනය කරන ලද බිල්ට් ටෝකනයකි, එහි ආධාරයෙන් Sonarcloud[bot] හට Git වෙත පුරනය වීමට හැකි වන අතර එමඟින් අපට ඇදීමේ ඉල්ලීම් වලදී පණිවිඩ ලබා දේ.

Dsonar.projectKey - සෝනාර් හි ව්‍යාපෘතියේ නම, ඔබට එය ව්‍යාපෘති සැකසුම් තුළ දැකිය හැකිය.

Dsonar.සංවිධානය - GitHub වෙතින් සංවිධානයේ නම.

අපි අදින්න ඉල්ලීමක් කර, අදහස් දැක්වීමේදී sonarcloud[bot] එනතෙක් බලා සිටිමු:

කළමනාකරණ කළමනාකරණය

ගොඩනැගීම වින්‍යාස කර ඇත, පරීක්ෂණ ක්‍රියාත්මක කර ඇත, අපට නිකුතුවක් කළ හැකිය. GitHub ක්‍රියා මගින් නිකුතු කළමනාකරණය වඩාත් පහසු කරන්නේ කෙසේදැයි බලමු.

රැකියාවේදී, මගේ කේත පදනම බිට්බකට් ඇති ව්‍යාපෘති තිබේ (හැම දෙයක්ම අර කතාවේ වගේ "මම දවල්ට බිට්බකට් එකට ලියමි, රාත්‍රියේ GitHub වෙත කැප වෙමි"). අවාසනාවන්ත ලෙස, bitbucket හි ඇති නිකුතු කළමනාකරණ මෙවලම් නොමැත. මෙය ගැටළුවකි, මන්ද සෑම නිකුතුවක් සඳහාම ඔබ අතින් එකතුවන පිටුවක් සාදා නිකුතුවේ ඇතුළත් සියලුම අංග එහි විසි කිරීම, මනසෙහි මාලිගා හරහා සෙවීම, ජිරා හි කාර්යයන්, ගබඩාවේ කැපවීම කළ යුතුය. වැරැද්දක් කිරීමට බොහෝ අවස්ථාවන් තිබේ, ඔබට යමක් අමතක කළ හැකිය, නැතහොත් දැනටමත් අවසන් වරට නිකුත් කර ඇති දෙයක් ඇතුළත් කළ හැකිය, සමහර විට එය ඇදීමේ ඉල්ලීමක් ලෙස වර්ගීකරණය කරන්නේ කුමක් දැයි පැහැදිලි නැත - එය විශේෂාංගයක් හෝ දෝෂ නිවැරදි කිරීමක් හෝ පරීක්ෂණ සංස්කරණය කිරීම හෝ යටිතල පහසුකම් යමක් .

GitHub ක්‍රියා අපට උපකාර කරන්නේ කෙසේද? විශිෂ්ට ක්‍රියාවක් ඇත - මුදා හැරීමේ කෙටුම්පත, එය ඔබට අදින්න ඉල්ලීම් කාණ්ඩ සැකසීමට සහ ඒවා ස්වයංක්‍රීයව නිකුත් කිරීමේ සටහන් ගොනුවේ කාණ්ඩ කිරීමට නිකුතු සටහන් ගොනු අච්චුවක් සැකසීමට ඉඩ දෙයි:

වාර්තාවක් පිහිටුවීම සඳහා උදාහරණ අච්චුව (.github/release-drafter.yml):

name-template: 'v$NEXT_PATCH_VERSION'
tag-template: 'v$NEXT_PATCH_VERSION'
categories:
  - title: ' New Features'
    labels:
      - 'type:features'
# в эту категорию собираем все PR с меткой type:features

  - title: ' Bugs Fixes'
    labels:
      - 'type:fix'
# аналогично для метки type:fix и т.д.

  - title: ' Documentation'
    labels:
      - 'type:documentation'

  - title: ' Configuration'
    labels:
      - 'type:config'

change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
template: |
  ## Changes
  $CHANGES

කෙටුම්පත් නිකුතුවක් උත්පාදනය කිරීමට ස්ක්‍රිප්ට් එකක් එක් කරන්න (.github/workflows/release-draft.yml):

name: "Create draft release"

on:
  push:
    branches:
      - master

jobs:
  update_draft_release:
    runs-on: ubuntu-18.04
    steps:
      - uses: release-drafter/release-drafter@v5
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

මෙතැන් සිට සියලු ඇදීමේ ඉල්ලීම් ස්වයංක්‍රීයව නිකුත් කිරීමේ සටහන් වල එකතු කරනු ලැබේ - මැජික්!

මෙහිදී ප්‍රශ්නය මතු විය හැකිය: සංවර්ධකයින්ට PR හි ටැග් දැමීමට අමතක වුවහොත් කුමක් කළ යුතුද? එවිට එය කුමන කාණ්ඩයට දැමිය යුතුද යන්න පැහැදිලි නැත, නැවතත් ඔබට එය අතින්, එක් එක් PR සමඟ වෙන වෙනම කටයුතු කිරීමට සිදුවනු ඇත. මෙම ගැටළුව විසඳීම සඳහා, අපට වෙනත් ක්‍රියාවක් භාවිතා කළ හැකිය - ලේබල් සත්‍යාපනය - එය ඇදීමේ ඉල්ලීම මත ටැග් තිබේදැයි පරීක්ෂා කරයි. අවශ්‍ය ටැග් නොමැති නම්, චෙක්පත අසාර්ථක වන අතර අපගේ ඇදීමේ ඉල්ලීමේ මේ ගැන පණිවිඩයක් අපට පෙනෙනු ඇත.

name: "Verify type labels"

on:
  pull_request:
    types: [opened, labeled, unlabeled, synchronize]

jobs:
  triage:
    runs-on: ubuntu-18.04
    steps:
      - uses: zwaldowski/match-label-action@v2
        with:
          allowed: 'type:fix, type:features, type:documentation, type:tests, type:config'

දැන් ඕනෑම ඇදීමේ ඉල්ලීමක් ටැග් එකකින් සලකුණු කළ යුතුය: වර්ගය: නිවැරදි කිරීම, වර්ගය: විශේෂාංග, වර්ගය: ලේඛනගත කිරීම, වර්ගය: පරීක්ෂණ, වර්ගය: config.

ඇදීමේ ඉල්ලීම් ස්වයංක්‍රීයව සටහන් කිරීම

අදින්න ඉල්ලීම් සමඟ ඵලදායී වැඩ කිරීම වැනි මාතෘකාවක් අප ස්පර්ශ කළ බැවින්, ලේබල් කිරීම වැනි එවැනි ක්රියාවක් ගැන කතා කිරීම වටී, එය වෙනස් කර ඇති ගොනු මත පදනම්ව PR හි ටැග් දමයි. උදාහරණයක් ලෙස, අපට නාමාවලියෙහි වෙනස්කම් අඩංගු ඕනෑම ඇදීමේ ඉල්ලීමක් [බිල්ඩ්] ලෙස සලකුණු කළ හැක .github/workflow.

එය සම්බන්ධ කිරීම තරමක් සරල ය:

name: "Auto-assign themes to PR"

on:
  - pull_request

jobs:
  triage:
    runs-on: ubuntu-18.04
    steps:
      - uses: actions/labeler@v2
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}

ව්‍යාපෘති නාමාවලි සහ ඇදීමේ ඉල්ලීම් මාතෘකා අතර ලිපි හුවමාරුව විස්තර කරන ගොනුවක් ද අපට අවශ්‍ය වේ:

theme:build:
  - ".github/**"
  - "pom.xml"
  - ".travis.yml"
  - ".gitignore"
  - "Dockerfile"

theme:code:
  - "src/main/*"

theme:tests:
  - "src/test/*"

theme:documentation:
  - "docs/**"

theme:TRASH:
  - ".idea/**"
  - "target/**"

අවශ්‍ය ලේබල තිබේදැයි පරීක්ෂා කරන ක්‍රියාව සමඟ ස්වයංක්‍රීයව පුල් ඉල්ලීම් තුළ ලේබල් ස්ථානගත කරන ක්‍රියාව යුගල කිරීමට මා සමත් වූයේ නැත; ගැලපීම් ලේබලයට බොට් විසින් එක් කරන ලද ලේබල දැකීමට අවශ්‍ය නැත. අදියර දෙකම ඒකාබද්ධ කරන ඔබේම ක්රියාවක් ලිවීමට පහසු බව පෙනේ. නමුත් මෙම පෝරමයේ පවා එය භාවිතා කිරීම තරමක් පහසුය; අදින්න ඉල්ලීමක් නිර්මාණය කිරීමේදී ඔබ ලැයිස්තුවෙන් ලේබලයක් තෝරා ගත යුතුය.

යෙදවීමට කාලයයි

මම GitHub ක්‍රියා හරහා (ssh හරහා, scp හරහා සහ ඩොකර්-හබ් භාවිතා කරමින්) යෙදවීමේ විකල්ප කිහිපයක් උත්සාහ කළ අතර, මට කිව හැක්කේ, ඔබේ නල මාර්ගය කෙතරම් වංක වුවත්, බොහෝ විට, ඔබ ද්විමය සේවාදායකයට උඩුගත කිරීමට ක්‍රමයක් සොයා ගනු ඇති බවයි. වේ.

සම්පූර්ණ යටිතල ව්‍යුහයම එක තැනක තබා ගැනීමේ විකල්පයට මම කැමතියි, එබැවින් GitHub පැකේජ වෙත යෙදවිය යුතු ආකාරය බලමු (මෙය ද්විමය අන්තර්ගතය, npm, jar, docker සඳහා ගබඩාවකි).

ඩොකර් රූපයක් තැනීම සහ එය GitHub පැකේජවල ප්‍රකාශනය කිරීම සඳහා ස්ක්‍රිප්ට්:

name: Deploy docker image

on:
  push:
    branches:
      - 'master'

jobs:

  build_docker_image:
    runs-on: ubuntu-18.04
    steps:

#     Build JAR:
      - uses: actions/checkout@v1
      - name: set up JDK 11
        uses: actions/setup-java@v1
        with:
          java-version: 1.11
      - name: Maven Package
        run: mvn -B clean compile package -DskipTests

#     Set global environment variables:
      - name: set global env
        id: global_env
        run: |
          echo "::set-output name=IMAGE_NAME::${GITHUB_REPOSITORY#*/}"
          echo "::set-output name=DOCKERHUB_IMAGE_NAME::docker.pkg.github.com/${GITHUB_REPOSITORY}/${GITHUB_REPOSITORY#*/}"

#     Build Docker image:
      - name: Build and tag image
        run: |
          docker build -t "${{ steps.global_env.outputs.DOCKERHUB_IMAGE_NAME }}:latest" -t "${{ steps.global_env.outputs.DOCKERHUB_IMAGE_NAME }}:${GITHUB_SHA::8}" .

      - name: Docker login
        run: docker login docker.pkg.github.com -u $GITHUB_ACTOR -p ${{secrets.GITHUB_TOKEN}}

#     Publish image to github package repository:
      - name: Publish image
        env:
          IMAGE_NAME: $GITHUB_REPOSITORY
        run: docker push "docker.pkg.github.com/$GITHUB_REPOSITORY/${{ steps.global_env.outputs.IMAGE_NAME }}"

පළමුව, අපි අපගේ යෙදුමේ JAR ගොනුව ගොඩනගා ගත යුතු අතර, ඉන් පසුව අපි GitHub ඩොකර් රෙජිස්ට්‍රියට යන මාර්ගය සහ අපගේ රූපයේ නම ගණනය කරමු. අපට තවම හමු නොවූ උපක්‍රම කිහිපයක් මෙහි ඇත:

• ඉදිකිරීම් වැනි: echo "::set-output name=NAME::VALUE" මඟින් ඔබට වත්මන් පියවරේදී විචල්‍යයක අගය සැකසීමට ඉඩ සලසයි, එවිට එය අනෙකුත් සියලුම පියවරයන්හිදී කියවිය හැක.
• ඔබට මෙම පියවරෙහි හැඳුනුම්කාරකය හරහා පෙර පියවරේදී සැකසූ විචල්‍යයේ අගය ලබා ගත හැක: ${{ steps.global_env.outputs.DOCKERHUB_IMAGE_NAME }}
• සම්මත GITHUB_REPOSITORY විචල්‍යය ගබඩාවේ නම සහ එහි හිමිකරු ("හිමිකරු/repo-name") ගබඩා කරයි. ගබඩාවේ නම හැර මෙම පේළියෙන් සියල්ල කපා හැරීම සඳහා, අපි bash වාක්‍ය ඛණ්ඩය භාවිතා කරමු: ${GITHUB_REPOSITORY#*/}

ඊළඟට අපි ඩොකර් රූපය ගොඩනගා ගත යුතුයි:

docker build -t "docker.pkg.github.com/antkorwin/github-actions/github-actions:latest"

රෙජිස්ට්රි වෙත ලොග් වන්න:

docker login docker.pkg.github.com -u $GITHUB_ACTOR -p ${{secrets.GITHUB_TOKEN}}

රූපය GitHub Packages Repository වෙත ප්‍රකාශ කරන්න:

docker push "docker.pkg.github.com/antkorwin/github-actions/github-actions"

රූපයේ අනුවාදය දැක්වීම සඳහා, අපි කැපවීමේ SHA හෑෂ් වෙතින් පළමු ඉලක්කම් භාවිතා කරමු - GITHUB_SHA, ඔබ එවැනි ගොඩනැගීම් මාස්ටර් වෙත ඒකාබද්ධ කිරීමේදී පමණක් නොව, ඇදීමේ ඉල්ලීම් නිර්මාණයට අනුවද කරන්නේ නම් මෙහි සූක්ෂ්මතා ඇත. event, එවිට SHA අප git ඉතිහාසයේ දකින හැෂ් සමඟ නොගැලපේ, මන්ද PR හි අවහිර කිරීමේ ක්‍රියාවන් වළක්වා ගැනීමට ක්‍රියා/පරීක්ෂා කිරීමේ ක්‍රියාව තමන්ගේම අද්විතීය හැෂ් සාදන බැවිනි.

සෑම දෙයක්ම හොඳින් ක්‍රියාත්මක වූයේ නම්, ගබඩාවේ පැකේජ කොටස (https://github.com/antkorwin/github-actions/packages) විවෘත කිරීමෙන් ඔබට නව ඩොකර් රූපයක් පෙනෙනු ඇත:

එහිදී ඔබට ඩොකර් රූපයේ අනුවාද ලැයිස්තුවක් ද දැකිය හැකිය.

ඉතිරිව ඇත්තේ මෙම රෙජිස්ට්‍රි සමඟ වැඩ කිරීමට අපගේ සේවාදායකය වින්‍යාස කර සේවාව නැවත ආරම්භ කිරීම පමණි. මම සමහරවිට systemd හරහා මේක කරන්නේ කොහොමද කියලා වෙන වෙලාවක කතා කරන්නම්.

අධීක්ෂණය

GitHub ක්‍රියා භාවිතයෙන් අපගේ යෙදුම සඳහා සෞඛ්‍ය පරීක්‍ෂණයක් කරන්නේ කෙසේද යන්න පිළිබඳ සරල විකල්පයක් දෙස බලමු. අපගේ ඇරඹුම් යෙදුමට ක්‍රියාකාරකයක් ඇත, එබැවින් අපට එහි තත්ත්වය පරීක්ෂා කිරීමට API ලිවීමට අවශ්‍ය නැත; අපි දැනටමත් කම්මැලියන් සඳහා සියල්ල කර ඇත. ඔබට අවශ්‍ය වන්නේ ධාරකය අදින්න: SERVER-URL:PORT/actuator/health

$ curl -v 127.0.0.1:8080/actuator/health

> GET /actuator/health HTTP/1.1
> Host: 127.0.0.1:8080
> User-Agent: curl/7.61.1
> Accept: */*

< HTTP/1.1 200
< Content-Type: application/vnd.spring-boot.actuator.v3+json
< Transfer-Encoding: chunked
< Date: Thu, 04 Jun 2020 12:33:37 GMT

{"status":"UP"}

අපට අවශ්‍ය වන්නේ ක්‍රෝන් භාවිතයෙන් සේවාදායකය පරීක්ෂා කිරීම සඳහා කාර්යයක් ලිවීමයි, හදිසියේම එය අපට පිළිතුරු නොදෙන්නේ නම්, අපි විදුලි පණිවුඩයක් හරහා දැනුම්දීමක් යවන්නෙමු.

පළමුව, ක්‍රෝන් වැඩ ප්‍රවාහයක් ක්‍රියාත්මක කරන්නේ කෙසේදැයි සොයා බලමු:

on:
  schedule:
    - cron:  '*/5 * * * *'

එය සරලයි, Github හි ඔබට webhooks වලට කිසිසේත්ම නොගැලපෙන සිදුවීම් නිර්මාණය කළ හැකි බව මට විශ්වාස කළ නොහැක. විස්තර ලේඛනවල ඇත: help.github.com/en/actions/reference/events-that-trigger-workflows#scheduled-events-schedule

අපි curl හරහා සේවාදායක තත්ත්වය අතින් පරීක්ෂා කරමු:

jobs:
  ping:
    runs-on: ubuntu-18.04
    steps:

      - name: curl actuator
        id: ping
        run: |
          echo "::set-output name=status::$(curl ${{secrets.SERVER_HOST}}/api/actuator/health)"

      - name: health check
        run: |
          if [[ ${{ steps.ping.outputs.status }} != *"UP"* ]]; then
            echo "health check is failed"
            exit 1
          fi
          echo "It's OK"

පළමුව, අපි සේවාදායකයා ඉල්ලීමට ප්‍රතිචාර දැක්වූ දේ විචල්‍යයකට සුරකිමු, ඊළඟ පියවරේදී අපි තත්ත්වය UP දැයි පරීක්ෂා කර, මෙය එසේ නොවේ නම්, අපි දෝෂයකින් පිට වෙමු. ඔබ ඔබේ අත්වලින් ක්රියාවක් "අධික" කිරීමට අවශ්ය නම්, එසේ නම් පිටවීම 1 - සුදුසු ආයුධය.

  - name: send alert in telegram
    if: ${{ failure() }}
    uses: appleboy/telegram-action@master
    with:
      to: ${{ secrets.TELEGRAM_TO }}
      token: ${{ secrets.TELEGRAM_TOKEN }}
      message: |
        Health check of the:
        ${{secrets.SERVER_HOST}}/api/actuator/health
        failed with the result:
        ${{ steps.ping.outputs.status }}

අපි ටෙලිග්‍රාම් වෙත යවන්නේ පෙර පියවරේදී ක්‍රියාව අසාර්ථක වුවහොත් පමණි. පණිවිඩයක් යැවීමට අපි appleboy/telegram-action භාවිතා කරමු; ඔබට ප්‍රලේඛනය තුළ බොට් ටෝකනයක් සහ චැට් හැඳුනුම්පතක් ලබා ගන්නේ කෙසේද යන්න ගැන කියවිය හැකිය: github.com/appleboy/telegram-action

Github හි රහස් ලිවීමට අමතක නොකරන්න: සේවාදායකය සඳහා URL සහ ටෙලිග්‍රාම් බොට් සඳහා ටෝකන.

ප්‍රසාද ධාවන පථය - කම්මැලියන් සඳහා JIRA

අපි නැවත ජිරා වෙත පැමිණෙන බවට මම පොරොන්දු වූ අතර අපි ආපසු පැමිණියෙමු. සංවර්ධකයින් විශේෂාංගයක් සෑදූ විට, ශාඛාවක් ඒකාබද්ධ කළ විට, නමුත් ගැටලුව JIRA වෙත ඇද ගැනීමට අමතක වූ විට මම සිය වතාවක් නැගී සිටීමේ තත්වයක් නිරීක්ෂණය කර ඇත්තෙමි. ඇත්ත වශයෙන්ම, මේ සියල්ල එක තැනක සිදු කළේ නම්, එය පහසු වනු ඇත, නමුත් ඇත්ත වශයෙන්ම අපි IDE හි කේතය ලියන්නෙමු, ශාඛා bitbucket හෝ GitHub වෙත ඒකාබද්ධ කරන්න, ඉන්පසු කාර්යයන් Jira වෙත ඇද දමන්න, මේ සඳහා අපි නව කවුළු විවෘත කළ යුතුය. , සමහර විට නැවත ලොග් වීම සහ යනාදිය. ඔබ ඊළඟට කළ යුතු දේ හොඳින් මතක තබා ගත් විට, පුවරුව නැවත විවෘත කිරීමේ තේරුමක් නැත. එහි ප්රතිඵලයක් වශයෙන්, උදෑසන ස්ථාවර ස්ථානයක ඔබ කාර්ය මණ්ඩලය යාවත්කාලීන කිරීමට කාලය ගත කළ යුතුය.

මෙම සාමාන්‍ය කාර්යයේදී GitHub ද අපට උදවු කරනු ඇත; ආරම්භකයින් සඳහා, අපි ඇදීමේ ඉල්ලීමක් ඉදිරිපත් කරන විට අපට ස්වයංක්‍රීයව ගැටලු code_review තීරුවට ඇදගෙන යා හැක. ඔබ කළ යුත්තේ ශාඛාව නම් කිරීමේ සම්මුතිය අනුගමනය කිරීමයි:

[имя проекта]-[номер таска]-название

උදාහරණයක් ලෙස, "GitHub Actions" ව්‍යාපෘති යතුර GA නම්, එසේ නම් GA-8-jira-bot GA-8 කාර්යය ක්රියාත්මක කිරීම සඳහා ශාඛාවක් විය හැකිය.

JIRA සමඟ ඒකාබද්ධ වීම Atlassian වෙතින් ක්‍රියා හරහා ක්‍රියා කරයි, ඒවා පරිපූර්ණ නොවේ, සමහර ඒවා මට කිසිසේත් වැඩ නොකළ බව මම පැවසිය යුතුය. නමුත් අපි සාකච්ඡා කරන්නේ නියත වශයෙන්ම ක්‍රියාත්මක වන සහ ක්‍රියාකාරීව භාවිතා කරන ඒවා පමණි.

පළමුව ඔබ ක්‍රියාව භාවිතා කර JIRA වෙත ලොග් විය යුතුය: atlassian/gajira-login

jobs:
  build:
    runs-on: ubuntu-latest
    name: Jira Workflow
    steps:
      - name: Login
        uses: atlassian/gajira-login@master
        env:
          JIRA_BASE_URL: ${{ secrets.JIRA_BASE_URL }}
          JIRA_USER_EMAIL: ${{ secrets.JIRA_USER_EMAIL }}
          JIRA_API_TOKEN: ${{ secrets.JIRA_API_TOKEN }}

මෙය සිදු කිරීම සඳහා, ඔබ JIRA හි ටෝකනයක් ලබා ගත යුතුය, මෙය කරන්නේ කෙසේද යන්න මෙහි විස්තර කර ඇත: confluence.atlassian.com/Cloud/api-tokens-938839638.html

අපි ශාඛා නාමයෙන් කාර්ය හැඳුනුම්කාරකය උපුටා ගනිමු:

  - name: Find Issue
    id: find_issue
    shell: bash
    run: |
      echo "::set-output name=ISSUE_ID::$(echo ${GITHUB_HEAD_REF} | egrep -o 'GA-[0-9]{1,4}')"
      echo brach name: $GITHUB_HEAD_REF
      echo extracted issue: ${GITHUB_HEAD_REF} | egrep -o 'GA-[0-9]{1,4}'

  - name: Check Issue
    shell: bash
    run: |
      if [[ "${{steps.find_issue.outputs.ISSUE_ID}}" == "" ]]; then
        echo "Please name your branch according to the JIRA issue: [project_key]-[task_number]-branch_name"
        exit 1
      fi
      echo succcessfully found JIRA issue: ${{steps.find_issue.outputs.ISSUE_ID}}

GitHub marketplace එකේ search කලොත් ඔයාට මේ task එකට action එකක් හොයාගන්න පුළුවන්, ඒත් මට ඒකම grep එකෙන් ලියන්න උනේ branch එකේ නම දාල, මොකද Atlassian ගේ මේ action එක මගේ project එකේ කිසිම විදියකින් වැඩ කරන්න ඕන උනේ නෑ. , එහි ඇති වැරැද්ද කුමක්දැයි සොයා ගැනීමට - ඔබේ දෑතින් එකම දේ කිරීමට වඩා දිගු වේ.

අදින්න ඉල්ලීමක් නිර්මාණය කිරීමේදී කාර්යය "කේත සමාලෝචන" තීරුව වෙත ගෙන යාම පමණක් ඉතිරිව ඇත:

  - name: Transition issue
    if: ${{ success() }}
    uses: atlassian/gajira-transition@master
    with:
      issue: ${{ steps.find_issue.outputs.ISSUE_ID }}
      transition: "Code review"

GitHub හි මේ සඳහා විශේෂ ක්‍රියාවක් ඇත, එයට අවශ්‍ය වන්නේ පෙර පියවරේදී ලබාගත් නිකුතු හැඳුනුම්පත සහ අප ඉහත කළ JIRA හි අවසරය පමණි.

එලෙසම, ඔබට මාස්ටර් වෙත ඒකාබද්ධ වන විට කාර්යයන් සහ GitHub කාර්ය ප්‍රවාහයෙන් වෙනත් සිදුවීම් ඇදගෙන යා හැක. පොදුවේ, එය ඔබගේ පරිකල්පනය සහ සාමාන්ය ක්රියාවලීන් ස්වයංක්රීය කිරීමට ඇති ආශාව මත රඳා පවතී.

සොයා ගැනීම්

ඔබ සම්භාව්‍ය DEVOPS රූප සටහන දෙස බැලුවහොත්, සමහර විට ක්‍රියාත්මක වීම හැර, අපි සියලුම අදියර ආවරණය කර ඇත, මම හිතන්නේ ඔබ උත්සාහ කළහොත්, ඔබට උපකාරක මේස පද්ධතිය සමඟ ඒකාබද්ධ කිරීම සඳහා වෙළඳපොලේ යම් ක්‍රියාමාර්ගයක් සොයාගත හැකිය, එබැවින් නල මාර්ගය හැරී ඇති බව අපි උපකල්පනය කරමු. පරිපූර්ණ විය යුතු අතර එහි භාවිතය මත පදනම්ව නිගමනවලට එළඹිය හැකිය.

වාසි:

• සියලුම අවස්ථාවන් සඳහා සූදානම් කළ ක්‍රියා සහිත වෙළඳපල, මෙය ඉතා සිසිල් ය. ඒවායින් බොහොමයක්, ඔබට සමාන ගැටළුවක් විසඳන්නේ කෙසේද යන්න තේරුම් ගැනීමට මූලාශ්‍ර කේතය දෙස බැලිය හැකිය, නැතහොත් කර්තෘ වෙත විශේෂාංග ඉල්ලීමක් කෙලින්ම GitHub ගබඩාවේ පළ කරන්න.
• එකලස් කිරීම සඳහා ඉලක්කගත වේදිකාව තෝරාගැනීම: Linux, mac os, windows ඉතා රසවත් අංගයකි.
• Github පැකේජ විශිෂ්ට දෙයක්, සම්පූර්ණ යටිතල පහසුකම් එක තැනක තබා ගැනීම පහසුය, ඔබට විවිධ කවුළු හරහා සැරිසැරීමට අවශ්‍ය නැත, සෑම දෙයක්ම මූසික ක්ලික් කිරීම් එකක් හෝ දෙකක අරයක් තුළ ඇති අතර GitHub ක්‍රියා සමඟ පරිපූර්ණව ඒකාබද්ධ වේ. නිදහස් අනුවාදයේ ඩොකර් රෙජිස්ට්‍රි සහාය ද හොඳ වාසියකි.
• GitHub ගොඩනැගීමේ ලොග් වල රහස් සඟවයි, එබැවින් මුරපද සහ ටෝකන ගබඩා කිරීමට එය භාවිතා කිරීම එතරම් බියජනක නොවේ. මගේ සියලු අත්හදා බැලීම් අතරතුර, කොන්සෝලය තුළ රහස එහි පිරිසිදු ස්වරූපයෙන් දැකීමට මට කිසිදා නොහැකි විය.
• විවෘත මූලාශ්‍ර ව්‍යාපෘති සඳහා නොමිලේ

එය:

• YML, හොඳයි, මම ඔහුට කැමති නැහැ. එවැනි ප්‍රවාහයක් සමඟ වැඩ කරන විට, මා සතුව ඇති වඩාත් පොදු කැපවීමේ පණිවිඩය වන්නේ “yml ආකෘතිය නිවැරදි කරන්න”, එවිට ඔබට ටැබ් එකක් කොහේ හෝ තැබීමට අමතක වේ, නැතහොත් ඔබ එය වැරදි රේඛාවක ලියා ඇත. පොදුවේ ගත් කල, ප්‍රොටෙක්ටරයක් ​​​​සහ පාලකයක් සහිත තිරයක් ඉදිරිපිට වාඩි වී සිටීම වඩාත් ප්‍රසන්න අත්දැකීමක් නොවේ.
• නිදොස් කිරීම, කැපවීම් සමඟ ප්‍රවාහය නිදොස් කිරීම, නැවත ගොඩනැගීමක් ක්‍රියාත්මක කිරීම සහ කොන්සෝලයට ප්‍රතිදානය කිරීම සැමවිටම පහසු නොවේ, නමුත් එය “ඔබ ඉක්මවා ඇත” කාණ්ඩයට වඩා වැඩි ය; ඔබට ඕනෑම දෙයක් දෝෂහරණය කළ හැකි විට පහසු IDEA සමඟ වැඩ කිරීමට ඔබ පුරුදු වී ඇත. .
• ඔබ එය Docker හි ඔතා ඇත්නම් ඔබට ඕනෑම දෙයක් මත ඔබේ ක්‍රියාව ලිවිය හැකිය, නමුත් javascript පමණක් ස්වදේශිකව සහය දක්වයි, ඇත්ත වශයෙන්ම මෙය රසය පිළිබඳ කාරණයකි, නමුත් මම js වෙනුවට වෙනත් දෙයකට කැමතියි.

සියලුම ස්ක්‍රිප්ට් සහිත ගබඩාව මෙහි ඇති බව මම ඔබට මතක් කරමි: github.com/antkorwin/github-actions

ලබන සතියේ මම රඟපානවා වාර්තාව Heisenbug 2020 Piter සමුළුවේදී. පරීක්ෂණ දත්ත සකස් කිරීමේදී වැරදි වළක්වා ගන්නේ කෙසේදැයි මම ඔබට කියමි, නමුත් ජාවා යෙදුම්වල දත්ත කට්ටල සමඟ වැඩ කිරීමේ මගේ රහස් බෙදා ගන්න!

මූලාශ්රය: www.habr.com