Tip:
Highlight text to annotate it
X
[Teams and Organizations]
[GitHub] [Social Coding]
Welcome to GitHub Teams and Organizations,
a useful way to orchestrate
collaborative efforts on a larger scale than
just person-by-person to repos.
This is very frequently used for hack-a-thons
and other open source events and this will
give you the step-by-step instructions as well as
the diagram of what the big picture of an
organization and team is, so that you can leverage it
for your upcoming event.
First off, let's draw a picture of what it is
that we'll achieve, and then, let's take it
step-by-step actually showing you how it's done.
We're going to work with a series of users.
We'll put up six on this screen for the sake of
our description here. One of these users,
we'll claim the one who's initiating this entire effort,
will start off by creating an organization.
Organizations are a grouping unit that contain some other
finer-grained grouping units.
User 1 now belongs to the organization Octocats.
And that belonging, or membership,
puts them as the creator of the organization,
in a special team called Owners, that has permission
above the administrative level.
We'll add another person to act as our backup,
in case we're unavailable and also put them
in the Owners team. We'll then start
creating repositories. Repos, owned by the
organization, not by a single individual.
And those will be where this big conglomerate
of teams does their work and performs their
open-source hacking.
The second repository down here and the first
are always accessible by persons, individuals,
who are in the Owners team.
Now we'll talk about a more fine-grained and
lower level of access.
We'll create a team that we call Red.
It'll have the lowest level of permissions:
just pull. We'll assign a user to this team. It doesn't copy,
it's just a linkage to an individual's already established
GitHub account. We'll add a second user to the same team,
user number four. We'll then create a linkage
on the team management page to connect it to
repo number one. We'll also connect the
same team to have pull-only access to repo number two.
We'll create another team Blue that has a higher level
of permissions, both pull and push.
We'll put a user inside this team, and then
we'll add User 2 to this team. And lastly, just as we did
with Team Red, we'll connect it with a repository,
but in this case, just repo number two.
We'll finish with a fourth team, Team Green
that has pull, push and admin level access,
but I'll remind you that administrative access
is still slightly less than that of being an Owner.
If there's billing involved, in a case of tacking
open source, this is all free, but if there is billing
involved, the owners can see that information,
whereas the administrators are just delegated authority
to manage the repos themselves.
In Team Green, we'll put a user, in fact User 6,
who's already participating in one of the other teams,
so that for a given repository, User 6 has higher level
permissions on that second repo.
Users can belong to more than one team.
In fact, it's an encouraged strategy.
This is what we're finished with, when we take off
the idea of the individual accounts.
But remember that the participants in each of these
teams are actually individual GitHub accounts.
Let's now step through the process on the website itself.
When we first open github.com, we have a
couple of options: we can create a new account or
login to an existing one. Login at the top right,
and the creation of an account towards the middle of the page.
We'll also create a new free account.
You could login to your existing one and then
pick up on the subsequent step.
When we create this personal account, only a
minimal amount of information has to be filled in.
We'll choose the free, open-source account,
since we're referring to creating organizations and teams
for an event like a hackathon.
A simple little fill-in of these four fields
and creation of the account takes us to the next step
in which we can then begin focussing on
the organization and the teams.
Here we are, at the conclusion of creating the account,
and now, we can begin talking about the org.
Setting up the organization happens from that same
page that we left off on, just a moment ago.
You'll manage your organization, and that will take you to a
specialized dashboard that allows you to create a new org, or
convert your existing account.
It generally makes sense to create a brand new one.
A quick name, and an email address,
which yes, must be distinct from the email address
of the individual that will be the first owner of the repository.
And then a click of the "create organization"
and you have the relationship established between the
user that was logged in and the organization
that was just created. And you have the possibility
on this screen very conveniently to add other owners,
but you can do it later if you also wish.
We'll continue from there to the organizational dashboard,
and then managing the owners kind of after the fact.
On that page, you can just auto-complete any
name of any other person that you'd like to share
in the responsibility in managing the organization.
We'll pop in Matthew McCullough, and tlberglund in this case.
We'll finish, and continue our way to the
organizational dashboard, Which then primes us
for the next step, which is creating a team.
So far we have the outermost shell or container, and
we're going to proceed inward to actually create
maybe the Red Team, the Blue Team, and the Green Team.
We'll click a new team from the teams tab,
which will then simply have the name field,
and then a selection of the permissions, and then
a choice of the participants.
This team grants, the drop-down to the right hand side
over here, has three modes: pull, pull and push,
pull, push and admin. Those are the three levels
that a team itself has, and thus grants,
transitively, to its members.
We'll save this team, and now we have three members
of a team called "TeamPullOnly".
We'll create one more, just to have some separation
between that one and one with slightly different
permissions. TeamPullPush, choose the appropriate
corresponding grant, on the right-hand side, create
several different members to this one,
and save this one, giving us two teams with distinct
permissions, but no connections to any repositories just yet.
We've established the containers and the members, and next,
we should discuss adding the repos.
The organization doesn't have any repos yet,
and in this case, we'll go create some brand new ones,
thinking that we're starting projects afresh.
We'll click from the organization's dashboard,
a new repository in the right hand side.
We'll fill in the project name, the description and a home page,
the later two are optional, and we'll leave it as public repos,
hence again, following our plan of calling this
an open-source, or a hack-a-thon type of event.
You can choose very conveniently to give
this brand new repository at least one team already
assigned to it, during the creation process there.
The repo is created and has no contents, which means
we'll need to follow the usual procedure for
pushing in our first readme, or our first commit.
We are at the step, in which we can start gluing
other teams, relationship-wise, to these repositories.
We can do that through another piece of the
organizational management, by drilling into one of the teams
- it is team directed - and then choosing one of
the repositories using auto-complete on the right hand side.
Clicking add on that links the permissions, push and pull,
of this particular team and its members,
with this repository, on the right hand side of the screen.
Now that we have at least one team for each of the repos
that we've created, we'll finish up by cloning that repo.
As a consumer, as one of the other participants of
the event, you can browse to that demo org and a
repository path beneath it, if you've been granted
push access then use your SSH url, otherwise your
HTTPS or Git protocol. Clone the repo, and start contributing.
That helps you with the setup of the organizational and
team structure necessary for a hack-a-thon-like event,
and the only piece you have to bring to the table is
the creativity and the code.
Start coding! And if you have any troubles with this process,
we're always happy to help you at support@github.com.
Thanks for giving me a few moments of your time.
This has been Matthew McCullough at GitHub. I wish you a successful event.
[Teams and Organizations]
[An Introduction for Open Source Events]