Route to an Uploaded File in Github
Upload-Artifact v3
This uploads artifacts from your workflow allowing you to share data between jobs and store information once a workflow is complete.
See also download-antiquity.
What's new
- Easier upload
- Specify a wildcard design
- Specify an private file
- Specify a directory (previously you were express to simply this option)
- Multi path upload
- Use a combination of private files, wildcards or directories
- Back up for excluding certain files
- Upload an antiquity without providing a name
- Fix for antiquity uploads sometimes non working with containers
- Proxy support out of the box
- Port unabridged action to typescript from a runner plugin so it is easier to collaborate and accept contributions
Refer hither for the previous version
Usage
Meet activeness.yml
Upload an Individual File
steps: - uses: actions/checkout@v2 - run: mkdir -p path/to/artifact - run: echo hello > path/to/artifact/globe.txt - uses: actions/upload-artifact@v3 with: proper name: my-artifact path: path/to/artifact/world.txt Upload an Entire Directory
- uses: actions/upload-artifact@v3 with: name: my-artifact path: path/to/artifact/ # or path/to/artifact Upload using a Wildcard Pattern
- uses: deportment/upload-artifact@v3 with: name: my-artifact path: path/**/[abc]rtifac?/* Upload using Multiple Paths and Exclusions
- uses: deportment/upload-artifact@v3 with: proper name: my-artifact path: | path/output/bin/ path/output/test-results !path/**/*.tmp For supported wildcards forth with behavior and documentation, see @actions/glob which is used internally to search for files.
If a wildcard pattern is used, the path bureaucracy will be preserved subsequently the outset wildcard pattern:
path/to/*/directory/foo?.txt => ∟ path/to/some/directory/foo1.txt ∟ path/to/some/directory/foo2.txt ∟ path/to/other/directory/foo1.txt would exist flattened and uploaded as => ∟ some/directory/foo1.txt ∟ some/directory/foo2.txt ∟ other/directory/foo1.txt If multiple paths are provided as input, the least common ancestor of all the search paths will be used every bit the root directory of the artifact. Exclude paths do not affect the directory structure.
Relative and absolute file paths are both allowed. Relative paths are rooted confronting the current working directory. Paths that brainstorm with a wildcard character should be quoted to avoid being interpreted equally YAML aliases.
The @actions/artifact package is used internally to handle about of the logic around uploading an artifact. At that place is extra documentation around upload limitations and behavior in the toolkit repo that is worth checking out.
Customization if no files are found
If a path (or paths), result in no files being found for the antiquity, the action volition succeed but print out a alert. In certain scenarios it may be desirable to neglect the action or suppress the warning. The if-no-files-found option allows y'all to customize the behavior of the activeness if no files are found:
- uses: actions/upload-artifact@v3 with: proper name: my-antiquity path: path/to/artifact/ if-no-files-found: error # 'warn' or 'ignore' are too bachelor, defaults to `warn` Conditional Artifact Upload
To upload artifacts just when the previous step of a job failed, use if: failure():
- uses: actions/upload-artifact@v3 if: failure() with: proper name: my-artifact path: path/to/antiquity/ Uploading without an artifact name
You can upload an artifact without specifying a proper name
- uses: deportment/upload-artifact@v3 with: path: path/to/artifact/world.txt If non provided, antiquity volition be used every bit the default name which will manifest itself in the UI after upload.
Uploading to the same artifact
With the following example, the available artifact (named antiquity by default if no name is provided) would contain both world.txt (hello) and extra-file.txt (howdy):
- run: repeat how-do-you-do > earth.txt - uses: actions/upload-artifact@v3 with: path: world.txt - run: echo hello > extra-file.txt - uses: deportment/upload-artifact@v3 with: path: extra-file.txt - run: echo hello > world.txt - uses: actions/upload-artifact@v3 with: path: earth.txt Each antiquity behaves equally a file share. Uploading to the aforementioned artifact multiple times in the same workflow can overwrite and append already uploaded files:
strategy: matrix: node-version: [eight.ten, x.x, 12.10, xiii.x] steps: - name: Create a file run: echo ${{ matrix.node-version }} > my_file.txt - name: Accidentally upload to the same antiquity via multiple jobs uses: deportment/upload-antiquity@v3 with: name: my-artifact path: ${{ github.workspace }} Warning: Exist conscientious when uploading to the same artifact via multiple jobs equally artifacts may become corrupted. When uploading a file with an identical name and path in multiple jobs, uploads may neglect with 503 errors due to alien uploads happening at the same time. Ensure uploads to identical locations to non interfere with each other.
In the to a higher place example, four jobs volition upload four dissimilar files to the same artifact but in that location volition only be ane file available when my-artifact is downloaded. Each job overwrites what was previously uploaded. To ensure that jobs don't overwrite existing artifacts, use a different name per job:
uses: actions/upload-artifact@v3 with: name: my-artifact ${{ matrix.node-version }} path: ${{ github.workspace }} Environment Variables and Tilde Expansion
You can use ~ in the path input as a substitute for $Dwelling house. Basic tilde expansion is supported:
- run: | mkdir -p ~/new/artifact repeat hello > ~/new/artifact/globe.txt - uses: deportment/upload-artifact@v3 with: proper noun: Artifacts-V3 path: ~/new/**/* Surround variables along with context expressions tin can also exist used for input. For documentation run across context and expression syntax:
env: proper name: my-artifact steps: - run: | mkdir -p ${{ github.workspace }}/artifact repeat hello > ${{ github.workspace }}/antiquity/globe.txt - uses: deportment/upload-artifact@v3 with: name: ${{ env.name }}-name path: ${{ github.workspace }}/artifact/**/* For surroundings variables created in other steps, brand sure to apply the env expression syntax
steps: - run: | mkdir testing echo "This is a file to upload" > testing/file.txt echo "artifactPath=testing/file.txt" >> $GITHUB_ENV - uses: deportment/upload-antiquity@v3 with: proper name: artifact path: ${{ env.artifactPath }} # this will resolve to testing/file.txt at runtime Retention Period
Artifacts are retained for ninety days past default. You can specify a shorter memory period using the retentiveness-days input:
- name: Create a file run: echo "I won't live long" > my_file.txt - name: Upload Antiquity uses: actions/upload-antiquity@v3 with: name: my-antiquity path: my_file.txt retention-days: five The retention menstruation must be betwixt one and 90 inclusive. For more than information meet artifact and log retention policies.
Where does the upload go?
At the bottom of the workflow summary page, in that location is a dedicated section for artifacts. Here'south a screenshot of something you might encounter:
There is a trashcan icon that tin can be used to delete the artifact. This icon will but appear for users who have write permissions to the repository.
The size of the artifact is denoted in bytes. The displayed artifact size denotes the raw uploaded antiquity size (the sum of all the individual files uploaded during the workflow run for the artifact), not the compressed size. When yous click to download an artifact from the summary page, a compressed zilch is created with all the contents of the antiquity and the size of the zip that you download may differ significantly from the displayed size. Billing is based on the raw uploaded size and not the size of the zero.
Limitations
Zipped Artifact Downloads
During a workflow run, files are uploaded and downloaded individually using the upload-antiquity and download-antiquity actions. However, when a workflow run finishes and an antiquity is downloaded from either the UI or through the download api, a zippo is dynamically created with all the file contents that were uploaded. At that place is currently no style to download artifacts afterwards a workflow run finishes in a format other than a nix or to download artifact contents individually. I of the consequences of this limitation is that if a nix is uploaded during a workflow run and then downloaded from the UI, there volition be a double zip created.
Permission Loss
chmod and then upload that file, post-download the file is no longer guaranteed to exist set as an executable.
Example Insensitive Uploads
A.txt and a.txt with the aforementioned root path, simply a single file will exist saved and available during download.
Maintaining file permissions and example sensitive files
If file permissions and instance sensitivity are required, you tin can tar all of your files together before artifact upload. Post download, the tar file will maintain file permissions and case sensitivity:
- name: Tar files run: tar -cvf my_files.tar /path/to/my/directory - name: Upload Artifact uses: deportment/upload-antiquity@v3 with: proper noun: my-artifact path: my_files.tar Too many uploads resulting in 429 responses
A very minute subset of users who upload a very very large amount of artifacts in a short period of time may run into their uploads throttled or fail because of Asking was blocked due to exceeding usage of resource 'DBCPU' in namespace or Unable to copy file to server StatusCode=TooManyRequests.
To reduce the chance of this happening, you can reduce the number of HTTP calls made during artifact upload by zipping or archiving the contents of your artifact before an upload starts. Every bit an case, imagine an artifact with 1000 files (each x Kb in size). Without whatever modification, there would exist around 1000 HTTP calls made to upload the artifact. If you cypher or archive the antiquity beforehand, the number of HTTP calls tin be dropped to unmarried digit territory. Measures like this will significantly speed up your upload and preclude uploads from being throttled or in some cases fail.
Additional Documentation
Run across Storing workflow data as artifacts for additional examples and tips.
Come across extra documentation for the @deportment/artifact package that is used internally regarding sure behaviors and limitations.
License
The scripts and documentation in this projection are released under the MIT License.
Source: https://github.com/actions/upload-artifact
Post a Comment for "Route to an Uploaded File in Github"