Как установить и настроить Go на Windows

Go является простым языком программирования общего назначения, которого будет не лишним добавить в вашу коллекцию изученных языков. Проект стартовал в 2007 году, и благодаря усилиям разработчиков Google, стал тем языком Go, с которым мы можем работать сегодня. Внимание уделялось легкости и согласованности языка, его инструментов и стандартных библиотек, делая Go простым и занятным в использовании.

Содержание статьи

У Go открытый исходный код, что здорово. И не забывайте — данный язык чувствителен к регистру.

Рекомендуем вам супер TELEGRAM канал по Golang где собраны все материалы для качественного изучения языка. Удивите всех своими знаниями на собеседовании! 😎

Мы публикуем в паблике ВК и Telegram качественные обучающие материалы для быстрого изучения Go. Подпишитесь на нас в ВК и в Telegram. Поддержите сообщество Go программистов.

Разберем процесс установки Go на Windows 10. Вы увидите, как это просто — достаточно базовых знаний о GitHub и работы с командной строкой. Конечно, это не единственный способ установки, однако он будет наиболее простым для тех, чьи знания кодирования ограничены. Просто придерживайтесь данных инструкций.

Следуйте указаниям, придерживаясь правильного порядка, чтобы потом не мучиться и не исправлять ошибки, возникшие во время процесса инсталляции.

Установка элементов в правильном порядке

1. Так как зачастую Go использует бесплатные репозитории с открытым исходным кодом, сначала установить пакет Git, перейдя по ссылке;
2. Перейдите на сайт инсталляции Go по ссылке. Скачайте и установите последний 64-битный набор Go для Microsoft Windows OS;
3. Следуйте инструкциям по установке программы Go;
4. Откройте командную строку cmd и наберите go version ;
5. Вывод после ввода go version должен выглядеть следующим образом (в зависимости от версии, она может быть у вас другая):

Создание рабочего пространства Go

Для начала подтвердим работоспособность Go. Откройте Панель Управления, затем следуйте в Система и безопасность > Система > Дополнительные параметры системы. Кликните на Переменные Среды с правой нижней стороны. Убедитесь, что у Path в Системные Переменные есть значение C:\Go\bin .

Затем нужно создать рабочее пространство Go. Оно будет в отдельной новой папке от той, где сохранены и установлены файлы Go. К примеру, ваши установленные файлы Go могут находиться по пути C:\Go , а создать рабочее пространство Go можно по адресу C:\Projects\Go .

В новой папке рабочего пространства Go настраиваем три новые папки — bin , pkg , src :

Создание переменной среды GOPATH

Создадим переменную GOPATH и свяжем ее с недавно созданным рабочим пространством Go. Перейдите обратно в Панель Управления, затем в Система и потом на Переменные среды. Затем под Системные Переменные нажмите на Создать.

Рядом с Имя переменной введите GOPATH, а рядом с Значение переменной введите C:\Projects\Go:

Проверить, установлены ли пути верно можно через ввод echo %GOPATH% в командной строке.

Тестирование установки Golang в Windows

Теперь можно проверить, действительно ли все работает правильно. Откройте командную строку и наберите: go get github.com/golang/example/hello .

Подождите, когда код будет полностью скомпилировано (на это уйдет пару секунд), затем наберите следующую команду: %GOPATH%/bin/hello .

Если установка была успешной, вы должны получить следующее сообщение: “Hello, Go examples!”

Надеюсь, у вас все получилось. Если же возникли какие-то ошибки или появились непонятные сообщения, наберите внизу результат командной строки: “go env” .

При составлении данной статьи использовались указанные ниже ресурсы, которые также могут помочь при настройке Go на операционной системе Windows: Wade Wegner’s visually-simple & stylistic article.

Администрирую данный сайт с целью распространения как можно большего объема обучающего материала для языка программирования Go. В IT с 2008 года, с тех пор изучаю и применяю интересующие меня технологии. Проявляю огромный интерес к машинному обучению и анализу данных.

E-mail: vasile.buldumac@ati.utm.md

Образование

Технический Университет Молдовы (utm.md), Факультет Вычислительной Техники, Информатики и Микроэлектроники

• 2014 — 2018 Universitatea Tehnică a Moldovei, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
• 2018 — 2020 Universitatea Tehnică a Moldovei, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

Golang

Блог о языке программирования Go

понедельник, 24 июня 2019 г.

Установка Go

Загрузите дистрибутив Go

Официальные бинарный дистрибутивы доступны для операционных систем FreeBSD (версия 10-STABLE и выше), Linux, macOS (10.10 и выше) и Windows, а также 32-битных (386) и 64-битных (amd64) процессорных архитектур x86.

Если бинарный дистрибутив недоступен для вашей комбинации операционной системы и архитектуры, попробуйте установить из исходного кода или установить gccgo вместо gc.

Системные требования

Бинарный дистрибутивы Go доступны для следующих поддерживаемых операционных систем и архитектур. Пожалуйста, убедитесь, что ваша система соответствует этим требованиям, прежде чем продолжить. Если вашей ОС или архитектуры нет в списке, вы можете установить ее из исходного кода или использовать вместо нее gccgo.

Установите инструменты Go

Если вы обновляете более старую версию Go, вы должны сначала удалить существующую версию.

Tarboll’ы для Linux, macOS и FreeBSD

Загрузите архив и распакуйте его в /usr/local, создав дерево Go в /usr/local/go. Например:

Выберите файл архива, подходящий для вашей установки. Например, если вы устанавливаете Go версии 1.2.1 для 64-битной x86 в Linux, то нужный вам архив называется go1.2.1.linux-amd64.tar.gz.

(Обычно эти команды должны запускаться от имени пользователя root или через sudo.)

Добавьте /usr/local/go/bin в переменную окружения PATH. Вы можете сделать это, добавив эту строку в ваш /etc/profile (для общесистемной установки) или в $HOME/.profile:

Примечание. Изменения, внесенные в файл профиля, могут не применяться до следующего входа в систему. Чтобы немедленно применить изменения, просто запустите команды оболочки напрямую или выполните их из профиля, используя команду, например source $HOME/.profile.

Установщик пакета macOS

Загрузите файл пакета, откройте его и следуйте инструкциям по установке инструментов Go. Пакет устанавливает дистрибутив Go в /usr/local/go.

Пакет должен поместить каталог /usr/local/go/bin в переменную среды PATH. Вам может потребоваться перезапустить все открытые сеансы терминала, чтобы изменения вступили в силу.

Windows

Проект Go предоставляет два варианта установки для пользователей Windows (помимо установки из источника): zip-архив, в котором требуется установить некоторые переменные среды, и установщик MSI, который автоматически настраивает установку.

Установщик MSI

Откройте файл MSI и следуйте инструкциям по установке инструментов Go. По умолчанию установщик помещает дистрибутив Go в c:\Go.

Установщик должен поместить каталог c:\Go\bin в переменную окружения PATH. Вам может потребоваться перезапустить любые открытые командные строки, чтобы изменения вступили в силу.

Zip архив

Загрузите zip-файл и распакуйте его в каталог по вашему выбору (предлагается c:\Go).

Добавьте подкаталог bin вашего корневого каталога Go (например, c:\Go\bin) в переменную среды PATH.

Установка переменных среды под Windows

В Windows вы можете установить переменные среды с помощью кнопки «Переменные среды» на вкладке «Дополнительно» панели управления «Система». Некоторые версии Windows предоставляют эту панель управления через параметр «Дополнительные параметры системы» на панели управления «Система».

Проверьте вашу установку

Убедитесь, что Go установлен правильно, настроив рабочее пространство и собрав простую программу следующим образом.

Создайте свой каталог рабочей области, $HOME/go. (Если вы хотите использовать другой каталог, вам нужно установить переменную среды GOPATH.)

Затем создайте в вашей рабочей области каталог src/hello, и в этом каталоге создайте файл с именем hello.go, который выглядит следующим образом:

Затем соберите его с помощью инструмента go:

Команда выше создаст исполняемый файл с именем hello в каталоге вместе с вашим исходным кодом. Выполните его, чтобы увидеть приветствие:

Если вы видите сообщение «hello, world», значит, ваша установка Go работает.

Вы можете запустить go install, чтобы установить бинарный файл в каталог bin вашего рабочего пространства, или выполните команду go clean -i, чтобы удалить его.

Установка дополнительных версий Go

В некоторых случаях может быть полезным иметь несколько версий Go на одном компьютере, например, чтобы гарантировать, что тесты пакета пройдут на нескольких версиях Go. После установки одной версии Go вы можете установить другую (например, 1.10.7) следующим образом:

Недавно загруженную версию можно использовать как go:

Все версии Go, доступные с помощью этого метода, перечислены на странице загрузки. Вы можете узнать, где установлена каждая из этих дополнительных версий Go, взглянув на GOROOT; например, go1.10.7 env GOROOT. Чтобы удалить загруженную версию, просто удалите ее каталог GOROOT и бинарный файл goX.Y.Z.

Удаление Go

Чтобы удалить существующую установку Go из вашей системы, удалите каталог go. Обычно это /usr/local/go под Linux, macOS и FreeBSD или c:\Go под Windows.

Быстрый старт – программируем на Go под Windows — настройка Environment

Update (22.07.2013)

С момента изначального написания статьи многое изменилось. Я немного обновил пост, чтобы в сети не висела устаревшая инструкция.

Вместо вступления

Установка Go

На момент последнего редактирования статьи, актуальная версия — Go 1.1.1. Дистрибутив можно скачать по ссылке: code.google.com/p/go/downloads/list. Дистрибутив выбираем в зависимости от разрядности установленной версии Windows: x64 — go1.1.1.windows-amd64.msi; x32 — go1.1.1.windows-386.msi. Скачиваем, устанавливаем. Теперь Go живет в C:\Go. Инсталлятор сам настроит нужные переменные среды.

Workspace

Теперь необходимо создать папку, которая будет чем-то вроде корневой рабочей директории. В составе дистрибутива Go идет утилита «go», которая «все в одном» — она используется для сборки проектов, для установки сторонник библиотек, для запуска тестов и т.п. Используется парадигма Convention over Configuration. Единственная настройка, которую нужно сделать — это добавить переменную среды GOPATH, в которой указать корневую папку, где у нас будут хранится все исходники наших и сторонних проектов, скомпилированные библиотеки и исполняемые файлы. Создаем такую папку: C:\gopath и добавляем переменную среды:

Также нужно добавить %GOPATH%\bin в перменную среды PATH.

Установка IDE

Перепробовав много различных редакторов текста и IDE, я остановил свой выбор на GoLangIDE (http://code.google.com/p/golangide/). Она очень легковесная, т.е. можно просто открыть file.go и скомпилировать его; но в то же время полностью поддерживает работу с проектами по Convention утилиты «go». Для debug’а в мире Go используют gdb, эта IDE интегрируется с gdb – можно ставить breakpoint’ы, просматривать значения локальных переменных.
В общем, скачиваем и распаковываем в C:\. Запускаем C:\liteide\bin\liteide.exe. Полу-русский язык советую сразу сменить на английский: Вид -> Options, меняем язык на English, “Применить”, надо перезапустить IDE.

Hello World

В последней версии GoLangIDE, аналог IntelliSense (GoCode) уже встроен и ничего дополнительно устанавливать не нужно. Поэтому сразу приступаем к делу:
Запускаем IDE, создаем новый проект (Ctrl+N):

Пишем fmt, ставим точку – видим выпадающий список функций.

Выбираем функцию (жмем Tab) — можно вводить параметры функции, жмем F1 — видим подсказку с сигнатурой функции.

Компилируем наш Hello World: Ctrl + B
Запускаем в отдельном окне консоли: Ctrl + Shift + F5

Кросс-компиляция в Go

Несмотря на то, что кроссплатформенность стала фактически стандартным атрибутом практически всех современных языков и библиотек, создавать по-настоящему кроссплатформенный продукт, всё равно было непросто. Компилируемые языки и сопутствующие библиотеки требовали сложной установки и настройки среды сборки и библиотек, а интерпретируемые — обязывали иметь или деплоить в составе необходимую версию интерпретатора. Есть немало проектов, пытающихся сделать этот процесс чуть более простым, но зачастую единственным решением оставалось устанавливать отдельный сервер и компилировать нативно.

В Go кросс-платформенность вышла на тот уровень, когда впервые можно смело отказаться от compile farms, специально настроенных dev-сред, виртуальных машин для сборки или chroot/docker-dev решений. И это ещё один серьезный game-changer, подробнее о котором я и хочу рассказать и показать на примерах
Поехали.

Как известно, в Go сознательно отказались от динамической линковки — по ряду причин, основная из которых очень схожа с обычным объяснением дизайна почти любого аспекта Go — «преимущества [динамической линковки] намного меньше её недостатков и сложности, которая она привносит в архитектуру». Что ж, главной причиной появления dynamic linking было желание экономить ресурсы — прежде всего диcковое пространство и память — которые сейчас достаточно дешевы, не только на серверах, но и в embedded-устройствах (коптеры, к примеру, несут на борту уже по 1-2 Гб RAM!). Вобщем, перечислять плюсы и минусы отдельного способа линковки — это потянет на отдельный пост, так что пока просто принимаем, как есть — в Go на выходе всегда имеем статический бинарник.

На данный момент для актуальной версии Go 1.4.1 реализована поддержка следующих платформ:

• Linux 2.6 1 и выше — amd64, 386, arm
• MacOS X 10.6 и выше — amd64, 386
• Windows XP и выше — amd64, 386
• FreeBSD 8 и выше — amd64, 386, arm
• NetBSD — amd64, 386, arm
• OpenBSD — amd64, 386
• DragonFly BSD — amd64, 386
• Plan 9 — amd64, 386
• Google Native Client — amd64p32, 386
• Android — arm

1 — официально поддерживаются ядра 2.6.23 и выше, но в реальности всё работает и на более ранних ядрах ветки 2.6 — к примеру немало людей используют Go на RHEL5/CentOS5 с 2.6.18.

В Go 1.5 ожидается поддержка iOS.
Еще примечательно, что изначально поддержки Windows в Go не было — команда маленькая, и пачкать руки заниматься имплементацией кода для Windows было некому, но благодаря тому, что проект открыли для open-source разработки — порт для Windows был очень быстро написан сторонними людьми и интегрирован в официальную кодовую базу.

Хотя описанные далее процессы будут абсолютно одинаковы для всех платформ (за исключеним, разве что, Android и Native Client (NaCl), для которых нужны лишние телодвижения), далее в статье будет по-умолчанию считаться, что вы используете одну из трех самых популярных десктопных платформ — Linux, MacOS X или Windows. Кроме того, для большей простоты я буду подразумевать, что мы пишем и используем исключительно Go-код, без необходимости линковаться с С-библиотеками (и, тем самым, без необходимости использовать cgo/gcc). Есть еще отдельный кейс — когда нужно использовать ряд функций из стандартной библиотеки, завязанных на cgo, но об этом я напишу отдельной главой в конце.

Подготовка toolchain

Первый шаг, который необходимо выполнить — это собрать toolchain для нужной платформы.

Переходим в директорию с исходным кодом Go (она же $GOROOT/src, она же всегда есть у вас на машине) и пересобираем под нужную платформу, скажем Windows/amd64:

Процесс занимает на Macbook Air 2012 около 26 секунд. Скрипт make.bash — это стандартный скрипт сборки Go, которым бы вы инсталлировали Go, если бы ставили из исходников. Он собирает, собственно, Go, и всю стандартную библиотеку, только в этот раз — для платформы windows/amd64.
Также, по упомянутой выше причине, мы отключили поддержку CGO.

Значения GOOS и GOARCH

Таблица значений GOOS (если кто знает, как на Хабре сделать таблица в 50% ширины — подскажите):

OS	$GOOS
Linux	linux
MacOS X	darwin
Windows	windows
FreeBSD	freebsd
NetBSD	netbsd
OpenBSD	openbsd
DragonFly BSD	dragonfly
Plan 9	plan9
Native Client	nacl
Android	android

И GOARCH:

Architecture	$GOARCH
x386	386
AMD64	amd64
AMD64 с 32-указателями	amd64p32
ARM	arm

Пример 1. Веб-сервер, написанный и собранный в Linux для Windows

Напишем простенький веб-сервер, который в Go писать проще, чем в некоторых языках/библиотеках парсить командную строку.

И соберем его для Windows 32- и 64-bit:

Думаю, не нужно говорить, что оба бинарника готовы к копированию на целевую Windows-систему и будут работать.

Пример 2. Кросс-компиляция под ARM для телефона Nokia N9

Сразу скажу, что сейчас я с embedded-девайсами плотно не работаю, поэтому могу какие-то детали не знать — так что постараюсь не углубляться в эту тему, но в целом за ситуацией с Go на embedded слежу. Вообще говоря, Go не позиционировался как язык для embedded-платформ, что, впрочем, не помешало народу активно начать его использовать в этой области. Возможно, причина в том, что embedded-индустрия сделала скачок вперед, и теперь «встраиваемое» устройство уже не означает критически малое количество ресурсов, а возможно компромиссы не в пользу экономии памяти в Go оказались гораздо менее ощутимыми на практике, но факт есть факт — для Go уже создано масса проектов вроде Gobot (robotics-фреймворк для целой кучи платформ — от Arduino, Raspberry PI и Beaglebone Back до LeapMotion, Pebble и ArDrone) или EMBD (фреймворк для работы с hobby-бордами), а PayPal уже пару лет использует Go в своем beacon-девайсе для беспроводных чекинов и платежей.

Для примера возьмем Nokia N9 (или N950, кому повезло) — и соберем вышеприведенный пример для него:

Вот так просто, да.

Для ARM-платформ, на самом деле, может понадобиться еще указывать флаг GOARM, но тут, если версия по-умолчанию не подходит, бинарник на целевой платформе выдаст понятное сообщение, вроде такого:

Автоматизируем процесс

Казалось бы, что может быть проще указания одной переменной перед go build. Но есть ситуации, когда код нужно собирать и деплоить на разные платформы по 100 раз в день. Для таких задач есть несколько проектов, для автоматизации процессов подготовки toolchain-ов и, непосредственно, сборки кода под нужную платформу.

Ссылка: github.com/mitchellh/gox
Инсталляция и подготовка сразу всех возможных toolchain-ов:

Теперь, вместо «go build», пишем «gox»:

Можно указывать конкретный пакет или конкретную платформу:

Остальные аргументы командной строки идентичны go build. Достаточно интуитивно.

GoCX — это один из самых известных врапперов вокруг фич кросс-компиляции, но с упором на пакаджинг (умеет делать .deb даже) и различные плюшки для автоматизированных сборок. Сам не пользовал, поэтому, кому интересно, смотрите сайт и документацию.
github.com/laher/goxc

Разбираемся с CGO

Если кто-то смотрел видео с конференции GopherCon 2014, которая проходила прошлой весной в Денвере, то, возможно, помнит выступление Alan Shreve «Build Your Developer Tools in Go» — и одну из вещей, которую он говорит достаточно категорично: «не используйте кросс-компиляцию, компилируйте нативно». Дальше идет объяснение — причина в Cgo. Если вам не нужно использовать cgo — все окей. И на самом деле, очень малая часть очень специфичного кода в Go нуждается в сторонних С-библиотеках. В чем же проблема?

Проблема в том, что некоторые функции стандартной библиотеки зависят от cgo. Тоесть, если мы собираем Go с CGO_ENABLED=0, они просто не будут доступны и на этапе компиляции мы получим ошибку. Несмотря на то, что тут есть очень удобный и красивый workaround, давайте разберемся, что же именно в стандартной библиотеке зависит от cgo.

К счастью, сделать это просто:

Вкратце пройдемся по этим файлам:

• crypto/x509/root_cgo_darwin.go — имплементирует одну функцию для получения корневых X.509 сертификатов в MacOS X. Если вы не используете явно эту фичу — ничего страшного, без cgo у вас все будет работать.
• net/cgo_android/linux/netbsd/openbsd/cgo_unix_test.go — код необходимый для использования нативного DNS-резолвера в разных unix-ах. Чуть ниже подробности.
• os/user/lookup_unix.go — функции из пакета os/user — для получения информации о текущем юзере (uid, gid, username). Используется getpwuid_r() для чтения passwd-записей
• runtime/crash_cgo_test.go — файл с тестами для хендлинга крешей, ничего релевантного

Теперь подробнее про DNS-resolver.
Каждый файл из того списка (который скомпилируется только для своей платформы благодаря тегам // +build) содержит имплементацию единственной функции cgoAddrInfoFlags(), которая, в свою очередь, используется в cgoLookupIP(), которая, используется в dnsclient_unix.go, в котором мы находим функцию goLookupIP(), которая служит fallback-вариантом при отсутствии cgo-enabled кода, и тут же находим объяснение:

// goLookupIP is the native Go implementation of LookupIP.
// Used only if cgoLookupIP refuses to handle the request
// (that is, only if cgoLookupIP is the stub in cgo_stub.go).
// Normally we let cgo use the C library resolver instead of
// depending on our lookup code, so that Go and C get the same
// answers.

goLookupIP фактически резолвит только по Hosts-файлу и по DNS-протоколу, что для большинства систем — ок. Но могут быть проблемы, если в системе будут использоваться нестандартные методы резолвинга имён. Полагаю, что в 99% случаев, hosts и dns будут более, чем достаточно.

В сухом остатке имеем — если ваш код не использует С/С++-библиотеки через Cgo, и не использует следующие две вещи:

• проверку x.509 сертификатов, которая должна работать на MacOS X
• гарантированно получать системную информацию о текущем юзере

то на все заморочки с Cgo можно забить.

Первая часть (с X.509) на самом деле не такая уж редкая. Если я правильно понимаю — этот код нужен, если ваша программа использует стандартный net/http.StartAndListenTLS() — и вы используете реальные сертификаты, которые реально нужно проверять.

Поэтому вкратце о простом workaround вокруг этой темы — называется он gonative, и делает одну простую вещь — скачивает с официального сайта бинарные версии golang нужной версии для нужной платформы, в которой уже есть скомпилированные бинарники всех стандартных пакетов и, фактически, завершает процесс «собрать toolchain с cgo-кодом».
Всё что нужно сделать, это установить её (go get github.com/inconshreveable/gonative) и выполнить одну простую команду:

И дальше использовать стандартные процедуры кросскомпиляции, как и раньше, ручками или через gox/gocx.
Подробнее о gonative тут: inconshreveable.com/04-30-2014/cross-compiling-golang-programs-with-native-libraries

Практическое применение

Теперь о главном — применении на практике. Я использовал в продакшене пока только три схемы — «сборка на darwin/amd64 -> деплой на linux/386», «linux/amd64 -> linux/386» и «linux/amd64 -> windows/amd64». Это продукты, которые уже больше года полноценно работают. Третий случай (деплой на windows) тогда меня вообще застал врасплох — был сервер, успешно бегущий на Linux, и тут вдруг резко понадобилось его запускать на Windows. Причем «вот срочно надо». Вспоминая бессонные ночи опыта с кросс- — да что там кросс, просто с компиляцией Qt для деплоя на Windows — 60-секундный процесс «гуглим как это делается → сборка toolchain → перекомпиляция проекта → деплой на windows» — стал просто шоком, я тогда даже не поверил глазам.

Но тут возникает следующий момент — раз кросс-компиляция и деплой становятся такими простыми и быстрыми, появляется стимул все зависимости от файлов — будь-то конфиги, сертификаты или что угодно еще — встраивать в бинарник тоже. Впрочем, это достаточно простая задача, даже для сторонних библиотек, благодаря эффективному использованию io.Reader интерфейса и пакету go-bindata, но это уже тема для отдельной статьи.

Надеюсь, ничего из главного не упустил.
Но в целом это на самом деле очень существенная разница со всем предыдущим опытом кросс-сборки. Если честно, я до сих пор не привык к этой перемене. Больше не нужны виртуалки с настроенной dev-средой, не нужны докер-имиджи для сборки — да вообще dev-environment отпадает как таковой. Это слишком резкий game changer, чтобы так быстро привыкнуть.