Sikker filoverføring mellom servere med SCP i Linux
La oss anta at du trenger å flytte filer mellom servere på et Linux-system. Det finnes flere metoder for å gjøre dette, men hvis sikkerhet er din høyeste prioritet, er det noen få alternativer som skiller seg ut. Den enkleste og mest effektive metoden er å bruke kommandoen `scp`, også kjent som sikker kopi, for å overføre filene dine trygt. Denne artikkelen vil forklare hvordan du kan overføre filer på en sikker måte ved å bruke `scp`-kommandoen i et Linux-miljø.
Hva er `scp`-kommandoen i Linux?
Når det gjelder overføring av filer over et nettverk på en sikker måte, er `scp`-kommandoen svært nyttig. `scp` står for Secure Copy Protocol, og det muliggjør overføring av både filer og mapper mellom to datamaskiner via en SSH-tilkobling (Secure Shell). Med SSH er filene dine beskyttet av kryptering som standard. Enkelt sagt, `scp`-kommandoen er en sikrere variant av `cp`-kommandoen. Du kan lære mer om `cp`-kommandoen i vår artikkel om Linux Terminal-kommandoer.
Hvordan bruke `scp`-kommandoen: Syntaks og alternativer
Før vi begynner å overføre filer med `scp`, la oss se på kommandoens syntaks og tilgjengelige alternativer:
`scp` `<alternativer>` `<kilde_bruker>@<kilde_ip>:<sti/til/kilde/fil>` `<mål_bruker>@<mål_ip>:<sti/til/mål/fil>`
La oss bryte ned denne syntaksen:
- `<kilde_bruker>@<kilde_ip>:<sti/til/kilde/fil>` refererer til kildesystemet hvor filene eller mappene skal kopieres fra.
- `<mål_bruker>@<mål_ip>:<sti/til/mål/fil>` angir målsystemet hvor filene eller mappene skal overføres til.
Hvis en av disse parametrene utelates, vil `scp` først forsøke å finne filen lokalt og deretter kopiere filen internt på maskinen. Her er noen av de vanlige alternativene som kan brukes med kommandoen:
| Alternativ | Beskrivelse |
| `-P` | Spesifiserer portnummeret for tilkobling til vertssystemet. Hvis ikke spesifisert, brukes port 22 som standard. |
| `-p` | Bevarer endringstidspunkter, tilgangstidspunkter og filmoduser fra den originale filen ved kopiering. |
| `-r` | Kopierer hele mapper rekursivt til målsystemet. |
| `-J` | Brukes for å koble til kilde- og målsystemer via en proxy-server (jump host). |
| `-3` | Ved bruk av dette flagget, kopieres filene både til målsystemet og lokalt. |
| `-4` | Tvinger `scp`-kommandoen til å kun bruke IPv4-adresser. |
| `-6` | Tvinger `scp`-kommandoen til å kun bruke IPv6-adresser. |
Hvordan kopiere filer med `scp`-kommandoen
Før du bruker `scp`-kommandoen i Linux, må du sjekke at følgende betingelser er oppfylt både på kilde- og målsystemet:
- SSH må være installert og konfigurert.
- Du må ha root-tilgang eller en bruker med sudo-rettigheter.
Kopier filer fra lokal maskin til ekstern server
Hvis du skal overføre en fil fra din lokale maskin til en ekstern server, må du bruke denne syntaksen:
`scp` `<alternativer>` `<sti_til_lokal_fil>` `<ekstern_bruker>@<ekstern_mål_ip>:<sti_for_lagring_eksternt>`
Et konkret eksempel vil gjøre det klarere:
`scp` `test.txt` `<email protected>`: `/home/remote2/Documents/`
Her:
- `test.txt` er navnet på filen som skal overføres og befinner seg i nåværende mappe på lokal maskin.
- `test` er brukernavnet på målsystemet.
- `139.144.11.105` er IP-adressen til målsystemet.
- `/home/remote2/Documents/` er lokasjonen på målsystemet der den overførte filen skal lagres.
Kopier filer fra ekstern server til lokal maskin
For å overføre en fil fra en ekstern server til din lokale maskin, bruk denne `scp`-kommandoen:
`scp` `<alternativer>` `<ekstern_bruker>@<ekstern_vert_ip>:<sti_til_fil_eksternt>` `<sti_til_lagring_lokalt>`
La oss si at du skal hente filen `test.py` fra serveren du jobber på, bruk denne kommandoen:
`scp` `<email protected>`:`/home/test/test1.py` `~/test1.py`
Her:
- `test` er brukernavnet på den eksterne serveren.
- `10.10.11.113` er IP-adressen til den eksterne serveren.
- `/home/test/test1.py` er banen til filen som skal overføres fra serveren.
- `~/test1.py` er navnet på filen etter overføringen og lagring i hjemme-mappen.
Overfør filer mellom to eksterne servere
Med `scp` kan du også overføre filer mellom to eksterne servere. Men før du overfører, er det anbefalt å generere en privat og offentlig SSH-nøkkel på kildeserveren og lagre en kopi av den offentlige nøkkelen på målserveren.
Brukere opplever ofte feilen «Vertsnøkkelbekreftelse mislyktes» ved overføring mellom to eksterne servere. For å unngå dette, bruk en SSH-nøkkel som en ekstra sikkerhetsforanstaltning. Vi beskriver hvordan du gjør det her:
1. Generer et offentlig/privat nøkkelpar på kildeserveren med denne kommandoen:
`ssh-keygen -t` `<krypteringsalgoritme>`
2. For `<krypteringsalgoritme>`, kan du bruke `rsa`, som er den mest brukte, eller en annen algoritme du foretrekker.
3. Du vil bli bedt om å velge plasseringen for å lagre SSH-nøkkelen. Du kan lagre den hvor du vil eller i standardmappen.
4. For passordfrasen kan du skrive inn et passord eller la den stå tom ved å trykke Enter.
5. Kopier deretter den offentlige nøkkelen til målserveren med kommandoen nedenfor. Dette lar deg også logge inn på destinasjonssystemet uten passord ved hjelp av SSH.
`ssh-copy-id` `<mål_brukernavn>@<mål_ip>`
Merk: Passordfri pålogging fungerer kun for brukeren du genererte SSH-nøkkelen for.
6. Etter å ha opprettet og lagret SSH-nøkkelen på den eksterne serveren, bruk denne `scp`-syntaksen for å overføre filer mellom de to eksterne Linux-systemene:
`scp` `<alternativer>` `<ekstern_bruker_1>@<ekstern_kilde_ip>:<sti_til_fil_overfør>` `<ekstern_bruker_2>@<ekstern_mål_ip>:<sti_til_lagring_eksternt>`
La oss si at du må overføre filen `test.txt` fra en ekstern server til en annen ekstern server, bruk denne kommandoen:
`scp` `<email protected>`:`/home/test1/test.txt` `<email protected>`:`/home/remote2/Documents/test1.txt`
I dette eksemplet:
- `remote1` er brukernavnet på den eksterne avsenderverten.
- `10.10.11.113` er IP-adressen til den eksterne avsenderverten.
- `/home/test1/test.txt` er stien til filen som skal sendes.
- `remote2` er brukernavnet på den eksterne mottakerverten.
- `10.11.27.111` er IP-adressen til den eksterne mottakerverten.
- `/home/remote2/Documents/test1.txt` er navnet og stien der filen skal lagres.
Overfør flere filer med `scp`-kommandoen
Å overføre mange filer en etter en kan være tungvint. Bruk i stedet denne syntaksen for å utveksle flere filer med `scp`:
`scp` `<sti_til_fil_1>` `<sti_til_fil_2>` `<ekstern_mottaker>@<ekstern_mål_ip>:<sti_til_lagring_eksternt>`
La oss si at du skal sende fire filer, `test1.txt`, `test2.py`, `test3.sh` og `test4.c` til en ekstern mottaker, du kan da bruke denne kommandoen:
`scp` `-P 22` `test1.txt` `test2.py` `test3.sh` `test4.c` `<email protected>`:`/home/remote_1/Documents`
La oss se hva denne kommandoen gjør:
- `-P 22` brukes for å spesifisere tilkobling via port 22.
- `test1.txt`, `test2.py`, `test3.sh` og `test4.c` er navnene på filene som skal overføres.
- `remote_1` er brukernavnet til mottakersystemet.
- `10.10.11.113` er IP-adressen til mottakersystemet.
- `/home/remote_1/Documents` viser til stien for lagring av mottatte filer.
Du kan også bruke jokertegn for å sende flere filer med samme filtype, som vist her:
`scp` `<jokertegn>` .`<filtype>` `<ekstern_mottaker>@<ekstern_mål_ip>:<sti_til_lagring_eksternt>`
Hvis du f.eks skal sende alle `.py`-filer til en ekstern server, kan du bruke denne kommandoen:
`scp` `*.py` `<email protected>`:`/home/remote_1/`
Her:
- `*.py` betyr alle filer som har filtypen `.py`.
- `remote1` er mottakerens brukernavn.
- `10.10.11.113` er mottakerens IP-adresse.
- `/home/remote_1/` er plasseringen for lagring av de mottatte filene.
Ofte stilte spørsmål
Er SCP-filoverføring sikker?
Secure Copy Protocol (scp) er basert på SSH-teknologi og bruker kryptering og autentisering for å utveksle filer mellom to maskiner. Dette sikrer full datasikkerhet og integritet mellom de to maskinene.
Er SCP sikrere enn SFTP?
Både SCP- og SFTP-protokoller har samme sikkerhetsnivå. Den største fordelen med å bruke `scp` fremfor SFTP er den raskere overføringshastigheten, som spesielt er nyttig i nettverk med høy latenstid.
Sikker filoverføring med `scp`-kommandoen i Linux
På et eller annet tidspunkt må alle brukere utveksle filer over nettverket. `scp`-kommandoen gjør det enkelt å overføre filer på en sikker og effektiv måte, selv over nettverk med høy latenstid. Det er også nyttig å kjenne til de ulike alternativene og syntaksen til `scp`. Du kan også se våre guider om hvordan du endrer navn på filer i Linux og hvordan du sletter filer i Linux for å forbedre dine filbehandlingsferdigheter i operativsystemet. Vi håper denne artikkelen har hjulpet deg med å lære hvordan du bruker `scp`-kommandoen til å overføre filer i Linux. Hvis du støter på problemer underveis, gi oss gjerne beskjed i kommentarfeltet.