Docker ko KR - Rudokhvist/ArchiSteamFarm GitHub Wiki
ASF๋ 3.0.3.2 ๋ฒ์ ๋ถํฐ ๋์ปค ์ปจํ ์ด๋ ๋ก๋ ์ฌ์ฉ๊ฐ๋ฅํฉ๋๋ค. Our docker packages are currently available on ghcr.io as well as Docker Hub.
It's important to note that running ASF in Docker container is considered advanced setup, which is not needed for vast majority of users, and typically gives no advantages over container-less setup. If you're considering Docker as a solution for running ASF as a service, for example making it start automatically with your OS, then you should consider reading management section instead and set up a proper systemd
service which will be almost always a better idea than running ASF in a Docker container.
Running ASF in Docker container usually involves several new problems and issues that you'll have to face and resolve yourself. This is why we strongly recommend you to avoid it unless you already have Docker knowledge and don't need help understanding its internals, about which we won't elaborate here on ASF wiki. This section is mostly for valid use cases of very complex setups, for example in regards to advanced networking or security beyond standard sandboxing that ASF comes with in systemd
service (which already ensures superior process isolation through very advanced security mechanics). For those handful amount of people, here we explain better ASF concepts in regards to its Docker compatibility, and only that, you're assumed to have adequate Docker knowledge yourself if you decide to use it together with ASF.
ASF๋ 4๊ฐ์ง ์ฃผ์ ์ ํ์ ํ๊ทธ ์ํ๋ฅผ ๊ฐ์ต๋๋ค.
This tag always points to the ASF built from latest commit in main
branch, which works the same as grabbing latest artifact directly from our CI pipeline. ์ผ๋ฐ์ ์ผ๋ก ์ด ํ๊ทธ๋ ํผํด์ผ ํฉ๋๋ค. ์ด๋ ๊ฐ๋ฐ๋ชฉ์ ์ ์ํด ๊ฐ๋ฐ์์ ๊ณ ๊ธ์ฌ์ฉ์์ฉ์ ์ต๊ณ ์์ค์ผ๋ก ๋ฒ๊ทธ๊ฐ ๋ง์ ์ํํธ์จ์ด์
๋๋ค. The image is being updated with each commit in the main
GitHub branch, therefore you can expect very often updates (and stuff being broken). ๋ฆด๋ฆฌ์ค ์ฃผ๊ธฐ์์ ์ด์ผ๊ธฐํ ๊ฒ ์ฒ๋ผ ์ด๋ ASF ํ๋ก์ ํธ์ ํ์ฌ ์ํ๋ฅผ ๋ํ๋ด๊ธฐ ์ํด ์๋๊ฒ์ด์ง, ์์ ์ ์ด๊ฑฐ๋ ํ
์คํธ์๋ฃ๋์์์ ๋ณด์ฅํ๋ ๊ฒ์ด ์๋๋๋ค. ์ด ํ๊ทธ๋ ์ ์ ํ๊ฒฝ์์ ์ฌ์ฉํด์๋ ์๋ฉ๋๋ค.
์์ ๋งค์ฐ ์ ์ฌํ์ง๋ง, ์ด ํ๊ทธ๋ ์ฌ์ ๋ฆด๋ฆฌ์ค๋ฅผ ํฌํจํ ์ต์ ๋ฆด๋ฆฌ์ค ๋ฒ์ ์ ํญ์ ๊ฐ๋ฆฌํต๋๋ค. Compared to main
tag, this image is being updated each time a new GitHub tag is pushed. ์์ ์ ์ด๋ฉด์๋ ์๋ก์ด, ์ต์ฒจ๋จ์ ์๊ธฐ๋ฅผ ์ข์ํ๋ ๊ณ ๊ธ ์ฌ์ฉ์๋ฅผ ์ํ ๊ฒ์
๋๋ค. latest
๋ฅผ ์ฌ์ฉํ๊ณ ์ถ์ง ์์ ๊ฒฝ์ฐ ์ถ์ฒํฉ๋๋ค. In practice, it works the same as rolling tag pointing to the most recent A.B.C.D
release at the time of pulling. ์ด ํ๊ทธ์ ์ฌ์ฉ์ ์ฌ์ ๋ฆด๋ฆฌ์ค ์ ์ฌ์ฉ๊ณผ ๋์ผํฉ๋๋ค.
This tag in comparison with others, is the only one that includes ASF auto-updates feature and points to the latest stable ASF version. The objective of this tag is to provide a sane default Docker container that is capable of running self-updating, OS-specific build of ASF. ์ด ๋๋ฌธ์ ๊ฐ๋ฅํ๋งํผ ์์ฃผ ์
๋ฐ์ดํธ ๋ ํ์๊ฐ ์์ต๋๋ค. ํฌํจ๋ ASF ๋ฒ์ ์ ํ์ํ๋ค๋ฉด ์ค์ค๋ก ์
๋ฐ์ดํธ๋ ์ ์์ต๋๋ค. ๋ฌผ๋ก UpdatePeriod
๋ ์์ ํ๊ฒ ๊บผ๋ ๋ฉ๋๋ค(0
์ผ๋ก ์ค์ ). ์ด ๊ฒฝ์ฐ A.B.C.D
๋ฆด๋ฆฌ์ค๋ฅผ ์ฌ์ฉํด์ผ ํ ๊ฒ์
๋๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก, ๊ทธ๋์ ์๋์ผ๋ก ์
๋ฐ์ดํธ ๋๋ released
ํ๊ทธ๋ฅผ ๋ง๋ค๊ธฐ ์ํด ๊ธฐ๋ณธ UpdateChannel
์ ๋ณ๊ฒฝํ ์๋ ์์ต๋๋ค.
Due to the fact that the latest
image comes with capability of auto-updates, it includes bare OS with OS-specific linux
ASF version, contrary to all other tags that include OS with .NET runtime and generic
ASF version. This is because newer (updated) ASF version might also require newer runtime than the one the image could possibly be built with, which would otherwise require image to be re-built from scratch, nullifying the planned use-case.
์์ ํ๊ทธ์ ๋น๊ตํ์๋ฉด, ์ด ํ๊ทธ๋ ์์ ํ ๋๊ฒฐ๋์์ต๋๋ค. ์ฆ, ํ๋ฒ ๋ฆด๋ฆฌ์ค๋๋ฉด ์
๋ฐ์ดํธ ๋์ง ์์ต๋๋ค. ์ต์ด ๋ฆด๋ฆฌ์ค ํ ํ๋ฒ๋ ๊ฑด๋๋ฆฌ์ง ์์ GitHub ๋ฆด๋ฆฌ์ค์ ์ ์ฌํ๊ฒ ๋์ํ๊ณ , ์์ ์ ์ด๊ณ ๋๊ฒฐ๋ ํ๊ฒฝ์ ๋ณด์ฅํฉ๋๋ค. Typically you should use this tag when you want to use some specific ASF release and you don't want to use any kind of auto-updates (e.g. those offered in latest
tag).
์ฐพ๊ณ ์๋ ๊ฒ์ ๋ฐ๋ผ ๋ค๋ฆ
๋๋ค. ๋๋ถ๋ถ์ ์ฌ์ฉ์์๊ฒ latest
ํ๊ทธ๊ฐ ์ต์ ์
๋๋ค. ์ด๋ ์๋น์ค๋ก ๋์ด์๋ ํน๋ณํ ๋์ปค ์ปจํ
์ด๋์ ๋ด๊ฒจ์์ ๋ฟ ๋ฐ์คํฌํ ASF๊ฐ ์ ๊ณตํ๋ ๊ฒ์ ์ ํํ๊ฒ ๋์ผํ๊ฒ ์ ๊ณตํฉ๋๋ค. People that are rebuilding their images quite often and would instead prefer full control with ASF version tied to given release are welcome to use released
tag. ๋น์ ์ ๋ช
ํํ ์๋ ์์ด ์ด๋ค๊ฒ๋ ๋ฐ๋์ง ์๋ ํน์ ํ ๋๊ฒฐ ๋ฒ์ ์ ์ฌ์ฉํ๊ธธ ์ํ๋ค๋ฉด A.B.C.D
๋ฆด๋ฆฌ์ค๊ฐ ๋น์ ์ด ํญ์ ๋์๊ฐ ์ ์๋ ๊ณ ์ ๋ ASF ๋ง์ผ์คํค์ด ๋ ๊ฒ์
๋๋ค.
We generally discourage trying main
builds, as those are here for us to mark current state of ASF project. ๊ทธ ์ํ๋ ์ด๋ค๊ฒ๋ ์ ์์๋์ ๋ณด์ฅํ์ง ์์ง๋ง, ASF ๊ฐ๋ฐ์ ๊ด์ฌ์ด ์๋ค๋ฉด ์๋ํด๋ณด๋ ๊ฒ๋ ์ข์ต๋๋ค.
ASF docker image is currently built on linux
platform targetting 3 architectures - x64
, arm
and arm64
. ๋ ๋ง์ ์ ๋ณด๋ ํธํ์ฑ ํญ๋ชฉ์ ์ฐธ๊ณ ํ์ญ์์ค.
Since ASF version V5.0.2.2, our tags are using multi-platform manifest, which means that Docker installed on your machine will automatically select the proper image for your platform when pulling the image. If by any chance you'd like to pull a specific platform image which doesn't match the one you're currently running, you can do that through --platform
switch in appropriate docker commands, such as docker run
. See docker documentation on image manifest for more info.
์์ ํ ์ฐธ์กฐ๋ **๋์ปค ๊ณต์ ๋ฌธ์**๋ฅผ ์ฐธ๊ณ ํ์๊ณ , ์ด ๊ฐ์ด๋์์๋ ๊ฐ๋จํ ์ฌ์ฉ๋ฒ๋ง ๋ค๋ฃน๋๋ค. ๋ ๊น์ด ๊ณต๋ถํ๋ ๊ฒ๋ ์ข์ต๋๋ค.
๋จผ์ ๋์ปค๊ฐ ์ ์์ ์ผ๋ก ์๋ํ๋์ง ํ์ธํด์ผํฉ๋๋ค. ์ด๊ฒ์ด ASF์ "Hello World!" ์ ๋๋ค.
docker run -it --name asf --pull always --rm justarchi/archisteamfarm
docker run
์ผ๋ก ๋น์ ์ ์๋ก์ด ASF ๋์ปค ์ปจํ
์ด๋๋ฅผ ์์ฑํ๊ณ ์ ๊ฒฝ์์ ์คํ๋๋๋ก ํฉ๋๋ค(-it
). --pull always
ensures that up-to-date image will be pulled first, and --rm
ensures that our container will be purged once stopped, since we're just testing if everything works fine for now.
๋ชจ๋ ๊ฒ์ด ์ฑ๊ณต์ ์ผ๋ก ๋๋๋ฉด, ๋ชจ๋ ๋ ์ด์ด๋ฅผ ๋น๊ธฐ๊ณ ์ปจํ
์ด๋๋ฅผ ์์ํ ๋ค ASF๊ฐ ์ ์์ ์ผ๋ก ์์ํด์ ์ ์๋ ๋ด์ด ์๋ค๊ณ ์๋ฆฌ๊ณ ์์์ ์๊ฒ ๋ฉ๋๋ค. ASF๊ฐ ๋์ปค์์ ์ ์์ ์ผ๋ก ์๋ํ๊ณ ์์ต๋๋ค. CTRL+P
์ CTRL+Q
๋ฅผ ์์๋๋ก ๋๋ฌ์ ์ ๊ฒฝ ๋์ปค ์ปจํ
์ด๋์์ ๋น ์ ธ๋์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ docker stop asf
๋ฅผ ์
๋ ฅํด ASF๋ฅผ ์ค์งํฉ๋๋ค.
๋ช
๋ น์ด๋ฅผ ์์ธํ ๋ดค๋ค๋ฉด ํ๊ทธ๋ฅผ ์ ์ธํ์ง ์์์์ ์๊ฒ ๋์์ ๊ฒ๋๋ค. ํ๊ทธ๋ ์๋์ผ๋ก ๊ธฐ๋ณธ๊ฐ์ธ latest
๊ฐ ๋ฉ๋๋ค. If you want to use other tag than latest
, for example released
, then you should declare it explicitly:
docker run -it --name asf --pull always --rm justarchi/archisteamfarm:released
ASF๋ฅผ ๋์ปค ์ปจํ
์ด๋์์ ์ฌ์ฉํ๊ณ ์๋ค๋ฉด ํ๋ก๊ทธ๋จ ์์ฒด๋ฅผ ํ๊ฒฝ์ค์ ํ ํ์๊ฐ ์์ต๋๋ค. ๋ค์ํ ๋ฐฉ๋ฒ์ผ๋ก ํ ์ ์์ง๋ง, ์ถ์ฒํ๋ ๊ฒ์ ๋ก์ปฌ ๊ธฐ๊ธฐ์ ASF config
๋๋ ํ ๋ฆฌ๋ฅผ ๋ง๋ค์ด์ ASF ๋์ปค ์ปจํ
์ด๋์ ๊ณต์ ๋ณผ๋ฅจ์ผ๋ก ๋ง์ดํธ ํ๋ ๊ฒ์
๋๋ค.
์๋ฅผ ๋ค์ด, ๋น์ ์ ASF ํ๊ฒฝ์ค์ ํด๋๊ฐ /home/archi/ASF/config
๋๋ ํ ๋ฆฌ์ ์๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ์ด ๋๋ ํ ๋ฆฌ๋ ํต์ฌ ASF.json
๊ณผ ์คํํ๋ ค๋ ๋ด์ด ๋ด๊ฒจ ์์ต๋๋ค. ์ด์ ํ ์ผ์ ๋จ์ํ ์ด ๋๋ ํ ๋ฆฌ๋ฅผ ๋์ปค ์ปจํ
์ด๋์ ๊ณต์ ๋ณผ๋ฅจ์ผ๋ก ๋ถ์ด๋ ๊ฒ์
๋๋ค. ASF๋ ์ฌ๊ธฐ์ ํ๊ฒฝ์ค์ ๋๋ ํ ๋ฆฌ(/app/config
)๊ฐ ์๋ค๊ณ ์๊ฐํฉ๋๋ค.
docker run -it -v /home/archi/ASF/config:/app/config --name asf --pull always justarchi/archisteamfarm
๊ทธ๋ฌ๋ฉด ๋์
๋๋ค. ์ด์ ASF ๋์ปค ์ปจํ
์ด๋๋ ๋ก์ปฌ ๊ธฐ๊ธฐ์ ์๋ ๊ณต์ ๋๋ ํ ๋ฆฌ๋ฅผ ์ฝ๊ธฐ-์ฐ๊ธฐ ๋ชจ๋๋ก ์ฌ์ฉํ๊ณ , ์ด๋ ASF๋ฅผ ์ค์ ํ๋๋ฐ ํ์ํ ์ ๋ถ์
๋๋ค. In similar way you can mount other volumes that you'd like to share with ASF, such as /app/logs
or /app/plugins/MyCustomPluginDirectory
.
๋ฌผ๋ก , ์ด๋ ์ฐ๋ฆฌ๊ฐ ์ํ๋ ๋ฐ๋ฅผ ๋ฌ์ฑํ๊ธฐ ์ํ ํ๋์ ๋ฐฉ๋ฒ์ผ๋ฟ์ด๊ณ , ์์ ๋ง์ Dockerfile
์ ๋ง๋ค์ด์ ํ๊ฒฝ์ค์ ํ์ผ์ ASF ๋์ปค ์ปจํ
์ด๋ ์์ /app/config
๋๋ ํ ๋ฆฌ๋ก ๋ณต์ฌํ๋ ๋ฑ ๋น์ ์ด ํ๋ ค๋ ๊ฒ์ ๋ง์์ ์๋ ๊ฒ์ ์์ต๋๋ค. ์ด ๊ฐ์ด๋์์๋ ๊ธฐ๋ณธ์ ์ธ ๊ฒ๋ง์ ๋ค๋ฃน๋๋ค.
ASF container by default is initialized with default root
user, which allows it to handle the internal permissions stuff and then eventually switch to asf
(UID 1000
) user for the remaining part of the main process. While this should be satisfying for the vast majority of users, it does affect the shared volume as newly-generated files will be normally owned by asf
user, which may not be desired situation if you'd like some other user for your shared volume.
๋์ปค๋ docker run
๋ช
๋ น์ด์ --user
ํ๋๊ทธ ๋ฅผ ์ ๋ฌํ์ฌ ASF๋ฅผ ์คํํ ๊ธฐ๋ณธ ์ฌ์ฉ์๋ฅผ ์ ์ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด id
๋ช
๋ น์ด๋ฅผ ํตํด uid
์ gid
๋ฅผ ํ์ธํ๊ณ ์ด๋ฅผ ๋ช
๋ น์ด์ ์ผ๋ถ๋ก ์ค ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ํด๋น ์ฌ์ฉ์์ uid
์ gid
๊ฐ 1001 ์ธ ๊ฒฝ์ฐ,
docker run -it -u 1001:1001 -v /home/archi/ASF/config:/app/config --name asf --pull always justarchi/archisteamfarm
Remember that by default /app
directory used by ASF is still owned by asf
. ASF๋ฅผ ๋ค๋ฅธ ์ฌ์ฉ์๋ก ์คํํ๋ฉด ASF ํ๋ก์ธ์ค๋ ํ์ผ์ ์ฐ๊ธฐ ๊ถํ์ ๊ฐ์ง ๋ชปํฉ๋๋ค. ์ฐ๊ธฐ ๊ถํ์ ์์
์ ํ์์ ์ธ ๊ฒ์ ์๋์ง๋ง ์๋ ์
๋ฐ์ดํธ ๊ธฐ๋ฅ ๋ฑ์์๋ ์น๋ช
์ ์
๋๋ค. In order to fix this, it's enough to change ownership of all ASF files from default asf
to your new custom user.
docker exec -u root asf chown -hR 1001:1001 /app
ASF ํ๋ก์ธ์ค์ ์ผ๋ฐ ์ฌ์ฉ์๋ฅผ ์ฌ์ฉํ๊ธฐ๋ก ์ ํ ๊ฒฝ์ฐ์๋ง, ์ปจํ
์ด๋๋ฅผ docker run
์ผ๋ก ์์ฑํ ํ ํ๋ฒ๋ง ํ๋ฉด ๋ฉ๋๋ค. ์์ 1001:1001
์ธ์๋ฅผ ASF๊ฐ ์คํ๋ ์ค์ uid
์ gid
๋ก ๋ณ๊ฒฝํ๋ ๊ฒ์ ์์ง ๋ง์ญ์์ค.
If you're using SELinux in enforced state on your OS, which is the default for example on RHEL-based distros, then you should mount the volume appending :Z
option, which will set correct SELinux context for it.
docker run -it -v /home/archi/ASF/config:/app/config:Z --name asf --pull always justarchi/archisteamfarm
This will allow ASF to create files targetting the volume while inside docker container.
ASF includes support for multiple instances synchronization, as stated in management section. When running ASF in docker container, you can optionally "opt-in" into the process, in case you're running multiple containers with ASF and you'd like for them to synchronize with each other.
By default, each ASF running inside a docker container is standalone, which means that no synchronization takes place. In order to enable synchronization between them, you must bind /tmp/ASF
path in every ASF container that you want to synchronize, to one, shared path on your docker host, in read-write mode. This is achieved exactly the same as binding a volume which was described above, just with different paths:
mkdir -p /tmp/ASF-g1
docker run -v /tmp/ASF-g1:/tmp/ASF -v /home/archi/ASF/config:/app/config --name asf1 --pull always justarchi/archisteamfarm
docker run -v /tmp/ASF-g1:/tmp/ASF -v /home/john/ASF/config:/app/config --name asf2 --pull always justarchi/archisteamfarm
# ์ด์ ๋ชจ๋ ASF ์ปจํ
์ด๋๊ฐ ์๋ก ๋๊ธฐํ๋ฉ๋๋ค.
We recommend to bind ASF's /tmp/ASF
directory also to a temporary /tmp
directory on your machine, but of course you're free to choose any other one that satisfies your usage. Each ASF container that is expected to be synchronized should have its /tmp/ASF
directory shared with other containers that are taking part in the same synchronization process.
As you've probably guessed from example above, it's also possible to create two or more "synchronization groups", by binding different docker host paths into ASF's /tmp/ASF
.
Mounting /tmp/ASF
is completely optional and actually not recommended, unless you explicitly want to synchronize two or more ASF containers. We do not recommend mounting /tmp/ASF
for single-container usage, as it brings absolutely no benefits if you expect to run just one ASF container, and it might actually cause issues that could otherwise be avoided.
ASF๋ ํ๊ฒฝ๋ณ์๋ฅผ ํตํด ๋ช
๋ น์ค ์ธ์ ๋ฅผ ๋์ปค ์ปจํ
์ด๋๋ก ๋๊ฒจ์ค ์ ์์ต๋๋ค. ์ง์ํ๋ ์ค์์น๋ฅผ ์ํด์๋ ํน๋ณํ ํ๊ฒฝ๋ณ์๋ฅผ, ๊ทธ ์ธ์๋ ASF_ARGS
๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค. docker run
์ -e
์ค์์น๋ฅผ ๋ถ์ด๋ฉด ๋ฉ๋๋ค. ๋ค์์ ์์์
๋๋ค.
docker run -it -e "ASF_CRYPTKEY=MyPassword" -e "ASF_ARGS=--no-config-migrate" --name asf --pull always justarchi/archisteamfarm
์ด๋ ๊ฒ ํ๋ฉด --cryptkey
์ธ์ ๋ฟ ์๋๋ผ ๋ค๋ฅธ ์ธ์๋ค๋ ๋์ปค ์ปจํ
์ด๋ ๋ด๋ถ์์ ์คํ๋๋ ASF ํ๋ก์ธ์ค๋ก ์ ๋ฌํ ๊ฒ์
๋๋ค. Of course, if you're advanced user then you can also modify ENTRYPOINT
or add CMD
and pass your custom arguments yourself.
Unless you want to provide custom encryption key or other advanced options, usually you don't need to include any special environment variables, as our docker containers are already configured to run with a sane expected default options of --no-restart
--process-required
--system-required
, so those flags do not need to be specified explicitly in ASF_ARGS
.
Assuming you didn't change the default value for IPC
global configuration property, it's already enabled. However, you must do two additional things for IPC to work in Docker container. Firstly, you must use IPCPassword
or modify default KnownNetworks
in custom IPC.config
to allow you to connect from the outside without using one. Unless you really know what you're doing, just use IPCPassword
. Secondly, you have to modify default listening address of localhost
, as docker can't route outside traffic to loopback interface. ๋ชจ๋ ์ธํฐํ์ด์ค๋ฅผ ๋ฆฌ์จํ๋ ์ค์ ๊ฐ์ ์์์
๋๋ค. http://*:1242
. ๋ฌผ๋ก ๋ก์ปฌ LAN์ด๋ VPN ๋คํธ์ํฌ ๊ฐ์ ๋ ์ ํ์ ์ธ ๋ฐ์ธ๋ฉ์ ์ฌ์ฉํ ์๋ ์์ง๋ง, ์ธ๋ถ์์ ๋ผ์ฐํ
๊ฐ๋ฅํด์ผ ํฉ๋๋ค. localhost
๋ ๊ฒ์คํธ ๊ธฐ๊ธฐ์์์๋ง ๋ผ์ฐํ
ํ๋ฏ๋ก ์ด๊ฒ์ด ๋ถ๊ฐ๋ฅํฉ๋๋ค.
์์ ๊ฐ์ด ํ๋ ค๋ฉด, ์๋์ ๊ฐ์ **์ฌ์ฉ์ ์ค์ IPC**๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
{
"Kestrel": {
"Endpoints": {
"HTTP": {
"Url": "http://*:1242"
}
}
}
}
IPC๋ฅผ ๋ฃจํ๋ฐฑ์ด ์๋ ์ธํฐํ์ด์ค์ ์ค์ ํ๊ณ ๋๋ฉด, -P
๋ -p
์ค์์น๋ฅผ ์ฌ์ฉํด์ ๋์ปค์๊ฒ ASF์ 1242/tcp
ํฌํธ๋ฅผ ์๋ ค์ฃผ์ด์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ์ด ๋ช ๋ น์ด๋ ASF์ IPC ์ธํฐํ์ด์ค๋ฅผ ํธ์คํธ ๊ธฐ๊ธฐ์ ์ด ๊ฒ์ ๋๋ค.
docker run -it -p 127.0.0.1:1242:1242 -p [::1]:1242:1242 --name asf --pull always justarchi/archisteamfarm
๋ชจ๋ ๊ฒ์ ์ ํํ๊ฒ ์ค์ ํ๋ค๋ฉด ์์ docker run
๋ช
๋ น์ด๋ ํธ์คํธ ๊ธฐ๊ธฐ์ IPC ์ธํฐํ์ด์ค๊ฐ ๊ฒ์คํธ ๊ธฐ๊ธฐ๋ก ๋ฆฌ๋ค์ด๋ ํธ๋ ํ์ค localhost:1242
๋ผ์ฐํธ์์๋์ํ๋๋ก ํ ๊ฒ์
๋๋ค. ์ด ๋ผ์ฐํธ๋ฅผ ๋ ๋ง์ด ๋
ธ์ถํ์ง ์์์ ์์ ๋์ญ์์ค. ์ฐ๊ฒฐ์ ์ค์ง ๋์ปค ํธ์คํธ์์์๋ง ์ด๋ฃจ์ด์ง๊ณ ์์ ํ๊ฒ ์ ์ง๋ฉ๋๋ค. Of course, you can expose the route further if you know what you're doing and ensure appropriate security measures.
์์ ์ง์์ ๋ชจ๋ ํฉ์น๋ฉด ์์ ํ ์ค์น ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
docker run -p 127.0.0.1:1242:1242 -p [::1]:1242:1242 -v /home/archi/ASF/config:/app/config --name asf --pull always justarchi/archisteamfarm
This assumes that you'll use a single ASF container, with all ASF config files in /home/archi/ASF/config
. You should modify the config path to the one that matches your machine. ๋ค์๊ณผ ๊ฐ์ IPC.config
๋ฅผ ํ๊ฒฝ์ค์ ๋๋ ํ ๋ฆฌ์ ๋ฃ๊ธฐ๋ก ๊ฒฐ์ ํ๋ค๋ฉด ์ถ๊ฐ๋ก IPC ์ฌ์ฉ๋ ๊ฐ๋ฅํฉ๋๋ค.
{
"Kestrel": {
"Endpoints": {
"HTTP": {
"Url": "http://*:1242"
}
}
}
}
ASF ๋์ปค ์ปจํ
์ด๋๊ฐ ์ค๋น๋์ด์๋ค๋ฉด docker run
๋ฅผ ๋งค๋ฒ ์คํํ ํ์๊ฐ ์์ต๋๋ค. docker stop asf
์ docker start asf
๋ก ASF ๋์ปค ์ปจํ
์ด๋๋ฅผ ์ฝ๊ฒ ๋ฉ์ถ๊ณ ์์ํ ์ ์์ต๋๋ค. Keep in mind that if you're not using latest
tag then using up-to-date ASF will still require from you to docker stop
, docker rm
and docker run
again. ์ด๋ ๋งค ๋ฒ์ ๋ง๋ค ์๋ก์ด ASF ๋์ปค ์ด๋ฏธ์ง๋ก๋ถํฐ ๋ค์ ๋น๋ํด์ผ ํ๊ธฐ ๋๋ฌธ์
๋๋ค. In latest
tag, ASF has included capability to auto-update itself, so rebuilding the image is not necessary for using up-to-date ASF (but it's still a good idea to do it from time to time in order to use fresh .NET runtime dependencies and the underlying OS).
์์์ ์์ํ์๋ฏ์ด, latest
๊ฐ ์๋ ASF ํ๊ทธ๋ ์ค์ค๋ก ์๋ ์
๋ฐ์ดํธํ์ง ์์ต๋๋ค. ์ฆ, ๋น์ ์ด ์ต์ ์ justarchi/archisteamfarm
์ ์ฅ์๋ฅผ ์ฌ์ฉํ ์ฃผ์ฒด์
๋๋ค. ๋ณดํต ์ฑ์ด ์คํ์ค์๋ ์ฝ๋๋ฅผ ๊ฑด๋๋ ค์๋ ์๋๊ธฐ ๋๋ฌธ์ ๋ง์ ์ฅ์ ์ ๊ฐ์ง๋ง, ๋์ปค ์ปจํ
์ด๋์ ์๋ ASF๋ ๊ฑฑ์ ํ ํ์๊ฐ ์๋ค๋ ํธ๋ฆฌํจ๋ ์์ต๋๋ค. ์ข์ ์ฌ๋ก์ ์ ํํ ๋์ปค ์ฌ์ฉ๋ก๋ฅผ ์ ์ดํ๋ค๋ฉด ์ฐ๋ฆฌ๊ฐ ์ถ์ฒํ๋ ๊ฒ์ latest
ํ๊ทธ๊ฐ ์๋ released
ํ๊ทธ์
๋๋ค. ํ์ง๋ง ๊ทธ๊ฒ ๊ท์ฐฎ๊ณ ASF๊ฐ ๋์๋ ์ํ๊ณ ์๋ ์
๋ฐ์ดํธ๋ ํ๊ธธ ์ํ๋ฉด latest
ํ๊ทธ๊ฐ ๊ทธ ๋ต์
๋๋ค.
๋ณดํต ASF ๋์ปค ์ปจํ
์ด๋๋ Headless: true
์ผ๋ฐ ์ค์ ์ํ๋ก ์คํํด์ผ ํฉ๋๋ค. ์ด๋ ASF์๊ฒ ์ธ๋ถ์ ์ธ ๋ด์ฉ์ด ๋น ์ ธ์์ด๋ ๋น์ ์ด ์ค ์ ์์ผ๋ฉฐ ๋ฌป์ง ๋ง ๊ฒ์ ์๋ฆฝ๋๋ค. ๋ฌผ๋ก ์ด๊ธฐ ์ค์น๋จ๊ณ์์๋ ์ด ์ต์
์ false
๋ก ํด์ ์ฝ๊ฒ ์ค์ ํ ์ ์์ง๋ง, ์ฅ๊ธฐ์ ์ผ๋ก๋ ASF ์ฝ์์ ๋งค์ฌ์์ง ์์ผ๋ฏ๋ก ASF์๊ฒ ์ด๋ฅผ ์๋ฆฌ๊ณ ํ์๊ฐ ์์ผ๋ฉด input
๋ช
๋ น์ด ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ง์ต๋๋ค. ์ด๋ ๊ฒ ํด์ ASF๋ ์ผ์ด๋์ง ์์ ์ฌ์ฉ์ ์
๋ ฅ์ ๋ฌดํํ ๊ธฐ๋ค๋ฆฌ์ง ์์ ์ ์๊ณ ์ด์ ์์๋๋ ์์๋ญ๋น๋ฅผ ๋ง์ ์ ์์ต๋๋ค. It will also allow ASF to run in non-interactive mode inside container, which is crucial e.g. in regards to forwarding signals, making it possible for ASF to gracefully close on docker stop asf
request.